red-arrow 18.1.0 → 19.0.1

data/test/test-record-batch.rb

@@ -1,182 +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 RecordBatchTest < Test::Unit::TestCase
-  sub_test_case(".new") do
-    def setup
-      @schema = Arrow::Schema.new(visible: :boolean,
-                                  count: :uint32)
-    end
-
-    test("[raw_table]") do
-      raw_table = {
-        visible: [true, nil, false],
-        count: [1, nil, 3],
-      }
-      record_batch = Arrow::RecordBatch.new(raw_table)
-      assert_equal([
-                     {"visible" => true,  "count" => 1},
-                     {"visible" => nil,   "count" => nil},
-                     {"visible" => false, "count" => 3},
-                   ],
-                   record_batch.each_record.collect(&:to_h))
-    end
-
-    test("[Schema, records]") do
-      records = [
-        {visible: true, count: 1},
-        nil,
-        [false, 3],
-      ]
-      record_batch = Arrow::RecordBatch.new(@schema, records)
-      assert_equal([
-                     {"visible" => true,  "count" => 1},
-                     {"visible" => nil,   "count" => nil},
-                     {"visible" => false, "count" => 3},
-                   ],
-                   record_batch.each_record.collect(&:to_h))
-    end
-
-    test("[Schema, columns]") do
-      columns = {
-        visible: [true, nil, false],
-        count: [1, 2, nil],
-      }
-      record_batch = Arrow::RecordBatch.new(@schema, columns)
-      assert_equal([
-                     {"visible" => true,  "count" => 1},
-                     {"visible" => nil,   "count" => 2},
-                     {"visible" => false, "count" => nil},
-                   ],
-                   record_batch.each_record.collect(&:to_h))
-    end
-
-    test("[Schema, n_rows, columns]") do
-      columns = [
-        Arrow::BooleanArray.new([true, nil, false]),
-        Arrow::UInt32Array.new([1, 2, nil]),
-      ]
-      n_rows = columns[0].length
-      record_batch = Arrow::RecordBatch.new(@schema, n_rows, columns)
-      assert_equal([
-                     {"visible" => true,  "count" => 1},
-                     {"visible" => nil,   "count" => 2},
-                     {"visible" => false, "count" => nil},
-                   ],
-                   record_batch.each_record.collect(&:to_h))
-    end
-  end
-
-  sub_test_case("instance methods") do
-    def setup
-      @schema = Arrow::Schema.new(count: :uint32)
-      @counts = Arrow::UInt32Array.new([1, 2, 4, 8])
-      @record_batch = Arrow::RecordBatch.new(@schema, @counts.length, [@counts])
-    end
-
-    sub_test_case("#each") do
-      test("default") do
-        records = []
-        @record_batch.each do |record|
-          records << [record, record.index]
-        end
-        assert_equal([
-                       [0, 0],
-                       [1, 1],
-                       [2, 2],
-                       [3, 3],
-                     ],
-                     records.collect {|record, i| [record.index, i]})
-      end
-
-      test("reuse_record: true") do
-        records = []
-        @record_batch.each(reuse_record: true) do |record|
-          records << [record, record.index]
-        end
-        assert_equal([
-                       [3, 0],
-                       [3, 1],
-                       [3, 2],
-                       [3, 3],
-                     ],
-                     records.collect {|record, i| [record.index, i]})
-      end
-    end
-
-    test("#to_table") do
-      assert_equal(Arrow::Table.new(@schema, [@counts]),
-                   @record_batch.to_table)
-    end
-
-    sub_test_case("#==") do
-      test("Arrow::RecordBatch") do
-        assert do
-          @record_batch == @record_batch
-        end
-      end
-
-      test("not Arrow::RecordBatch") do
-        assert do
-          not (@record_batch == 29)
-        end
-      end
-    end
-
-    sub_test_case("#[]") do
-      def setup
-        @record_batch = Arrow::RecordBatch.new(a: [true],
-                                               b: [true],
-                                               c: [true],
-                                               d: [true],
-                                               e: [true],
-                                               f: [true],
-                                               g: [true])
-      end
-
-      test("[String]") do
-        assert_equal(Arrow::Column.new(@record_batch, 0),
-                     @record_batch["a"])
-      end
-
-      test("[Symbol]") do
-        assert_equal(Arrow::Column.new(@record_batch, 1),
-                     @record_batch[:b])
-      end
-
-      test("[Integer]") do
-        assert_equal(Arrow::Column.new(@record_batch, 6),
-                     @record_batch[-1])
-      end
-
-      test("[Range]") do
-        assert_equal(Arrow::RecordBatch.new(d: [true],
-                                            e: [true]),
-                     @record_batch[3..4])
-      end
-
-      test("[[Symbol, String, Integer, Range]]") do
-        assert_equal(Arrow::RecordBatch.new(c: [true],
-                                            a: [true],
-                                            g: [true],
-                                            d: [true],
-                                            e: [true]),
-                     @record_batch[[:c, "a", -1, 3..4]])
-      end
-    end
-  end
-end

data/test/test-scalar.rb

@@ -1,65 +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 ScalarTest < Test::Unit::TestCase
-  sub_test_case(".resolve") do
-    test("Scalar") do
-      assert_equal(Arrow::Int32Scalar.new(29),
-                   Arrow::Scalar.resolve(Arrow::Int32Scalar.new(29)))
-    end
-
-    test("true") do
-      assert_equal(Arrow::BooleanScalar.new(true),
-                   Arrow::Scalar.resolve(true))
-    end
-
-    test("false") do
-      assert_equal(Arrow::BooleanScalar.new(false),
-                   Arrow::Scalar.resolve(false))
-    end
-
-    test("Symbol") do
-      assert_equal(Arrow::StringScalar.new("hello"),
-                   Arrow::Scalar.resolve(:hello))
-    end
-
-    test("String") do
-      assert_equal(Arrow::StringScalar.new("hello"),
-                   Arrow::Scalar.resolve("hello"))
-    end
-
-    test("Integer") do
-      assert_equal(Arrow::Int64Scalar.new(-29),
-                   Arrow::Scalar.resolve(-29))
-    end
-
-    test("Float") do
-      assert_equal(Arrow::DoubleScalar.new(2.9),
-                   Arrow::Scalar.resolve(2.9))
-    end
-
-    test("Int64Scalar, :int32") do
-      assert_equal(Arrow::Int32Scalar.new(-29),
-                   Arrow::Scalar.resolve(Arrow::Int64Scalar.new(-29), :int32))
-    end
-
-    test("Integer, :int32") do
-      assert_equal(Arrow::Int32Scalar.new(-29),
-                   Arrow::Scalar.resolve(-29, :int32))
-    end
-  end
-end

data/test/test-schema.rb

@@ -1,134 +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 SchemaTest < Test::Unit::TestCase
-  include Helper::Omittable
-
-  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("count: uint32\n" +
-                   "visible: bool",
-                   Arrow::Schema.new(fields).to_s)
-    end
-
-    test("[Arrow::Field, Hash]") do
-      fields = [
-        @count_field,
-        {name: "visible", type: :boolean},
-      ]
-      assert_equal("count: uint32\n" +
-                   "visible: bool",
-                   Arrow::Schema.new(fields).to_s)
-    end
-
-    test("{String, Symbol => Arrow::DataType}") do
-      fields = {
-        "count" => Arrow::UInt32DataType.new,
-        :visible => :boolean,
-      }
-      assert_equal("count: uint32\n" +
-                   "visible: bool",
-                   Arrow::Schema.new(fields).to_s)
-    end
-
-    test("{String, Symbol => Hash}") do
-      fields = {
-        "count" => {type: :uint32},
-        :tags => {
-          type: :list,
-          field: {
-            name: "tag",
-            type: :string,
-          },
-        },
-      }
-      assert_equal("count: uint32\n" +
-                   "tags: list<tag: string>",
-                   Arrow::Schema.new(fields).to_s)
-    end
-  end
-
-  sub_test_case("instance methods") do
-    def setup
-      super
-      @schema = Arrow::Schema.new([@count_field, @visible_field])
-    end
-
-    sub_test_case("#[]") do
-      test("[String]") do
-        assert_equal([@count_field, @visible_field],
-                     [@schema["count"], @schema["visible"]])
-      end
-
-      test("[Symbol]") do
-        assert_equal([@count_field, @visible_field],
-                     [@schema[:count], @schema[:visible]])
-      end
-
-      test("[Integer]") do
-        assert_equal([@count_field, @visible_field],
-                     [@schema[0], @schema[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
-          @schema[invalid]
-        end
-      end
-    end
-
-    sub_test_case("#==") do
-      test("Arrow::Schema") do
-        assert do
-          @schema == @schema
-        end
-      end
-
-      test("not Arrow::Schema") do
-        assert do
-          not (@schema == 29)
-        end
-      end
-    end
-
-    sub_test_case("#to_s") do
-      test("show_metadata") do
-        require_gi_bindings(3, 4, 2)
-
-        schema = @schema.with_metadata("key" => "value")
-        assert_equal(<<-SCHEMA.chomp, schema.to_s(show_metadata: true))
-count: uint32
-visible: bool
--- metadata --
-key: value
-        SCHEMA
-      end
-    end
-  end
-end