ceph/src/arrow/c_glib/test/test-array-builder.rb

   1 # Licensed to the Apache Software Foundation (ASF) under one
   2 # or more contributor license agreements.  See the NOTICE file
   3 # distributed with this work for additional information
   4 # regarding copyright ownership.  The ASF licenses this file
   5 # to you under the Apache License, Version 2.0 (the
   6 # "License"); you may not use this file except in compliance
   7 # with the License.  You may obtain a copy of the License at
   8 #
   9 #   http://www.apache.org/licenses/LICENSE-2.0
  10 #
  11 # Unless required by applicable law or agreed to in writing,
  12 # software distributed under the License is distributed on an
  13 # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  14 # KIND, either express or implied.  See the License for the
  15 # specific language governing permissions and limitations
  16 # under the License.
  17
  18 module ArrayBuilderAppendValueBytesTests
  19   def test_append
  20     builder = create_builder
  21     value = "\x00\xff"
  22     builder.append_value_bytes(GLib::Bytes.new(value))
  23     assert_equal(build_array([value]),
  24                  builder.finish)
  25   end
  26 end
  27
  28 module ArrayBuilderAppendValuesTests
  29   def test_empty
  30     builder = create_builder
  31     builder.append_values([])
  32     assert_equal(build_array([]),
  33                  builder.finish)
  34   end
  35
  36   def test_values_only
  37     builder = create_builder
  38     builder.append_values(sample_values)
  39     assert_equal(build_array(sample_values),
  40                  builder.finish)
  41   end
  42
  43   def test_with_is_valids
  44     builder = create_builder
  45     builder.append_values(sample_values, [true, true, false])
  46     actual_sample_values = sample_values.dup
  47     actual_sample_values[2] = nil
  48     assert_equal(build_array(actual_sample_values),
  49                  builder.finish)
  50   end
  51
  52   def test_with_large_is_valids
  53     builder = create_builder
  54     n = 10000
  55     large_sample_values = sample_values * n
  56     large_is_valids = [true, true, false] * n
  57     builder.append_values(large_sample_values, large_is_valids)
  58     actual_sample_values = sample_values.dup
  59     actual_sample_values[2] = nil
  60     actual_large_sample_values = actual_sample_values * n
  61     assert_equal(build_array(actual_large_sample_values),
  62                  builder.finish)
  63   end
  64
  65   def test_mismatch_length
  66     builder = create_builder
  67     message = "[#{builder_class_name}][append-values]: " +
  68       "values length and is_valids length must be equal: <3> != <2>"
  69     assert_raise(Arrow::Error::Invalid.new(message)) do
  70       builder.append_values(sample_values, [true, true])
  71     end
  72   end
  73 end
  74
  75 module ArrayBuilderAppendValuesWithNullTests
  76   def test_values_only
  77     builder = create_builder
  78     builder.append_values(sample_values_with_null)
  79     assert_equal(build_array(sample_values_with_null),
  80                  builder.finish)
  81   end
  82
  83   def test_large_values_only
  84     builder = create_builder
  85     n = 10000
  86     large_sample_values_with_null = sample_values_with_null * n
  87     builder.append_values(large_sample_values_with_null)
  88     assert_equal(build_array(large_sample_values_with_null),
  89                  builder.finish)
  90   end
  91
  92   def test_with_is_valids
  93     builder = create_builder
  94     builder.append_values(sample_values_with_null, [true, true, false])
  95     actual_sample_values = sample_values_with_null.dup
  96     actual_sample_values[2] = nil
  97     assert_equal(build_array(actual_sample_values),
  98                  builder.finish)
  99   end
 100
 101   def test_with_large_is_valids
 102     builder = create_builder
 103     n = 10000
 104     large_sample_values = sample_values_with_null * n
 105     large_is_valids = [true, true, false] * n
 106     builder.append_values(large_sample_values, large_is_valids)
 107     actual_sample_values = sample_values_with_null.dup
 108     actual_sample_values[2] = nil
 109     actual_large_sample_values = actual_sample_values * n
 110     assert_equal(build_array(actual_large_sample_values),
 111                  builder.finish)
 112   end
 113 end
 114
 115 module ArrayBuilderAppendValuesPackedTests
 116   def test_empty
 117     builder = create_builder
 118     builder.append_values_packed("")
 119     assert_equal(build_array([]),
 120                  builder.finish)
 121   end
 122
 123   def test_values_only
 124     builder = create_builder
 125     builder.append_values_packed(pack_values(sample_values))
 126     assert_equal(build_array(sample_values),
 127                  builder.finish)
 128   end
 129
 130   def test_with_is_valids
 131     builder = create_builder
 132     builder.append_values_packed(pack_values(sample_values),
 133                                  [true, true, false])
 134     sample_values_with_null = sample_values
 135     sample_values_with_null[2] = nil
 136     assert_equal(build_array(sample_values_with_null),
 137                  builder.finish)
 138   end
 139
 140   def test_with_large_is_valids
 141     builder = create_builder
 142     n = 10000
 143     large_sample_values = sample_values * n
 144     large_is_valids = [true, true, false] * n
 145     builder.append_values_packed(pack_values(large_sample_values),
 146                                  large_is_valids)
 147     sample_values_with_null = sample_values
 148     sample_values_with_null[2] = nil
 149     large_sample_values_with_null = sample_values_with_null * n
 150     assert_equal(build_array(large_sample_values_with_null),
 151                  builder.finish)
 152   end
 153
 154   def test_mismatch_length
 155     builder = create_builder
 156     message = "[fixed-size-binary-array-builder][append-values-packed]: " +
 157       "the number of values and is_valids length must be equal: <3> != <2>"
 158     assert_raise(Arrow::Error::Invalid.new(message)) do
 159       builder.append_values_packed(pack_values(sample_values),
 160                                    [true, true])
 161     end
 162   end
 163 end
 164
 165 module ArrayBuilderAppendStringsTests
 166   def test_empty
 167     builder = create_builder
 168     builder.append_strings([])
 169     assert_equal(build_array([]),
 170                  builder.finish)
 171   end
 172
 173   def test_strings_only
 174     builder = create_builder
 175     builder.append_strings(sample_values)
 176     assert_equal(build_array(sample_values),
 177                  builder.finish)
 178   end
 179
 180   def test_with_is_valids
 181     builder = create_builder
 182     builder.append_strings(sample_values, [true, true, false])
 183     sample_values_with_null = sample_values
 184     sample_values_with_null[2] = nil
 185     assert_equal(build_array(sample_values_with_null),
 186                  builder.finish)
 187   end
 188
 189   def test_with_large_is_valids
 190     builder = create_builder
 191     n = 10000
 192     large_sample_values = sample_values * n
 193     large_is_valids = [true, true, false] * n
 194     builder.append_strings(large_sample_values, large_is_valids)
 195     sample_values_with_null = sample_values
 196     sample_values_with_null[2] = nil
 197     large_sample_values_with_null = sample_values_with_null * n
 198     assert_equal(build_array(large_sample_values_with_null),
 199                  builder.finish)
 200   end
 201
 202   def test_mismatch_length
 203     builder = create_builder
 204     message = "[#{builder_class_name}][append-strings]: " +
 205       "values length and is_valids length must be equal: <3> != <2>"
 206     assert_raise(Arrow::Error::Invalid.new(message)) do
 207       builder.append_strings(sample_values, [true, true])
 208     end
 209   end
 210 end
 211
 212 module ArrayBuilderAppendNullsTests
 213   def test_zero
 214     builder = create_builder
 215     builder.append_nulls(0)
 216     assert_equal(build_array([]),
 217                  builder.finish)
 218   end
 219
 220   def test_positive
 221     builder = create_builder
 222     builder.append_nulls(3)
 223     assert_equal(build_array([nil, nil, nil]),
 224                  builder.finish)
 225   end
 226
 227   def test_negative
 228     builder = create_builder
 229     message = "[array-builder][append-nulls]: " +
 230       "the number of nulls must be 0 or larger: <-1>"
 231     assert_raise(Arrow::Error::Invalid.new(message)) do
 232       builder.append_nulls(-1)
 233     end
 234   end
 235 end
 236
 237 module ArrayBuilderAppendEmptyValueTests
 238   def test_append
 239     builder = create_builder
 240     builder.append_empty_value
 241     assert_equal(build_array([empty_value]),
 242                  builder.finish)
 243   end
 244 end
 245
 246 module ArrayBuilderAppendEmptyValuesTests
 247   def test_zero
 248     builder = create_builder
 249     builder.append_empty_values(0)
 250     assert_equal(build_array([]),
 251                  builder.finish)
 252   end
 253
 254   def test_positive
 255     builder = create_builder
 256     builder.append_empty_values(3)
 257     assert_equal(build_array([empty_value] * 3),
 258                  builder.finish)
 259   end
 260
 261   def test_negative
 262     builder = create_builder
 263     message = "[array-builder][append-empty-values]: " +
 264       "the number of empty values must be 0 or larger: <-1>"
 265     assert_raise(Arrow::Error::Invalid.new(message)) do
 266       builder.append_empty_values(-1)
 267     end
 268   end
 269 end
 270
 271 module ArrayBuilderValueTypeTests
 272   def test_value_data_type
 273     assert_equal(value_data_type,
 274                  build_array(sample_values).value_data_type)
 275   end
 276
 277   def test_value_type
 278     assert_equal(value_data_type.id,
 279                  build_array(sample_values).value_type)
 280   end
 281 end
 282
 283 module ArrayBuilderCapacityControlTests
 284   def test_resize
 285     builder = create_builder
 286     before_capacity = builder.capacity
 287     builder.resize(before_capacity + 100)
 288     after_capacity = builder.capacity
 289
 290     assert do
 291       after_capacity >= before_capacity + 100
 292     end
 293   end
 294
 295   def test_reserve
 296     builder = create_builder
 297     before_capacity = builder.capacity
 298     builder.reserve(100)
 299     after_capacity = builder.capacity
 300
 301     assert do
 302       after_capacity >= before_capacity + 100
 303     end
 304   end
 305 end
 306
 307 module ArrayBuilderLengthTests
 308   def test_length
 309     builder = create_builder
 310     sample_values_with_null = sample_values
 311     sample_values_with_null[2, 0] = nil
 312     lengths = [builder.length]
 313     sample_values_with_null.each do |value|
 314       if value.nil?
 315         builder.append_null
 316       else
 317         builder.append_value(value)
 318       end
 319       lengths << builder.length
 320     end
 321     expected_lengths = [*0 ... (sample_values_with_null.length+1)]
 322     assert_equal(expected_lengths,
 323                  lengths)
 324   end
 325 end
 326
 327 module ArrayBuilderNNullsTests
 328   def test_n_nulls
 329     builder = create_builder
 330     sample_values_with_null = sample_values
 331     sample_values_with_null[2, 0] = nil
 332     null_counts = [builder.n_nulls]
 333     sample_values_with_null.each do |value|
 334       if value.nil?
 335         builder.append_null
 336       else
 337         builder.append_value(value)
 338       end
 339       null_counts << builder.n_nulls
 340     end
 341     expected_null_counts = [0, 0, 0] + [1] * (sample_values_with_null.length - 2)
 342     assert_equal(expected_null_counts,
 343                  null_counts)
 344   end
 345 end
 346
 347 class TestArrayBuilder < Test::Unit::TestCase
 348   include Helper::Buildable
 349   include Helper::Omittable
 350
 351   def setup
 352     require_gi_bindings(3, 1, 9)
 353   end
 354
 355   def build_array(values)
 356     super(create_builder, values)
 357   end
 358
 359   sub_test_case("NullArrayBuilder") do
 360     def create_builder
 361       Arrow::NullArrayBuilder.new
 362     end
 363
 364     def value_data_type
 365       Arrow::NullDataType.new
 366     end
 367
 368     def builder_class_name
 369       "null-array-builder"
 370     end
 371
 372     def sample_values
 373       [nil, nil, nil]
 374     end
 375
 376     def empty_value
 377       nil
 378     end
 379
 380     sub_test_case("value type") do
 381       include ArrayBuilderValueTypeTests
 382     end
 383
 384     test("#append_null") do
 385       builder = create_builder
 386       builder.append_null
 387       assert_equal(build_array([nil]),
 388                    builder.finish)
 389     end
 390
 391     sub_test_case("#append_nulls") do
 392       include ArrayBuilderAppendNullsTests
 393     end
 394
 395     sub_test_case("#append_empty_value") do
 396       include ArrayBuilderAppendEmptyValueTests
 397     end
 398
 399     sub_test_case("#append_empty_values") do
 400       include ArrayBuilderAppendEmptyValuesTests
 401     end
 402
 403     sub_test_case("capacity control") do
 404       include ArrayBuilderCapacityControlTests
 405     end
 406
 407     test("#length") do
 408       builder = create_builder
 409       before = builder.length
 410       builder.append_null
 411       after = builder.length
 412       assert_equal(1,
 413                    after - before)
 414     end
 415
 416     test("#n_nulls") do
 417       builder = create_builder
 418       before = builder.length
 419       builder.append_null
 420       after = builder.length
 421       assert_equal(1,
 422                    after - before)
 423     end
 424   end
 425
 426   sub_test_case("BooleanArrayBuilder") do
 427     def create_builder
 428       Arrow::BooleanArrayBuilder.new
 429     end
 430
 431     def value_data_type
 432       Arrow::BooleanDataType.new
 433     end
 434
 435     def builder_class_name
 436       "boolean-array-builder"
 437     end
 438
 439     def sample_values
 440       [true, false, true]
 441     end
 442
 443     def empty_value
 444       false
 445     end
 446
 447     sub_test_case("value type") do
 448       include ArrayBuilderValueTypeTests
 449     end
 450
 451     sub_test_case("#append_values") do
 452       include ArrayBuilderAppendValuesTests
 453     end
 454
 455     sub_test_case("#append_nulls") do
 456       include ArrayBuilderAppendNullsTests
 457     end
 458
 459     sub_test_case("#append_empty_value") do
 460       include ArrayBuilderAppendEmptyValueTests
 461     end
 462
 463     sub_test_case("#append_empty_values") do
 464       include ArrayBuilderAppendEmptyValuesTests
 465     end
 466
 467     sub_test_case("capacity control") do
 468       include ArrayBuilderCapacityControlTests
 469     end
 470
 471     sub_test_case("#length") do
 472       include ArrayBuilderLengthTests
 473     end
 474
 475     sub_test_case("#n_nulls") do
 476       include ArrayBuilderNNullsTests
 477     end
 478   end
 479
 480   sub_test_case("IntArrayBuilder") do
 481     def create_builder
 482       Arrow::IntArrayBuilder.new
 483     end
 484
 485     def value_data_type
 486       Arrow::Int8DataType.new
 487     end
 488
 489     def builder_class_name
 490       "int-array-builder"
 491     end
 492
 493     def sample_values
 494       [1, -2, 3]
 495     end
 496
 497     def empty_value
 498       0
 499     end
 500
 501     sub_test_case("value type") do
 502       include ArrayBuilderValueTypeTests
 503     end
 504
 505     sub_test_case("#append_values") do
 506       include ArrayBuilderAppendValuesTests
 507     end
 508
 509     sub_test_case("#append_nulls") do
 510       include ArrayBuilderAppendNullsTests
 511     end
 512
 513     sub_test_case("#append_empty_value") do
 514       include ArrayBuilderAppendEmptyValueTests
 515     end
 516
 517     sub_test_case("#append_empty_values") do
 518       include ArrayBuilderAppendEmptyValuesTests
 519     end
 520
 521     sub_test_case("capacity control") do
 522       include ArrayBuilderCapacityControlTests
 523     end
 524
 525     sub_test_case("#length") do
 526       include ArrayBuilderLengthTests
 527     end
 528
 529     sub_test_case("#n_nulls") do
 530       include ArrayBuilderNNullsTests
 531     end
 532   end
 533
 534   sub_test_case("UIntArrayBuilder") do
 535     def create_builder
 536       Arrow::UIntArrayBuilder.new
 537     end
 538
 539     def value_data_type
 540       Arrow::UInt8DataType.new
 541     end
 542
 543     def builder_class_name
 544       "uint-array-builder"
 545     end
 546
 547     def sample_values
 548       [1, 2, 3]
 549     end
 550
 551     def empty_value
 552       0
 553     end
 554
 555     sub_test_case("value type") do
 556       include ArrayBuilderValueTypeTests
 557     end
 558
 559     sub_test_case("#append_values") do
 560       include ArrayBuilderAppendValuesTests
 561     end
 562
 563     sub_test_case("#append_nulls") do
 564       include ArrayBuilderAppendNullsTests
 565     end
 566
 567     sub_test_case("#append_empty_value") do
 568       include ArrayBuilderAppendEmptyValueTests
 569     end
 570
 571     sub_test_case("#append_empty_values") do
 572       include ArrayBuilderAppendEmptyValuesTests
 573     end
 574
 575     sub_test_case("capacity control") do
 576       include ArrayBuilderCapacityControlTests
 577     end
 578
 579     sub_test_case("#length") do
 580       include ArrayBuilderLengthTests
 581     end
 582
 583     sub_test_case("#n_nulls") do
 584       include ArrayBuilderNNullsTests
 585     end
 586   end
 587
 588   sub_test_case("Int8ArrayBuilder") do
 589     def create_builder
 590       Arrow::Int8ArrayBuilder.new
 591     end
 592
 593     def value_data_type
 594       Arrow::Int8DataType.new
 595     end
 596
 597     def builder_class_name
 598       "int8-array-builder"
 599     end
 600
 601     def sample_values
 602       [1, -2, 3]
 603     end
 604
 605     def empty_value
 606       0
 607     end
 608
 609     sub_test_case("value type") do
 610       include ArrayBuilderValueTypeTests
 611     end
 612
 613     sub_test_case("#append_values") do
 614       include ArrayBuilderAppendValuesTests
 615     end
 616
 617     sub_test_case("#append_nulls") do
 618       include ArrayBuilderAppendNullsTests
 619     end
 620
 621     sub_test_case("#append_empty_value") do
 622       include ArrayBuilderAppendEmptyValueTests
 623     end
 624
 625     sub_test_case("#append_empty_values") do
 626       include ArrayBuilderAppendEmptyValuesTests
 627     end
 628
 629     sub_test_case("capacity control") do
 630       include ArrayBuilderCapacityControlTests
 631     end
 632
 633     sub_test_case("#length") do
 634       include ArrayBuilderLengthTests
 635     end
 636
 637     sub_test_case("#n_nulls") do
 638       include ArrayBuilderNNullsTests
 639     end
 640   end
 641
 642   sub_test_case("UInt8ArrayBuilder") do
 643     def create_builder
 644       Arrow::UInt8ArrayBuilder.new
 645     end
 646
 647     def value_data_type
 648       Arrow::UInt8DataType.new
 649     end
 650
 651     def builder_class_name
 652       "uint8-array-builder"
 653     end
 654
 655     def sample_values
 656       [1, 2, 3]
 657     end
 658
 659     def empty_value
 660       0
 661     end
 662
 663     sub_test_case("value type") do
 664       include ArrayBuilderValueTypeTests
 665     end
 666
 667     sub_test_case("#append_values") do
 668       include ArrayBuilderAppendValuesTests
 669     end
 670
 671     sub_test_case("#append_nulls") do
 672       include ArrayBuilderAppendNullsTests
 673     end
 674
 675     sub_test_case("#append_empty_value") do
 676       include ArrayBuilderAppendEmptyValueTests
 677     end
 678
 679     sub_test_case("#append_empty_values") do
 680       include ArrayBuilderAppendEmptyValuesTests
 681     end
 682
 683     sub_test_case("capacity control") do
 684       include ArrayBuilderCapacityControlTests
 685     end
 686
 687     sub_test_case("#length") do
 688       include ArrayBuilderLengthTests
 689     end
 690
 691     sub_test_case("#n_nulls") do
 692       include ArrayBuilderNNullsTests
 693     end
 694   end
 695
 696   sub_test_case("Int16ArrayBuilder") do
 697     def create_builder
 698       Arrow::Int16ArrayBuilder.new
 699     end
 700
 701     def value_data_type
 702       Arrow::Int16DataType.new
 703     end
 704
 705     def builder_class_name
 706       "int16-array-builder"
 707     end
 708
 709     def sample_values
 710       [1, -2, 3]
 711     end
 712
 713     def empty_value
 714       0
 715     end
 716
 717     sub_test_case("value type") do
 718       include ArrayBuilderValueTypeTests
 719     end
 720
 721     sub_test_case("#append_values") do
 722       include ArrayBuilderAppendValuesTests
 723     end
 724
 725     sub_test_case("#append_nulls") do
 726       include ArrayBuilderAppendNullsTests
 727     end
 728
 729     sub_test_case("#append_empty_value") do
 730       include ArrayBuilderAppendEmptyValueTests
 731     end
 732
 733     sub_test_case("#append_empty_values") do
 734       include ArrayBuilderAppendEmptyValuesTests
 735     end
 736
 737     sub_test_case("capacity control") do
 738       include ArrayBuilderCapacityControlTests
 739     end
 740
 741     sub_test_case("#length") do
 742       include ArrayBuilderLengthTests
 743     end
 744
 745     sub_test_case("#n_nulls") do
 746       include ArrayBuilderNNullsTests
 747     end
 748   end
 749
 750   sub_test_case("UInt16ArrayBuilder") do
 751     def create_builder
 752       Arrow::UInt16ArrayBuilder.new
 753     end
 754
 755     def value_data_type
 756       Arrow::UInt16DataType.new
 757     end
 758
 759     def builder_class_name
 760       "uint16-array-builder"
 761     end
 762
 763     def sample_values
 764       [1, 2, 3]
 765     end
 766
 767     def empty_value
 768       0
 769     end
 770
 771     sub_test_case("value type") do
 772       include ArrayBuilderValueTypeTests
 773     end
 774
 775     sub_test_case("#append_values") do
 776       include ArrayBuilderAppendValuesTests
 777     end
 778
 779     sub_test_case("#append_nulls") do
 780       include ArrayBuilderAppendNullsTests
 781     end
 782
 783     sub_test_case("#append_empty_value") do
 784       include ArrayBuilderAppendEmptyValueTests
 785     end
 786
 787     sub_test_case("#append_empty_values") do
 788       include ArrayBuilderAppendEmptyValuesTests
 789     end
 790
 791     sub_test_case("capacity control") do
 792       include ArrayBuilderCapacityControlTests
 793     end
 794
 795     sub_test_case("#length") do
 796       include ArrayBuilderLengthTests
 797     end
 798
 799     sub_test_case("#n_nulls") do
 800       include ArrayBuilderNNullsTests
 801     end
 802   end
 803
 804   sub_test_case("Int32ArrayBuilder") do
 805     def create_builder
 806       Arrow::Int32ArrayBuilder.new
 807     end
 808
 809     def value_data_type
 810       Arrow::Int32DataType.new
 811     end
 812
 813     def builder_class_name
 814       "int32-array-builder"
 815     end
 816
 817     def sample_values
 818       [1, -2, 3]
 819     end
 820
 821     def empty_value
 822       0
 823     end
 824
 825     sub_test_case("value type") do
 826       include ArrayBuilderValueTypeTests
 827     end
 828
 829     sub_test_case("#append_values") do
 830       include ArrayBuilderAppendValuesTests
 831     end
 832
 833     sub_test_case("#append_nulls") do
 834       include ArrayBuilderAppendNullsTests
 835     end
 836
 837     sub_test_case("#append_empty_value") do
 838       include ArrayBuilderAppendEmptyValueTests
 839     end
 840
 841     sub_test_case("#append_empty_values") do
 842       include ArrayBuilderAppendEmptyValuesTests
 843     end
 844
 845     sub_test_case("capacity control") do
 846       include ArrayBuilderCapacityControlTests
 847     end
 848
 849     sub_test_case("#length") do
 850       include ArrayBuilderLengthTests
 851     end
 852
 853     sub_test_case("#n_nulls") do
 854       include ArrayBuilderNNullsTests
 855     end
 856   end
 857
 858   sub_test_case("UInt32ArrayBuilder") do
 859     def create_builder
 860       Arrow::UInt32ArrayBuilder.new
 861     end
 862
 863     def value_data_type
 864       Arrow::UInt32DataType.new
 865     end
 866
 867     def builder_class_name
 868       "uint32-array-builder"
 869     end
 870
 871     def sample_values
 872       [1, 2, 3]
 873     end
 874
 875     def empty_value
 876       0
 877     end
 878
 879     sub_test_case("value type") do
 880       include ArrayBuilderValueTypeTests
 881     end
 882
 883     sub_test_case("#append_values") do
 884       include ArrayBuilderAppendValuesTests
 885     end
 886
 887     sub_test_case("#append_nulls") do
 888       include ArrayBuilderAppendNullsTests
 889     end
 890
 891     sub_test_case("#append_empty_value") do
 892       include ArrayBuilderAppendEmptyValueTests
 893     end
 894
 895     sub_test_case("#append_empty_values") do
 896       include ArrayBuilderAppendEmptyValuesTests
 897     end
 898
 899     sub_test_case("capacity control") do
 900       include ArrayBuilderCapacityControlTests
 901     end
 902
 903     sub_test_case("#length") do
 904       include ArrayBuilderLengthTests
 905     end
 906
 907     sub_test_case("#n_nulls") do
 908       include ArrayBuilderNNullsTests
 909     end
 910   end
 911
 912   sub_test_case("Int64ArrayBuilder") do
 913     def create_builder
 914       Arrow::Int64ArrayBuilder.new
 915     end
 916
 917     def value_data_type
 918       Arrow::Int64DataType.new
 919     end
 920
 921     def builder_class_name
 922       "int64-array-builder"
 923     end
 924
 925     def sample_values
 926       [1, -2, 3]
 927     end
 928
 929     def empty_value
 930       0
 931     end
 932
 933     sub_test_case("value type") do
 934       include ArrayBuilderValueTypeTests
 935     end
 936
 937     sub_test_case("#append_values") do
 938       include ArrayBuilderAppendValuesTests
 939     end
 940
 941     sub_test_case("#append_nulls") do
 942       include ArrayBuilderAppendNullsTests
 943     end
 944
 945     sub_test_case("#append_empty_value") do
 946       include ArrayBuilderAppendEmptyValueTests
 947     end
 948
 949     sub_test_case("#append_empty_values") do
 950       include ArrayBuilderAppendEmptyValuesTests
 951     end
 952
 953     sub_test_case("capacity control") do
 954       include ArrayBuilderCapacityControlTests
 955     end
 956
 957     sub_test_case("#length") do
 958       include ArrayBuilderLengthTests
 959     end
 960
 961     sub_test_case("#n_nulls") do
 962       include ArrayBuilderNNullsTests
 963     end
 964   end
 965
 966   sub_test_case("UInt64ArrayBuilder") do
 967     def create_builder
 968       Arrow::UInt64ArrayBuilder.new
 969     end
 970
 971     def value_data_type
 972       Arrow::UInt64DataType.new
 973     end
 974
 975     def builder_class_name
 976       "uint64-array-builder"
 977     end
 978
 979     def sample_values
 980       [1, 2, 3]
 981     end
 982
 983     def empty_value
 984       0
 985     end
 986
 987     sub_test_case("value type") do
 988       include ArrayBuilderValueTypeTests
 989     end
 990
 991     sub_test_case("#append_values") do
 992       include ArrayBuilderAppendValuesTests
 993     end
 994
 995     sub_test_case("#append_nulls") do
 996       include ArrayBuilderAppendNullsTests
 997     end
 998
 999     sub_test_case("#append_empty_value") do
1000       include ArrayBuilderAppendEmptyValueTests
1001     end
1002
1003     sub_test_case("#append_empty_values") do
1004       include ArrayBuilderAppendEmptyValuesTests
1005     end
1006
1007     sub_test_case("capacity control") do
1008       include ArrayBuilderCapacityControlTests
1009     end
1010
1011     sub_test_case("#length") do
1012       include ArrayBuilderLengthTests
1013     end
1014
1015     sub_test_case("#n_nulls") do
1016       include ArrayBuilderNNullsTests
1017     end
1018   end
1019
1020   sub_test_case("FloatArrayBuilder") do
1021     def create_builder
1022       Arrow::FloatArrayBuilder.new
1023     end
1024
1025     def value_data_type
1026       Arrow::FloatDataType.new
1027     end
1028
1029     def builder_class_name
1030       "float-array-builder"
1031     end
1032
1033     def sample_values
1034       [1.1, -2.2, 3.3]
1035     end
1036
1037     def empty_value
1038       0.0
1039     end
1040
1041     sub_test_case("value type") do
1042       include ArrayBuilderValueTypeTests
1043     end
1044
1045     sub_test_case("#append_values") do
1046       include ArrayBuilderAppendValuesTests
1047     end
1048
1049     sub_test_case("#append_nulls") do
1050       include ArrayBuilderAppendNullsTests
1051     end
1052
1053     sub_test_case("#append_empty_value") do
1054       include ArrayBuilderAppendEmptyValueTests
1055     end
1056
1057     sub_test_case("#append_empty_values") do
1058       include ArrayBuilderAppendEmptyValuesTests
1059     end
1060
1061     sub_test_case("capacity control") do
1062       include ArrayBuilderCapacityControlTests
1063     end
1064
1065     sub_test_case("#length") do
1066       include ArrayBuilderLengthTests
1067     end
1068
1069     sub_test_case("#n_nulls") do
1070       include ArrayBuilderNNullsTests
1071     end
1072   end
1073
1074   sub_test_case("DoubleArrayBuilder") do
1075     def create_builder
1076       Arrow::DoubleArrayBuilder.new
1077     end
1078
1079     def value_data_type
1080       Arrow::DoubleDataType.new
1081     end
1082
1083     def builder_class_name
1084       "double-array-builder"
1085     end
1086
1087     def sample_values
1088       [1.1, -2.2, 3.3]
1089     end
1090
1091     def empty_value
1092       0.0
1093     end
1094
1095     sub_test_case("value type") do
1096       include ArrayBuilderValueTypeTests
1097     end
1098
1099     sub_test_case("#append_values") do
1100       include ArrayBuilderAppendValuesTests
1101     end
1102
1103     sub_test_case("#append_nulls") do
1104       include ArrayBuilderAppendNullsTests
1105     end
1106
1107     sub_test_case("#append_empty_value") do
1108       include ArrayBuilderAppendEmptyValueTests
1109     end
1110
1111     sub_test_case("#append_empty_values") do
1112       include ArrayBuilderAppendEmptyValuesTests
1113     end
1114
1115     sub_test_case("capacity control") do
1116       include ArrayBuilderCapacityControlTests
1117     end
1118
1119     sub_test_case("#length") do
1120       include ArrayBuilderLengthTests
1121     end
1122
1123     sub_test_case("#n_nulls") do
1124       include ArrayBuilderNNullsTests
1125     end
1126   end
1127
1128   sub_test_case("Date32ArrayBuilder") do
1129     def create_builder
1130       Arrow::Date32ArrayBuilder.new
1131     end
1132
1133     def value_data_type
1134       Arrow::Date32DataType.new
1135     end
1136
1137     def builder_class_name
1138       "date32-array-builder"
1139     end
1140
1141     def sample_values
1142       [
1143         0,     # epoch
1144         17406, # 2017-08-28
1145         17427, # 2017-09-18
1146       ]
1147     end
1148
1149     def empty_value
1150       0
1151     end
1152
1153     sub_test_case("value type") do
1154       include ArrayBuilderValueTypeTests
1155     end
1156
1157     sub_test_case("#append_values") do
1158       include ArrayBuilderAppendValuesTests
1159     end
1160
1161     sub_test_case("#append_nulls") do
1162       include ArrayBuilderAppendNullsTests
1163     end
1164
1165     sub_test_case("#append_empty_value") do
1166       include ArrayBuilderAppendEmptyValueTests
1167     end
1168
1169     sub_test_case("#append_empty_values") do
1170       include ArrayBuilderAppendEmptyValuesTests
1171     end
1172
1173     sub_test_case("capacity control") do
1174       include ArrayBuilderCapacityControlTests
1175     end
1176
1177     sub_test_case("#length") do
1178       include ArrayBuilderLengthTests
1179     end
1180
1181     sub_test_case("#n_nulls") do
1182       include ArrayBuilderNNullsTests
1183     end
1184   end
1185
1186   sub_test_case("Date64ArrayBuilder") do
1187     def create_builder
1188       Arrow::Date64ArrayBuilder.new
1189     end
1190
1191     def value_data_type
1192       Arrow::Date64DataType.new
1193     end
1194
1195     def builder_class_name
1196       "date64-array-builder"
1197     end
1198
1199     def sample_values
1200       [
1201         -315619200,    # 1960-01-01T00:00:00Z
1202         0,             # epoch
1203         1503878400000, # 2017-08-28T00:00:00Z
1204       ]
1205     end
1206
1207     def empty_value
1208       0
1209     end
1210
1211     sub_test_case("value type") do
1212       include ArrayBuilderValueTypeTests
1213     end
1214
1215     sub_test_case("#append_values") do
1216       include ArrayBuilderAppendValuesTests
1217     end
1218
1219     sub_test_case("#append_nulls") do
1220       include ArrayBuilderAppendNullsTests
1221     end
1222
1223     sub_test_case("#append_empty_value") do
1224       include ArrayBuilderAppendEmptyValueTests
1225     end
1226
1227     sub_test_case("#append_empty_values") do
1228       include ArrayBuilderAppendEmptyValuesTests
1229     end
1230
1231     sub_test_case("capacity control") do
1232       include ArrayBuilderCapacityControlTests
1233     end
1234
1235     sub_test_case("#length") do
1236       include ArrayBuilderLengthTests
1237     end
1238
1239     sub_test_case("#n_nulls") do
1240       include ArrayBuilderNNullsTests
1241     end
1242   end
1243
1244   sub_test_case("TimestampArrayBuilder") do
1245     def create_builder
1246       data_type = Arrow::TimestampDataType.new(:milli)
1247       Arrow::TimestampArrayBuilder.new(data_type)
1248     end
1249
1250     def value_data_type
1251       Arrow::TimestampDataType.new(:milli)
1252     end
1253
1254     def builder_class_name
1255       "timestamp-array-builder"
1256     end
1257
1258     def sample_values
1259       [
1260         0,             # epoch
1261         1504953190854, # 2017-09-09T10:33:10.854Z
1262         1505660812942, # 2017-09-17T15:06:52.942Z
1263       ]
1264     end
1265
1266     def empty_value
1267       0
1268     end
1269
1270     sub_test_case("value type") do
1271       include ArrayBuilderValueTypeTests
1272     end
1273
1274     sub_test_case("#append_values") do
1275       include ArrayBuilderAppendValuesTests
1276     end
1277
1278     sub_test_case("#append_nulls") do
1279       include ArrayBuilderAppendNullsTests
1280     end
1281
1282     sub_test_case("#append_empty_value") do
1283       include ArrayBuilderAppendEmptyValueTests
1284     end
1285
1286     sub_test_case("#append_empty_values") do
1287       include ArrayBuilderAppendEmptyValuesTests
1288     end
1289
1290     sub_test_case("capacity control") do
1291       include ArrayBuilderCapacityControlTests
1292     end
1293
1294     sub_test_case("#length") do
1295       include ArrayBuilderLengthTests
1296     end
1297
1298     sub_test_case("#n_nulls") do
1299       include ArrayBuilderNNullsTests
1300     end
1301   end
1302
1303   sub_test_case("Time32ArrayBuilder") do
1304     def create_builder
1305       data_type = Arrow::Time32DataType.new(:second)
1306       Arrow::Time32ArrayBuilder.new(data_type)
1307     end
1308
1309     def value_data_type
1310       Arrow::Time32DataType.new(:second)
1311     end
1312
1313     def builder_class_name
1314       "time32-array-builder"
1315     end
1316
1317     def sample_values
1318       [
1319         0,                # midnight
1320         60 * 10,          # 00:10:00
1321         60 * 60 * 2 + 30, # 02:00:30
1322       ]
1323     end
1324
1325     def empty_value
1326       0
1327     end
1328
1329     sub_test_case("value type") do
1330       include ArrayBuilderValueTypeTests
1331     end
1332
1333     sub_test_case("#append_values") do
1334       include ArrayBuilderAppendValuesTests
1335     end
1336
1337     sub_test_case("#append_nulls") do
1338       include ArrayBuilderAppendNullsTests
1339     end
1340
1341     sub_test_case("#append_empty_value") do
1342       include ArrayBuilderAppendEmptyValueTests
1343     end
1344
1345     sub_test_case("#append_empty_values") do
1346       include ArrayBuilderAppendEmptyValuesTests
1347     end
1348
1349     sub_test_case("capacity control") do
1350       include ArrayBuilderCapacityControlTests
1351     end
1352
1353     sub_test_case("#length") do
1354       include ArrayBuilderLengthTests
1355     end
1356
1357     sub_test_case("#n_nulls") do
1358       include ArrayBuilderNNullsTests
1359     end
1360   end
1361
1362   sub_test_case("Time64ArrayBuilder") do
1363     def create_builder
1364       data_type = Arrow::Time64DataType.new(:micro)
1365       Arrow::Time64ArrayBuilder.new(data_type)
1366     end
1367
1368     def value_data_type
1369       Arrow::Time64DataType.new(:micro)
1370     end
1371
1372     def builder_class_name
1373       "time64-array-builder"
1374     end
1375
1376     def sample_values
1377       [
1378         0,                                # midnight
1379         60 * 10 * 1000 * 1000,            # 00:10:00.000000
1380         (60 * 60 * 2 + 30) * 1000 * 1000, # 02:00:30.000000
1381       ]
1382     end
1383
1384     def empty_value
1385       0
1386     end
1387
1388     sub_test_case("value type") do
1389       include ArrayBuilderValueTypeTests
1390     end
1391
1392     sub_test_case("#append_values") do
1393       include ArrayBuilderAppendValuesTests
1394     end
1395
1396     sub_test_case("#append_nulls") do
1397       include ArrayBuilderAppendNullsTests
1398     end
1399
1400     sub_test_case("#append_empty_value") do
1401       include ArrayBuilderAppendEmptyValueTests
1402     end
1403
1404     sub_test_case("#append_empty_values") do
1405       include ArrayBuilderAppendEmptyValuesTests
1406     end
1407
1408     sub_test_case("capacity control") do
1409       include ArrayBuilderCapacityControlTests
1410     end
1411
1412     sub_test_case("#length") do
1413       include ArrayBuilderLengthTests
1414     end
1415
1416     sub_test_case("#n_nulls") do
1417       include ArrayBuilderNNullsTests
1418     end
1419   end
1420
1421   sub_test_case("BinaryArrayBuilder") do
1422     def create_builder
1423       Arrow::BinaryArrayBuilder.new
1424     end
1425
1426     def value_data_type
1427       Arrow::BinaryDataType.new
1428     end
1429
1430     def builder_class_name
1431       "binary-array-builder"
1432     end
1433
1434     def sample_values
1435       [
1436         "\x00\x01",
1437         "\xfe\xff",
1438         "",
1439       ]
1440     end
1441
1442     def empty_value
1443       ""
1444     end
1445
1446     sub_test_case("value type") do
1447       include ArrayBuilderValueTypeTests
1448     end
1449
1450     sub_test_case("#append_value_bytes") do
1451       include ArrayBuilderAppendValueBytesTests
1452     end
1453
1454     sub_test_case("#append_values") do
1455       include ArrayBuilderAppendValuesTests
1456
1457       def setup
1458         require_gi_bindings(3, 4, 1)
1459       end
1460     end
1461
1462     sub_test_case("#append_nulls") do
1463       include ArrayBuilderAppendNullsTests
1464     end
1465
1466     sub_test_case("#append_empty_value") do
1467       include ArrayBuilderAppendEmptyValueTests
1468     end
1469
1470     sub_test_case("#append_empty_values") do
1471       include ArrayBuilderAppendEmptyValuesTests
1472     end
1473
1474     sub_test_case("capacity control") do
1475       include ArrayBuilderCapacityControlTests
1476     end
1477
1478     sub_test_case("#length") do
1479       include ArrayBuilderLengthTests
1480     end
1481
1482     sub_test_case("#n_nulls") do
1483       include ArrayBuilderNNullsTests
1484     end
1485   end
1486
1487   sub_test_case("LargeBinaryArrayBuilder") do
1488     def create_builder
1489       Arrow::LargeBinaryArrayBuilder.new
1490     end
1491
1492     def value_data_type
1493       Arrow::LargeBinaryDataType.new
1494     end
1495
1496     def builder_class_name
1497       "large-binary-array-builder"
1498     end
1499
1500     def sample_values
1501       [
1502         "\x00\x01",
1503         "\xfe\xff",
1504         "",
1505       ]
1506     end
1507
1508     def empty_value
1509       ""
1510     end
1511
1512     sub_test_case("value type") do
1513       include ArrayBuilderValueTypeTests
1514     end
1515
1516     sub_test_case("#append_value_bytes") do
1517       include ArrayBuilderAppendValueBytesTests
1518     end
1519
1520     sub_test_case("#append_values") do
1521       include ArrayBuilderAppendValuesTests
1522
1523       def setup
1524         require_gi_bindings(3, 4, 1)
1525       end
1526     end
1527
1528     sub_test_case("#append_nulls") do
1529       include ArrayBuilderAppendNullsTests
1530     end
1531
1532     sub_test_case("#append_empty_value") do
1533       include ArrayBuilderAppendEmptyValueTests
1534     end
1535
1536     sub_test_case("#append_empty_values") do
1537       include ArrayBuilderAppendEmptyValuesTests
1538     end
1539
1540     sub_test_case("capacity control") do
1541       include ArrayBuilderCapacityControlTests
1542     end
1543
1544     sub_test_case("#length") do
1545       include ArrayBuilderLengthTests
1546     end
1547
1548     sub_test_case("#n_nulls") do
1549       include ArrayBuilderNNullsTests
1550     end
1551   end
1552
1553   sub_test_case("StringArrayBuilder") do
1554     def create_builder
1555       Arrow::StringArrayBuilder.new
1556     end
1557
1558     def value_data_type
1559       Arrow::StringDataType.new
1560     end
1561
1562     def builder_class_name
1563       "string-array-builder"
1564     end
1565
1566     def sample_values
1567       [
1568         "hello",
1569         "world!!",
1570         "",
1571       ]
1572     end
1573
1574     def empty_value
1575       ""
1576     end
1577
1578     sub_test_case("value type") do
1579       include ArrayBuilderValueTypeTests
1580     end
1581
1582     sub_test_case("#append_values") do
1583       include ArrayBuilderAppendValuesTests
1584
1585       def setup
1586         require_gi_bindings(3, 4, 1)
1587       end
1588
1589       def builder_class_name
1590         "binary-array-builder"
1591       end
1592     end
1593
1594     sub_test_case("#append_strings") do
1595       include ArrayBuilderAppendStringsTests
1596     end
1597
1598     sub_test_case("#append_nulls") do
1599       include ArrayBuilderAppendNullsTests
1600     end
1601
1602     sub_test_case("#append_empty_value") do
1603       include ArrayBuilderAppendEmptyValueTests
1604     end
1605
1606     sub_test_case("#append_empty_values") do
1607       include ArrayBuilderAppendEmptyValuesTests
1608     end
1609
1610     sub_test_case("capacity control") do
1611       include ArrayBuilderCapacityControlTests
1612     end
1613
1614     sub_test_case("#length") do
1615       include ArrayBuilderLengthTests
1616     end
1617
1618     sub_test_case("#n_nulls") do
1619       include ArrayBuilderNNullsTests
1620     end
1621   end
1622
1623   sub_test_case("LargeStringArrayBuilder") do
1624     def create_builder
1625       Arrow::LargeStringArrayBuilder.new
1626     end
1627
1628     def value_data_type
1629       Arrow::LargeStringDataType.new
1630     end
1631
1632     def builder_class_name
1633       "large-string-array-builder"
1634     end
1635
1636     def sample_values
1637       [
1638         "hello",
1639         "world!!",
1640         "",
1641       ]
1642     end
1643
1644     def empty_value
1645       ""
1646     end
1647
1648     sub_test_case("value type") do
1649       include ArrayBuilderValueTypeTests
1650     end
1651
1652     sub_test_case("#append_values") do
1653       include ArrayBuilderAppendValuesTests
1654
1655       def setup
1656         require_gi_bindings(3, 4, 1)
1657       end
1658
1659       def builder_class_name
1660         "large-binary-array-builder"
1661       end
1662     end
1663
1664     sub_test_case("#append_strings") do
1665       include ArrayBuilderAppendStringsTests
1666     end
1667
1668     sub_test_case("#append_nulls") do
1669       include ArrayBuilderAppendNullsTests
1670     end
1671
1672     sub_test_case("#append_empty_value") do
1673       include ArrayBuilderAppendEmptyValueTests
1674     end
1675
1676     sub_test_case("#append_empty_values") do
1677       include ArrayBuilderAppendEmptyValuesTests
1678     end
1679
1680     sub_test_case("capacity control") do
1681       include ArrayBuilderCapacityControlTests
1682     end
1683
1684     sub_test_case("#length") do
1685       include ArrayBuilderLengthTests
1686     end
1687
1688     sub_test_case("#n_nulls") do
1689       include ArrayBuilderNNullsTests
1690     end
1691   end
1692
1693   sub_test_case("FixedSizeBinaryArrayBuilder") do
1694     def create_builder
1695       Arrow::FixedSizeBinaryArrayBuilder.new(value_data_type)
1696     end
1697
1698     def value_data_type
1699       Arrow::FixedSizeBinaryDataType.new(4)
1700     end
1701
1702     def builder_class_name
1703       "fixed-size-binary-array-builder"
1704     end
1705
1706     def sample_values
1707       [
1708         "0123",
1709         "abcd",
1710         "\x0\x0\x0\x0".b,
1711       ]
1712     end
1713
1714     def sample_values_with_null
1715       [
1716         "0123",
1717         nil,
1718         "\x0\x0\x0\x0".b,
1719       ]
1720     end
1721
1722     def pack_values(values)
1723       values.join("")
1724     end
1725
1726     def empty_value
1727       "\x0\x0\x0\x0"
1728     end
1729
1730     sub_test_case("value type") do
1731       include ArrayBuilderValueTypeTests
1732     end
1733
1734     sub_test_case("#append_value") do
1735       test("nil") do
1736         builder = create_builder
1737         builder.append_value(nil)
1738         assert_equal(build_array([nil]),
1739                      builder.finish)
1740       end
1741     end
1742
1743     sub_test_case("#append_values") do
1744       include ArrayBuilderAppendValuesTests
1745       include ArrayBuilderAppendValuesWithNullTests
1746     end
1747
1748     sub_test_case("#append_values_packed") do
1749       include ArrayBuilderAppendValuesPackedTests
1750     end
1751
1752     sub_test_case("#append_nulls") do
1753       include ArrayBuilderAppendNullsTests
1754     end
1755
1756     sub_test_case("#append_empty_value") do
1757       include ArrayBuilderAppendEmptyValueTests
1758     end
1759
1760     sub_test_case("#append_empty_values") do
1761       include ArrayBuilderAppendEmptyValuesTests
1762     end
1763
1764     sub_test_case("capacity control") do
1765       include ArrayBuilderCapacityControlTests
1766     end
1767
1768     sub_test_case("#length") do
1769       include ArrayBuilderLengthTests
1770     end
1771
1772     sub_test_case("#n_nulls") do
1773       include ArrayBuilderNNullsTests
1774     end
1775   end
1776
1777   sub_test_case("Decimal128ArrayBuilder") do
1778     def create_builder
1779       Arrow::Decimal128ArrayBuilder.new(value_data_type)
1780     end
1781
1782     def value_data_type
1783       Arrow::Decimal128DataType.new(8, 2)
1784     end
1785
1786     def builder_class_name
1787       "decimal128-array-builder"
1788     end
1789
1790     def sample_values
1791       [
1792         Arrow::Decimal128.new("23423445"),
1793         Arrow::Decimal128.new("00012345"),
1794         Arrow::Decimal128.new("00000000"),
1795       ]
1796     end
1797
1798     def sample_values_with_null
1799       [
1800         Arrow::Decimal128.new("23423445"),
1801         nil,
1802         Arrow::Decimal128.new("00000000"),
1803       ]
1804     end
1805
1806     def pack_values(values)
1807       values.collect(&:to_bytes).collect(&:to_s).join("")
1808     end
1809
1810     def empty_value
1811       Arrow::Decimal128.new("0")
1812     end
1813
1814     sub_test_case("value type") do
1815       include ArrayBuilderValueTypeTests
1816     end
1817
1818     sub_test_case("#append_value") do
1819       test("nil") do
1820         builder = create_builder
1821         builder.append_value(nil)
1822         assert_equal(build_array([nil]),
1823                      builder.finish)
1824       end
1825     end
1826
1827     sub_test_case("#append_values") do
1828       include ArrayBuilderAppendValuesTests
1829       include ArrayBuilderAppendValuesWithNullTests
1830     end
1831
1832     sub_test_case("#append_values_packed") do
1833       include ArrayBuilderAppendValuesPackedTests
1834     end
1835
1836     sub_test_case("#append_nulls") do
1837       include ArrayBuilderAppendNullsTests
1838     end
1839
1840     sub_test_case("#append_empty_value") do
1841       include ArrayBuilderAppendEmptyValueTests
1842     end
1843
1844     sub_test_case("#append_empty_values") do
1845       include ArrayBuilderAppendEmptyValuesTests
1846     end
1847
1848     sub_test_case("capacity control") do
1849       include ArrayBuilderCapacityControlTests
1850     end
1851
1852     sub_test_case("#length") do
1853       include ArrayBuilderLengthTests
1854     end
1855
1856     sub_test_case("#n_nulls") do
1857       include ArrayBuilderNNullsTests
1858     end
1859   end
1860
1861   sub_test_case("Decimal256ArrayBuilder") do
1862     def create_builder
1863       Arrow::Decimal256ArrayBuilder.new(value_data_type)
1864     end
1865
1866     def value_data_type
1867       Arrow::Decimal256DataType.new(38, 2)
1868     end
1869
1870     def builder_class_name
1871       "decimal256-array-builder"
1872     end
1873
1874     def sample_values
1875       [
1876         Arrow::Decimal256.new("23423445"),
1877         Arrow::Decimal256.new("00012345"),
1878         Arrow::Decimal256.new("00000000"),
1879       ]
1880     end
1881
1882     def sample_values_with_null
1883       [
1884         Arrow::Decimal256.new("23423445"),
1885         nil,
1886         Arrow::Decimal256.new("00000000"),
1887       ]
1888     end
1889
1890     def pack_values(values)
1891       values.collect(&:to_bytes).collect(&:to_s).join("")
1892     end
1893
1894     def empty_value
1895       Arrow::Decimal256.new("0")
1896     end
1897
1898     sub_test_case("value type") do
1899       include ArrayBuilderValueTypeTests
1900     end
1901
1902     sub_test_case("#append_value") do
1903       test("nil") do
1904         builder = create_builder
1905         builder.append_value(nil)
1906         assert_equal(build_array([nil]),
1907                      builder.finish)
1908       end
1909     end
1910
1911     sub_test_case("#append_values") do
1912       include ArrayBuilderAppendValuesTests
1913       include ArrayBuilderAppendValuesWithNullTests
1914     end
1915
1916     sub_test_case("#append_values_packed") do
1917       include ArrayBuilderAppendValuesPackedTests
1918     end
1919
1920     sub_test_case("#append_nulls") do
1921       include ArrayBuilderAppendNullsTests
1922     end
1923
1924     sub_test_case("#append_empty_value") do
1925       include ArrayBuilderAppendEmptyValueTests
1926     end
1927
1928     sub_test_case("#append_empty_values") do
1929       include ArrayBuilderAppendEmptyValuesTests
1930     end
1931
1932     sub_test_case("capacity control") do
1933       include ArrayBuilderCapacityControlTests
1934     end
1935
1936     sub_test_case("#length") do
1937       include ArrayBuilderLengthTests
1938     end
1939
1940     sub_test_case("#n_nulls") do
1941       include ArrayBuilderNNullsTests
1942     end
1943   end
1944 end