rubyduino 0.2.0 → 0.2.1

data/vendor/spinel/test/bundle_hash_b1.rb

@@ -0,0 +1,99 @@
+# Bundled tests:
+#   - hash_dup_str_int_str
+#   - hash_each_block_param_types
+#   - hash_merge_cross_variant
+
+# === hash_dup_str_int_str ===
+def t_hash_dup_str_int_str
+  # Hash#dup was missing from the str_str_hash and int_str_hash codegen
+  # dispatch tables -- the runtime helpers exist (sp_StrStrHash_dup,
+  # sp_IntStrHash_dup) but the codegen arms didn't dispatch to them, so
+  # `m = h.dup` lowered to `cannot resolve call to 'dup' on str_str_hash
+  # (emitting 0)` and subsequent `.length` / `[]=` / `.each` calls on
+  # the int-typed `0` segfaulted at runtime.
+  #
+  # Sibling Hash variants (sym_int / sym_str / sym_poly / str_int /
+  # str_poly) already had dup arms; this closes the coverage gap.
+  # Issue #592.
+  
+  # str_str_hash
+  h1 = {"a" => "1", "b" => "2"}
+  m1 = h1.dup
+  m1["c"] = "3"
+  puts h1.length          # 2
+  puts m1.length          # 3
+  puts m1["a"]            # 1
+  puts m1["c"]            # 3
+  
+  # int_str_hash
+  h2 = {1 => "one", 2 => "two"}
+  m2 = h2.dup
+  m2[3] = "three"
+  puts h2.length          # 2
+  puts m2.length          # 3
+  puts m2[1]              # one
+  puts m2[3]              # three
+  
+  # Verify the dup is independent (original unchanged).
+  puts h1.has_key?("c")   # false
+  puts h2.has_key?(3)     # false
+end
+t_hash_dup_str_int_str
+
+# === hash_each_block_param_types ===
+def t_hash_each_block_param_types
+  # `h.each do |k, v|` previously had its block params typed via
+  # elem_type_of_array(recv_type), which only knows about typed
+  # arrays — for a hash receiver it fell back to "int" for both
+  # `k` and `v`. Code inside the block like `puts k + ": " + v.to_s`
+  # then had analyze cache (and codegen's infer_type fallback)
+  # return "int" for the chained `+`, lowering `puts` to
+  # `printf("%lld", (long long)(string_concat + int_to_s))` — both
+  # the cast and the raw `+` between pointers fail C compile.
+  #
+  # Fix: block_param_type_at now branches on is_hash_type for the
+  # `each` family and returns the hash's key part for pi==0 and the
+  # value part for pi==1, expanded to full names (str→string,
+  # sym→symbol). Codegen's infer_type CallNode cache-miss path also
+  # learned `+` on string recv returns string and `.to_s` returns
+  # string, covering nodes inside block bodies that walk_and_cache
+  # doesn't cache.
+  
+  h = { "a" => 1, "b" => 2 }
+  h.each do |k, v|
+    puts k + ": " + v.to_s
+  end
+end
+t_hash_each_block_param_types
+
+# === hash_merge_cross_variant ===
+def t_hash_merge_cross_variant
+  # Issue #661: Hash#merge across hash variants with different value
+  # types. Previously the codegen used the receiver's prefix
+  # unconditionally (sp_SymIntHash_merge(h1, h2) where h2 was
+  # sp_SymStrHash *), failing C compile.
+  #
+  # Fix: when recv and arg are both sym-keyed (or both str-keyed) but
+  # their value types differ, the analyzer pulls the call's return
+  # type up to sym_poly_hash / str_poly_hash, and codegen promotes
+  # both sides via the existing *_to_sym_poly / *_from_str_int_hash
+  # converters before dispatching sp_*PolyHash_merge.
+  
+  # Sym + Sym with mixed value types.
+  h1 = { a: 1, b: 2 }
+  h2 = { c: "x", d: "y" }
+  h3 = h1.merge(h2)
+  puts h3[:a].inspect
+  puts h3[:c].inspect
+  
+  # Str + Str with mixed value types.
+  s1 = { "a" => 1, "b" => 2 }
+  s2 = { "c" => "x", "d" => "y" }
+  s3 = s1.merge(s2)
+  puts s3["a"].inspect
+  puts s3["c"].inspect
+  
+  puts "ok"
+end
+t_hash_merge_cross_variant
+

data/vendor/spinel/test/bundle_hash_b2.rb

@@ -0,0 +1,107 @@
+# Bundled tests:
+#   - hash_new_default_value
+#   - hash_or_fallback_missing_key
+
+# === hash_new_default_value ===
+def t_hash_new_default_value
+  # `Hash.new(default_value)` per-instance default support.
+  #
+  # Each hash variant struct (StrIntHash / StrStrHash / IntStrHash /
+  # SymIntHash / SymStrHash / StrPolyHash / SymPolyHash) gains a
+  # `default_v` field. `_new` initializes it to the variant's
+  # sentinel zero (so legacy `{}` literals unchanged); `_new_with_default`
+  # is a new constructor that sets the field. `_get` returns
+  # `default_v` on miss; `_dup` / `_merge` propagate (merge inherits
+  # the LEFT receiver's default per CRuby).
+  #
+  # Codegen routes `Hash.new(N)` through `_new_with_default` and
+  # adds `Hash#default` / `Hash#default=` accessor arms to each
+  # variant. The analyzer's `infer_call_type` arm picks the right
+  # variant from the default's type (string → str_str_hash, int
+  # / nil / bool → str_int_hash) and types `h.default` as the
+  # value-slot type so `puts h.default` dispatches correctly.
+  #
+  # Block form `Hash.new { |h, k| ... }` (proc default) remains
+  # deferred -- separate feature.
+  #
+  # Issue #600 puzzle 2.
+  
+  # Int default
+  h = Hash.new(5)
+  puts h[:a]              # 5
+  puts h["x"]             # 5
+  puts h.length           # 0
+  puts h.key?(:a)         # false
+  puts h.default          # 5
+  
+  # Modify default; existing key unaffected
+  h.default = 99
+  puts h["missing"]       # 99
+  h["b"] = 10
+  puts h["b"]             # 10
+  puts h["c"]             # 99
+  
+  # String default
+  s = Hash.new("none")
+  puts s["x"]             # none
+  puts s.default          # none
+  
+  # dup propagates default
+  h2 = Hash.new(42)
+  h2["a"] = 1
+  d = h2.dup
+  puts d.default          # 42
+  puts d["never_set"]     # 42
+  puts d.length           # 1
+  puts d["a"]             # 1
+  
+  # merge inherits left default
+  m = h2.merge({"x" => 100})
+  puts m.default          # 42
+  puts m["not_there"]     # 42
+  
+  # Hash.new(0) -- pre-existing lrama_features shape, default ==
+  # sentinel, behaviour unchanged.
+  counter = Hash.new(0)
+  counter["x"] = counter["x"] + 1
+  puts counter["x"]       # 1
+  puts counter["z"]       # 0
+end
+t_hash_new_default_value
+
+# === hash_or_fallback_missing_key ===
+def t_hash_or_fallback_missing_key
+  # Issue #660: `hash[k] || rhs` on a typed-hash receiver must return
+  # rhs when the key is missing -- not the value-type zero (0 / "").
+  #
+  # Background: typed hash variants (sp_StrIntHash, sp_StrStrHash, ...)
+  # materialize the value type's zero as the missing-key default. Combined
+  # with the `||` truthy-lhs ternary lowering, the rhs arm was unreachable:
+  # 0 / "" are truthy in Ruby, so the always-present zero short-circuited
+  # the fallback.
+  #
+  # Fix: compile_or detects `hash[k]` on a typed-hash recv and rewrites
+  # to `has_key(h, k) ? get(h, k) : rhs`. Poly-hash variants already
+  # return sp_box_nil on miss, so they keep the legacy truthy lowering.
+  
+  # Empty hash, no writes (inferred str_int_hash).
+  h1 = {}
+  puts (h1[:missing] || "fallback")
+  
+  # String-valued hash via prior write.
+  h2 = {}
+  h2[:set_key] = "value"
+  puts (h2[:missing] || "fallback")
+  
+  # Int-valued hash via prior write -- the missing-key 0 used to win.
+  h3 = {}
+  h3[:set] = 1
+  puts (h3[:missing] || -1)
+  
+  # Present key returns the value, not the fallback.
+  h4 = {}
+  h4[:found] = "got it"
+  puts (h4[:found] || "fallback")
+end
+t_hash_or_fallback_missing_key
+

data/vendor/spinel/test/bundle_int_a.rb

@@ -0,0 +1,104 @@
+# Bundled tests:
+#   - int_array_literal_lshift_heterogeneous
+#   - int_array_replace_expr
+#   - int_eq_nil_strict
+
+# === int_array_literal_lshift_heterogeneous ===
+def t_int_array_literal_lshift_heterogeneous
+  # `<int_array literal> << <non-int>` shape (`[1, 2] << "c"`).
+  # Pushing a non-int element onto a literal int_array previously
+  # emitted sp_IntArray_push with a pointer-from-int-conversion
+  # warning and produced a broken array. The contextual lift
+  # rebuilds the recv as a poly_array of box_int(...) elements and
+  # pushes the boxed arg, matching CRuby's heterogeneous-array
+  # semantic.
+  #
+  # Scoped to direct ArrayNode literals on the LHS, so a stored
+  # ivar / local (`@slots = [nil] * N; @slots << ...`) keeps the
+  # existing observation-widening path. Issue #619 puzzle 7.
+  p ([1, 2] << "c") == [1, 2, "c"]       # true
+  p ([1, 2] << nil) == [1, 2, nil]       # true
+  p ([1, 2] << 3) == [1, 2, 3]           # true (int <<, no lift)
+end
+t_int_array_literal_lshift_heterogeneous
+
+# === int_array_replace_expr ===
+def t_int_array_replace_expr
+  # `Array#replace` in *expression* position on an int_array.
+  # The stmt-form arm has long supported this; the expr-form was
+  # missing — unresolved-call warning + literal `0` emitted.
+  # Surfaced via optcarrot's `def load_battery; ...; @wrk.replace(sav.bytes); end`,
+  # where the call sits at the tail of the method (its value is
+  # the implicit return).
+  
+  a = [1, 2, 3]
+  b = [10, 20, 30, 40]
+  
+  # Expression position: assigned. Should yield the (mutated) `a`.
+  c = a.replace(b)
+  
+  # `a` mutated in place
+  puts a[0]
+  puts a[1]
+  puts a[2]
+  puts a[3]
+  puts a.length
+  
+  # `c` is the same array (replace returns the receiver)
+  puts c[0]
+  puts c.length
+end
+t_int_array_replace_expr
+
+# === int_eq_nil_strict ===
+def t_int_eq_nil_strict
+  # Partial fix for #521. In CRuby `0 == nil` is false -- only nil
+  # equals nil. Spinel used to emit `(lc op rc)` for `int == nil`,
+  # where `rc` was "0" (compile_expr of NilNode); since unboxed ints
+  # share the C representation with the nil sentinel, this conflated
+  # stored 0 with nil and made `0 == nil` return true.
+  #
+  # Fix: compile_eq has explicit value-type-vs-nil arms that
+  # constant-fold to FALSE (or TRUE for `!=`). This does NOT solve
+  # the deeper #521 problem -- Hash<String,Int> still returns 0 for
+  # missing keys -- but it does fix the categorical bug that made a
+  # *stored* 0 in the hash indistinguishable from "the value is
+  # nil." With this fix, `v != nil` reflects the static type
+  # honestly, so users who need to distinguish missing-vs-stored
+  # zero have to reach for `Hash#has_key?` / `Hash#fetch`, as
+  # documented in the issue comment.
+  
+  # Pure int (no hash)
+  v = 0
+  puts (v == nil).inspect   # false
+  puts (v != nil).inspect   # true
+  
+  w = 5
+  puts (w == nil).inspect   # false
+  puts (w != nil).inspect   # true
+  
+  # Float / bool same.
+  f = 0.0
+  puts (f == nil).inspect   # false
+  puts (f != nil).inspect   # true
+  
+  b = false
+  puts (b == nil).inspect   # false
+  
+  # Hash<String,Int> stored 0 case now reports != nil correctly.
+  h = {}
+  h["x"] = 0
+  h["y"] = 5
+  vx = h["x"]
+  vy = h["y"]
+  puts (vx == nil).inspect  # false (was true)
+  puts (vx != nil).inspect  # true  (was false)
+  puts (vy == nil).inspect  # false
+  puts (vy != nil).inspect  # true
+  
+  # Symmetric: nil == int is also false.
+  puts (nil == 0).inspect   # false
+  puts (nil != 0).inspect   # true
+end
+t_int_eq_nil_strict
+

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

@@ -0,0 +1,23 @@
+true
+true
+true
+10
+20
+30
+40
+4
+10
+4
+false
+true
+false
+true
+false
+true
+false
+false
+true
+false
+true
+false
+true

data/vendor/spinel/test/bundle_misc_c_08.rb

@@ -0,0 +1,170 @@
+# Bundled tests:
+#   - dig_nested_poly_array
+#   - each_cons_map_chain_fusion
+#   - each_cons_with_index_map_chain_fusion
+#   - env_fetch
+#   - equality_should_be_true
+#   - fiber_storage_assign_expr
+
+# === dig_nested_poly_array ===
+def t_dig_nested_poly_array
+  # Array#dig walks through nested poly_array elements with int keys.
+  # Pre-fix emit_dig_step's int-key branch only emitted an arm for
+  # SP_BUILTIN_INT_STR_HASH; every other receiver kind collapsed the
+  # accumulator to nil at the next step, so a nested poly_array
+  # dig surfaced nil instead of the leaf value. Issue #619 puzzle 6.
+  
+  p [[1, [2, "3"]]].dig(0, 1, 1) == "3"   # true (string leaf)
+  p [[1, [2, "3"]]].dig(0, 0) == 1        # true (int leaf via box_int)
+  p [[1, [2, "3"]]].dig(0, 1, 0) == 2     # true
+  p [[1, [2, "3"]]].dig(0, 1, 5).nil?     # true (OOB at the last step)
+end
+t_dig_nested_poly_array
+
+# === each_cons_map_chain_fusion ===
+def t_each_cons_map_chain_fusion
+  # Phase A of Enumerator-chain strategy (#566): `arr.each_cons(n)`
+  # called without a block returns an Enumerator in CRuby. When the
+  # very next call is a terminal like `.map { |pair| ... }`, the
+  # Enumerator is consumed immediately and the chain has the same
+  # observable result as eagerly materialising each window. Spinel
+  # fuses the source + terminal into a single C loop, so no
+  # Enumerator object is allocated and no intermediate
+  # array-of-arrays is built (one window allocation per iteration,
+  # bounded by .map's accumulator).
+  #
+  # The terminal block may take the window as a single param
+  # (`|pair|`, typed as the receiver's array shape) or destructure
+  # it (`|(a, b)|`, binds individual locals -- the per-iteration
+  # window allocation is skipped on this path).
+  
+  # T1: plain |pair| form, scalar block result
+  p [1, 2, 3, 4].each_cons(2).map { |pair| pair[0] + pair[1] }
+  
+  # T2: destructure |(a, b)|, scalar block result
+  p [10, 20, 30, 40].each_cons(2).map { |(a, b)| b - a }
+  
+  # T3: |pair| with array-returning block -> result is int_array_ptr_array
+  p [1, 2, 3].each_cons(2).map { |pair| [pair[0], pair[1]] }
+  
+  # T4: empty / short receiver (length < n) -> empty result
+  p [1].each_cons(2).map { |pair| pair[0] }
+end
+t_each_cons_map_chain_fusion
+
+# === each_cons_with_index_map_chain_fusion ===
+def t_each_cons_with_index_map_chain_fusion
+  # Phase A.3 of Enumerator-chain strategy (#566): three-step
+  # `arr.each_cons(n).with_index(off).map { ... }` chain. CRuby
+  # returns an Enumerator from each_cons, then another from
+  # with_index, and consumes both at the terminal .map. Spinel
+  # fuses the whole chain into a single C loop with an idx counter
+  # initialised from `off` (default 0) and incremented after each
+  # pair, so no Enumerator object is allocated.
+  #
+  # Block param shapes:
+  #   |pair, i|       -- pair is the typed sub-array, i is the int idx
+  #   |(a, b), i|     -- nested destructure of pair into individual
+  #                      window slots (skips the per-iteration sub-
+  #                      array allocation), trailing i as int idx
+  
+  # T1: |pair, i| with explicit offset
+  p [10, 20, 30, 40].each_cons(2).with_index(1).map { |pair, i| pair[0] + pair[1] + i }
+  
+  # T2: |(a, b), i| destructure, explicit offset
+  p [10, 20, 30, 40].each_cons(2).with_index(1).map { |(a, b), i| b - a + i }
+  
+  # T3: default offset (0)
+  p [1, 2, 3].each_cons(2).with_index.map { |pair, i| pair[1] - pair[0] + i }
+  
+  # T4: block returns array -> result is int_array_ptr_array
+  p [1, 2, 3, 4].each_cons(2).with_index(1).map { |(a, b), i| [b - a, i] }
+end
+t_each_cons_with_index_map_chain_fusion
+
+# === env_fetch ===
+def t_env_fetch
+  # Regression: `ENV.fetch(key, default)` returns the env value when
+  # set, otherwise `default`. Pre-fix the codegen emitted "cannot
+  # resolve call to 'fetch' on int" and segfaulted at runtime.
+  
+  # ---- unset / default branch ----
+  
+  # Literal default.
+  puts ENV.fetch("DEFINITELY_UNSET_VAR_XYZ_42", "fallback-value")
+  
+  # Default expression need not be a literal.
+  default = "computed-default"
+  puts ENV.fetch("ANOTHER_UNSET_VAR_XYZ_42", default)
+  
+  # Default by string concatenation.
+  puts ENV.fetch("THIRD_UNSET_VAR_XYZ_42", "pre-" + "fix")
+  
+  # ---- set / retrieval branch ----
+  # Spinel doesn't currently expose `ENV[]=` from Ruby, so we can't
+  # set a var ourselves. HOME is always exported by POSIX `make` and
+  # in CI, so we use that as the "set" probe. We only assert "non-
+  # empty + not the fallback string" so the test stays portable
+  # across runners (the actual home value differs per machine).
+  # A regression that inverted the getenv-result ternary would
+  # return the fallback here and print "set=fallback-not-used".
+  home = ENV.fetch("HOME", "fallback-not-used")
+  if home.length > 0 && home != "fallback-not-used"
+    puts "set=ok"
+  else
+    puts "set=" + home
+  end
+  
+  # Symmetric: an unset var with a literal default round-trips
+  # through the same ternary. (Would catch a regression that always
+  # returned the env value -- empty string -- regardless.)
+  maybe = ENV.fetch("DEFINITELY_UNSET_VAR_ABC_99", "fallback-used")
+  puts "unset=" + maybe
+end
+t_env_fetch
+
+# === equality_should_be_true ===
+def t_equality_should_be_true
+  # #555 (gurgeous/Adam Doppelt). A corpus of `should be true`
+  # expressions that compiled to false in spinel pre-fix.
+  # Each line is an independent equality predicate; CRuby
+  # returns true for all twelve, and after the followup
+  # commits spinel matches on all 12.
+  
+  p ({} == {})                                     # 01
+  p ({a: 1} == {a: 1})                             # 02
+  p ({:a= => 1} == {:"a=" => 1})                   # 03
+  p ({:a! => 1} == {:"a!" => 1})                   # 04
+  p ({:a? => 1} == {:"a?" => 1})                   # 05
+  a = [1] ; a.shift ; a << :foo ; p (a == [:foo])  # 06
+  p ([42, { foo: :bar }].dig(1, :foo) == :bar)     # 07
+  a2 = [1, 2, 3, 4, 5] ; p ((a2[2, 3] = 10) == 10) # 08
+  p ("hello".chars == ['h', 'e', 'l', 'l', 'o'])   # 09
+  p "abc\r\n".chomp(nil) == "abc\r\n"              # 10
+  p ((/(.)(.)(.)/ =~ "abc") == 0)                  # 11
+  p ((1..).send(:include?, 2.4) == true)           # 12
+end
+t_equality_should_be_true
+
+# === fiber_storage_assign_expr ===
+def t_fiber_storage_assign_expr
+  # `(Fiber[:k] = v)` as an expression returns the assigned value,
+  # matching MRI's `(h[k]=v) => v` semantics. The codegen path is
+  # distinct from the statement form `Fiber[:k] = v` — that lands in
+  # compile_mutating_call_stmt, while the expression-context dispatch
+  # emits a gcc statement-expression so the RHS reaches the outer
+  # assignment.
+  
+  x = (Fiber[:n] = 42)
+  puts x                # 42 — value of the assignment expression
+  puts Fiber[:n]        # 42 — confirms the write also took effect
+  
+  # Chained: `Fiber[:a] = Fiber[:b] = 7`. Right-to-left associativity
+  # makes `Fiber[:b] = 7` evaluate first (yielding 7), then
+  # `Fiber[:a] = 7`.
+  Fiber[:a] = Fiber[:b] = 7
+  puts Fiber[:a]
+  puts Fiber[:b]
+end
+t_fiber_storage_assign_expr
+

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

@@ -0,0 +1,33 @@
+true
+true
+true
+true
+[3, 5, 7]
+[10, 10, 10]
+[[1, 2], [2, 3]]
+[]
+[31, 52, 73]
+[11, 12, 13]
+[1, 2]
+[[1, 1], [1, 2], [1, 3]]
+fallback-value
+computed-default
+pre-fix
+set=ok
+unset=fallback-used
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+42
+42
+7
+7

data/vendor/spinel/test/bundle_misc_c_09.rb

@@ -0,0 +1,72 @@
+# Bundled tests:
+#   - fiber_storage_basic
+#   - fiber_storage_current_alias
+#   - fiber_storage_gc_root
+
+# === fiber_storage_basic ===
+def t_fiber_storage_basic
+  Fiber[:user_id] = 42
+  puts Fiber[:user_id]
+  
+  Fiber[:user_id] = 43
+  puts Fiber[:user_id]
+  
+  # Unset key reads as nil.
+  v = Fiber[:not_set]
+  if v.nil?
+    puts "nil_ok"
+  else
+    puts "nil_unexpected"
+  end
+end
+t_fiber_storage_basic
+
+# === fiber_storage_current_alias ===
+def t_fiber_storage_current_alias
+  # `Fiber.current[:k]` and `Fiber.current[:k] = v` are aliases for
+  # `Fiber[:k]` and `Fiber[:k] = v` — both target the same storage Hash
+  # on the currently-running fiber.
+  
+  Fiber.current[:via_current] = 100
+  puts Fiber[:via_current]                       # 100 — reads via Fiber[]
+  
+  Fiber[:via_bare] = 200
+  puts Fiber.current[:via_bare]                  # 200 — reads via Fiber.current[]
+end
+t_fiber_storage_current_alias
+
+# === fiber_storage_gc_root ===
+def t_fiber_storage_gc_root
+  # Regression: sp_fiber_root.storage must survive GC. sp_fiber_root
+  # is a static (not sp_gc_alloc'd) so its scan never runs via the
+  # heap walker. Without explicit marking in sp_re_mark_globals, the
+  # SymPolyHash allocated by `Fiber[:k] = v` at top level gets
+  # prematurely collected on the next cycle.
+  #
+  # Force GC by allocating many sp_gc_alloc'd objects (arrays of
+  # strings, each becoming garbage on the next iteration) to push
+  # sp_gc_bytes past the 256KB threshold. Then verify the storage
+  # value still reads back.
+  
+  Fiber[:answer] = 42
+  
+  i = 0
+  while i < 10000
+    # Each iteration allocates a fresh PolyArray + a String element;
+    # both are GC-tracked (sp_gc_alloc), so this drives sp_gc_bytes
+    # past the auto-collect threshold within the loop.
+    garbage = ["garbage_" + i.to_s, "more_" + i.to_s, "still_" + i.to_s]
+    i = i + 1
+  end
+  
+  # If sp_fiber_root.storage wasn't marked, the SymPolyHash holding
+  # :answer would have been freed and read would return nil.
+  v = Fiber[:answer]
+  if v == 42
+    puts "survived"
+  else
+    puts "lost"
+  end
+end
+t_fiber_storage_gc_root
+

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

@@ -0,0 +1,6 @@
+42
+43
+nil_ok
+100
+200
+survived

data/vendor/spinel/test/bundle_misc_c_10.rb

@@ -0,0 +1,73 @@
+# Bundled tests:
+#   - fiber_storage_inherits
+#   - fiber_storage_persists
+#   - fiber_storage_siblings
+
+# === fiber_storage_inherits ===
+def t_fiber_storage_inherits
+  # Parent fiber's storage is snapshot-copied into a child fiber at
+  # Fiber.new time. Subsequent writes on either side are independent
+  # (shallow copy).
+  Fiber[:user] = "alice"
+  
+  f = Fiber.new do
+    # Inherited at creation.
+    puts Fiber[:user]
+    # Local write — does not leak back to parent.
+    Fiber[:user] = "bob"
+    puts Fiber[:user]
+  end
+  f.resume
+  
+  # Parent's value is unchanged by the child's write.
+  puts Fiber[:user]
+end
+t_fiber_storage_inherits
+
+# === fiber_storage_persists ===
+def t_fiber_storage_persists
+  # Storage values persist across yield/resume cycles within the same
+  # fiber. Mirrors the existing fiber_ivar_persists_across_yield test
+  # but exercises the storage path instead of ivars.
+  f = Fiber.new do
+    Fiber[:n] = 1
+    Fiber.yield
+    # After resume, the previous storage write is still visible.
+    Fiber[:n] = Fiber[:n] + 1
+    Fiber.yield
+    Fiber[:n] = Fiber[:n] + 1
+    puts Fiber[:n]
+  end
+  
+  f.resume   # sets :n = 1
+  f.resume   # bumps to 2, yields
+  f.resume   # bumps to 3, prints 3
+end
+t_fiber_storage_persists
+
+# === fiber_storage_siblings ===
+def t_fiber_storage_siblings
+  # Sibling fibers have independent storage. A write in one does not
+  # affect the other even if they share a parent.
+  Fiber[:tag] = "parent"
+  
+  a = Fiber.new do
+    Fiber[:tag] = "a"
+    puts Fiber[:tag]
+  end
+  
+  b = Fiber.new do
+    # b was created BEFORE a ran, so it inherited "parent", not "a".
+    puts Fiber[:tag]
+    Fiber[:tag] = "b"
+    puts Fiber[:tag]
+  end
+  
+  a.resume
+  b.resume
+  
+  # Parent's storage still reads "parent" — neither child leaked back.
+  puts Fiber[:tag]
+end
+t_fiber_storage_siblings
+

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

@@ -0,0 +1,8 @@
+alice
+bob
+alice
+3
+a
+parent
+b
+parent