rubyduino 0.2.0 → 0.2.1

data/vendor/spinel/test/return_unify_int_vs_pointer.rb

@@ -0,0 +1,37 @@
+# #581 (Sam Ruby). When a function's explicit `return X` and
+# implicit final-expression return disagree on the value-vs-
+# pointer axis (here int param early return + hash literal
+# implicit), the analyzer's lenient unify_return_type previously
+# demoted the int as a default sentinel and picked the hash
+# type, declaring the function as `sp_StrStrHash *`. The early
+# `return value` then emitted `return mrb_int` from a
+# pointer-typed function -- fatal -Wint-conversion under -Werror.
+#
+# Fix: post-fixpoint pass widens the function's stored return
+# type to "poly" when the body's actual return paths contradict
+# the analyzer's narrow choice on the value-vs-pointer axis.
+# The existing codegen-side `@current_method_return == "poly"`
+# boxing arm in compile_return_stmt then routes both branches
+# through box_expr_to_poly correctly.
+#
+# Scope-set-up at the widen-check site (push_scope + declare
+# params + refine_method_body_locals) is load-bearing: without
+# it, ivar / local reads in the body fall back to int default
+# and the check reports spurious mismatches for methods whose
+# body is actually homogeneous (e.g. spinel's own helpers like
+# `parse_id_list` returning `@parse_id_pool[k]`).
+
+def f(value)
+  return value if value < 0
+  {"k" => "v"}
+end
+
+# The early-return path returns the int parameter.
+r1 = f(-1)
+puts r1.is_a?(Integer)
+puts r1
+
+# The implicit-return path returns the hash literal.
+r2 = f(5)
+puts r2.is_a?(Hash)
+puts r2["k"]

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

@@ -0,0 +1,4 @@
+true
+-1
+true
+v

data/vendor/spinel/test/return_unify_isa_early_return.rb

@@ -0,0 +1,29 @@
+# #585 (Sam Ruby). Sibling shape of #581. A method that early-
+# returns the param when `value.is_a?(Hash)` is false, then falls
+# through to a pointer-shaped value, declared its return type as
+# the pointer-shaped path and the early `return value` (int) tried
+# to return mrb_int from a pointer-typed function -- fatal under
+# -Werror.
+#
+# The function-signature side surfaces the same widen-to-poly fix
+# as #581 (post-fixpoint widen pass). The fix here also closes a
+# latent bug in the @unified_imeth_returns marker (spinel's
+# Array#index returns -1 for not-found, not nil, so the
+# `.index == nil` check at the producer site never added entries
+# and the marker stayed empty). Switching to `.include?` lets the
+# imeth-family marker get populated, which the widen pass then
+# honors -- so the #563 self-operator dispatch family stays intact
+# even after the value-vs-pointer widen lands.
+
+class Host
+  def stringify_keys(value)
+    return value unless value.is_a?(Hash)
+    "stringified"
+  end
+end
+
+# The early-return path returns the int parameter as-is.
+puts Host.new.stringify_keys(42)
+
+# The fall-through path returns the pointer-shaped value.
+puts Host.new.stringify_keys({"a" => 1})

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

@@ -0,0 +1,2 @@
+42
+stringified

data/vendor/spinel/test/rightward_assign_destructure.rb

@@ -0,0 +1,27 @@
+# Rightward assignment with an array / hash pattern (MatchRequiredNode):
+# `value => [a, b, c]` destructures and binds, raising
+# NoMatchingPatternError when the value does not match.
+
+# Integer array.
+[1, 2, 3] => a, b, c
+puts a
+puts b
+puts c
+
+# String array (binds string-typed locals).
+["x", "y"] => p, q
+puts p
+puts q
+
+# Hash pattern binds by key.
+{name: "Alice", age: 30} => {name:, age:}
+puts name
+puts age
+
+# Length mismatch raises NoMatchingPatternError.
+begin
+  [1, 2] => d, e, f
+  puts "no raise"
+rescue NoMatchingPatternError
+  puts "raised"
+end

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

@@ -0,0 +1,8 @@
+1
+2
+3
+x
+y
+Alice
+30
+raised

data/vendor/spinel/test/safe_navigation_returns_nil.expected

@@ -0,0 +1,6 @@
+nil
+HELLO
+nil
+5
+1
+nil

data/vendor/spinel/test/safe_navigation_returns_nil.rb

@@ -0,0 +1,28 @@
+# Issue #701: safe navigation `&.` on nil returns nil.
+
+# Literal nil receiver — short-circuits without warning.
+v1 = nil&.foo
+puts v1.inspect
+
+# Dynamic nullable receiver — short-circuits when nil, dispatches when not.
+def maybe_str(b)
+  b ? "hello" : nil
+end
+
+puts maybe_str(true)&.upcase
+puts maybe_str(false)&.upcase.inspect
+
+# Non-nil case — `&.` behaves identical to `.`.
+s = "world"
+puts s&.length
+
+# Hash recv (typed nullable from RBS / return inference).
+def maybe_hash(b)
+  return nil unless b
+  h = {}
+  h["k"] = "v"
+  h
+end
+
+puts maybe_hash(true)&.length
+puts maybe_hash(false)&.length.inspect

data/vendor/spinel/test/same_named_attr_no_widen.rb

@@ -0,0 +1,24 @@
+# #684: a concretely-typed receiver's attr_reader must not widen to
+# poly just because an unrelated class shares the same attr name.
+class Bag
+  attr_accessor :payload
+  def initialize; @payload = {"k" => "v"}; end
+end
+
+class Wire
+  attr_accessor :payload
+  def initialize; @payload = ""; end
+end
+
+def first_byte_of(s)
+  s.bytes[0]
+end
+
+def handle_wire(w)
+  first_byte_of(w.payload)
+end
+
+_b = Bag.new
+_w = Wire.new
+_w.payload = "hello"
+puts handle_wire(_w)

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

@@ -0,0 +1 @@
+104

data/vendor/spinel/test/scan_locals_def_boundary.rb

@@ -0,0 +1,58 @@
+# #450 cascade 1. `scan_locals` walked into nested DefNode bodies
+# from any outer-context caller (notably infer_main_call_types' top-
+# level scan), pulling locals from inside unrelated methods into the
+# enclosing scope. Two methods that each defined `local_name = ...`
+# with disagreeing inferred types then collided via scan_locals'
+# repeated-write merge and widened the conflated slot to poly.
+# The poly local then poisoned every call-site arg type read of
+# that local name, propagating into callee params via the module-
+# dispatch widening arms in scan_new_calls.
+#
+# Real-world repro shape (after roundhouse-style boil-down):
+#
+#   module CgiIo
+#     def self.parse_request(env, stdin)
+#       path = env["PATH_INFO"] || "/"   # path local : nullable-via-||
+#       { path: path }
+#     end
+#   end
+#
+#   module Db
+#     def self.configure(path); ...; end  # path : should be string
+#   end
+#
+#   module Main
+#     def self.run_setup
+#       path = "/tmp/db"
+#       Db.configure(path)               # this call's arg was poly
+#                                        # because of cgi_io.parse_request's
+#                                        # path-local leakage
+#     end
+#   end
+#
+# Pin both shapes here so a future scan_locals regression that
+# re-introduces def-boundary crossing fails immediately.
+
+module CgiIo
+  def self.parse_request(env)
+    path = env["PATH_INFO"] || "/"
+    { path: path }
+  end
+end
+
+module Db
+  def self.configure(path)
+    "opening " + path
+  end
+end
+
+module Main
+  def self.run_setup
+    db_path = "/tmp/db"
+    path = (!db_path.nil? && !db_path.empty?) ? db_path : ":memory:"
+    Db.configure(path)
+  end
+end
+
+puts CgiIo.parse_request({ "PATH_INFO" => "/articles" })[:path]
+puts Main.run_setup

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

@@ -0,0 +1,2 @@
+/articles
+opening /tmp/db

data/vendor/spinel/test/scan_walkers_def_boundary.rb

@@ -0,0 +1,52 @@
+# Audit follow-up to #450 cascade 1. Several AST-walking helpers in
+# spinel_analyze.rb recursively descend into nested DefNode /
+# ClassNode / ModuleNode bodies without resetting scope context.
+# That leaks per-method state (locals, param-method observations,
+# push-element types) across method boundaries and pollutes the
+# outer scope. cascade 1 of #450 was scan_locals itself; this file
+# pins three siblings:
+#
+#   - scan_locals_first_type   (used by infer_lambda_param_types)
+#   - scan_poly_assigns         (used by detect_poly_locals)
+#   - collect_param_methods     (used by infer_cls_meth_param_from_body)
+#   - collect_param_push_elem_types  (used by infer_param_array_type_from_body)
+#   - scan_param_body_write_unify     (used by widen_param_types_from_body_writes)
+#
+# All of these now early-return at DefNode / ClassNode / ModuleNode.
+#
+# The shape: a top-level module with one def whose local shadows
+# an outer name. Pre-fix, the outer scope's poly-detection / param
+# inference would conflate the two and the resulting types would
+# either widen unnecessarily or fail to widen for the right call
+# site.
+
+module Outer
+  def self.process(path)
+    # `path` is the param; body uses it as a string.
+    parts = path.split("/")
+    parts.length
+  end
+end
+
+# Top-level local with the same name as Outer.process's param.
+# Pre-fix, this main-level `path` would be conflated with Outer's
+# param in scan_poly_assigns / scan_locals if scan walked into
+# the module body.
+path = "/tmp/db"
+puts Outer.process(path)
+puts Outer.process("/articles/1")
+
+# Module with a deeper structure: two defs, each with the same
+# param name, calling each other. The cascade-1 shape.
+module Resolver
+  def self.outer_resolve(path)
+    inner_resolve(path)
+  end
+
+  def self.inner_resolve(path)
+    path.upcase + ":" + path.length.to_s
+  end
+end
+
+puts Resolver.outer_resolve("hello")
+puts Resolver.outer_resolve("world")

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

@@ -0,0 +1,4 @@
+3
+3
+HELLO:5
+WORLD:5

data/vendor/spinel/test/self_class_divergent_returns.rb

@@ -0,0 +1,61 @@
+# Issue #431 (#422 residual). `self.class.<cmeth>` dispatch in a
+# parent-defined instance method now lowers to a cls_id switch
+# even when the base and subclass overrides have divergent
+# return types -- the canonical Rails "abstract base raises,
+# subclass returns concrete value" pattern.
+#
+# Pre-fix: #422's switch was gated on all candidate owners
+# returning the same type. When Base.label raised (no return
+# value, default int) and Article.label returned a String,
+# the gate failed and the dispatch fell through to a direct
+# call to sp_Base_cls_label -- which raised even when self
+# was statically a subclass instance whose override was the
+# intended target.
+#
+# Fix shape:
+#   - codegen: divergent-types path boxes each arm's return
+#     to sp_RbVal so the result temp has a single C type;
+#     base call lands in `default:` so it only runs when the
+#     runtime cls_id genuinely is the base.
+#   - analyze: infer_type for `<obj>.class.<m>` chain widens
+#     to "poly" when descendants override with divergent
+#     return types, so downstream callers route through the
+#     poly-dispatch path.
+#
+# Coverage:
+#   - Variant 1: Base.label raises, Article.label returns
+#     String. Article.new.describe should print the String.
+#   - Variant 2: Base.foo returns int, Article.foo returns
+#     String. Both instance routes return through the cls_id
+#     switch (Article gets the String, Base gets the int via
+#     the default arm). Both render correctly via puts on the
+#     boxed sp_RbVal.
+
+class Base
+  def self.label
+    raise "subclass must override"
+  end
+
+  def describe
+    self.class.label
+  end
+end
+
+class Article < Base
+  def self.label
+    "articles"
+  end
+end
+
+puts Article.new.describe
+
+class IntBase
+  def self.foo; 42; end
+  def show; self.class.foo; end
+end
+class StrChild < IntBase
+  def self.foo; "child"; end
+end
+
+puts StrChild.new.show
+puts IntBase.new.show

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

@@ -0,0 +1,3 @@
+articles
+child
+42

data/vendor/spinel/test/self_class_new_construction.rb

@@ -0,0 +1,16 @@
+# `self.class.new(args)` in an instance method of a leaf class (no
+# subclasses) constructs the enclosing class statically — the
+# idiomatic functional-update pattern (e.g. AST::Node#updated).
+class Node
+  attr_reader :children
+  def initialize(children = [])
+    @children = children.to_a.freeze
+  end
+  def with(more)
+    self.class.new(@children + more)
+  end
+end
+n = Node.new([Node.new, Node.new])
+m = n.with([Node.new])
+puts m.children.size
+puts n.children.size

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

@@ -0,0 +1,2 @@
+3
+2

data/vendor/spinel/test/self_operator_subclass_dispatch.rb

@@ -0,0 +1,40 @@
+# #563 (Sam Ruby). `self[k]` and `self[k] = v` from inside a
+# parent-defined method should dispatch to the subclass
+# override at runtime. Sibling of bare_imeth_subclass_dispatch.rb
+# but for the operator forms; pre-fix the dispatch resolved
+# statically to the parent's operator stub, ignoring the
+# subclass override.
+#
+# Roundhouse trigger: ActiveRecord::Base#fill_timestamps does
+# `self[:updated_at] = now if cols.include?(:updated_at)`,
+# expecting the dispatch to land on the subclass's column
+# routing. Pre-fix every model raised NotImplementedError.
+
+class Base
+  def [](name)
+    raise NotImplementedError
+  end
+
+  def []=(name, value)
+    raise NotImplementedError
+  end
+
+  def fetch
+    self[:foo]
+  end
+
+  def fill
+    self[:foo] = "bar"
+  end
+end
+
+class Article < Base
+  def [](name); "result"; end
+  def []=(name, value); @foo = value; end
+  def foo; @foo; end
+end
+
+a = Article.new
+puts a.fetch
+a.fill
+puts a.foo

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

@@ -0,0 +1,2 @@
+result
+bar

data/vendor/spinel/test/signal_trap_stub.rb

@@ -0,0 +1,30 @@
+# trap / Signal.trap / ::Signal.trap compile to no-ops at every shape;
+# Spinel has no signal-handler runtime, so the block body (if any)
+# never fires. Expression position returns "DEFAULT" -- CRuby's value
+# for any signal that was never previously trapped.
+#
+# Each section uses a distinct signal name so no signal's state is
+# observed twice (CRuby would return the prior handler on the second
+# touch, which Spinel does not yet model).
+
+# Stmt position, implicit-self.
+trap("INT") { puts "handler" }
+
+# Stmt position, explicit Signal receiver (ConstantReadNode).
+Signal.trap("TERM") { puts "handler" }
+
+# Stmt position, toplevel ::Signal receiver (ConstantPathNode).
+::Signal.trap("HUP") { puts "handler" }
+
+# Stmt position, no block.
+trap("QUIT", "EXIT")
+
+# Expr position, first call on a never-trapped signal returns "DEFAULT".
+prev = trap("USR1") { puts "x" }
+puts prev
+
+# Expr position via Signal receiver, also returns "DEFAULT" on first call.
+prev2 = Signal.trap("USR2") { puts "y" }
+puts prev2
+
+puts "done"

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

@@ -0,0 +1,3 @@
+DEFAULT
+DEFAULT
+done

data/vendor/spinel/test/sort_min_max_block_comparator.rb

@@ -0,0 +1,18 @@
+# Array#sort / min / max with a 2-param comparator block.
+# Block returns -1/0/1; sort uses it for ordering, min/max pick
+# the element that the comparator places at the extremum.
+
+# Sort with reverse comparator
+puts [3,1,4,1,5].sort { |a,b| b <=> a }.inspect
+puts ["c","a","b"].sort { |a,b| b <=> a }.inspect
+
+# Sort with custom comparator
+puts ["banana","cat","ape"].sort { |a,b| a.length <=> b.length }.inspect
+
+# min/max with reverse comparator inverts the result
+puts [3,1,4,1,5].min { |a,b| b <=> a }
+puts [3,1,4,1,5].max { |a,b| b <=> a }
+
+# min/max with length comparator
+puts ["banana","cat","ape"].min { |a,b| a.length <=> b.length }
+puts ["banana","cat","ape"].max { |a,b| a.length <=> b.length }

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

@@ -0,0 +1,7 @@
+[5, 4, 3, 1, 1]
+["c", "b", "a"]
+["cat", "ape", "banana"]
+5
+1
+cat
+banana

data/vendor/spinel/test/source_encoding.rb

@@ -0,0 +1,19 @@
+# Issue #843. `__ENCODING__` should behave like an Encoding value,
+# not a plain String.
+
+puts __ENCODING__.class
+puts __ENCODING__.name
+puts __ENCODING__.to_s
+puts __ENCODING__.is_a?(Encoding)
+puts __ENCODING__ == __ENCODING__
+puts __ENCODING__ != "UTF-8"
+
+values = [__ENCODING__, 1]
+puts values[0]
+
+enc_hash = {}
+enc_hash[__ENCODING__] = 7
+puts enc_hash[__ENCODING__]
+
+mixed = ARGV.length > 0 ? __ENCODING__ : 1
+puts mixed

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

@@ -0,0 +1,9 @@
+Encoding
+UTF-8
+UTF-8
+true
+true
+true
+UTF-8
+7
+1

data/vendor/spinel/test/sp_crypto_basic.rb

@@ -0,0 +1,45 @@
+# sp_crypto.c -- ffi exposed to spinel programs.
+#
+# Covers the canonical surface with deterministic vectors:
+#   - HMAC-SHA256 against RFC 4231 test case 4 (4-character key, 50
+#     byte message). The standard vector for hex output is
+#     82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff46729665b
+#     -- truncated to its first 43 b64url chars for the b64url variant.
+#   - Base64URL round-trip on a string with a 2-byte tail (RFC 4648
+#     standard padding/tail behaviour).
+#   - PBKDF2-HMAC-SHA256 with a single iteration (matches RFC 7914
+#     scrypt-vector format, simpler than the 1024-iter RFC 6070 case).
+#   - Random b64url returns the right length for the requested byte
+#     count, and (because it's random) doesn't compare-equal across
+#     calls.
+module Crypto
+  ffi_func :sp_crypto_hmac_sha256_hex,      [:str, :str],       :str
+  ffi_func :sp_crypto_hmac_sha256_b64url,   [:str, :str],       :str
+  ffi_func :sp_crypto_b64url_encode,        [:str],             :str
+  ffi_func :sp_crypto_b64url_decode,        [:str],             :str
+  ffi_func :sp_crypto_pbkdf2_sha256_b64url, [:str, :str, :int], :str
+  ffi_func :sp_crypto_random_b64url,        [:int],             :str
+end
+
+# RFC 4231 test case 4: 25-byte key, 50-byte message.
+key = "Jefe"
+msg = "what do ya want for nothing?"
+puts Crypto.sp_crypto_hmac_sha256_hex(key, msg)
+
+# Base64URL round-trip on a 5-byte input (length 5 % 3 == 2 so the
+# tail emits 3 chars and no padding). Should print "hello" twice.
+enc = Crypto.sp_crypto_b64url_encode("hello")
+puts enc
+puts Crypto.sp_crypto_b64url_decode(enc)
+
+# PBKDF2 with iters=1 is HMAC(key, salt||0x00000001). The expected
+# 43-char b64url is a stable property of the salt+password+1 input.
+puts Crypto.sp_crypto_pbkdf2_sha256_b64url("password", "salt", 1)
+
+# Random: two calls of the same size must differ (probability of
+# collision on 16 bytes is 2^-128). Print the length and the
+# inequality result so the .expected stays deterministic.
+r1 = Crypto.sp_crypto_random_b64url(16) + ""
+r2 = Crypto.sp_crypto_random_b64url(16) + ""
+puts r1.length
+puts(r1 == r2 ? "same" : "diff")

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

@@ -0,0 +1,6 @@
+5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843
+aGVsbG8
+hello
+Eg-2z_z4syxD5yJSVsT4N6hlSMkszDVICAWYfLcL4Xs
+22
+diff

data/vendor/spinel/test/sp_crypto_sha1.rb

@@ -0,0 +1,18 @@
+# sp_crypto SHA-1 + WebSocket handshake sugar.
+#
+# SHA-1 is a legacy hash, only kept for the WebSocket handshake
+# (RFC 6455 §1.3 explicitly requires it for Sec-WebSocket-Accept).
+# The two FIPS-180 sample vectors and the RFC 6455 §1.3 example
+# are deterministic, so this test stays tight.
+module Crypto
+  ffi_func :sp_crypto_sha1_hex,           [:str], :str
+  ffi_func :sp_crypto_websocket_accept,   [:str], :str
+end
+
+# FIPS-180-4 standard vectors.
+puts Crypto.sp_crypto_sha1_hex("abc")        # a9993e36...
+puts Crypto.sp_crypto_sha1_hex("")           # da39a3ee...
+
+# RFC 6455 §1.3 worked example. The handshake-key+GUID combo plus
+# base64 of the SHA-1 hash is the only modern use of SHA-1 here.
+puts Crypto.sp_crypto_websocket_accept("dGhlIHNhbXBsZSBub25jZQ==")

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

@@ -0,0 +1,3 @@
+a9993e364706816aba3e25717850c26c9cd0d89d
+da39a3ee5e6b4b0d3255bfef95601890afd80709
+s3pPLMBiTxaQ9kYGzzhZRbK+xOo=

data/vendor/spinel/test/sp_net_basic.rb

@@ -0,0 +1,17 @@
+# sp_net.c -- ffi exposed to spinel programs.
+#
+# Cross-platform-deterministic smoke: shell_capture + getpid produce
+# the same output on every POSIX target, so the .expected holds for
+# Linux + macOS CI. (On Windows sp_net is stubbed -- the Makefile
+# filters this test out there; the socket/poll/process surface is
+# exercised by the consumer suites, e.g. tep, which run on POSIX.)
+module Net
+  ffi_func :sp_net_getpid,        [],           :int
+  ffi_func :sp_net_shell_capture, [:str, :int], :str
+end
+
+# Shell capture: stdout of `printf hello` is exactly "hello".
+puts Net.sp_net_shell_capture("printf hello", 64)
+
+# getpid is always a positive pid (print a stable token, not the pid).
+puts(Net.sp_net_getpid > 0 ? "pid-ok" : "pid-bad")

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

@@ -0,0 +1,2 @@
+hello
+pid-ok

data/vendor/spinel/test/splat_heterogeneous_call.rb

@@ -0,0 +1,14 @@
+# Issue #666: heterogeneous call sites against a `def f(*args)` method
+# previously left the splat slot at the default `int_array` and packed
+# subsequent string args through `(mrb_int)<char*>` casts. Each was
+# then re-interpreted by `puts x.to_s` as a giant integer (the pointer
+# bit-pattern). Fix widens the splat slot to `poly_array` when call
+# sites disagree, and emits a PolyArray builder at the heterogeneous
+# call site so each arg is boxed under its concrete type.
+
+def test_splat(*args)
+  args.each { |x| puts x.to_s }
+end
+
+test_splat(1, 2, 3)
+test_splat("a", "b")

data/vendor/spinel/test/splat_params_instance.rb

@@ -0,0 +1,21 @@
+# Splat parameter (def f(*a)) on instance methods: the call site packs
+# trailing args into the rest array instead of spilling each into its
+# own slot (which produced "too many arguments to function").
+class T
+  def go(*a); a.size; end
+  def withpre(x, *a); x + a.size; end
+  def firstrest(*a); a[0]; end
+  def sumrest(*a); s = 0; a.each { |v| s += v }; s; end
+end
+class Obj; def initialize(n); @n = n; end; def n; @n; end; end
+class ObjSub < Obj; end  # heap, not value-typed
+t = T.new
+puts t.go(1, 2)
+puts t.go(1, 2, 3, 4)
+puts t.go
+puts t.withpre(10, 1, 2, 3)
+puts t.firstrest(7, 8, 9)
+puts t.sumrest(1, 2, 3, 4)
+xs = [5, 6, 7]
+puts t.sumrest(*xs)
+puts t.go(Obj.new(1), Obj.new(2))