red-arrow 18.1.0 → 19.0.1

data/test/test-float-scalar.rb

@@ -1,46 +0,0 @@
-# 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
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-class FloatScalarTest < Test::Unit::TestCase
-  sub_test_case("#equal_scalar?") do
-    test("no options") do
-      scalar1 = Arrow::FloatScalar.new(1.1)
-      scalar2 = Arrow::FloatScalar.new(1.1000001)
-      assert do
-        not scalar1.equal_scalar?(scalar2)
-      end
-    end
-
-    test(":approx") do
-      scalar1 = Arrow::FloatScalar.new(1.1)
-      scalar2 = Arrow::FloatScalar.new(1.1000001)
-      assert do
-        scalar1.equal_scalar?(scalar2, approx: true)
-      end
-    end
-
-    test(":absolute_tolerance") do
-      scalar1 = Arrow::FloatScalar.new(1.1)
-      scalar2 = Arrow::FloatScalar.new(1.1001)
-      assert do
-        scalar1.equal_scalar?(scalar2,
-                              approx: true,
-                              absolute_tolerance: 0.001)
-      end
-    end
-  end
-end

data/test/test-function.rb

@@ -1,210 +0,0 @@
-# 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
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-class FunctionTest < Test::Unit::TestCase
-  sub_test_case("#execute") do
-    test("Arrow::Array") do
-      or_function = Arrow::Function.find("or")
-      args = [
-        Arrow::BooleanArray.new([true, false, false]),
-        Arrow::BooleanArray.new([true, false, true]),
-      ]
-      assert_equal([true, false, true],
-                   or_function.execute(args).value.to_a)
-    end
-
-    test("Array") do
-      or_function = Arrow::Function.find("or")
-      args = [
-        [true, false, false],
-        [true, false, true],
-      ]
-      assert_equal([true, false, true],
-                   or_function.execute(args).value.to_a)
-    end
-
-    test("Arrow::ChunkedArray") do
-      or_function = Arrow::Function.find("or")
-      args = [
-        Arrow::ChunkedArray.new([
-                                  Arrow::BooleanArray.new([true]),
-                                  Arrow::BooleanArray.new([false, false]),
-                                ]),
-        Arrow::ChunkedArray.new([
-                                  Arrow::BooleanArray.new([true, false]),
-                                  Arrow::BooleanArray.new([true]),
-                                ]),
-      ]
-      assert_equal([true, false, true],
-                   or_function.execute(args).value.to_a)
-    end
-
-    test("Arrow::Column") do
-      or_function = Arrow::Function.find("or")
-      table = Arrow::Table.new(a: [true, false, false],
-                               b: [true, false, true])
-      assert_equal([true, false, true],
-                   or_function.execute([table.a, table.b]).value.to_a)
-    end
-
-    test("Arrow::Scalar") do
-      add_function = Arrow::Function.find("add")
-      args = [
-        Arrow::Int8Array.new([1, 2, 3]),
-        Arrow::Int8Scalar.new(5),
-      ]
-      assert_equal([6, 7, 8],
-                   add_function.execute(args).value.to_a)
-    end
-
-    test("Integer") do
-      add_function = Arrow::Function.find("add")
-      args = [
-        [1, 2, 3],
-        5,
-      ]
-      assert_equal([6, 7, 8],
-                   add_function.execute(args).value.to_a)
-    end
-
-    test("Float") do
-      add_function = Arrow::Function.find("add")
-      args = [
-        [1, 2, 3],
-        5.1,
-      ]
-      assert_equal([6.1, 7.1, 8.1],
-                   add_function.execute(args).value.to_a)
-    end
-
-    test("true") do
-      and_function = Arrow::Function.find("and")
-      args = [
-        Arrow::BooleanArray.new([true, false, false]),
-        true,
-      ]
-      assert_equal([true, false, false],
-                   and_function.execute(args).value.to_a)
-    end
-
-    test("false") do
-      or_function = Arrow::Function.find("or")
-      args = [
-        Arrow::BooleanArray.new([true, false, false]),
-        false,
-      ]
-      assert_equal([true, false, false],
-                   or_function.execute(args).value.to_a)
-    end
-
-    test("String") do
-      ascii_upper_function = Arrow::Function.find("ascii_upper")
-      args = [
-        "Hello",
-      ]
-      assert_equal("HELLO",
-                   ascii_upper_function.execute(args).value.to_s)
-    end
-
-    test("Date") do
-      cast_function = Arrow::Function.find("cast")
-      date = Date.new(2021, 6, 12)
-      args = [date]
-      options = {
-        to_data_type: Arrow::TimestampDataType.new(:second),
-      }
-      time = Time.utc(date.year,
-                      date.month,
-                      date.day)
-      assert_equal(Arrow::TimestampScalar.new(options[:to_data_type],
-                                              time.to_i),
-                   cast_function.execute(args, options).value)
-    end
-
-    test("Arrow::Time: second") do
-      cast_function = Arrow::Function.find("cast")
-      arrow_time = Arrow::Time.new(Arrow::TimeUnit::SECOND,
-                                   # 00:10:00
-                                   60 * 10)
-      args = [arrow_time]
-      options = {
-        to_data_type: Arrow::Time64DataType.new(:micro),
-      }
-      assert_equal(Arrow::Time64Scalar.new(options[:to_data_type],
-                                           # 00:10:00.000000
-                                           60 * 10 * 1000 * 1000),
-                   cast_function.execute(args, options).value)
-    end
-
-    test("Arrow::Time: micro") do
-      cast_function = Arrow::Function.find("cast")
-      arrow_time = Arrow::Time.new(Arrow::TimeUnit::MICRO,
-                                   # 00:10:00.000000
-                                   60 * 10 * 1000 * 1000)
-      args = [arrow_time]
-      options = {
-        to_data_type: Arrow::Time32DataType.new(:second),
-        allow_time_truncate: true,
-      }
-      assert_equal(Arrow::Time32Scalar.new(options[:to_data_type],
-                                           # 00:10:00
-                                           60 * 10),
-                   cast_function.execute(args, options).value)
-    end
-
-    test("Time") do
-      cast_function = Arrow::Function.find("cast")
-      time = Time.utc(2021, 6, 12, 1, 2, 3, 1)
-      args = [time]
-      options = {
-        to_data_type: Arrow::TimestampDataType.new(:second),
-        allow_time_truncate: true,
-      }
-      time = Time.utc(time.year,
-                      time.month,
-                      time.day,
-                      time.hour,
-                      time.min,
-                      time.sec)
-      assert_equal(Arrow::TimestampScalar.new(options[:to_data_type],
-                                              time.to_i),
-                   cast_function.execute(args, options).value)
-    end
-
-    test("SetLookupOptions") do
-      is_in_function = Arrow::Function.find("is_in")
-      args = [
-        Arrow::Int16Array.new([1, 0, 1, 2]),
-      ]
-      options = {
-        value_set: Arrow::Int16Array.new([2, 0]),
-      }
-      assert_equal(Arrow::BooleanArray.new([false, true, false, true]),
-                   is_in_function.execute(args, options).value)
-    end
-  end
-
-  def test_call
-    or_function = Arrow::Function.find("or")
-    args = [
-      Arrow::BooleanArray.new([true, false, false]),
-      Arrow::BooleanArray.new([true, false, true]),
-    ]
-    assert_equal([true, false, true],
-                 or_function.call(args).value.to_a)
-  end
-end

data/test/test-group.rb

@@ -1,193 +0,0 @@
-# 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
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-class GroupTest < Test::Unit::TestCase
-  include Helper::Fixture
-
-  def setup
-    raw_table = {
-      :group_key1 => Arrow::UInt8Array.new([1, 1, 2, 3, 3, 3]),
-      :group_key2 => Arrow::UInt8Array.new([1, 1, 1, 1, 2, 2]),
-      :int => Arrow::Int32Array.new([-1, -2, nil, -4, -5, -6]),
-      :uint => Arrow::UInt32Array.new([1, nil, 3, 4, 5, 6]),
-      :float => Arrow::FloatArray.new([nil, 2.2, 3.3, 4.4, 5.5, 6.6]),
-      :string => Arrow::StringArray.new(["a", "b", "c", nil, "e", "f"]),
-    }
-    @table = Arrow::Table.new(raw_table)
-  end
-
-  sub_test_case("key") do
-    test("Time") do
-      time_values = [
-        Time.parse("2018-01-29"),
-        Time.parse("2018-01-30"),
-      ]
-      raw_table = {
-        :time => Arrow::ArrayBuilder.build(time_values),
-        :int => Arrow::Int32Array.new([-1, -2]),
-      }
-      table = Arrow::Table.new(raw_table)
-      assert_equal(<<-TABLE, table.group(:time).count.to_s)
-	                     time	count(int)
-	              (timestamp)	   (int64)
-0	#{time_values[0].iso8601}	         1
-1	#{time_values[1].iso8601}	         1
-      TABLE
-    end
-  end
-
-  sub_test_case("#count") do
-    test("single") do
-      assert_equal(<<-TABLE, @table.group(:group_key1).count.to_s)
-	group_key1	count(group_key2)	count(int)	count(uint)	count(float)	count(string)
-	   (uint8)	          (int64)	   (int64)	    (int64)	     (int64)	      (int64)
-0	         1	                2	         2	          1	           1	            2
-1	         2	                1	         0	          1	           1	            1
-2	         3	                3	         3	          3	           3	            2
-      TABLE
-    end
-
-    test("multiple") do
-      assert_equal(<<-TABLE, @table.group(:group_key1, :group_key2).count.to_s)
-	group_key1	group_key2	count(int)	count(uint)	count(float)	count(string)
-	   (uint8)	   (uint8)	   (int64)	    (int64)	     (int64)	      (int64)
-0	         1	         1	         2	          1	           1	            2
-1	         2	         1	         0	          1	           1	            1
-2	         3	         1	         1	          1	           1	            0
-3	         3	         2	         2	          2	           2	            2
-      TABLE
-    end
-
-    test("column") do
-      group = @table.group(:group_key1, :group_key2)
-      assert_equal(<<-TABLE, group.count(:int, :uint).to_s)
-	group_key1	group_key2	count(int)	count(uint)
-	   (uint8)	   (uint8)	   (int64)	    (int64)
-0	         1	         1	         2	          1
-1	         2	         1	         0	          1
-2	         3	         1	         1	          1
-3	         3	         2	         2	          2
-      TABLE
-    end
-  end
-
-  sub_test_case("#sum") do
-    test("single") do
-      assert_equal(<<-TABLE, @table.group(:group_key1).sum.to_s)
-	group_key1	sum(group_key2)	sum(int)	sum(uint)	sum(float)
-	   (uint8)	       (uint64)	 (int64)	 (uint64)	  (double)
-0	         1	              2	      -3	        1	  2.200000
-1	         2	              1	  (null)	        3	  3.300000
-2	         3	              5	     -15	       15	 16.500000
-      TABLE
-    end
-
-    test("multiple") do
-      assert_equal(<<-TABLE, @table.group(:group_key1, :group_key2).sum.to_s)
-	group_key1	group_key2	sum(int)	sum(uint)	sum(float)
-	   (uint8)	   (uint8)	 (int64)	 (uint64)	  (double)
-0	         1	         1	      -3	        1	  2.200000
-1	         2	         1	  (null)	        3	  3.300000
-2	         3	         1	      -4	        4	  4.400000
-3	         3	         2	     -11	       11	 12.100000
-      TABLE
-    end
-  end
-
-  sub_test_case("#mean") do
-    test("single") do
-      assert_equal(<<-TABLE, @table.group(:group_key1).mean.to_s)
-	group_key1	mean(group_key2)	 mean(int)	mean(uint)	mean(float)
-	   (uint8)	        (double)	  (double)	  (double)	   (double)
-0	         1	        1.000000	 -1.500000	  1.000000	   2.200000
-1	         2	        1.000000	    (null)	  3.000000	   3.300000
-2	         3	        1.666667	 -5.000000	  5.000000	   5.500000
-      TABLE
-    end
-
-    test("multiple") do
-      assert_equal(<<-TABLE, @table.group(:group_key1, :group_key2).mean.to_s)
-	group_key1	group_key2	 mean(int)	mean(uint)	mean(float)
-	   (uint8)	   (uint8)	  (double)	  (double)	   (double)
-0	         1	         1	 -1.500000	  1.000000	   2.200000
-1	         2	         1	    (null)	  3.000000	   3.300000
-2	         3	         1	 -4.000000	  4.000000	   4.400000
-3	         3	         2	 -5.500000	  5.500000	   6.050000
-      TABLE
-    end
-  end
-
-  sub_test_case("#min") do
-    test("single") do
-      assert_equal(<<-TABLE, @table.group(:group_key1).min.to_s)
-	group_key1	min(group_key2)	min(int)	min(uint)	min(float)
-	   (uint8)	        (uint8)	 (int32)	 (uint32)	   (float)
-0	         1	              1	      -2	        1	  2.200000
-1	         2	              1	  (null)	        3	  3.300000
-2	         3	              1	      -6	        4	  4.400000
-      TABLE
-    end
-
-    test("multiple") do
-      assert_equal(<<-TABLE, @table.group(:group_key1, :group_key2).min.to_s)
-	group_key1	group_key2	min(int)	min(uint)	min(float)
-	   (uint8)	   (uint8)	 (int32)	 (uint32)	   (float)
-0	         1	         1	      -2	        1	  2.200000
-1	         2	         1	  (null)	        3	  3.300000
-2	         3	         1	      -4	        4	  4.400000
-3	         3	         2	      -6	        5	  5.500000
-      TABLE
-    end
-  end
-
-  sub_test_case("#max") do
-    test("single") do
-      assert_equal(<<-TABLE, @table.group(:group_key1).max.to_s)
-	group_key1	max(group_key2)	max(int)	max(uint)	max(float)
-	   (uint8)	        (uint8)	 (int32)	 (uint32)	   (float)
-0	         1	              1	      -1	        1	  2.200000
-1	         2	              1	  (null)	        3	  3.300000
-2	         3	              2	      -4	        6	  6.600000
-      TABLE
-    end
-
-    test("multiple") do
-      assert_equal(<<-TABLE, @table.group(:group_key1, :group_key2).max.to_s)
-	group_key1	group_key2	max(int)	max(uint)	max(float)
-	   (uint8)	   (uint8)	 (int32)	 (uint32)	   (float)
-0	         1	         1	      -1	        1	  2.200000
-1	         2	         1	  (null)	        3	  3.300000
-2	         3	         1	      -4	        4	  4.400000
-3	         3	         2	      -5	        6	  6.600000
-      TABLE
-    end
-  end
-
-  sub_test_case("#aggregate") do
-    test("function()") do
-      group = @table.group(:group_key1, :group_key2)
-      assert_equal(<<-TABLE, group.aggregate("count(int)", "sum(uint)").to_s)
-	group_key1	group_key2	count(int)	sum(uint)
-	   (uint8)	   (uint8)	   (int64)	 (uint64)
-0	         1	         1	         2	        1
-1	         2	         1	         0	        3
-2	         3	         1	         1	        4
-3	         3	         2	         2	       11
-      TABLE
-    end
-  end
-end

data/test/test-half-float-array.rb

@@ -1,43 +0,0 @@
-# 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
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-class HalfFloatArrayTest < Test::Unit::TestCase
-  sub_test_case(".new") do
-    test("Float") do
-      array = Arrow::HalfFloatArray.new([1.5])
-      assert_equal([1.5], array.to_a)
-    end
-
-    test("Integer") do
-      one_half = Arrow::HalfFloat.new(1.5)
-      array = Arrow::HalfFloatArray.new([one_half.to_uint16])
-      assert_equal([one_half.to_f], array.to_a)
-    end
-
-    test("HalfFloat") do
-      one_half = Arrow::HalfFloat.new(1.5)
-      array = Arrow::HalfFloatArray.new([one_half])
-      assert_equal([one_half.to_f], array.to_a)
-    end
-  end
-
-  test("#[]") do
-    one_half = Arrow::HalfFloat.new(1.5)
-    array = Arrow::HalfFloatArray.new([one_half.to_uint16])
-    assert_equal(one_half.to_f, array[0])
-  end
-end

data/test/test-half-float.rb

@@ -1,130 +0,0 @@
-# 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
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-class HalfFloatTest < Test::Unit::TestCase
-  sub_test_case(".new") do
-    test("Array") do
-      positive_infinity = Arrow::HalfFloat.new(0b1, 0b11111, 0b0000000000)
-      assert_equal([0b1, 0b11111, 0b0000000000],
-                   [
-                     positive_infinity.sign,
-                     positive_infinity.exponent,
-                     positive_infinity.fraction,
-                   ])
-    end
-
-    test("Integer - 0") do
-      zero = Arrow::HalfFloat.new(0)
-      assert_equal([0b0, 0b00000, 0b0000000000],
-                   [
-                     zero.sign,
-                     zero.exponent,
-                     zero.fraction,
-                   ])
-    end
-
-    test("Integer - +infinity") do
-      positive_infinity = Arrow::HalfFloat.new(0x7c00)
-      assert_equal([0b0, 0b11111, 0b0000000000],
-                   [
-                     positive_infinity.sign,
-                     positive_infinity.exponent,
-                     positive_infinity.fraction,
-                   ])
-    end
-
-    test("Integer - -infinity") do
-      negative_infinity = Arrow::HalfFloat.new(0xfc00)
-      assert_equal([0b1, 0b11111, 0b0000000000],
-                   [
-                     negative_infinity.sign,
-                     negative_infinity.exponent,
-                     negative_infinity.fraction,
-                   ])
-    end
-
-    test("Integer - 1/3") do
-      one_thirds = Arrow::HalfFloat.new(0x3555)
-      assert_equal([0b0, 0b01101, 0b0101010101],
-                   [
-                     one_thirds.sign,
-                     one_thirds.exponent,
-                     one_thirds.fraction,
-                   ])
-    end
-
-    test("Float - 0") do
-      zero = Arrow::HalfFloat.new(0.0)
-      assert_equal([0b0, 0b00000, 0b0000000000],
-                   [
-                     zero.sign,
-                     zero.exponent,
-                     zero.fraction,
-                   ])
-    end
-
-    test("Float - too large") do
-      positive_infinity = Arrow::HalfFloat.new(65504.1)
-      assert_equal([0b0, 0b11111, 0b0000000000],
-                   [
-                     positive_infinity.sign,
-                     positive_infinity.exponent,
-                     positive_infinity.fraction,
-                   ])
-    end
-
-    test("Float - +infinity") do
-      positive_infinity = Arrow::HalfFloat.new(Float::INFINITY)
-      assert_equal([0b0, 0b11111, 0b0000000000],
-                   [
-                     positive_infinity.sign,
-                     positive_infinity.exponent,
-                     positive_infinity.fraction,
-                   ])
-    end
-
-    test("Float - too small") do
-      negative_infinity = Arrow::HalfFloat.new(-65504.1)
-      assert_equal([0b1, 0b11111, 0b0000000000],
-                   [
-                     negative_infinity.sign,
-                     negative_infinity.exponent,
-                     negative_infinity.fraction,
-                   ])
-    end
-
-    test("Float - -infinity") do
-      negative_infinity = Arrow::HalfFloat.new(-Float::INFINITY)
-      assert_equal([0b1, 0b11111, 0b0000000000],
-                   [
-                     negative_infinity.sign,
-                     negative_infinity.exponent,
-                     negative_infinity.fraction,
-                   ])
-    end
-
-    test("Float - 1/3") do
-      one_thirds = Arrow::HalfFloat.new((2 ** -2) * (1 + 341 / 1024.0))
-      assert_equal([0b0, 0b01101, 0b0101010101],
-                   [
-                     one_thirds.sign,
-                     one_thirds.exponent,
-                     one_thirds.fraction,
-                   ])
-    end
-  end
-end

data/test/test-list-array-builder.rb

@@ -1,79 +0,0 @@
-# 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
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-class ListArrayBuilderTest < Test::Unit::TestCase
-  def setup
-    @data_type = Arrow::ListDataType.new(name: "visible", type: :boolean)
-    @builder = Arrow::ListArrayBuilder.new(@data_type)
-  end
-
-  sub_test_case("#append_value") do
-    test("nil") do
-      @builder.append_value(nil)
-      array = @builder.finish
-      assert_equal(nil, array[0])
-    end
-
-    test("Array") do
-      @builder.append_value([true, false, true])
-      array = @builder.finish
-      assert_equal([true, false, true], array[0].to_a)
-    end
-  end
-
-  sub_test_case("#append_values") do
-    test("[nil, Array]") do
-      @builder.append_values([[false], nil, [true, false, true]])
-      array = @builder.finish
-      assert_equal([
-                     [false],
-                     nil,
-                     [true, false, true],
-                   ],
-                   array.collect {|list| list ? list.to_a : nil})
-    end
-
-    test("is_valids") do
-      @builder.append_values([[false], [true, true], [true, false, true]],
-                             [true, false, true])
-      array = @builder.finish
-      assert_equal([
-                     [false],
-                     nil,
-                     [true, false, true],
-                   ],
-                   array.collect {|list| list ? list.to_a : nil})
-    end
-  end
-
-  sub_test_case("#append") do
-    test("backward compatibility") do
-      @builder.append
-      @builder.value_builder.append(true)
-      @builder.value_builder.append(false)
-      @builder.append
-      @builder.value_builder.append(true)
-      array = @builder.finish
-
-      assert_equal([
-                     [true, false],
-                     [true],
-                   ],
-                   array.collect(&:to_a))
-    end
-  end
-end