red-arrow 18.1.0 → 19.0.1

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-array.rb

@@ -1,38 +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 SparseUnionArrayTest < Test::Unit::TestCase
-  def setup
-    data_type_fields = [
-      Arrow::Field.new("number", :int16),
-      Arrow::Field.new("text", :string),
-    ]
-    type_codes = [11, 13]
-    @data_type = Arrow::SparseUnionDataType.new(data_type_fields, type_codes)
-    type_ids = Arrow::Int8Array.new([11, 13, 11, 13, 11])
-    fields = [
-      Arrow::Int16Array.new([1, nil, nil, nil, 5]),
-      Arrow::StringArray.new([nil, "b", nil, "d", nil]),
-    ]
-    @array = Arrow::SparseUnionArray.new(@data_type, type_ids, fields)
-  end
-
-  def test_get_value
-    assert_equal([1, "b", nil, "d", 5],
-                 @array.length.times.collect {|i| @array[i]})
-  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

data/test/test-stream-listener.rb

@@ -1,60 +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 TestStreamListener < Test::Unit::TestCase
-  class Listener < Arrow::StreamListener
-    attr_reader :events
-    def initialize
-      super
-      @events = []
-    end
-
-    def on_eos
-      @events << [:eos]
-    end
-
-    def on_record_batch_decoded(record_batch, metadata)
-      @events << [:record_batch_decoded, record_batch, metadata]
-    end
-
-    def on_schema_decoded(schema, filtered_schema)
-      @events << [:schema_decoded, schema, filtered_schema]
-    end
-  end
-
-  def setup
-    @record_batch = Arrow::RecordBatch.new(enabled: [true, false, nil, true])
-    @schema = @record_batch.schema
-
-    @buffer = Arrow::ResizableBuffer.new(0)
-    table = Arrow::Table.new(@schema, [@record_batch])
-    table.save(@buffer, format: :stream)
-
-    @listener = Listener.new
-    @decoder = Arrow::StreamDecoder.new(@listener)
-  end
-
-  def test_consume
-    @decoder.consume(@buffer)
-    assert_equal([
-                   [:schema_decoded, @schema, @schema],
-                   [:record_batch_decoded, @record_batch, nil],
-                   [:eos],
-                 ],
-                 @listener.events)
-  end
-end

data/test/test-string-dictionary-array-builder.rb

@@ -1,103 +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 StringDictionaryArrayBuilderTest < Test::Unit::TestCase
-  def setup
-    @builder = Arrow::StringDictionaryArrayBuilder.new
-  end
-
-  sub_test_case("#append_values") do
-    test("[nil]") do
-      @builder.append_values([nil])
-      array = @builder.finish
-      assert_equal([
-                     [],
-                     [nil],
-                   ],
-                   [
-                     array.dictionary.to_a,
-                     array.indices.to_a,
-                   ])
-    end
-
-    test("[String]") do
-      @builder.append_values(["hello"])
-      array = @builder.finish
-      assert_equal([
-                     ["hello"],
-                     [0],
-                   ],
-                   [
-                     array.dictionary.to_a,
-                     array.indices.to_a,
-                   ])
-    end
-
-    test("[Symbol]") do
-      @builder.append_values([:hello])
-      array = @builder.finish
-      assert_equal([
-                     ["hello"],
-                     [0],
-                   ],
-                   [
-                     array.dictionary.to_a,
-                     array.indices.to_a,
-                   ])
-    end
-
-    test("[nil, String, Symbol]") do
-      @builder.append_values([
-                               nil,
-                               "Hello",
-                               :world,
-                               "world",
-                             ])
-      array = @builder.finish
-      assert_equal([
-                     ["Hello", "world"],
-                     [nil, 0, 1, 1],
-                   ],
-                   [
-                     array.dictionary.to_a,
-                     array.indices.to_a,
-                   ])
-    end
-
-    test("is_valids") do
-      @builder.append_values([
-                               "Hello",
-                               :world,
-                               :goodbye,
-                             ],
-                             [
-                               true,
-                               false,
-                               true,
-                             ])
-      array = @builder.finish
-      assert_equal([
-                     ["Hello", "goodbye"],
-                     [0, nil, 1],
-                   ],
-                   [
-                     array.dictionary.to_a,
-                     array.indices.to_a,
-                   ])
-    end
-  end
-end

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

@@ -1,184 +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 StructArrayBuilderTest < Test::Unit::TestCase
-  def setup
-    @data_type = Arrow::StructDataType.new(visible: {type: :boolean},
-                                           count: {type: :uint64})
-    @builder = Arrow::StructArrayBuilder.new(@data_type)
-  end
-
-  sub_test_case("#append_value") do
-    test("nil") do
-      @builder.append_value(nil)
-      array = @builder.finish
-      assert_equal([
-                     [false],
-                     [0],
-                   ],
-                   [
-                     array.find_field(0).to_a,
-                     array.find_field(1).to_a,
-                   ])
-    end
-
-    test("Array") do
-      @builder.append_value([true, 1])
-      @builder.append_value([])
-      @builder.append_value([false])
-      array = @builder.finish
-      assert_equal([
-                     [true, nil, false],
-                     [1, nil, nil],
-                   ],
-                   [
-                     array.find_field(0).to_a,
-                     array.find_field(1).to_a,
-                   ])
-    end
-
-    test("Arrow::Struct") do
-      source_array = Arrow::StructArray.new(@data_type, [[true, 1]])
-      struct = source_array.get_value(0)
-      @builder.append_value(struct)
-      array = @builder.finish
-      assert_equal([
-                     [true],
-                     [1],
-                   ],
-                   [
-                     array.find_field(0).to_a,
-                     array.find_field(1).to_a,
-                   ])
-    end
-
-    test("Hash") do
-      @builder.append_value(count: 1, visible: true)
-      @builder.append_value(visible: false)
-      @builder.append_value(count: 2)
-      array = @builder.finish
-      assert_equal([
-                     [true, false, nil],
-                     [1, nil, 2],
-                   ],
-                   [
-                     array.find_field(0).to_a,
-                     array.find_field(1).to_a,
-                   ])
-    end
-  end
-
-  sub_test_case("#append_values") do
-    test("[nil]") do
-      @builder.append_values([nil])
-      array = @builder.finish
-      assert_equal([
-                     [false],
-                     [0],
-                   ],
-                   [
-                     array.find_field(0).to_a,
-                     array.find_field(1).to_a,
-                   ])
-    end
-
-    test("[Array]") do
-      @builder.append_values([[true, 1]])
-      array = @builder.finish
-      assert_equal([
-                     [true],
-                     [1],
-                   ],
-                   [
-                     array.find_field(0).to_a,
-                     array.find_field(1).to_a,
-                   ])
-    end
-
-    test("[Hash]") do
-      @builder.append_values([{count: 1, visible: true}])
-      array = @builder.finish
-      assert_equal([
-                     [true],
-                     [1],
-                   ],
-                   [
-                     array.find_field(0).to_a,
-                     array.find_field(1).to_a,
-                   ])
-    end
-
-    test("[nil, Array, Hash]") do
-      @builder.append_values([
-                               nil,
-                               [true, 1],
-                               {count: 2, visible: false},
-                             ])
-      array = @builder.finish
-      assert_equal([
-                     [false, true, false],
-                     [0, 1, 2],
-                   ],
-                   [
-                     array.find_field(0).to_a,
-                     array.find_field(1).to_a,
-                   ])
-    end
-
-    test("is_valids") do
-      @builder.append_values([
-                               [true, 1],
-                               [false, 2],
-                               [true, 3],
-                             ],
-                             [
-                               true,
-                               false,
-                               true,
-                             ])
-      array = @builder.finish
-      assert_equal([
-                     [true, false, true],
-                     [1, 0, 3],
-                   ],
-                   [
-                     array.find_field(0).to_a,
-                     array.find_field(1).to_a,
-                   ])
-    end
-  end
-
-  sub_test_case("#append") do
-    test("backward compatibility") do
-      @builder.append
-      @builder.get_field_builder(0).append(true)
-      @builder.get_field_builder(1).append(1)
-      @builder.append
-      @builder.get_field_builder(0).append(false)
-      @builder.get_field_builder(1).append(2)
-      array = @builder.finish
-      assert_equal([
-                     {"visible" => true,  "count" => 1},
-                     {"visible" => false, "count" => 2},
-                   ],
-                   [
-                     array.get_value(0),
-                     array.get_value(1),
-                   ])
-    end
-  end
-end

data/test/test-struct-array.rb

@@ -1,94 +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 StructArrayTest < Test::Unit::TestCase
-  sub_test_case(".new") do
-    test("build") do
-      data_type = Arrow::StructDataType.new(visible: :boolean,
-                                            count: :uint64)
-      values = [
-        [true, 1],
-        nil,
-        [false, 2],
-      ]
-      array = Arrow::StructArray.new(data_type, values)
-      assert_equal([
-                     [true, false, false],
-                     [1, 0, 2],
-                   ],
-                   [
-                     array.find_field(0).to_a,
-                     array.find_field(1).to_a,
-                   ])
-    end
-  end
-
-  sub_test_case("instance methods") do
-    def setup
-      @data_type = Arrow::StructDataType.new(visible: {type: :boolean},
-                                             count: {type: :uint64})
-      @values = [
-        [true, 1],
-        [false, 2],
-      ]
-      @array = Arrow::StructArray.new(@data_type, @values)
-    end
-
-    test("#[]") do
-      assert_equal([
-                     {"visible" => true,  "count" => 1},
-                     {"visible" => false, "count" => 2},
-                   ],
-                   @array.to_a)
-    end
-
-    test("#get_value") do
-      assert_equal([
-                     {"visible" => true,  "count" => 1},
-                     {"visible" => false, "count" => 2},
-                   ],
-                   [
-                     @array.get_value(0),
-                     @array.get_value(1),
-                   ])
-    end
-
-    sub_test_case("#find_field") do
-      test("Integer") do
-        assert_equal([
-                       [true, false],
-                       [1, 2],
-                     ],
-                     [
-                       @array.find_field(0).to_a,
-                       @array.find_field(1).to_a,
-                     ])
-      end
-
-      test("String, Symbol") do
-        assert_equal([
-                       [true, false],
-                       [1, 2],
-                     ],
-                     [
-                       @array.find_field("visible").to_a,
-                       @array.find_field(:count).to_a,
-                     ])
-      end
-    end
-  end
-end

data/test/test-struct-data-type.rb

@@ -1,112 +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 StructDataTypeTest < Test::Unit::TestCase
-  def setup
-    @count_field = Arrow::Field.new("count", :uint32)
-    @visible_field = Arrow::Field.new("visible", :boolean)
-  end
-
-  sub_test_case(".new") do
-    test("[Arrow::Field]") do
-      fields = [
-        @count_field,
-        @visible_field,
-      ]
-      assert_equal("struct<count: uint32, visible: bool>",
-                   Arrow::StructDataType.new(fields).to_s)
-    end
-
-    test("[Hash]") do
-      fields = [
-        {name: "count", data_type: :uint32},
-        {name: "visible", data_type: :boolean},
-      ]
-      assert_equal("struct<count: uint32, visible: bool>",
-                   Arrow::StructDataType.new(fields).to_s)
-    end
-
-    test("[Arrow::Field, Hash]") do
-      fields = [
-        @count_field,
-        {name: "visible", data_type: :boolean},
-      ]
-      assert_equal("struct<count: uint32, visible: bool>",
-                   Arrow::StructDataType.new(fields).to_s)
-    end
-
-    test("{Arrow::DataType}") do
-      fields = {
-        "count" => Arrow::UInt32DataType.new,
-        "visible" => Arrow::BooleanDataType.new,
-      }
-      assert_equal("struct<count: uint32, visible: bool>",
-                   Arrow::StructDataType.new(fields).to_s)
-    end
-
-    test("{Hash}") do
-      fields = {
-        "count" => {type: :uint32},
-        "visible" => {type: :boolean},
-      }
-      assert_equal("struct<count: uint32, visible: bool>",
-                   Arrow::StructDataType.new(fields).to_s)
-    end
-
-    test("{String, Symbol}") do
-      fields = {
-        "count" => "uint32",
-        "visible" => :boolean,
-      }
-      assert_equal("struct<count: uint32, visible: bool>",
-                   Arrow::StructDataType.new(fields).to_s)
-    end
-  end
-
-  sub_test_case("instance methods") do
-    def setup
-      super
-      @data_type = Arrow::StructDataType.new([@count_field, @visible_field])
-    end
-
-    sub_test_case("#[]") do
-      test("[String]") do
-        assert_equal([@count_field, @visible_field],
-                     [@data_type["count"], @data_type["visible"]])
-      end
-
-      test("[Symbol]") do
-        assert_equal([@count_field, @visible_field],
-                     [@data_type[:count], @data_type[:visible]])
-      end
-
-      test("[Integer]") do
-        assert_equal([@count_field, @visible_field],
-                     [@data_type[0], @data_type[1]])
-      end
-
-      test("[invalid]") do
-        invalid = []
-        message = +"field name or index must be String, Symbol or Integer"
-        message << ": <#{invalid.inspect}>"
-        assert_raise(ArgumentError.new(message)) do
-          @data_type[invalid]
-        end
-      end
-    end
-  end
-end