red-arrow 8.0.0 → 24.0.0

data/test/test-chunked-array.rb

@@ -1,183 +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 ChunkedArrayTest < Test::Unit::TestCase
-  test("#each") do
-    arrays = [
-      Arrow::BooleanArray.new([true, false]),
-      Arrow::BooleanArray.new([nil, true]),
-    ]
-    chunked_array = Arrow::ChunkedArray.new(arrays)
-    assert_equal([true, false, nil, true],
-                 chunked_array.to_a)
-  end
-
-  sub_test_case("#pack") do
-    test("basic array") do
-      arrays = [
-        Arrow::BooleanArray.new([true, false]),
-        Arrow::BooleanArray.new([nil, true]),
-      ]
-      chunked_array = Arrow::ChunkedArray.new(arrays)
-      packed_chunked_array = chunked_array.pack
-      assert_equal([
-                     Arrow::BooleanArray,
-                     [true, false, nil, true],
-                   ],
-                   [
-                     packed_chunked_array.class,
-                     packed_chunked_array.to_a,
-                   ])
-    end
-
-    test("TimestampArray") do
-      type = Arrow::TimestampDataType.new(:nano)
-      arrays = [
-        Arrow::TimestampArrayBuilder.new(type).build([Time.at(0)]),
-        Arrow::TimestampArrayBuilder.new(type).build([Time.at(1)]),
-      ]
-      chunked_array = Arrow::ChunkedArray.new(arrays)
-      packed_chunked_array = chunked_array.pack
-      assert_equal([
-                     Arrow::TimestampArray,
-                     [Time.at(0), Time.at(1)],
-                   ],
-                   [
-                     packed_chunked_array.class,
-                     packed_chunked_array.to_a,
-                   ])
-    end
-  end
-
-  sub_test_case("#==") do
-    def setup
-      arrays = [
-        Arrow::BooleanArray.new([true]),
-        Arrow::BooleanArray.new([false, true]),
-      ]
-      @chunked_array = Arrow::ChunkedArray.new(arrays)
-    end
-
-    test("Arrow::ChunkedArray") do
-      assert do
-        @chunked_array == @chunked_array
-      end
-    end
-
-    test("not Arrow::ChunkedArray") do
-      assert do
-        not (@chunked_array == 29)
-      end
-    end
-  end
-
-  sub_test_case("#filter") do
-    def setup
-      arrays = [
-        Arrow::BooleanArray.new([false, true]),
-        Arrow::BooleanArray.new([false, true, false]),
-      ]
-      @chunked_array = Arrow::ChunkedArray.new(arrays)
-      @options = Arrow::FilterOptions.new
-      @options.null_selection_behavior = :emit_null
-    end
-
-    test("Array: boolean") do
-      filter = [nil, true, true, false, true]
-      chunks = [
-        Arrow::BooleanArray.new([nil, true]),
-        Arrow::BooleanArray.new([false, false]),
-      ]
-      filtered_chunked_array = Arrow::ChunkedArray.new(chunks)
-      assert_equal(filtered_chunked_array,
-                   @chunked_array.filter(filter, @options))
-    end
-
-    test("Arrow::BooleanArray") do
-      filter = Arrow::BooleanArray.new([nil, true, true, false, true])
-      chunks = [
-        Arrow::BooleanArray.new([nil, true]),
-        Arrow::BooleanArray.new([false, false]),
-      ]
-      filtered_chunked_array = Arrow::ChunkedArray.new(chunks)
-      assert_equal(filtered_chunked_array,
-                   @chunked_array.filter(filter, @options))
-    end
-
-    test("Arrow::ChunkedArray") do
-      chunks = [
-        Arrow::BooleanArray.new([nil, true]),
-        Arrow::BooleanArray.new([true, false, true]),
-      ]
-      filter = Arrow::ChunkedArray.new(chunks)
-      filtered_chunks = [
-        Arrow::BooleanArray.new([nil, true]),
-        Arrow::BooleanArray.new([false, false]),
-      ]
-      filtered_chunked_array = Arrow::ChunkedArray.new(filtered_chunks)
-      assert_equal(filtered_chunked_array,
-                   @chunked_array.filter(filter, @options))
-    end
-  end
-
-  sub_test_case("#take") do
-    def setup
-      chunks = [
-        Arrow::Int16Array.new([1, 0]),
-        Arrow::Int16Array.new([2]),
-      ]
-      @chunked_array = Arrow::ChunkedArray.new(chunks)
-    end
-
-    test("Arrow: boolean") do
-      chunks = [
-        Arrow::Int16Array.new([0, 1]),
-        Arrow::Int16Array.new([2])
-      ]
-      taken_chunked_array = Arrow::ChunkedArray.new(chunks)
-      indices = [1, 0, 2]
-      assert_equal(taken_chunked_array,
-                   @chunked_array.take(indices))
-    end
-
-    test("Arrow::Array") do
-      chunks = [
-        Arrow::Int16Array.new([0, 1]),
-        Arrow::Int16Array.new([2])
-      ]
-      taken_chunked_array = Arrow::ChunkedArray.new(chunks)
-      indices = Arrow::Int16Array.new([1, 0, 2])
-      assert_equal(taken_chunked_array,
-                   @chunked_array.take(indices))
-    end
-
-    test("Arrow::ChunkedArray") do
-      taken_chunks = [
-        Arrow::Int16Array.new([0, 1]),
-        Arrow::Int16Array.new([2])
-      ]
-      taken_chunked_array = Arrow::ChunkedArray.new(taken_chunks)
-      indices_chunks = [
-        Arrow::Int16Array.new([1, 0]),
-        Arrow::Int16Array.new([2])
-      ]
-      indices = Arrow::ChunkedArray.new(indices_chunks)
-      assert_equal(taken_chunked_array,
-                   @chunked_array.take(indices))
-    end
-  end
-end

data/test/test-column.rb

@@ -1,92 +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 ColumnTest < Test::Unit::TestCase
-  def setup
-    table = Arrow::Table.new("visible" => [true, nil, false])
-    @column = table.visible
-  end
-
-  test("#name") do
-    assert_equal("visible", @column.name)
-  end
-
-  test("#data_type") do
-    assert_equal(Arrow::BooleanDataType.new, @column.data_type)
-  end
-
-  test("#null?") do
-    assert do
-      @column.null?(1)
-    end
-  end
-
-  test("#valid?") do
-    assert do
-      @column.valid?(0)
-    end
-  end
-
-  test("#each") do
-    assert_equal([true, nil, false], @column.each.to_a)
-  end
-
-  test("#reverse_each") do
-    assert_equal([false, nil, true], @column.reverse_each.to_a)
-  end
-
-  test("#n_rows") do
-    assert_equal(3, @column.n_rows)
-  end
-
-  test("#n_nulls") do
-    assert_equal(1, @column.n_nulls)
-  end
-
-  sub_test_case("#==") do
-    test("same value") do
-      table1 = Arrow::Table.new("visible" => [true, false])
-      table2 = Arrow::Table.new("visible" => [true, false])
-      assert do
-        table1.visible == table2.visible
-      end
-    end
-
-    test("different name") do
-      table1 = Arrow::Table.new("visible" => [true, false])
-      table2 = Arrow::Table.new("invisible" => [true, false])
-      assert do
-        not table1.visible == table2.invisible
-      end
-    end
-
-    test("different value") do
-      table1 = Arrow::Table.new("visible" => [true, false])
-      table2 = Arrow::Table.new("visible" => [true, true])
-      assert do
-        not table1.visible == table2.visible
-      end
-    end
-
-    test("not Arrow::Column") do
-      table = Arrow::Table.new("visible" => [true, false])
-      assert do
-        not table.visible == 29
-      end
-    end
-  end
-end

data/test/test-csv-loader.rb

@@ -1,250 +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 CSVLoaderTest < Test::Unit::TestCase
-  include Helper::Fixture
-
-  def load_csv(input)
-    Arrow::CSVLoader.load(input, skip_lines: /^#/)
-  end
-
-  sub_test_case(".load") do
-    test("String: data: with header") do
-      data = fixture_path("with-header-float.csv").read
-      assert_equal(<<-TABLE, load_csv(data).to_s)
-	name	     score
-0	alice	 10.100000
-1	bob 	 29.200000
-2	chris	 -1.300000
-      TABLE
-    end
-
-    test("String: data: without header") do
-      data = fixture_path("without-header-float.csv").read
-      assert_equal(<<-TABLE, load_csv(data).to_s)
-	0	         1
-0	alice	 10.100000
-1	bob	 29.200000
-2	chris	 -1.300000
-      TABLE
-    end
-
-    test("String: path: with header") do
-      path = fixture_path("with-header-float.csv").to_s
-      assert_equal(<<-TABLE, load_csv(path).to_s)
-	name	     score
-0	alice	 10.100000
-1	bob 	 29.200000
-2	chris	 -1.300000
-      TABLE
-    end
-
-    test("String: path: without header") do
-      path = fixture_path("without-header-float.csv").to_s
-      assert_equal(<<-TABLE, load_csv(path).to_s)
-	0	         1
-0	alice	 10.100000
-1	bob	 29.200000
-2	chris	 -1.300000
-      TABLE
-    end
-
-    test("Pathname: with header") do
-      path = fixture_path("with-header-float.csv")
-      assert_equal(<<-TABLE, load_csv(path).to_s)
-	name	     score
-0	alice	 10.100000
-1	bob 	 29.200000
-2	chris	 -1.300000
-      TABLE
-    end
-
-    test("Pathname: without header") do
-      path = fixture_path("without-header-float.csv")
-      assert_equal(<<-TABLE, load_csv(path).to_s)
-	0	         1
-0	alice	 10.100000
-1	bob	 29.200000
-2	chris	 -1.300000
-      TABLE
-    end
-
-    test("null: with double quote") do
-      path = fixture_path("null-with-double-quote.csv").to_s
-      assert_equal(<<-TABLE, load_csv(path).to_s)
-	name	 score
-0	alice	    10
-1	bob 	(null)
-2	chris	    -1
-      TABLE
-    end
-
-    test("null: without double quote") do
-      path = fixture_path("null-without-double-quote.csv").to_s
-      assert_equal(<<-TABLE, load_csv(path).to_s)
-	name	 score
-0	alice	    10
-1	bob 	(null)
-2	chris	    -1
-      TABLE
-    end
-
-    test("number: float, integer") do
-      path = fixture_path("float-integer.csv").to_s
-      assert_equal([2.9, 10, -1.1],
-                   load_csv(path)[:score].to_a)
-    end
-
-    test("number: integer, float") do
-      path = fixture_path("integer-float.csv").to_s
-      assert_equal([10.0, 2.9, -1.1],
-                   load_csv(path)[:score].to_a)
-    end
-  end
-
-  sub_test_case("CSVReader") do
-    def load_csv(data, **options)
-      Arrow::CSVLoader.load(data, **options)
-    end
-
-    sub_test_case(":headers") do
-      test("true") do
-        values = Arrow::StringArray.new(["a", "b", "c"])
-        assert_equal(Arrow::Table.new(value: values),
-                     load_csv(<<-CSV, headers: true))
-value
-a
-b
-c
-                     CSV
-      end
-
-      test(":first_line") do
-        values = Arrow::StringArray.new(["a", "b", "c"])
-        assert_equal(Arrow::Table.new(value: values),
-                     load_csv(<<-CSV, headers: :first_line))
-value
-a
-b
-c
-                     CSV
-      end
-
-      test("truthy") do
-        values = Arrow::StringArray.new(["a", "b", "c"])
-        assert_equal(Arrow::Table.new(value: values),
-                     load_csv(<<-CSV, headers: 0))
-value
-a
-b
-c
-                     CSV
-      end
-
-      test("Array of column names") do
-        values = Arrow::StringArray.new(["a", "b", "c"])
-        assert_equal(Arrow::Table.new(column: values),
-                     load_csv(<<-CSV, headers: ["column"]))
-a
-b
-c
-                     CSV
-      end
-
-      test("false") do
-        values = Arrow::StringArray.new(["a", "b", "c"])
-        assert_equal(Arrow::Table.new(f0: values),
-                     load_csv(<<-CSV, headers: false))
-a
-b
-c
-                     CSV
-      end
-
-      test("nil") do
-        values = Arrow::StringArray.new(["a", "b", "c"])
-        assert_equal(Arrow::Table.new(f0: values),
-                     load_csv(<<-CSV, headers: nil))
-a
-b
-c
-                     CSV
-      end
-
-      test("string") do
-        values = Arrow::StringArray.new(["a", "b", "c"])
-        assert_equal(Arrow::Table.new(column: values),
-                     load_csv(<<-CSV, headers: "column"))
-a
-b
-c
-                     CSV
-      end
-    end
-
-    test(":column_types") do
-      assert_equal(Arrow::Table.new(:count => Arrow::UInt16Array.new([1, 2, 4])),
-                   load_csv(<<-CSV, column_types: {count: :uint16}))
-count
-1
-2
-4
-                   CSV
-    end
-
-    test(":schema") do
-      table = Arrow::Table.new(:count => Arrow::UInt16Array.new([1, 2, 4]))
-      assert_equal(table,
-                   load_csv(<<-CSV, schema: table.schema))
-count
-1
-2
-4
-                   CSV
-    end
-
-    test(":encoding") do
-      messages = [
-        "\u3042", # U+3042 HIRAGANA LETTER A
-        "\u3044", # U+3044 HIRAGANA LETTER I
-        "\u3046", # U+3046 HIRAGANA LETTER U
-      ]
-      table = Arrow::Table.new(:message => Arrow::StringArray.new(messages))
-      encoding = "cp932"
-      assert_equal(table,
-                   load_csv((["message"] + messages).join("\n").encode(encoding),
-                            schema: table.schema,
-                            encoding: encoding))
-    end
-
-    test(":encoding and :compression") do
-      messages = [
-        "\u3042", # U+3042 HIRAGANA LETTER A
-        "\u3044", # U+3044 HIRAGANA LETTER I
-        "\u3046", # U+3046 HIRAGANA LETTER U
-      ]
-      table = Arrow::Table.new(:message => Arrow::StringArray.new(messages))
-      encoding = "cp932"
-      csv = (["message"] + messages).join("\n").encode(encoding)
-      assert_equal(table,
-                   load_csv(Zlib::Deflate.deflate(csv),
-                            schema: table.schema,
-                            encoding: encoding,
-                            compression: :gzip))
-    end
-  end
-end

data/test/test-data-type.rb

@@ -1,83 +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 DataTypeTest < Test::Unit::TestCase
-  sub_test_case(".resolve") do
-    test("DataType") do
-      assert_equal(Arrow::BooleanDataType.new,
-                   Arrow::DataType.resolve(Arrow::BooleanDataType.new))
-    end
-
-    test("String") do
-      assert_equal(Arrow::BooleanDataType.new,
-                   Arrow::DataType.resolve("boolean"))
-    end
-
-    test("Symbol") do
-      assert_equal(Arrow::BooleanDataType.new,
-                   Arrow::DataType.resolve(:boolean))
-    end
-
-    test("Array") do
-      field = Arrow::Field.new(:visible, :boolean)
-      assert_equal(Arrow::ListDataType.new(field),
-                   Arrow::DataType.resolve([:list, field]))
-    end
-
-    test("Hash") do
-      field = Arrow::Field.new(:visible, :boolean)
-      assert_equal(Arrow::ListDataType.new(field),
-                   Arrow::DataType.resolve(type: :list, field: field))
-    end
-
-    test("_") do
-      assert_equal(Arrow::FixedSizeBinaryDataType.new(10),
-                   Arrow::DataType.resolve([:fixed_size_binary, 10]))
-    end
-
-    test("abstract") do
-      message =
-        "abstract type: <:floating_point>: " +
-        "use one of not abstract type: [" +
-        "Arrow::DoubleDataType, " +
-        "Arrow::FloatDataType]"
-      assert_raise(ArgumentError.new(message)) do
-        Arrow::DataType.resolve(:floating_point)
-      end
-    end
-  end
-
-  sub_test_case("instance methods") do
-    def setup
-      @data_type = Arrow::StringDataType.new
-    end
-
-    sub_test_case("#==") do
-      test("Arrow::DataType") do
-        assert do
-          @data_type == @data_type
-        end
-      end
-
-      test("not Arrow::DataType") do
-        assert do
-          not (@data_type == 29)
-        end
-      end
-    end
-  end
-end