rubyduino 0.1.3 → 0.2.1

data/vendor/spinel/test/float_round_ndigits_return_type.rb

@@ -0,0 +1,24 @@
+# Float#ceil/floor/round/truncate return type is value-based on a
+# literal ndigits, matching CRuby: Integer when ndigits <= 0 (or
+# absent), Float when > 0. (A non-literal ndigits stays Float.) Values
+# stay numerically correct. See docs/FLOAT-ROUNDING.md.
+
+# no-arg -> Integer
+puts 1.9.ceil.class
+puts 1.9.floor.class
+puts 1.5.round.class
+puts 1.9.truncate.class
+
+# any ndigits arg -> Float
+puts 1.9.ceil(0).class
+puts 1.9.ceil(-1).class
+puts 1.111.ceil(1).class
+puts 1.9.round(0).class
+puts 1.9.round(-1).class
+puts 1.234.round(2).class
+puts 1.9.truncate(-1).class
+
+# numerically-correct values
+puts 1.9.ceil
+puts 1.234.round(2)
+puts 1.999.floor(1)

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

@@ -0,0 +1,14 @@
+Integer
+Integer
+Integer
+Integer
+Integer
+Integer
+Float
+Integer
+Integer
+Float
+Integer
+2
+1.23
+1.9

data/vendor/spinel/test/float_round_value_based_type.rb

@@ -0,0 +1,17 @@
+# CRuby's Float rounding return type is value-based on ndigits:
+# Integer when ndigits <= 0 (or absent), Float when > 0. Spinel used to
+# be presence-based (any arg => Float), so round(0)/round(-1) were Float.
+p 1.9.round
+p 1.9.round.class
+p 1.9.round(0)
+p 1.9.round(0).class
+p 1234.5.round(-1)
+p 1234.5.round(-1).class
+p 1.234.round(2)
+p 1.234.round(2).class
+p 1.5.ceil(0)
+p 1.5.ceil(0).class
+p 1.23.floor(1)
+p 1.23.floor(1).class
+p 19.9.truncate(-1)
+p 19.9.truncate(-1).class

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

@@ -0,0 +1,14 @@
+2
+Integer
+2
+Integer
+1230
+Integer
+1.23
+Float
+2
+Integer
+1.2
+Float
+10
+Integer

data/vendor/spinel/test/float_round_zero.rb

@@ -0,0 +1,18 @@
+# Float#round/ceil/floor/truncate return type matches CRuby's
+# value-based rule for a literal ndigits: no-arg and ndigits <= 0 return
+# Integer, ndigits > 0 returns Float. (A non-literal ndigits stays
+# Float.) See docs/FLOAT-ROUNDING.md.
+puts 3.5.round(0).inspect
+puts 3.5.round.inspect
+puts 3.5.round(1).inspect
+puts 3.5.round(2).inspect
+
+puts 3.7.ceil(0).inspect
+puts 3.7.ceil.inspect
+puts 3.7.ceil(1).inspect
+
+puts 3.7.floor(0).inspect
+puts 3.7.floor.inspect
+
+puts 3.7.truncate(0).inspect
+puts 3.7.truncate.inspect

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

@@ -0,0 +1,11 @@
+4
+4
+3.5
+3.5
+4
+4
+3.7
+3
+3
+3
+3

data/vendor/spinel/test/float_spaceship.rb

@@ -0,0 +1,13 @@
+# Float#<=> 3-way compare returns -1 / 0 / 1, mirroring Integer#<=>.
+p(3.0 <=> 5.0)
+p(5.0 <=> 3.0)
+p(3.0 <=> 3.0)
+p(3.5 <=> 3)
+p(3 <=> 3.5)
+
+# A float comparator block now drives sort / min / max / minmax.
+p [3.5, 1.5, 2.5].sort { |a, b| a <=> b }
+p [3.5, 1.5, 2.5].min { |a, b| a <=> b }
+p [3.5, 1.5, 2.5].max { |a, b| a <=> b }
+p [3.5, 1.5, 2.5].minmax { |a, b| a <=> b }
+p [3.5, 1.5, 2.5].minmax { |a, b| b <=> a }

data/vendor/spinel/test/float_step_block.rb

@@ -0,0 +1,16 @@
+# Issue #870: Float#step yields floats. Pre-fix the LV slot was
+# typed as mrb_int so `lv_x += 0.5` truncated to `+= 0` and looped
+# forever.
+result = []
+1.0.step(3.0, 0.5) { |x| result << x }
+puts result.inspect
+
+# int step still works
+out = []
+1.step(7, 2) { |i| out << i }
+puts out.inspect
+
+# float step argument widens int recv to float
+result2 = []
+1.step(3.0, 0.5) { |x| result2 << x }
+puts result2.inspect

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

@@ -0,0 +1,3 @@
+[1.0, 1.5, 2.0, 2.5, 3.0]
+[1, 3, 5, 7]
+[1.0, 1.5, 2.0, 2.5, 3.0]

data/vendor/spinel/test/float_step_to_a.rb

@@ -0,0 +1,20 @@
+# Float#step without a block materialises into an array.
+# Previously SEGV'd because the call fell through to the
+# unresolved-call int path (emitting 0), then `.to_a` was
+# dispatched on int 0 as if it were a pointer.
+puts 1.0.step(3.0, 0.5).to_a.inspect
+puts 1.0.step(2.0).to_a.inspect
+
+# Integer#step with int args returns an IntArray.
+puts 1.step(5).to_a.inspect
+puts 1.step(10, 2).to_a.inspect
+
+# Integer#step with a float step promotes to FloatArray.
+puts 1.step(5, 0.5).to_a.inspect
+
+# Empty: limit below start with positive step.
+puts 5.0.step(1.0, 1.0).to_a.inspect
+puts 5.step(1).to_a.inspect
+
+# Block form is unchanged.
+1.0.step(2.0, 0.5) { |x| puts x }

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

@@ -0,0 +1,10 @@
+[1.0, 1.5, 2.0, 2.5, 3.0]
+[1.0, 2.0]
+[1, 2, 3, 4, 5]
+[1, 3, 5, 7, 9]
+[1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0]
+[]
+[]
+1.0
+1.5
+2.0

data/vendor/spinel/test/gc_grandparent_ivar_scan.rb

@@ -0,0 +1,28 @@
+# Grandparent ivar must survive GC even when a passthrough middle
+# class introduces no ivars of its own. The leaf's scan function has
+# to walk the full ancestor chain, not just the immediate parent.
+class A
+  def payload=(v); @payload = v; end
+  def payload; @payload; end
+end
+class B < A          # passthrough: no ivars of its own
+end
+class C < B          # leaf with its own ivar
+  def own=(v); @own = v; end
+  def own; @own; end
+end
+
+def churn(n)
+  s = ""; i = 0
+  while i < n; s = s + i.to_s + ","; i += 1; end
+  s.length
+end
+
+obj = C.new
+obj.payload = "secret_" + 42.to_s
+obj.own     = "kept_" + 7.to_s
+GC.start
+churn(8000)
+GC.start
+puts "own=" + obj.own
+puts "payload=" + obj.payload

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

@@ -0,0 +1,2 @@
+own=kept_7
+payload=secret_42

data/vendor/spinel/test/gc_poly_local_int.rb

@@ -0,0 +1,11 @@
+# A poly local holding a non-pointer (int) value must be marked
+# tag-aware: rooting routes through sp_mark_rbval, which skips INT
+# rather than dereferencing the boxed integer as a pointer.
+class A; def v; 1; end; end
+def churn(k); s = ""; i = 0; while i < k; s = s + i.to_s + ","; i += 1; end; s.length; end
+arr = [A.new, 100 + 1]
+x = arr[1]
+GC.start
+churn(8000)
+GC.start
+p x

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

@@ -0,0 +1 @@
+101

data/vendor/spinel/test/gc_poly_local_root.rb

@@ -0,0 +1,19 @@
+# A poly (sp_RbVal) local assigned from a method whose return type
+# unifies to poly must be GC-rooted, or a collection while it's live
+# frees the object it holds (use-after-free).
+class A; def v=(x); @v = x; end; def v; @v; end; end
+class B; def v=(x); @v = x; end; def v; @v; end; end
+def pick(n)
+  if n == 0
+    A.new
+  else
+    B.new
+  end
+end
+def churn(k); s = ""; i = 0; while i < k; s = s + i.to_s + ","; i += 1; end; s.length; end
+obj = pick(1)
+obj.v = "keep_" + 5.to_s
+GC.start
+churn(8000)
+GC.start
+puts obj.v

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

@@ -0,0 +1 @@
+keep_5

data/vendor/spinel/test/gc_poly_local_setjmp.rb

@@ -0,0 +1,16 @@
+# A poly local live across a rescue (setjmp scope) with a GC: it must
+# be both volatile (longjmp-stable) and GC-rooted.
+class A; def v=(x); @v = x; end; def v; @v; end; end
+class B; def v=(x); @v = x; end; def v; @v; end; end
+def pick(n); n == 0 ? A.new : B.new; end
+def churn(k); s = ""; i = 0; while i < k; s = s + i.to_s + ","; i += 1; end; s.length; end
+obj = pick(1)
+obj.v = "keep_" + 9.to_s
+begin
+  GC.start
+  churn(8000)
+  raise "boom"
+rescue => e
+  GC.start
+end
+puts obj.v

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

@@ -0,0 +1 @@
+keep_9

data/vendor/spinel/test/gc_root_call_args.rb

@@ -0,0 +1,35 @@
+# Regression for #1057: a call's argument temporaries must stay GC-
+# rooted across evaluation of its sibling arguments. Each case puts a
+# fresh heap string in the slot gcc evaluates first (the last one)
+# beside a sibling whose evaluation triggers a collection. Without
+# rooting, the fresh string is freed mid-call and the callee reads
+# reused/garbage memory.
+
+def churn_gc(x)
+  GC.start
+  i = 0
+  s = ""
+  while i < 8000
+    s = s + i.to_s + ","
+    i += 1
+  end
+  x
+end
+
+def join2(a, b)
+  a + "|" + b
+end
+
+class Joiner
+  def join2(a, b)
+    a + "|" + b
+  end
+end
+
+# top-level method call
+puts join2(churn_gc("A"), "B_" + 1.to_s)
+# instance method call
+puts Joiner.new.join2(churn_gc("C"), "D_" + 2.to_s)
+# sprintf / string interpolation
+label = "E"
+puts "[#{churn_gc("F")}|#{label + "_" + 3.to_s}]"

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

@@ -0,0 +1,3 @@
+A|B_1
+C|D_2
+[F|E_3]

data/vendor/spinel/test/gc_root_heap_param.rb

@@ -0,0 +1,21 @@
+# A heap-typed (poly / string) method parameter must stay GC-rooted
+# across a collection triggered inside the method, so a later read of it
+# (e.g. sp_poly_to_s in a %s interpolation arg) is not a use-after-free.
+# Regression for #1068 (follow-up to #1057).
+def gc_then
+  GC.start
+  i = 0
+  s = ""
+  while i < 6000
+    s = s + i.to_s + ","
+    i += 1
+  end
+  "G"
+end
+
+def wrap(body)
+  "#{gc_then}-#{body}"
+end
+
+wrap(42)                  # int call site forces `body` to a poly param
+puts wrap("P_" + 7.to_s)  # string call site

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

@@ -0,0 +1 @@
+G-P_7

data/vendor/spinel/test/global_multi_assign.rb

@@ -0,0 +1,28 @@
+# Multi-assignment into global variables must declare and type every
+# target from the right-hand side, not only the first. A non-int RHS
+# (string / float / array) or a splat-rest target previously left the C
+# global declared as mrb_int and failed to compile.
+$g1, $g2 = 1, 2
+p [$g1, $g2]
+
+$s1, $s2 = "x", "y"
+p [$s1, $s2]
+
+$f1, $f2 = 1.5, 2.5
+p [$f1, $f2]
+
+$pp, $qq = [10, 20]
+p [$pp, $qq]
+
+# mixed local and global targets
+first, $g = 1, 2
+p [first, $g]
+
+# splat-rest target collects into an array global
+$x, *$rest = 1, 2, 3, 4
+p $x
+p $rest
+
+# heterogeneous targets
+$h1, $h2, $h3 = "a", 2, 3.0
+p [$h1, $h2, $h3]

data/vendor/spinel/test/global_var_punct.rb

@@ -0,0 +1,9 @@
+# Issue #831: punctuation global variables compile to safe
+# C identifiers. Pre-fix the generated C had `gv_!` / `gv_;` /
+# `gv_,` / `gv_/` etc. which aren't valid C and broke any program
+# that referenced them — including `rescue => e` bodies because
+# the parser implicitly threads `$!` through some shapes.
+puts $!.inspect       # nil outside rescue
+puts $;.inspect       # nil (split-default sep — spinel doesn't honor it)
+puts $,.inspect       # nil (Array#print sep — same)
+puts $/.inspect       # "\n" — the only one with a meaningful default

data/vendor/spinel/test/gsub_sub_block.rb

@@ -0,0 +1,14 @@
+# Block-form String#gsub / #sub: the block receives each match and
+# returns its replacement. The result used to be padded with trailing
+# NUL bytes (the working buffer was returned with its allocation size
+# as the byte length, not the content length).
+p "abc".gsub(/[ac]/) { |m| m.upcase }
+p "hello world".gsub(/o/) { |m| "0" }
+p "aaa".gsub(/a/) { |m| m + m }
+p "abc".sub(/b/) { |m| m.upcase }
+p "x y z".gsub(/\s/) { |m| "_" }
+p "no match here".gsub(/z+/) { |m| "!" }
+
+# Replacement much larger than input forces the buffer to grow
+# (realloc must operate on a plain malloc'd buffer, not a string alloc).
+p ("a" * 100).gsub(/a/) { |m| "XYZ" }

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

@@ -0,0 +1,7 @@
+"AbC"
+"hell0 w0rld"
+"aaaaaa"
+"aBc"
+"x_y_z"
+"no match here"
+"XYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZXYZ"

data/vendor/spinel/test/gsub_with_hash_replacement.rb

@@ -0,0 +1,19 @@
+# #485. `String#gsub(regex, hash)` — the per-match hash-lookup form
+# Ruby uses for HTML/JSON escape. Pre-fix codegen passed the hash
+# pointer through to sp_re_gsub's `const char *rep` parameter; the
+# binary read garbage from the pointer's memory in place of the
+# replacement string. Fix: detect a str_str_hash second arg and
+# route to a parallel runtime helper that does the per-match
+# lookup.
+
+ESCAPES = {
+  "&" => "&",
+  "<" => "&lt;",
+  ">" => "&gt;",
+}.freeze
+
+PATTERN = /[&<>]/.freeze
+
+puts "a&b<c".gsub(PATTERN, ESCAPES)
+puts "<p>x & y</p>".gsub(PATTERN, ESCAPES)
+puts "no specials here".gsub(PATTERN, ESCAPES)

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

@@ -0,0 +1,3 @@
+a&b<c
+<p>x & y</p>
+no specials here

data/vendor/spinel/test/hangs_548.rb

@@ -0,0 +1,66 @@
+# #548. Four shapes that compiled cleanly but hung at runtime.
+# Adam Doppelt's "Puzzles, third edition."
+#
+# 1. `a.concat(a, a)` -- two bugs in compile_call_stmt's concat
+#    arm. (a) Only the first arg was processed, so multi-arg
+#    concat dropped the tail silently. (b) The src-array length
+#    was queried inside the push loop; when an arg aliased the
+#    receiver (`a.concat(a)`) every push grew the source and
+#    the loop never terminated. Fix: snapshot each arg's length
+#    before its inner loop, then iterate every arg.
+#
+# 2. `/\#{re}/` -- regex compiler entered an infinite loop. The
+#    sequence `\#` lowered to literal `#`, then `{re}` arrived
+#    at compile_atom with `{` as the leading char. `{` was in
+#    compile_atom's "not an atom" filter, so the function
+#    returned without consuming and compile_seq's outer loop
+#    spun. CRuby treats `/{re}/` as matching the literal text
+#    `{re}` (`{...}` without a valid quantifier is literal); we
+#    mirror that by removing `{` from compile_atom's filter so
+#    a leading `{` falls through to the literal-char emit.
+#
+# 3. `while () ; 123 ; end` -- empty `()` infers as "void" and
+#    lowers to literal `0`. compile_cond_expr's catch-all
+#    `((expr), TRUE)` flipped the empty-parens condition to
+#    always-true and the loop hung. Treat "void" like "nil" in
+#    compile_cond_expr -- both lower to FALSE so `while ()`
+#    never enters the body, matching CRuby.
+#
+# 4. `i += 1; raise; rescue; retry unless i == 7` -- setjmp/
+#    longjmp local-preservation. `lv_i` modified inside the
+#    setjmp scope must be `volatile` to survive longjmp's
+#    register-unwind; with `-O3` the compiler register-cached
+#    `lv_i` and the rescue handler saw a stale 0, so `i == 7`
+#    was never satisfied and retry spun forever. Fix: pre-scan
+#    method bodies for setjmp-triggering shapes (begin/rescue,
+#    raise, retry) and mark non-pointer locals as `volatile`.
+#    Pointer locals stay non-volatile (GC-rooted via
+#    SP_GC_ROOT already keeps them stable; tagging them
+#    volatile triggers -Wdiscarded-qualifiers cascade at
+#    string/array helper call sites).
+
+# Repro 1: self-concat with self twice.
+a = [1, 2]
+a.concat(a, a)
+puts a.length      # 8 -- [1,2] + [1,2] + [1,2,1,2]
+
+# Repro 2: regex with literal `\#{re}` characters.
+re = /foo|bar/
+r2 = /\#{re}/
+puts "ok2"
+
+# Repro 3: while () never enters.
+while () ; 123 ; end
+puts "ok3"
+
+# Repro 4: retry-counter survives longjmp.
+def foo
+  i = 0
+  begin ; i += 1 ; raise "bar" ; rescue ; retry unless i == 7 ; end
+  raise "baz" unless i == 7
+rescue
+  123
+end
+puts foo  # 123  (foo's body would also raise "baz" if i != 7; here i == 7
+          #       so no raise, and the function falls through. The
+          #       outer rescue is dead code for this path.)

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

@@ -0,0 +1,4 @@
+8
+ok2
+ok3
+123

data/vendor/spinel/test/hash_block_methods_variants.rb

@@ -0,0 +1,15 @@
+# Hash block methods (map / each_value / transform_values / select /
+# reject) across the typed-hash variants. sym_int variants already
+# worked; this fills in the str_int / sym_str / str_str arms that
+# previously fell through to the unresolved-call path.
+puts({a: 1, b: 2}.map { |k, v| v * 10 }.inspect)
+puts({a: 1, b: 2}.transform_values { |v| v * 10 }.inspect)
+puts({a: 1, b: 2, c: 3}.select { |k, v| v > 1 }.inspect)
+puts({"a" => 1, "b" => 2}.map { |k, v| v * 10 }.inspect)
+puts({"a" => 1, "b" => 2}.transform_values { |v| v * 10 }.inspect)
+puts({a: "x", b: "y"}.map { |k, v| v }.inspect)
+puts({a: "x", b: "y"}.transform_values { |v| v + "!" }.inspect)
+puts({"a" => "x", "b" => "y"}.map { |k, v| v }.inspect)
+puts({"a" => "x", "b" => "y"}.transform_values { |v| v + "!" }.inspect)
+{a: 1, b: 2}.each_value { |v| puts v }
+{"a" => 1}.each_value { |v| puts v }

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

@@ -0,0 +1,12 @@
+[10, 20]
+{a: 10, b: 20}
+{b: 2, c: 3}
+[10, 20]
+{"a"=>10, "b"=>20}
+["x", "y"]
+{a: "x!", b: "y!"}
+["x", "y"]
+{"a"=>"x!", "b"=>"y!"}
+1
+2
+1

data/vendor/spinel/test/hash_clear.rb

@@ -0,0 +1,43 @@
+h1 = { a: 1, b: 2, c: 3 }
+h1.clear
+puts h1.size
+puts h1.empty?
+
+h2 = { "a" => 1, "b" => 2 }
+h2.clear
+puts h2.size
+
+h3 = { x: "one", y: "two" }
+h3.clear
+puts h3.size
+
+h4 = { a: 1, b: "x" }
+h4.clear
+puts h4.size
+
+h5 = { "a" => 1, "b" => "x" }
+h5.clear
+puts h5.size
+
+h6 = { "a" => "one", "b" => "two" }
+h6.clear
+puts h6.size
+
+h7 = { 1 => "one", 2 => "two" }
+h7.clear
+puts h7.size
+
+h8 = { 1 => "one", 2 => 2 }
+h8.clear
+puts h8.size
+
+h9 = { "a" => "one", 2 => 2 }
+h9.clear
+puts h9.size
+
+# After clear, can write again — slot reset works
+h_rw = { a: 1, b: 2 }
+h_rw.clear
+h_rw[:z] = 99
+puts h_rw[:z]
+puts h_rw.size

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

@@ -0,0 +1,12 @@
+0
+true
+0
+0
+0
+0
+0
+0
+0
+0
+99
+1

data/vendor/spinel/test/hash_compound_assign_more.rb

@@ -0,0 +1,21 @@
+# Hash#[] op= for string-valued and poly-valued typed hashes.
+
+# sym_str_hash: += str → concat.
+h = {a: "hello", b: "world"}
+h[:a] += "!"
+puts h[:a]
+
+# str_str_hash: += str → concat.
+h2 = {"a" => "hello", "b" => "world"}
+h2["a"] += "!"
+puts h2["a"]
+
+# sym_poly_hash: += int on a hash whose values are mixed.
+h3 = {a: 1, b: 2.0}
+h3[:a] += 10
+puts h3[:a]
+
+# str_poly_hash: += int.
+h4 = {"a" => 1, "b" => 2.0}
+h4["a"] += 10
+puts h4["a"]

data/vendor/spinel/test/hash_delete_if_select_reject_bang.rb

@@ -0,0 +1,19 @@
+# Hash#delete_if / #select! / #reject! on typed hashes mutate
+# the receiver in place.
+
+h = {a: 1, b: 2, c: 3, d: 4}
+h.delete_if { |k, v| v % 2 == 0 }
+puts h.inspect
+
+h2 = {a: 1, b: 2, c: 3}
+h2.select! { |k, v| v % 2 == 0 }
+puts h2.inspect
+
+h3 = {a: 1, b: 2, c: 3}
+h3.reject! { |k, v| v > 1 }
+puts h3.inspect
+
+# str_int_hash variant.
+h4 = {"x" => 10, "y" => 20, "z" => 30}
+h4.delete_if { |k, v| v >= 20 }
+puts h4.inspect

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

@@ -0,0 +1,4 @@
+{a: 1, c: 3}
+{b: 2}
+{a: 1}
+{"x"=>10}

data/vendor/spinel/test/hash_delete_returns_value.rb

@@ -0,0 +1,21 @@
+h_si = { a: 1, b: 2, c: 3 }
+v1 = h_si.delete(:a)
+puts v1
+puts h_si.size
+
+h_ss = { x: "one", y: "two" }
+v2 = h_ss.delete(:x)
+puts v2
+puts h_ss.size
+
+# delete missing key on sym_int_hash returns 0 (spinel int default,
+# diverges from CRuby's nil but matches existing has_key fallback)
+h2 = { a: 1 }
+puts h2.delete(:b)
+puts h2.size
+
+# Multi-value sym_poly_hash
+h_sp = { a: 1, b: "two", c: :sym }
+v3 = h_sp.delete(:b)
+puts v3.inspect
+puts h_sp.size

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

@@ -0,0 +1,8 @@
+1
+2
+one
+1
+0
+1
+"two"
+2