red-arrow 8.0.0 → 24.0.0

data/test/test-slicer.rb

@@ -1,487 +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 SlicerTest < Test::Unit::TestCase
-  def setup
-    @count_field = Arrow::Field.new("count", :uint32)
-    @visible_field = Arrow::Field.new("visible", :boolean)
-    schema = Arrow::Schema.new([@count_field, @visible_field])
-    count_arrays = [
-      Arrow::UInt32Array.new([0, 1, 2]),
-      Arrow::UInt32Array.new([4, 8, 16]),
-      Arrow::UInt32Array.new([32, 64, nil]),
-      Arrow::UInt32Array.new([256]),
-    ]
-    visible_arrays = [
-      Arrow::BooleanArray.new([nil, true, false, nil]),
-      Arrow::BooleanArray.new([true]),
-      Arrow::BooleanArray.new([true, false]),
-      Arrow::BooleanArray.new([nil]),
-      Arrow::BooleanArray.new([nil]),
-      Arrow::BooleanArray.new([true]),
-    ]
-    @count_array = Arrow::ChunkedArray.new(count_arrays)
-    @visible_array = Arrow::ChunkedArray.new(visible_arrays)
-    @table = Arrow::Table.new(schema, [@count_array, @visible_array])
-  end
-
-  sub_test_case("column") do
-    test("BooleanArray") do
-      sliced_table = @table.slice do |slicer|
-        slicer.visible
-      end
-      assert_equal(<<-TABLE, sliced_table.to_s)
-	 count	visible
-0	(null)	 (null)
-1	     1	true   
-2	(null)	 (null)
-3	     8	true   
-4	    16	true   
-5	(null)	 (null)
-6	(null)	 (null)
-7	   256	true   
-      TABLE
-    end
-
-    test("not BooleanArray") do
-      sliced_table = @table.slice do |slicer|
-        slicer.count
-      end
-      assert_equal(<<-TABLE, sliced_table.to_s)
-	 count	visible
-0	     1	true   
-1	     2	false  
-2	     4	 (null)
-3	     8	true   
-4	    16	true   
-5	    32	false  
-6	    64	 (null)
-7	(null)	 (null)
-8	   256	true   
-      TABLE
-    end
-  end
-
-  sub_test_case("!column") do
-    test("BooleanArray") do
-      sliced_table = @table.slice do |slicer|
-        !slicer.visible
-      end
-      assert_equal(<<-TABLE, sliced_table.to_s)
-	 count	visible
-0	(null)	 (null)
-1	     2	false  
-2	(null)	 (null)
-3	    32	false  
-4	(null)	 (null)
-5	(null)	 (null)
-      TABLE
-    end
-
-    test("not BooleanArray") do
-      sliced_table = @table.slice do |slicer|
-        !slicer.count
-      end
-      assert_equal(<<-TABLE, sliced_table.to_s)
-	 count	visible
-0	     0	 (null)
-1	(null)	 (null)
-      TABLE
-    end
-  end
-
-  test("column.null?") do
-    sliced_table = @table.slice do |slicer|
-      slicer.visible.null?
-    end
-    assert_equal(<<-TABLE, sliced_table.to_s)
-	 count	visible
-0	     0	 (null)
-1	     4	 (null)
-2	    64	 (null)
-3	(null)	 (null)
-    TABLE
-  end
-
-  test("column.valid?") do
-    sliced_table = @table.slice do |slicer|
-      slicer.visible.valid?
-    end
-    assert_equal(<<-TABLE, sliced_table.to_s)
-	count	visible
-0	    1	true   
-1	    2	false  
-2	    8	true   
-3	   16	true   
-4	   32	false  
-5	  256	true   
-    TABLE
-  end
-
-  sub_test_case("column ==") do
-    test("nil") do
-      sliced_table = @table.slice do |slicer|
-        slicer.visible == nil
-      end
-      assert_equal(<<-TABLE, sliced_table.to_s)
-	 count	visible
-0	     0	 (null)
-1	     4	 (null)
-2	    64	 (null)
-3	(null)	 (null)
-      TABLE
-    end
-
-    test("value") do
-      sliced_table = @table.slice do |slicer|
-        slicer.visible == true
-      end
-      assert_equal(<<-TABLE, sliced_table.to_s)
-	 count	visible
-0	(null)	 (null)
-1	     1	true   
-2	(null)	 (null)
-3	     8	true   
-4	    16	true   
-5	(null)	 (null)
-6	(null)	 (null)
-7	   256	true   
-      TABLE
-    end
-  end
-
-  sub_test_case("!(column ==)") do
-    test("nil") do
-      sliced_table = @table.slice do |slicer|
-        !(slicer.visible == nil)
-      end
-      assert_equal(<<-TABLE, sliced_table.to_s)
-	count	visible
-0	    1	true   
-1	    2	false  
-2	    8	true   
-3	   16	true   
-4	   32	false  
-5	  256	true   
-      TABLE
-    end
-
-    test("value") do
-      sliced_table = @table.slice do |slicer|
-        !(slicer.visible == true)
-      end
-      assert_equal(<<-TABLE, sliced_table.to_s)
-	 count	visible
-0	(null)	 (null)
-1	     2	false  
-2	(null)	 (null)
-3	    32	false  
-4	(null)	 (null)
-5	(null)	 (null)
-      TABLE
-    end
-  end
-
-  sub_test_case("column !=") do
-    test("nil") do
-      sliced_table = @table.slice do |slicer|
-        slicer.visible != nil
-      end
-      assert_equal(<<-TABLE, sliced_table.to_s)
-	count	visible
-0	    1	true   
-1	    2	false  
-2	    8	true   
-3	   16	true   
-4	   32	false  
-5	  256	true   
-      TABLE
-    end
-
-    test("value") do
-      sliced_table = @table.slice do |slicer|
-        slicer.visible != true
-      end
-      assert_equal(<<-TABLE, sliced_table.to_s)
-	 count	visible
-0	(null)	 (null)
-1	     2	false  
-2	(null)	 (null)
-3	    32	false  
-4	(null)	 (null)
-5	(null)	 (null)
-      TABLE
-    end
-  end
-
-  test("column < value") do
-    sliced_table = @table.slice do |slicer|
-      slicer.count < 16
-    end
-    assert_equal(<<-TABLE, sliced_table.to_s)
-	 count	visible
-0	     0	 (null)
-1	     1	true   
-2	     2	false  
-3	     4	 (null)
-4	     8	true   
-5	(null)	 (null)
-    TABLE
-  end
-
-  test("!(column < value)") do
-    sliced_table = @table.slice do |slicer|
-      !(slicer.count < 16)
-    end
-    assert_equal(<<-TABLE, sliced_table.to_s)
-	 count	visible
-0	    16	true   
-1	    32	false  
-2	    64	 (null)
-3	(null)	 (null)
-4	   256	true   
-    TABLE
-  end
-
-  test("column <= value") do
-    sliced_table = @table.slice do |slicer|
-      slicer.count <= 16
-    end
-    assert_equal(<<-TABLE, sliced_table.to_s)
-	 count	visible
-0	     0	 (null)
-1	     1	true   
-2	     2	false  
-3	     4	 (null)
-4	     8	true   
-5	    16	true   
-6	(null)	 (null)
-    TABLE
-  end
-
-  test("!(column <= value)") do
-    sliced_table = @table.slice do |slicer|
-      !(slicer.count <= 16)
-    end
-    assert_equal(<<-TABLE, sliced_table.to_s)
-	 count	visible
-0	    32	false  
-1	    64	 (null)
-2	(null)	 (null)
-3	   256	true   
-    TABLE
-  end
-
-  test("column > value") do
-    sliced_table = @table.slice do |slicer|
-      slicer.count > 16
-    end
-    assert_equal(<<-TABLE, sliced_table.to_s)
-	 count	visible
-0	    32	false  
-1	    64	 (null)
-2	(null)	 (null)
-3	   256	true   
-    TABLE
-  end
-
-  test("!(column > value)") do
-    sliced_table = @table.slice do |slicer|
-      !(slicer.count > 16)
-    end
-    assert_equal(<<-TABLE, sliced_table.to_s)
-	 count	visible
-0	     0	 (null)
-1	     1	true   
-2	     2	false  
-3	     4	 (null)
-4	     8	true   
-5	    16	true   
-6	(null)	 (null)
-    TABLE
-  end
-
-  test("column >= value") do
-    sliced_table = @table.slice do |slicer|
-      slicer.count >= 16
-    end
-    assert_equal(<<-TABLE, sliced_table.to_s)
-	 count	visible
-0	    16	true   
-1	    32	false  
-2	    64	 (null)
-3	(null)	 (null)
-4	   256	true   
-    TABLE
-  end
-
-  test("!(column >= value)") do
-    sliced_table = @table.slice do |slicer|
-      !(slicer.count >= 16)
-    end
-    assert_equal(<<-TABLE, sliced_table.to_s)
-	 count	visible
-0	     0	 (null)
-1	     1	true   
-2	     2	false  
-3	     4	 (null)
-4	     8	true   
-5	(null)	 (null)
-    TABLE
-  end
-
-  test("column.in") do
-    sliced_table = @table.slice do |slicer|
-      slicer.count.in?([1, 4, 16, 64])
-    end
-    assert_equal(<<-TABLE, sliced_table.to_s)
-	count	visible
-0	    1	true   
-1	    4	 (null)
-2	   16	true   
-3	   64	 (null)
-    TABLE
-  end
-
-  test("!column.in") do
-    sliced_table = @table.slice do |slicer|
-      !slicer.count.in?([1, 4, 16, 64])
-    end
-    assert_equal(<<-TABLE, sliced_table.to_s)
-	 count	visible
-0	     0	 (null)
-1	     2	false  
-2	     8	true   
-3	    32	false  
-4	(null)	 (null)
-5	   256	true   
-    TABLE
-  end
-
-  test("condition & condition") do
-    sliced_table = @table.slice do |slicer|
-      slicer.visible & (slicer.count >= 16)
-    end
-    assert_equal(<<-TABLE, sliced_table.to_s)
-	 count	visible
-0	(null)	 (null)
-1	(null)	 (null)
-2	    16	true   
-3	(null)	 (null)
-4	(null)	 (null)
-5	   256	true   
-    TABLE
-  end
-
-  test("condition | condition") do
-    sliced_table = @table.slice do |slicer|
-      slicer.visible | (slicer.count >= 16)
-    end
-    assert_equal(<<-TABLE, sliced_table.to_s)
-	 count	visible
-0	(null)	 (null)
-1	     1	true   
-2	(null)	 (null)
-3	     8	true   
-4	    16	true   
-5	    32	false  
-6	(null)	 (null)
-7	(null)	 (null)
-8	   256	true   
-    TABLE
-  end
-
-  test("condition ^ condition") do
-    sliced_table = @table.slice do |slicer|
-      slicer.visible ^ (slicer.count >= 16)
-    end
-    assert_equal(<<-TABLE, sliced_table.to_s)
-	 count	visible
-0	(null)	 (null)
-1	     1	true   
-2	(null)	 (null)
-3	     8	true   
-4	    32	false  
-5	(null)	 (null)
-6	(null)	 (null)
-    TABLE
-  end
-
-  test("select") do
-    sliced_table = @table.slice do |slicer|
-      slicer.visible.select do |value|
-        value.nil? or value
-      end
-    end
-    assert_equal(<<-TABLE, sliced_table.to_s)
-	 count	visible
-0	     0	 (null)
-1	     1	true   
-2	     4	 (null)
-3	     8	true   
-4	    16	true   
-5	    64	 (null)
-6	(null)	 (null)
-7	   256	true   
-    TABLE
-  end
-
-  test("!select") do
-    sliced_table = @table.slice do |slicer|
-      !slicer.visible.select do |value|
-        value.nil? or value
-      end
-    end
-    assert_equal(<<-TABLE, sliced_table.to_s)
-	count	visible
-0	    2	false  
-1	   32	false  
-    TABLE
-  end
-
-  test("reject") do
-    sliced_table = @table.slice do |slicer|
-      slicer.visible.reject do |value|
-        value.nil? or value
-      end
-    end
-    assert_equal(<<-TABLE, sliced_table.to_s)
-	count	visible
-0	    2	false  
-1	   32	false  
-    TABLE
-  end
-
-  test("!reject") do
-    sliced_table = @table.slice do |slicer|
-      !slicer.visible.reject do |value|
-        value.nil? or value
-      end
-    end
-    assert_equal(<<-TABLE, sliced_table.to_s)
-	 count	visible
-0	     0	 (null)
-1	     1	true   
-2	     4	 (null)
-3	     8	true   
-4	    16	true   
-5	    64	 (null)
-6	(null)	 (null)
-7	   256	true   
-    TABLE
-  end
-end

data/test/test-sort-indices.rb

@@ -1,40 +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 SortIndicesTest < Test::Unit::TestCase
-  def setup
-    @table = Arrow::Table.new(number1: [16, -1,   2, 32, -4, -4, -8],
-                              number2: [32,  2, -16,  8,  1,  4,  1])
-  end
-
-  sub_test_case("Table") do
-    test("Symbol") do
-      assert_equal(Arrow::UInt64Array.new([6, 4, 5, 1, 2, 0, 3]),
-                   @table.sort_indices(:number1))
-    end
-
-    test("-String") do
-      assert_equal(Arrow::UInt64Array.new([3, 0, 2, 1, 4, 5, 6]),
-                   @table.sort_indices("-number1"))
-    end
-
-    test("Symbol, -String") do
-      assert_equal(Arrow::UInt64Array.new([6, 5, 4, 1, 2, 0, 3]),
-                   @table.sort_indices([:number1, "-number2"]))
-    end
-  end
-end

data/test/test-sort-key.rb

@@ -1,81 +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 SortKeyTest < Test::Unit::TestCase
-  sub_test_case(".resolve") do
-    test("SortKey") do
-      assert_equal(Arrow::SortKey.new("-count"),
-                   Arrow::SortKey.resolve(Arrow::SortKey.new("-count")))
-    end
-
-    test("-String") do
-      assert_equal(Arrow::SortKey.new("-count"),
-                   Arrow::SortKey.resolve("-count"))
-    end
-
-    test("Symbol, Symbol") do
-      assert_equal(Arrow::SortKey.new("-count"),
-                   Arrow::SortKey.resolve(:count, :desc))
-    end
-  end
-
-  sub_test_case("#initialize") do
-    test("String") do
-      assert_equal("+count",
-                   Arrow::SortKey.new("count").to_s)
-    end
-
-    test("+String") do
-      assert_equal("+count",
-                   Arrow::SortKey.new("+count").to_s)
-    end
-
-    test("-String") do
-      assert_equal("-count",
-                   Arrow::SortKey.new("-count").to_s)
-    end
-
-    test("Symbol") do
-      assert_equal("+-count",
-                   Arrow::SortKey.new(:"-count").to_s)
-    end
-
-    test("String, Symbol") do
-      assert_equal("--count",
-                   Arrow::SortKey.new("-count", :desc).to_s)
-    end
-
-    test("String, String") do
-      assert_equal("--count",
-                   Arrow::SortKey.new("-count", "desc").to_s)
-    end
-
-    test("String, SortOrder") do
-      assert_equal("--count",
-                   Arrow::SortKey.new("-count",
-                                      Arrow::SortOrder::DESCENDING).to_s)
-    end
-  end
-
-  sub_test_case("#to_s") do
-    test("recreatable") do
-      key = Arrow::SortKey.new("-count", :desc)
-      assert_equal(key,
-                   Arrow::SortKey.new(key.to_s))
-    end
-  end
-end

data/test/test-sort-options.rb

@@ -1,58 +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 SortOptionsTest < Test::Unit::TestCase
-  sub_test_case("#initialize") do
-    test("none") do
-      options = Arrow::SortOptions.new
-      assert_equal([],
-                   options.sort_keys.collect(&:to_s))
-    end
-
-    test("-String, Symbol") do
-      options = Arrow::SortOptions.new("-count", :age)
-      assert_equal(["-count", "+age"],
-                   options.sort_keys.collect(&:to_s))
-    end
-  end
-
-  sub_test_case("instance methods") do
-    setup do
-      @options = Arrow::SortOptions.new
-    end
-
-    sub_test_case("#add_sort_key") do
-      test("-String") do
-        @options.add_sort_key("-count")
-        assert_equal(["-count"],
-                     @options.sort_keys.collect(&:to_s))
-      end
-
-      test("-String, Symbol") do
-        @options.add_sort_key("-count", :desc)
-        assert_equal(["--count"],
-                     @options.sort_keys.collect(&:to_s))
-      end
-
-      test("SortKey") do
-        @options.add_sort_key(Arrow::SortKey.new("-count"))
-        assert_equal(["-count"],
-                     @options.sort_keys.collect(&:to_s))
-      end
-    end
-  end
-end

data/test/test-sparse-union-data-type.rb

@@ -1,41 +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 SparseUnionDataTypeTest < Test::Unit::TestCase
-  sub_test_case(".new") do
-    def setup
-      @fields = [
-        Arrow::Field.new("visible", :boolean),
-        {
-          name: "count",
-          type: :int32,
-        },
-      ]
-    end
-
-    test("ordered arguments") do
-      assert_equal("sparse_union<visible: bool=2, count: int32=9>",
-                   Arrow::SparseUnionDataType.new(@fields, [2, 9]).to_s)
-    end
-
-    test("description") do
-      assert_equal("sparse_union<visible: bool=2, count: int32=9>",
-                   Arrow::SparseUnionDataType.new(fields: @fields,
-                                                  type_codes: [2, 9]).to_s)
-    end
-  end
-end