rubyduino 0.2.0 → 0.2.1

data/vendor/spinel/test/bundle_tiny_array.rb

@@ -0,0 +1,160 @@
+# Bundled tiny tests (auto-grouped by bundler):
+#   - array_bsearch
+#   - array_each_index
+#   - array_find_index_block
+#   - array_group_by_standalone
+#   - array_join_poly
+#   - array_member_alias
+#   - array_product_mixed
+#   - array_repeated_combination
+#   - int_array_fetch
+#   - int_array_one_arg
+#   - int_array_reduce_init_sym
+#   - poly_array_zip
+
+# === array_bsearch ===
+def t_array_bsearch
+# Array#bsearch (find-minimum mode) on a sorted typed array: returns the
+# first element for which the block is truthy, or nil when none is.
+p [1, 3, 5, 7, 9].bsearch { |x| x >= 5 }
+p [1, 3, 5, 7, 9].bsearch { |x| x >= 100 }
+p [1, 3, 5, 7, 9].bsearch { |x| x >= 1 }
+p [2, 4, 6, 8].bsearch { |x| x >= 7 }
+p ["a", "b", "c", "d"].bsearch { |s| s >= "c" }
+p ["a", "b", "c", "d"].bsearch { |s| s >= "z" }
+end
+t_array_bsearch
+
+# === array_each_index ===
+def t_array_each_index
+# Array#each_index { |i| } yields each index (0..length-1). Works on
+# any typed array; only the index is bound, no element.
+[10, 20, 30].each_index { |i| puts i }
+puts "---"
+%w[a b c].each_index { |i| puts "idx #{i}" }
+puts "---"
+[].each_index { |i| puts "never" }
+puts "done"
+end
+t_array_each_index
+
+# === array_find_index_block ===
+def t_array_find_index_block
+# Issue #864: Enumerable#find_index with block returns the index
+# of the first element where the block is truthy, nil otherwise.
+# Pre-fix the block form wasn't dispatched (warn + emit 0).
+puts [1, 2, 3, 2].find_index { |x| x > 2 }
+puts [1, 2, 3].find_index { |x| x > 10 }.inspect
+end
+t_array_find_index_block
+
+# === array_group_by_standalone ===
+def t_array_group_by_standalone
+# Array#group_by — standalone (no fused .each) returns a hash
+# keyed by the block result with arrays of matching elements.
+# Backed by poly_poly_hash + boxed poly_array values; key insertion
+# order is preserved.
+puts [1,2,3,4,5,6].group_by { |x| x % 3 }.inspect
+puts ["apple","ant","bee","cat","cow"].group_by { |s| s[0] }.inspect
+end
+t_array_group_by_standalone
+
+# === array_join_poly ===
+def t_array_join_poly
+# Array#join on a mixed-element (poly) array: each element is to_s'd and
+# joined with the separator. Homogeneous int_array/str_array have their
+# own join; these literals are heterogeneous so they use poly storage.
+puts [1, "x", :y].join(",")
+puts [1, "x", :y].join
+puts [10, "y"].join("-")
+puts "done"
+end
+t_array_join_poly
+
+# === array_member_alias ===
+def t_array_member_alias
+# Enumerable#member? is the documented alias of #include?. Both
+# need dispatching on typed arrays so the alias doesn't fall
+# through to the unresolved-call path.
+puts [1,2,3].member?(2)
+puts [1,2,3].member?(99)
+puts ["a","b"].member?("a")
+puts ["a","b"].member?("z")
+end
+t_array_member_alias
+
+# === array_product_mixed ===
+def t_array_product_mixed
+# Array#product with a single array argument of a different element type
+# yields a poly_array of [recv_elem, arg_elem] pairs. Two int arrays keep
+# the homogeneous result.
+p [1, 2].product(["a", "b"])
+p [1, 2, 3].product(["x"])
+p ["a", "b"].product([1, 2])
+p [1, 2].product([3, 4])
+p [1.5, 2.5].product([1, 2])
+end
+t_array_product_mixed
+
+# === array_repeated_combination ===
+def t_array_repeated_combination
+# Array#repeated_combination(k) on an int array: k-element combinations
+# allowing repeats, materialised as an array of arrays via .to_a.
+p [1, 2].repeated_combination(2).to_a
+p [1, 2, 3].repeated_combination(2).to_a
+p [1, 2].repeated_combination(3).to_a
+p [1, 2, 3].repeated_combination(1).to_a
+end
+t_array_repeated_combination
+
+# === int_array_fetch ===
+def t_int_array_fetch
+a = [10, 20, 30]
+p a.fetch(0)
+p a.fetch(2)
+p a.fetch(5, 99)
+p a.fetch(1, 99)
+s = [:x, :y, :z]
+p s.fetch(1)
+end
+t_int_array_fetch
+
+# === int_array_one_arg ===
+def t_int_array_one_arg
+# Enumerable#one?(x) — true iff exactly one element equals x.
+# The block form was already supported; the no-block / arg-form
+# fell through to unresolved-call.
+puts [1,2,3].one?(2)
+puts [1,2,3].one?(99)
+puts [1,2,2].one?(2)
+puts [].one?(1)
+puts [5].one?(5)
+end
+t_int_array_one_arg
+
+# === int_array_reduce_init_sym ===
+def t_int_array_reduce_init_sym
+# Enumerable#reduce(init, :op) — explicit init plus a symbol
+# operator. Single-arg sym form was already wired; the 2-arg form
+# (init + op-sym) fell through to unresolved-call.
+puts [1,2,3,4].reduce(:+)
+puts [1,2,3,4].reduce(:*)
+puts [1,2,3,4].reduce(10, :+)
+puts [1,2,3,4].reduce(100, :*)
+puts [].reduce(7, :+)
+end
+t_int_array_reduce_init_sym
+
+# === poly_array_zip ===
+def t_poly_array_zip
+# Array#zip on heterogeneous (poly_array) receivers — result is a
+# poly_array_ptr_array (array of poly_array pairs). The result type
+# was being misclassified as int_array_ptr_array, leaving inspect
+# walking raw sp_RbVal bytes as ints.
+puts [1, "a"].zip([2, "b"]).inspect
+
+# Three heterogeneous arrays
+puts [1, "a", :s].zip([2, "b", :t]).inspect
+end
+t_poly_array_zip
+

data/vendor/spinel/test/bundle_tiny_array.rb.expected

@@ -0,0 +1,53 @@
+5
+nil
+1
+8
+"c"
+nil
+0
+1
+2
+---
+idx 0
+idx 1
+idx 2
+---
+done
+2
+nil
+{1=>[1, 4], 2=>[2, 5], 0=>[3, 6]}
+{"a"=>["apple", "ant"], "b"=>["bee"], "c"=>["cat", "cow"]}
+1,x,y
+1xy
+10-y
+done
+true
+false
+true
+false
+[[1, "a"], [1, "b"], [2, "a"], [2, "b"]]
+[[1, "x"], [2, "x"], [3, "x"]]
+[["a", 1], ["a", 2], ["b", 1], ["b", 2]]
+[[1, 3], [1, 4], [2, 3], [2, 4]]
+[[1.5, 1], [1.5, 2], [2.5, 1], [2.5, 2]]
+[[1, 1], [1, 2], [2, 2]]
+[[1, 1], [1, 2], [1, 3], [2, 2], [2, 3], [3, 3]]
+[[1, 1, 1], [1, 1, 2], [1, 2, 2], [2, 2, 2]]
+[[1], [2], [3]]
+10
+30
+99
+20
+:y
+true
+false
+false
+false
+true
+10
+24
+20
+2400
+7
+[[1, 2], ["a", "b"]]
+[[1, 2], ["a", "b"], [:s, :t]]

data/vendor/spinel/test/bundle_tiny_misc.rb

@@ -0,0 +1,187 @@
+# Bundled tiny tests (auto-grouped by bundler):
+#   - comparable_clamp_string
+#   - file_separator_constants
+#   - hash_fetch_int_int
+#   - i897
+#   - i957
+#   - i976
+#   - i981
+#   - kernel_rand_no_arg_float
+#   - kernel_string_coercion
+#   - nil_coercion
+#   - nil_to_h
+#   - ruby_version_constants
+#   - sym_int_hash_key_value
+#   - symbol_name
+#   - time_subtraction_returns_float
+
+# === comparable_clamp_string ===
+def t_comparable_clamp_string
+# Issue #899: Comparable#clamp on a string receiver via strcmp.
+puts "b".clamp("a", "c")
+puts "z".clamp("a", "c")
+puts "a".clamp("b", "c")
+end
+t_comparable_clamp_string
+
+# === file_separator_constants ===
+def t_file_separator_constants
+# Issue #891: File::SEPARATOR / PATH_SEPARATOR / ALT_SEPARATOR
+# resolved at compile time as string literals.
+puts File::SEPARATOR
+puts File::PATH_SEPARATOR
+puts "a" + File::SEPARATOR + "b"
+end
+t_file_separator_constants
+
+# === hash_fetch_int_int ===
+def t_hash_fetch_int_int
+# Hash#fetch on an int->int specialized hash: plain lookup and the 2-arg
+# default form (the int->int variant previously had #[] but not #fetch).
+h = { 1 => 10, 2 => 20 }
+puts h.fetch(1)
+puts h.fetch(2)
+puts h.fetch(9, -1)
+puts h.fetch(0, 42)
+puts "done"
+end
+t_hash_fetch_int_int
+
+# === i897 ===
+def t_i897
+puts (1..Float::INFINITY).lazy.select { |x| x.odd? }.first(5).inspect
+puts (1..Float::INFINITY).lazy.select { |x| x % 3 == 0 }.first(4).inspect
+puts (1..Float::INFINITY).lazy.reject { |x| x.even? }.first(5).inspect
+puts (1..Float::INFINITY).lazy.first(3).inspect
+puts (10..Float::INFINITY).lazy.select { |x| x.even? }.first(3).inspect
+puts (1..100).lazy.select { |x| x % 7 == 0 }.first(3).inspect
+puts (1..Float::INFINITY).lazy.select { |x| x > 5 }.first
+end
+t_i897
+
+# === i957 ===
+def t_i957
+h = {a: 1, b: 2}
+p = h.to_proc
+puts p.call(:a)
+puts p.call(:b)
+
+g = {"x" => 10, "y" => 20}.to_proc
+puts g.call("x")
+puts g.call("y")
+end
+t_i957
+
+# === i976 ===
+def t_i976
+p = Proc.new { |a, b| puts "a=#{a.inspect} b=#{b.inspect}" }
+p.call(1)
+p.call(1, 2)
+
+q = Proc.new { |x, y, z| puts "x=#{x} y=#{y} z=#{z}" }
+q.call(10)
+q.call(10, 20)
+q.call(10, 20, 30)
+end
+t_i976
+
+# === i981 ===
+def t_i981
+puts ("a".."c").to_a.inspect
+puts ("A".."D").to_a.inspect
+puts ("aa".."ac").to_a.inspect
+puts ("az".."bb").to_a.inspect
+puts (1..3).to_a.inspect
+end
+t_i981
+
+# === kernel_rand_no_arg_float ===
+def t_kernel_rand_no_arg_float
+# Kernel#rand without args returns Float in [0.0, 1.0).
+puts rand.class
+puts rand(100).class
+v = rand
+puts v >= 0.0 && v < 1.0
+end
+t_kernel_rand_no_arg_float
+
+# === kernel_string_coercion ===
+def t_kernel_string_coercion
+# Issue #879: Kernel#String() coercion routes through .to_s for
+# each primitive type. nil -> "". Pre-fix: silently emitted 0.
+puts String(42)
+puts String(nil).inspect
+puts String(true)
+puts String("hi")
+puts String(:sym)
+puts String(3.14)
+end
+t_kernel_string_coercion
+
+# === nil_coercion ===
+def t_nil_coercion
+# Issue #871: NilClass coercion methods. v1 covers to_i / to_f /
+# to_a. to_c, to_r, to_h deferred (Complex, Rational unsupported;
+# typed-Hash empty needs element-type judgement).
+puts nil.to_i
+puts nil.to_f
+puts nil.to_a.inspect
+end
+t_nil_coercion
+
+# === nil_to_h ===
+def t_nil_to_h
+# NilClass#to_h returns an empty hash.
+p nil.to_h
+p nil.to_h.length
+p nil.to_h.empty?
+end
+t_nil_to_h
+
+# === ruby_version_constants ===
+def t_ruby_version_constants
+# Issue #890: RUBY_VERSION / RUBY_PLATFORM / RUBY_ENGINE built-in
+# string constants. Format-only check so the test stays stable
+# across platforms — the actual values are runtime-detected.
+puts RUBY_VERSION.is_a?(String)
+puts RUBY_PLATFORM.is_a?(String)
+puts RUBY_ENGINE.is_a?(String)
+puts RUBY_PLATFORM.length > 0
+end
+t_ruby_version_constants
+
+# === sym_int_hash_key_value ===
+def t_sym_int_hash_key_value
+# Hash#key(value) / #value? / #has_value? on sym_int_hash.
+# Missing-key #key returns the empty-sym sentinel since the typed
+# sym slot can't carry nil.
+h = {a: 1, b: 2, c: 3}
+puts h.key(2).inspect
+puts h.has_value?(2)
+puts h.has_value?(99)
+puts h.value?(3)
+end
+t_sym_int_hash_key_value
+
+# === symbol_name ===
+def t_symbol_name
+# Symbol#name returns the symbol's name as a string (not a pointer
+# value cast as int).
+puts :hello.name
+puts :foo.name.length
+end
+t_symbol_name
+
+# === time_subtraction_returns_float ===
+def t_time_subtraction_returns_float
+# Issue #901: Time - Time returns Float (elapsed seconds). LV
+# slot inferred as sp_Time on pass 1, refined to float on pass 2
+# once the rhs LV was declared as time. merge_refined_local_type
+# now accepts time -> float refinement.
+start = Time.now
+diff = Time.now - start
+puts diff >= 0
+puts diff.class
+end
+t_time_subtraction_returns_float
+

data/vendor/spinel/test/bundle_tiny_misc.rb.expected

@@ -0,0 +1,59 @@
+b
+c
+b
+/
+:
+a/b
+10
+20
+-1
+42
+done
+[1, 3, 5, 7, 9]
+[3, 6, 9, 12]
+[1, 3, 5, 7, 9]
+[1, 2, 3]
+[10, 12, 14]
+[7, 14, 21]
+6
+1
+2
+10
+20
+a=1 b=0
+a=1 b=2
+x=10 y=0 z=0
+x=10 y=20 z=0
+x=10 y=20 z=30
+["a", "b", "c"]
+["A", "B", "C", "D"]
+["aa", "ab", "ac"]
+["az", "ba", "bb"]
+[1, 2, 3]
+Float
+Integer
+true
+42
+""
+true
+hi
+sym
+3.14
+0
+0.0
+[]
+{}
+0
+true
+true
+true
+true
+true
+:b
+true
+false
+true
+hello
+3
+true
+Float

data/vendor/spinel/test/bundle_tiny_num.rb

@@ -0,0 +1,87 @@
+# Bundled tiny tests (auto-grouped by bundler):
+#   - float_infinite_nil
+#   - float_next_prev
+#   - float_zero_p
+#   - int_step_expr_block
+#   - integer_nonzero
+#   - range_size_exclusive
+#   - range_size_string
+
+# === float_infinite_nil ===
+def t_float_infinite_nil
+# Float#infinite?: nil for a finite value, -1 / +1 for -Inf / +Inf.
+p 0.0.infinite?
+p 3.14.infinite?
+p (1.0 / 0.0).infinite?
+p (-1.0 / 0.0).infinite?
+puts((1.0 / 0.0).infinite? ? "inf" : "finite")
+puts(2.5.infinite? ? "inf" : "finite")
+end
+t_float_infinite_nil
+
+# === float_next_prev ===
+def t_float_next_prev
+# Float#next_float / prev_float — adjacent IEEE 754 representable
+# values via libm's nextafter.
+puts 1.0.next_float
+puts 1.0.prev_float
+puts 0.0.next_float
+puts 0.0.prev_float
+end
+t_float_next_prev
+
+# === float_zero_p ===
+def t_float_zero_p
+# Float#zero?: true only for 0.0 / -0.0.
+p 0.0.zero?
+p(-0.0.zero?)
+p 3.5.zero?
+p (1.0 - 1.0).zero?
+puts(0.0.zero? ? "z" : "nz")
+end
+t_float_zero_p
+
+# === int_step_expr_block ===
+def t_int_step_expr_block
+# Integer#step with a block in expression position — CRuby returns
+# the receiver, not 0. Previously fell through to the unresolved-
+# call path and emitted 0 (and analyze inferred int_array, which
+# then SEGV'd when result was used as a pointer).
+result = 1.step(5) { |x| x }
+puts result.inspect
+puts result.class
+end
+t_int_step_expr_block
+
+# === integer_nonzero ===
+def t_integer_nonzero
+# Issue #874: Integer#nonzero? returns nil when receiver is 0,
+# self otherwise. Surfaces as int? (nullable int).
+puts 0.nonzero?.inspect
+puts 42.nonzero?.inspect
+puts(-5.nonzero? || "default")
+end
+t_integer_nonzero
+
+# === range_size_exclusive ===
+def t_range_size_exclusive
+# Range#size with exclusive range
+# (1...5).size should return 4, not 5.
+
+puts (1..5).size
+puts (1...5).size
+end
+t_range_size_exclusive
+
+# === range_size_string ===
+def t_range_size_string
+# A String range has no integer size; CRuby Range#size returns nil.
+# Integer ranges keep returning their element count.
+p (1..10).size
+p (1...10).size
+p ("a".."z").size
+p ("a".."z").size.nil?
+p ("a".."e").size
+end
+t_range_size_string
+

data/vendor/spinel/test/bundle_tiny_num.rb.expected

@@ -0,0 +1,27 @@
+nil
+nil
+1
+-1
+inf
+finite
+1.0000000000000002
+0.9999999999999999
+5.0e-324
+-5.0e-324
+true
+true
+false
+true
+z
+1
+Integer
+nil
+42
+-5
+5
+4
+10
+9
+nil
+true
+nil