rubyduino 0.1.1

data/vendor/spinel/test/bundle_int_array.rb

@@ -0,0 +1,125 @@
+# Bundled tests:
+#   - int_array_each_with_index
+#   - int_array_each_with_object
+#   - int_array_reduce
+#   - int_array_reject
+#   - int_array_select
+#   - int_array_zip
+
+# === int_array_each_with_index ===
+def t_int_array_each_with_index
+  # Array#each_with_index on an int_array. The element block param must
+  # shadow an outer same-named local of a different C type, and the
+  # index block param must be block-local mrb_int (not leak the outer
+  # `j`). Body skips reading the params to keep this scope-shadow case
+  # separate from the format-specifier path.
+  
+  i = "hi"
+  j = "ho"
+  puts i
+  puts j
+  foo = [10, 20, 30]
+  n = 0
+  foo.each_with_index { |i, j| n = n + 1 }
+  puts n   # 3
+end
+t_int_array_each_with_index
+
+# === int_array_each_with_object ===
+def t_int_array_each_with_object
+  # Array#each_with_object on an int_array. The element block param
+  # must shadow an outer same-named local of a different C type, and
+  # the accumulator block param must take the C type of the seed
+  # (here mrb_int) — not leak the outer `acc` (string). Body avoids
+  # reading the params to keep this scope-shadow case separate from
+  # the separate type-inferer behavior when reading the param inside
+  # the block.
+  
+  i = "hi"
+  acc = "ho"
+  puts i
+  puts acc
+  foo = [10, 20, 30]
+  n = 0
+  foo.each_with_object(0) { |i, acc| n = n + 1 }
+  puts n   # 3
+end
+t_int_array_each_with_object
+
+# === int_array_reduce ===
+def t_int_array_reduce
+  # Array#inject and Array#reduce share compile_reduce_block but have
+  # distinct dispatch entries. Cover both so a divergence at either
+  # entry surfaces. The block param `i` must also shadow an outer
+  # same-named local of a different C type without leaking back out.
+  
+  i = "hi"
+  puts i
+  
+  foo = [1, 2, 3, 4, 5]
+  sum_inject = foo.inject(0) { |acc, i| acc + i }
+  puts sum_inject   # 15
+  
+  sum_reduce = foo.reduce(0) { |acc, i| acc + i }
+  puts sum_reduce   # 15
+end
+t_int_array_reduce
+
+# === int_array_reject ===
+def t_int_array_reject
+  # Array#reject on an int_array. The block param must shadow an outer
+  # same-named local of a different C type. Body uses a constant
+  # predicate so this isolates the shadow case from the separate
+  # type-inferer behavior when reading the param inside the block.
+  
+  i = "hi"
+  puts i
+  foo = [10, 20, 30]
+  none = foo.reject { |i| true }
+  puts none.length  # 0
+  all = foo.reject { |i| false }
+  puts all.length   # 3
+  puts all[0]       # 10
+  puts all[1]       # 20
+  puts all[2]       # 30
+end
+t_int_array_reject
+
+# === int_array_select ===
+def t_int_array_select
+  # Array#select on an int_array. The block param must shadow an outer
+  # same-named local of a different C type. Body uses a constant
+  # predicate so this isolates the shadow case from the separate
+  # type-inferer behavior when reading the param inside the block.
+  
+  i = "hi"
+  puts i
+  foo = [10, 20, 30]
+  all = foo.select { |i| true }
+  puts all.length   # 3
+  puts all[0]       # 10
+  puts all[1]       # 20
+  puts all[2]       # 30
+  none = foo.select { |i| false }
+  puts none.length  # 0
+end
+t_int_array_select
+
+# === int_array_zip ===
+def t_int_array_zip
+  # Array#zip with a block on int_arrays. Both block params must shadow
+  # outer same-named locals of a different C type. Body uses a counter
+  # so this isolates the scope-shadow case from any param-read path.
+  
+  a = "ha"
+  b = "hb"
+  puts a
+  puts b
+  foo = [1, 2, 3]
+  bar = [10, 20, 30]
+  n = 0
+  foo.zip(bar) { |a, b| n = n + 1 }
+  puts n   # 3
+end
+t_int_array_zip
+

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

@@ -0,0 +1,24 @@
+hi
+ho
+3
+hi
+ho
+3
+hi
+15
+15
+hi
+0
+3
+10
+20
+30
+hi
+3
+10
+20
+30
+0
+ha
+hb
+3

data/vendor/spinel/test/bundle_integer.rb

@@ -0,0 +1,248 @@
+# Bundled tests:
+#   - integer_bit_index
+#   - integer_bits
+#   - integer_ceildiv
+#   - integer_divmod
+#   - integer_lcm
+#   - integer_powmod
+#   - integer_pred
+#   - integer_sqrt
+
+# === integer_bit_index ===
+def t_integer_bit_index
+  # `Integer#[N]` returns bit N (0-indexed from the LSB) of the
+  # integer. `data[5]` was previously falling through to the
+  # unknown-method 0-fallback. Lower as `((rc >> idx) & 1)`.
+  
+  # Static index
+  n = 0b10110100
+  puts n[0]    # 0
+  puts n[1]    # 0
+  puts n[2]    # 1
+  puts n[3]    # 0
+  puts n[4]    # 1
+  puts n[5]    # 1
+  puts n[6]    # 0
+  puts n[7]    # 1
+  
+  # Dynamic index
+  i = 0
+  while i < 4
+    puts n[i]
+    i += 1
+  end
+  # 0 0 1 0
+end
+t_integer_bit_index
+
+# === integer_bits ===
+def t_integer_bits
+  # Integer bit-test predicates: allbits? / nobits? / anybits?. Three
+  # parallel methods (true iff the bits in the mask are: all set / all
+  # clear / any set on the receiver). Same coverage matrix per method:
+  # basic, no-overlap / subset, zero mask, single bit, large value,
+  # negative receiver. Was three near-identical files.
+  
+  # === allbits? ===
+  puts 255.allbits?(255)
+  puts 255.allbits?(128)
+  puts 0.allbits?(0)
+  puts 42.allbits?(0)
+  puts 5.allbits?(6)
+  puts 8.allbits?(3)
+  puts 4.allbits?(4)
+  puts 4.allbits?(2)
+  puts 0xFFFF.allbits?(0xFF00)
+  puts((-1).allbits?(255))
+  puts 0.allbits?(1)
+  
+  # === nobits? ===
+  puts 256.nobits?(1)
+  puts 256.nobits?(255)
+  puts 8.nobits?(4)
+  puts 255.nobits?(1)
+  puts 6.nobits?(2)
+  puts 0.nobits?(0)
+  puts 42.nobits?(0)
+  puts 4.nobits?(2)
+  puts 4.nobits?(4)
+  puts((-1).nobits?(1))
+  puts((-4).nobits?(2))
+  puts 0xFF00.nobits?(0x00FF)
+  
+  # === anybits? ===
+  puts 255.anybits?(128)
+  puts 255.anybits?(1)
+  puts 0.anybits?(1)
+  puts 16.anybits?(8)
+  puts 4.anybits?(2)
+  puts 0.anybits?(0)
+  puts 42.anybits?(0)
+  puts 6.anybits?(4)
+  puts 6.anybits?(2)
+  puts((-1).anybits?(1))
+  puts((-4).anybits?(4))
+  puts 0xFF00.anybits?(0x0100)
+end
+t_integer_bits
+
+# === integer_ceildiv ===
+def t_integer_ceildiv
+  # basic
+  puts 7.ceildiv(2)
+  puts 10.ceildiv(5)
+  puts 11.ceildiv(5)
+  
+  # exact division
+  puts 6.ceildiv(3)
+  
+  # zero dividend
+  puts 0.ceildiv(3)
+  
+  # one
+  puts 1.ceildiv(1)
+  
+  # negative
+  puts((-7).ceildiv(2))
+  puts 7.ceildiv(-2)
+  puts((-7).ceildiv(-2))
+  
+  # large
+  puts 1000001.ceildiv(1000)
+end
+t_integer_ceildiv
+
+# === integer_divmod ===
+def t_integer_divmod
+  p 100.divmod(7)
+  # Float#divmod returns [Integer, Float] — exercises the
+  # tuple:int,float inspect arm.
+  p 5.5.divmod(2)
+end
+t_integer_divmod
+
+# === integer_lcm ===
+def t_integer_lcm
+  # basic
+  puts 6.lcm(4)
+  puts 4.lcm(6)
+  
+  # zero
+  puts 0.lcm(5)
+  puts 5.lcm(0)
+  puts 0.lcm(0)
+  
+  # negative
+  puts((-4).lcm(6))
+  puts 6.lcm(-4)
+  puts((-3).lcm(-7))
+  
+  # same
+  puts 7.lcm(7)
+  
+  # one
+  puts 1.lcm(5)
+  puts 5.lcm(1)
+  
+  # coprime
+  puts 8.lcm(9)
+  
+  # divisor — one divides the other
+  puts 3.lcm(9)
+  puts 9.lcm(3)
+  
+  # primes
+  puts 7.lcm(13)
+  
+  # one with one
+  puts 1.lcm(1)
+  
+  # large
+  puts 12345.lcm(67890)
+end
+t_integer_lcm
+
+# === integer_powmod ===
+def t_integer_powmod
+  # basic
+  puts 2.pow(10, 1000)
+  puts 5.pow(2, 3)
+  puts 3.pow(3, 8)
+  
+  # exp zero
+  puts 2.pow(0, 5)
+  puts 0.pow(0, 5)
+  
+  # mod one — always zero
+  puts 2.pow(100, 1)
+  puts 999.pow(999, 1)
+  
+  # negative base
+  puts((-2).pow(3, 5))
+  puts((-3).pow(2, 7))
+  
+  # large exponent
+  puts 2.pow(20, 1000000)
+  puts 7.pow(15, 100)
+  
+  # base larger than mod
+  puts 100.pow(3, 7)
+  
+  # base zero
+  puts 0.pow(5, 3)
+  
+  # base one
+  puts 1.pow(999, 7)
+  
+  # mod two
+  puts 7.pow(3, 2)
+  
+  # exp one
+  puts 5.pow(1, 3)
+  
+  # negative mod
+  puts 2.pow(2, -3)
+  puts 2.pow(3, -5)
+  
+  # one-arg pow
+  puts 2.pow(10)
+  puts 3.pow(3)
+end
+t_integer_powmod
+
+# === integer_pred ===
+def t_integer_pred
+  # basic
+  puts 5.pred
+  puts 1.pred
+  puts 0.pred
+  
+  # negative
+  puts((-1).pred)
+  puts((-100).pred)
+  
+  # large
+  puts 1000000.pred
+end
+t_integer_pred
+
+# === integer_sqrt ===
+def t_integer_sqrt
+  p Integer.sqrt(0)
+  p Integer.sqrt(1)
+  p Integer.sqrt(16)
+  p Integer.sqrt(99)
+  p Integer.sqrt(100)
+  p Integer.sqrt(101)
+  p Integer.sqrt(1_000_000)
+  
+  # Large-integer precision — beyond the 53-bit double mantissa.
+  # A double-based sqrt would round and produce off-by-one results
+  # for values above ~2^53; the Newton-method helper stays exact.
+  p Integer.sqrt(2**53)
+  p Integer.sqrt(2**53 + 1)
+  p Integer.sqrt(2**60)
+  p Integer.sqrt(2**62 - 1)
+end
+t_integer_sqrt
+

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

@@ -0,0 +1,113 @@
+0
+0
+1
+0
+1
+1
+0
+1
+0
+0
+1
+0
+true
+true
+true
+true
+false
+false
+true
+false
+true
+true
+false
+true
+true
+true
+false
+false
+true
+true
+true
+false
+false
+true
+true
+true
+true
+false
+false
+false
+false
+false
+true
+true
+true
+true
+true
+4
+2
+3
+2
+0
+1
+-3
+-3
+4
+1001
+[14, 2]
+[2, 1.5]
+12
+12
+0
+0
+0
+12
+12
+21
+7
+5
+5
+72
+9
+9
+91
+1
+55873470
+24
+1
+3
+1
+1
+0
+0
+2
+2
+48576
+43
+1
+0
+1
+1
+2
+-2
+-2
+1024
+27
+4
+0
+-1
+-2
+-101
+999999
+0
+1
+4
+9
+10
+10
+1000
+94906265
+94906265
+1073741824
+2147483647

data/vendor/spinel/test/bundle_io_sys.rb

@@ -0,0 +1,223 @@
+# Bundled tests:
+#   - file_binread
+#   - fileio
+#   - fileopen
+#   - fileops
+#   - system
+#   - system_expr
+#   - process_clock_gettime
+#   - time
+
+# === file_binread ===
+def t_file_binread
+  # `File.binread(path).bytes` — sp_str_bytes uses null-termination
+  # and stops at the first 0x00 byte, so for binary data (e.g. .nes
+  # ROM files where 0x00 appears mid-file) we need a dedicated
+  # helper that reads with the actual file size.
+  #
+  # `File.binread(path)` standalone is aliased to File.read.
+  #
+  # Uses a cwd-relative path so MSYS2 and the native-Windows-built
+  # spinel binary resolve to the same file (the harness runs each test
+  # from the project root). `/tmp/...` would land in different places
+  # on the two sides — see test/fileio.rb for the same workaround.
+  
+  # Set up a binary file with embedded NULs via a shell command.
+  # spinel's File.write uses fputs and would stop at the first NUL.
+  path = "spinel_binread_test.bin"
+  `printf 'AB\\000CD\\000EF' > #{path}`
+  
+  # Pattern-matched: emits sp_file_binread_bytes(path) which reads
+  # the file by its actual byte count, NOT through sp_str_bytes.
+  arr = File.binread(path).bytes
+  puts arr.length               # 8
+  puts arr[0]                   # 65 (A)
+  puts arr[1]                   # 66 (B)
+  puts arr[2]                   # 0  (NUL)
+  puts arr[3]                   # 67 (C)
+  puts arr[4]                   # 68 (D)
+  puts arr[5]                   # 0  (NUL)
+  puts arr[6]                   # 69 (E)
+  puts arr[7]                   # 70 (F)
+  
+  # `File.binread` standalone aliases `File.read`. spinel's strings
+  # are null-terminated so any NUL in the result is a hard stop —
+  # this branch is just verifying the alias resolves and returns
+  # something string-shaped.
+  puts File.binread(path)[0, 2] # AB
+  
+  File.delete(path) if File.exist?(path)
+end
+t_file_binread
+
+# === fileio ===
+def t_fileio
+  # Test basic File I/O.
+  # Uses cwd-relative paths so the harness (which runs each test from
+  # the project root) and the CRuby reference both write to the same
+  # place on every platform — `/tmp/...` doesn't resolve uniformly
+  # across MSYS2 mingw64 ruby and native-Windows-built spinel binaries.
+  
+  # Write a file
+  File.write("spinel_test.txt", "Hello from Spinel!\nLine 2\n")
+  
+  # Read the file
+  content = File.read("spinel_test.txt")
+  puts content
+  
+  # File.exist?
+  puts File.exist?("spinel_test.txt")  # true
+  puts File.exist?("spinel_nonexistent.txt")  # false
+  
+  # Clean up
+  File.delete("spinel_test.txt")
+  puts File.exist?("spinel_test.txt")  # false
+  
+  puts "done"
+end
+t_fileio
+
+# === fileopen ===
+def t_fileopen
+  # Test File.open with block.
+  # Uses a cwd-relative path for the same reason as test/fileio.rb.
+  
+  # Write with block
+  File.open("spinel_fopen_test.txt", "w") do |f|
+    f.puts "line 1"
+    f.puts "line 2"
+    f.puts "line 3"
+  end
+  
+  # Read with block
+  File.open("spinel_fopen_test.txt", "r") do |f|
+    f.each_line do |line|
+      puts line
+    end
+  end
+  
+  # File.open without block (returns file object)
+  # Skip — needs explicit close, less common
+  
+  # Cleanup
+  File.delete("spinel_fopen_test.txt")
+  puts "done"
+end
+t_fileopen
+
+# === fileops ===
+def t_fileops
+  puts File.join("home", "user")      # home/user
+  puts File.basename("/path/to/file") # file
+  puts "".empty?                      # true
+  puts "hi".empty?                    # false
+  puts 5.clamp(1, 10)                 # 5
+  puts 15.clamp(1, 10)                # 10
+  puts "hello".to_sym                 # hello
+  puts "a".ord                        # 97
+  puts "42".to_i + 1                  # 43
+  puts "done"
+end
+t_fileops
+
+# === system ===
+def t_system
+  # Test system features needed for ccm
+  
+  # system()
+  system("echo hello_from_system")  # hello_from_system
+  
+  # ENV
+  puts ENV['HOME'] != nil  # true
+  
+  # Dir.home
+  home = Dir.home
+  puts home.length > 0  # true
+  
+  # backtick
+  result = `echo backtick_test`.strip
+  puts result  # backtick_test
+  
+  # trap (just register, don't trigger)
+  trap('INT') { }
+  puts "trap set"
+  
+  # $stdin — skip interactive test
+  # File.readlink — skip (needs symlink)
+  
+  puts "done"
+end
+t_system
+
+# === system_expr ===
+def t_system_expr
+  ok = system("echo hello_from_expr")
+  puts ok
+  puts($? == 0)
+  ok = system("false")
+  puts ok
+  puts($? == 0)
+end
+t_system_expr
+
+# === process_clock_gettime ===
+def t_process_clock_gettime
+  # Process.clock_gettime(Process::CLOCK_MONOTONIC) returns a Float.
+  # We can't assert an exact value, but we can verify the call lowers
+  # correctly (returns a float, monotonic non-decreasing across two
+  # samples).
+  
+  t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  t2 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  
+  # t1 and t2 must be Float-typed in spinel; arithmetic should work.
+  diff = t2 - t1
+  if diff >= 0
+    puts "monotonic"
+  end
+end
+t_process_clock_gettime
+
+# === time ===
+def t_time
+  t = Time.now
+  puts t.to_f - t.to_i > 0.0
+  puts t.to_i > 1_000_000_000
+  puts t.to_i < 2_000_000_000
+  puts t.to_f > 1_000_000_000.0
+  puts t.to_i == t.to_f.to_i || t.to_i + 1 == t.to_f.to_i
+  
+  puts Time.at(1234567890).to_i == 1234567890
+  puts Time.at(0).to_i == 0
+  puts Time.at(-1).to_i == -1
+  
+  t2 = Time.at(1234567890.5)
+  puts t2.to_i == 1234567890
+  puts (t2.to_f - 1234567890.5).abs < 0.001
+  
+  a = Time.at(1000.5)
+  b = Time.at(500.25)
+  puts ((a - b) - 500.25).abs < 0.0001
+  
+  puts (Time.at(0) - Time.at(0)).abs < 0.0001
+  
+  puts ((Time.at(100) - Time.at(200)) + 100.0).abs < 0.0001
+  
+  # guards sp_time_at_float's frac < 0 normalization
+  puts Time.at(-0.5).to_i == -1
+  
+  puts Time.at(0.0).to_i == 0
+  
+  # d78149b: tv_nsec must reach Time#to_f for ms precision
+  puts Time.now.to_f * 1000 > 1_000_000_000_000.0
+  
+  puts Time.at(1).to_i + Time.at(2).to_i == 3
+  
+  puts (Time.at(1.5).to_f * 1000 - 1500.0).abs < 1.0
+  
+  puts (Time.at(2000) - Time.at(1000)).to_i == 1000
+  
+  puts "done"
+end
+t_time
+