From e6918187568dbd01842d8d1d2c808ce16a894239 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 21 Apr 2024 13:54:28 +0200 Subject: Adding upstream version 18.2.2. Signed-off-by: Daniel Baumann --- src/arrow/ruby/red-arrow/test/test-memory-view.rb | 434 ++++++++++++++++++++++ 1 file changed, 434 insertions(+) create mode 100644 src/arrow/ruby/red-arrow/test/test-memory-view.rb (limited to 'src/arrow/ruby/red-arrow/test/test-memory-view.rb') diff --git a/src/arrow/ruby/red-arrow/test/test-memory-view.rb b/src/arrow/ruby/red-arrow/test/test-memory-view.rb new file mode 100644 index 000000000..0b9c98c40 --- /dev/null +++ b/src/arrow/ruby/red-arrow/test/test-memory-view.rb @@ -0,0 +1,434 @@ +# 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 MemoryViewTest < Test::Unit::TestCase + def setup + unless Fiddle.const_defined?(:MemoryView) + omit("Fiddle::MemoryView is needed") + end + unless Fiddle::MemoryView.respond_to?(:export) + omit("Fiddle::MemoryView.export is needed") + end + end + + def little_endian? + [1].pack("s") == [1].pack("s<") + end + + test("BooleanArray") do + array = Arrow::BooleanArray.new([true] * 9) + Fiddle::MemoryView.export(array) do |memory_view| + if little_endian? + template = "b" + else + template = "B" + end + assert_equal([ + "#{template}8", + 1, + 2, + [(("1" * 9) + ("0" * 7))].pack("#{template}*"), + ], + [ + memory_view.format, + memory_view.item_size, + memory_view.byte_size, + memory_view.to_s, + ]) + end + end + + test("Int8Array") do + values = [-(2 ** 7), 0, (2 ** 7) - 1] + array = Arrow::Int8Array.new(values) + Fiddle::MemoryView.export(array) do |memory_view| + assert_equal([ + "c", + 1, + values.size, + values.pack("c*"), + ], + [ + memory_view.format, + memory_view.item_size, + memory_view.byte_size, + memory_view.to_s, + ]) + end + end + + test("Int16Array") do + values = [-(2 ** 15), 0, (2 ** 15) - 1] + array = Arrow::Int16Array.new(values) + Fiddle::MemoryView.export(array) do |memory_view| + assert_equal([ + "s", + 2, + 2 * values.size, + values.pack("s*"), + ], + [ + memory_view.format, + memory_view.item_size, + memory_view.byte_size, + memory_view.to_s, + ]) + end + end + + test("Int32Array") do + values = [-(2 ** 31), 0, (2 ** 31) - 1] + array = Arrow::Int32Array.new(values) + Fiddle::MemoryView.export(array) do |memory_view| + assert_equal([ + "l", + 4, + 4 * values.size, + values.pack("l*"), + ], + [ + memory_view.format, + memory_view.item_size, + memory_view.byte_size, + memory_view.to_s, + ]) + end + end + + test("Int64Array") do + values = [-(2 ** 63), 0, (2 ** 63) - 1] + array = Arrow::Int64Array.new(values) + Fiddle::MemoryView.export(array) do |memory_view| + assert_equal([ + "q", + 8, + 8 * values.size, + values.pack("q*"), + ], + [ + memory_view.format, + memory_view.item_size, + memory_view.byte_size, + memory_view.to_s, + ]) + end + end + + test("UInt8Array") do + values = [0, (2 ** 8) - 1] + array = Arrow::UInt8Array.new(values) + Fiddle::MemoryView.export(array) do |memory_view| + assert_equal([ + "C", + 1, + values.size, + values.pack("C*"), + ], + [ + memory_view.format, + memory_view.item_size, + memory_view.byte_size, + memory_view.to_s, + ]) + end + end + + test("UInt16Array") do + values = [0, (2 ** 16) - 1] + array = Arrow::UInt16Array.new(values) + Fiddle::MemoryView.export(array) do |memory_view| + assert_equal([ + "S", + 2, + 2 * values.size, + values.pack("S*"), + ], + [ + memory_view.format, + memory_view.item_size, + memory_view.byte_size, + memory_view.to_s, + ]) + end + end + + test("UInt32Array") do + values = [0, (2 ** 32) - 1] + array = Arrow::UInt32Array.new(values) + Fiddle::MemoryView.export(array) do |memory_view| + assert_equal([ + "L", + 4, + 4 * values.size, + values.pack("L*"), + ], + [ + memory_view.format, + memory_view.item_size, + memory_view.byte_size, + memory_view.to_s, + ]) + end + end + + test("UInt64Array") do + values = [(2 ** 64) - 1] + array = Arrow::UInt64Array.new(values) + Fiddle::MemoryView.export(array) do |memory_view| + assert_equal([ + "Q", + 8, + 8 * values.size, + values.pack("Q*"), + ], + [ + memory_view.format, + memory_view.item_size, + memory_view.byte_size, + memory_view.to_s, + ]) + end + end + + test("FloatArray") do + values = [-1.1, 0.0, 1.1] + array = Arrow::FloatArray.new(values) + Fiddle::MemoryView.export(array) do |memory_view| + assert_equal([ + "f", + 4, + 4 * values.size, + values.pack("f*"), + ], + [ + memory_view.format, + memory_view.item_size, + memory_view.byte_size, + memory_view.to_s, + ]) + end + end + + test("DoubleArray") do + values = [-1.1, 0.0, 1.1] + array = Arrow::DoubleArray.new(values) + Fiddle::MemoryView.export(array) do |memory_view| + assert_equal([ + "d", + 8, + 8 * values.size, + values.pack("d*"), + ], + [ + memory_view.format, + memory_view.item_size, + memory_view.byte_size, + memory_view.to_s, + ]) + end + end + + test("FixedSizeBinaryArray") do + values = ["\x01\x02", "\x03\x04", "\x05\x06"] + data_type = Arrow::FixedSizeBinaryDataType.new(2) + array = Arrow::FixedSizeBinaryArray.new(data_type, values) + Fiddle::MemoryView.export(array) do |memory_view| + assert_equal([ + "C2", + 2, + 2 * values.size, + values.join("").b, + ], + [ + memory_view.format, + memory_view.item_size, + memory_view.byte_size, + memory_view.to_s, + ]) + end + end + + test("Date32Array") do + n_days_since_epoch = 17406 # 2017-08-28 + values = [n_days_since_epoch] + array = Arrow::Date32Array.new(values) + Fiddle::MemoryView.export(array) do |memory_view| + assert_equal([ + "l", + 4, + 4 * values.size, + values.pack("l*"), + ], + [ + memory_view.format, + memory_view.item_size, + memory_view.byte_size, + memory_view.to_s, + ]) + end + end + + test("Date64Array") do + n_msecs_since_epoch = 1503878400000 # 2017-08-28T00:00:00Z + values = [n_msecs_since_epoch] + array = Arrow::Date64Array.new(values) + Fiddle::MemoryView.export(array) do |memory_view| + assert_equal([ + "q", + 8, + 8 * values.size, + values.pack("q*"), + ], + [ + memory_view.format, + memory_view.item_size, + memory_view.byte_size, + memory_view.to_s, + ]) + end + end + + test("Time32Array") do + values = [1, 2, 3] + array = Arrow::Time32Array.new(:milli, values) + Fiddle::MemoryView.export(array) do |memory_view| + assert_equal([ + "l", + 4, + 4 * values.size, + values.pack("l*"), + ], + [ + memory_view.format, + memory_view.item_size, + memory_view.byte_size, + memory_view.to_s, + ]) + end + end + + test("Time64Array") do + values = [1, 2, 3] + array = Arrow::Time64Array.new(:nano, values) + Fiddle::MemoryView.export(array) do |memory_view| + assert_equal([ + "q", + 8, + 8 * values.size, + values.pack("q*"), + ], + [ + memory_view.format, + memory_view.item_size, + memory_view.byte_size, + memory_view.to_s, + ]) + end + end + + test("TimestampArray") do + values = [1, 2, 3] + array = Arrow::TimestampArray.new(:micro, values) + Fiddle::MemoryView.export(array) do |memory_view| + assert_equal([ + "q", + 8, + 8 * values.size, + values.pack("q*"), + ], + [ + memory_view.format, + memory_view.item_size, + memory_view.byte_size, + memory_view.to_s, + ]) + end + end + + test("Decimal128Array") do + values = [ + Arrow::Decimal128.new("10.1"), + Arrow::Decimal128.new("11.1"), + Arrow::Decimal128.new("10.2"), + ] + data_type = Arrow::Decimal128DataType.new(3, 1) + array = Arrow::Decimal128Array.new(data_type, values) + Fiddle::MemoryView.export(array) do |memory_view| + assert_equal([ + "q2", + 16, + 16 * values.size, + values.collect {|value| value.to_bytes.to_s}.join(""), + ], + [ + memory_view.format, + memory_view.item_size, + memory_view.byte_size, + memory_view.to_s, + ]) + end + end + + test("Decimal256Array") do + values = [ + Arrow::Decimal256.new("10.1"), + Arrow::Decimal256.new("11.1"), + Arrow::Decimal256.new("10.2"), + ] + data_type = Arrow::Decimal256DataType.new(3, 1) + array = Arrow::Decimal256Array.new(data_type, values) + Fiddle::MemoryView.export(array) do |memory_view| + assert_equal([ + "q4", + 32, + 32 * values.size, + values.collect {|value| value.to_bytes.to_s}.join(""), + ], + [ + memory_view.format, + memory_view.item_size, + memory_view.byte_size, + memory_view.to_s, + ]) + end + end + + test("Buffer") do + values = [0, nil, nil] * 3 + array = Arrow::Int8Array.new(values) + buffer = array.null_bitmap + Fiddle::MemoryView.export(buffer) do |memory_view| + if little_endian? + template = "b" + else + template = "B" + end + assert_equal([ + "#{template}8", + 1, + 2, + ["100" * 3].pack("#{template}*"), + ], + [ + memory_view.format, + memory_view.item_size, + memory_view.byte_size, + memory_view.to_s, + ]) + end + end +end -- cgit v1.2.3