webruby 0.2.7 → 0.9.1

data/modules/mruby/tasks/mruby_build_gem.rake

@@ -31,9 +31,15 @@ module MRuby
       return nil unless Gem.current
 
       Gem.current.dir = gemdir
-      Gem.current.build = MRuby::Build.current
+      Gem.current.build = self.is_a?(MRuby::Build) ? self : MRuby::Build.current
       Gem.current.build_config_initializer = block
       gems << Gem.current
+
+      cxx_srcs = ['src', 'test', 'tools'].map do |subdir|
+        Dir.glob("#{Gem.current.dir}/#{subdir}/*.{cpp,cxx,cc}")
+      end.flatten
+      enable_cxx_abi unless cxx_srcs.empty?
+
       Gem.current
     end
 
@@ -41,7 +47,11 @@ module MRuby
       if params[:github]
         params[:git] = "https://github.com/#{params[:github]}.git"
       elsif params[:bitbucket]
-        params[:git] = "https://bitbucket.org/#{params[:bitbucket]}.git"
+        if params[:method] == "ssh"
+          params[:git] = "git@bitbucket.org:#{params[:bitbucket]}.git"
+        else
+          params[:git] = "https://bitbucket.org/#{params[:bitbucket]}.git"
+        end
       end
 
       if params[:core]
@@ -50,6 +60,9 @@ module MRuby
         url = params[:git]
         gemdir = "#{gem_clone_dir}/#{url.match(/([-\w]+)(\.[-\w]+|)$/).to_a[1]}"
 
+        # by default the 'master' branch is used
+        branch = params[:branch] ? params[:branch] : 'master'
+
         if File.exist?(gemdir)
           if $pull_gems
             git.run_pull gemdir, url
@@ -58,10 +71,19 @@ module MRuby
           end
         else
           options = [params[:options]] || []
-          options << "--branch \"#{params[:branch]}\"" if params[:branch]
+          options << "--branch \"#{branch}\""
+          options << "--depth 1" unless params[:checksum_hash]
           FileUtils.mkdir_p "#{gem_clone_dir}"
           git.run_clone gemdir, url, options
         end
+
+        if params[:checksum_hash]
+          # Jump to the specified commit
+          git.run_checkout gemdir, params[:checksum_hash]
+        else
+          # Jump to the top of the branch
+          git.run_checkout gemdir, branch
+        end
       else
         fail "unknown gem option #{params}"
       end

data/modules/mruby/tasks/ruby_ext.rake

@@ -16,13 +16,13 @@ class String
   def relative_path
     relative_path_from(Dir.pwd)
   end
-  
+
   # Compatible with 1.9 on 1.8
   def %(params)
     if params.is_a?(Hash)
       str = self.clone
       params.each do |k, v|
-        str.gsub!("%{#{k}}", v)
+        str.gsub!("%{#{k}}") { v }
       end
       str
     else
@@ -42,6 +42,15 @@ class Symbol
   end
 end
 
+module Enumerable
+  # Compatible with 1.9 on 1.8
+  def each_with_object(memo)
+    return to_enum :each_with_object, memo unless block_given?
+    each { |obj| yield obj, memo }
+    memo
+  end
+end
+
 $pp_show = true
 
 if $verbose.nil?

data/modules/mruby/tasks/toolchains/clang.rake

@@ -1,8 +1,9 @@
 MRuby::Toolchain.new(:clang) do |conf|
   toolchain :gcc
 
-  [conf.cc, conf.cxx, conf.objc, conf.asm].each do |cc|
+  [conf.cc, conf.objc, conf.asm].each do |cc|
     cc.command = ENV['CC'] || 'clang'
   end
+  conf.cxx.command = ENV['CXX'] || 'clang++'
   conf.linker.command = ENV['LD'] || 'clang'
 end

data/modules/mruby/tasks/toolchains/gcc.rake

@@ -1,8 +1,7 @@
 MRuby::Toolchain.new(:gcc) do |conf|
   [conf.cc, conf.objc, conf.asm].each do |cc|
     cc.command = ENV['CC'] || 'gcc'
-    cc.flags = [ENV['CFLAGS'] || %w(-g -std=gnu99 -O3 -Wall -Werror-implicit-function-declaration)]
-    cc.include_paths = ["#{MRUBY_ROOT}/include"]
+    cc.flags = [ENV['CFLAGS'] || %w(-g -std=gnu99 -O3 -Wall -Werror-implicit-function-declaration -Wdeclaration-after-statement)]
     cc.defines = %w(DISABLE_GEMS)
     cc.option_include_path = '-I%s'
     cc.option_define = '-D%s'
@@ -12,7 +11,6 @@ MRuby::Toolchain.new(:gcc) do |conf|
   [conf.cxx].each do |cxx|
     cxx.command = ENV['CXX'] || 'g++'
     cxx.flags = [ENV['CXXFLAGS'] || ENV['CFLAGS'] || %w(-g -O3 -Wall -Werror-implicit-function-declaration)]
-    cxx.include_paths = ["#{MRUBY_ROOT}/include"]
     cxx.defines = %w(DISABLE_GEMS)
     cxx.option_include_path = '-I%s'
     cxx.option_define = '-D%s'
@@ -28,4 +26,29 @@ MRuby::Toolchain.new(:gcc) do |conf|
     linker.option_library_path = '-L%s'
     linker.link_options = '%{flags} -o %{outfile} %{objs} %{flags_before_libraries} %{libs} %{flags_after_libraries}'
   end
+
+  [[conf.cc, 'c'], [conf.cxx, 'c++']].each do |cc, lang|
+    cc.instance_variable_set :@header_search_language, lang
+    def cc.header_search_paths
+      if @header_search_command != command
+        result = `echo | #{build.filename command} -x#{@header_search_language} -Wp,-v - -fsyntax-only 2>&1`
+        result = `echo | #{command} -x#{@header_search_language} -Wp,-v - -fsyntax-only 2>&1` if $?.exitstatus != 0
+        return include_paths if  $?.exitstatus != 0
+
+        @frameworks = []
+        @header_search_paths = result.lines.map { |v|
+          framework = v.match(/^ (.*)(?: \(framework directory\))$/)
+          if framework
+            @frameworks << framework[1]
+            next nil
+          end
+
+          v.match(/^ (.*)$/)
+        }.compact.map { |v| v[1] }.select { |v| File.directory? v }
+        @header_search_paths += include_paths
+        @header_search_command = command
+      end
+      @header_search_paths
+    end
+  end
 end

data/modules/mruby/tasks/toolchains/visualcpp.rake

@@ -1,34 +1,43 @@
 MRuby::Toolchain.new(:visualcpp) do |conf|
-  [conf.cc, conf.cxx].each do |cc|
+  [conf.cc].each do |cc|
     cc.command = ENV['CC'] || 'cl.exe'
-    cc.flags = [ENV['CFLAGS'] || %w(/c /nologo /W3 /D_DEBUG /MDd /Zi /Od /RTC1 /DHAVE_STRING_H /DNO_GETTIMEOFDAY /D_CRT_SECURE_NO_WARNINGS)]
-    cc.include_paths = ["#{MRUBY_ROOT}/include"]
-    cc.defines = %w(DISABLE_GEMS)
+    # C4013: implicit function declaration
+    cc.flags = [ENV['CFLAGS'] || %w(/c /nologo /W3 /we4013 /Zi /MD /O2 /D_CRT_SECURE_NO_WARNINGS)]
+    cc.defines = %w(DISABLE_GEMS MRB_STACK_EXTEND_DOUBLING)
     cc.option_include_path = '/I%s'
     cc.option_define = '/D%s'
     cc.compile_options = "%{flags} /Fo%{outfile} %{infile}"
   end
 
+  [conf.cxx].each do |cxx|
+    cxx.command = ENV['CXX'] || 'cl.exe'
+    cxx.flags = [ENV['CXXFLAGS'] || ENV['CFLAGS'] || %w(/c /nologo /W3 /Zi /MD /O2 /EHsc /D_CRT_SECURE_NO_WARNINGS)]
+    cxx.defines = %w(DISABLE_GEMS MRB_STACK_EXTEND_DOUBLING)
+    cxx.option_include_path = '/I%s'
+    cxx.option_define = '/D%s'
+    cxx.compile_options = "%{flags} /Fo%{outfile} %{infile}"
+  end
+
   conf.linker do |linker|
     linker.command = ENV['LD'] || 'link.exe'
-    linker.flags = [ENV['LDFLAGS'] || %w(/nologo)]
+    linker.flags = [ENV['LDFLAGS'] || %w(/NOLOGO /DEBUG /INCREMENTAL:NO /OPT:ICF /OPT:REF)]
     linker.libraries = %w()
     linker.library_paths = %w()
     linker.option_library = '%s.lib'
     linker.option_library_path = '/LIBPATH:%s'
     linker.link_options = "%{flags} /OUT:%{outfile} %{objs} %{flags_before_libraries} %{libs} %{flags_after_libraries}"
   end
- 
+
   conf.archiver do |archiver|
     archiver.command = ENV['AR'] || 'lib.exe'
     archiver.archive_options = '/nologo /OUT:%{outfile} %{objs}'
   end
- 
+
   conf.yacc do |yacc|
     yacc.command = ENV['YACC'] || 'bison.exe'
     yacc.compile_options = '-o %{outfile} %{infile}'
   end
- 
+
   conf.gperf do |gperf|
     gperf.command = 'gperf.exe'
     gperf.compile_options = '-L ANSI-C -C -p -j1 -i 1 -g -o -t -N mrb_reserved_word -k"1,3,$" %{infile} > %{outfile}'

data/modules/mruby/test/assert.rb

@@ -9,10 +9,11 @@ def t_print(*args)
   i = 0
   len = args.size
   while i < len
+    str = args[i].to_s
     begin
-      __printstr__ args[i].to_s
+      __printstr__ str
     rescue NoMethodError
-      __t_printstr__ args[i].to_s
+      __t_printstr__ str rescue print str
     end
     i += 1
   end
@@ -20,7 +21,7 @@ end
 
 ##
 # Create the assertion in a readable way
-def assertion_string(err, str, iso=nil, e=nil)
+def assertion_string(err, str, iso=nil, e=nil, bt=nil)
   msg = "#{err}#{str}"
   msg += " [#{iso}]" if iso && iso != ''
   msg += " => #{e.message}" if e
@@ -30,6 +31,7 @@ def assertion_string(err, str, iso=nil, e=nil)
       msg += "\n - Assertion[#{idx}] Failed: #{str}\n#{diff}"
     end
   end
+  msg += "\nbacktrace:\n\t#{bt.join("\n\t")}" if bt
   msg
 end
 
@@ -55,11 +57,12 @@ def assert(str = 'Assertion failed', iso = '')
       t_print('.')
     end
   rescue Exception => e
+    bt = e.backtrace if $mrbtest_verbose
     if e.class.to_s == 'MRubyTestSkip'
       $asserts.push "Skip: #{str} #{iso} #{e.cause}"
       t_print('?')
     else
-      $asserts.push(assertion_string('Error: ', str, iso, e))
+      $asserts.push(assertion_string("#{e.class}: ", str, iso, e, bt))
       $kill_test += 1
       t_print('X')
   end
@@ -77,7 +80,7 @@ end
 def assert_true(ret, msg = nil, diff = nil)
   if $mrbtest_assert
     $mrbtest_assert_idx += 1
-    if !ret
+    unless ret
       msg = "Expected #{ret.inspect} to be true" unless msg
       diff = assertion_diff(true, ret)  unless diff
       $mrbtest_assert.push([$mrbtest_assert_idx, msg, diff])
@@ -105,7 +108,7 @@ def assert_equal(arg1, arg2 = nil, arg3 = nil)
   else
     exp, act, msg = arg1, arg2, arg3
   end
-  
+
   msg = "Expected to be equal" unless msg
   diff = assertion_diff(exp, act)
   assert_true(exp == act, msg, diff)
@@ -173,6 +176,24 @@ def assert_raise(*exp)
   ret
 end
 
+def assert_nothing_raised(*exp)
+  ret = true
+  if $mrbtest_assert
+    $mrbtest_assert_idx += 1
+    msg = exp.last.class == String ? exp.pop : ""
+    begin
+      yield
+    rescue Exception => e
+      msg = "#{msg} exception raised."
+      diff = "      Class: <#{e.class}>\n" +
+             "    Message: #{e.message}"
+      $mrbtest_assert.push([$mrbtest_assert_idx, msg, diff])
+      ret = false
+    end
+  end
+  ret
+end
+
 ##
 # Fails unless +obj+ is a kind of +cls+.
 def assert_kind_of(cls, obj, msg = nil)
@@ -199,7 +220,7 @@ def report()
     puts msg
   end
 
-  $total_test = $ok_test.+($ko_test)
+  $total_test = $ok_test+$ko_test+$kill_test
   t_print("Total: #{$total_test}\n")
 
   t_print("   OK: #{$ok_test}\n")
@@ -207,7 +228,8 @@ def report()
   t_print("Crash: #{$kill_test}\n")
 
   if Object.const_defined?(:Time)
-    t_print(" Time: #{Time.now - $test_start} seconds\n")
+    t_time = Time.now - $test_start
+    t_print(" Time: #{t_time.round(2)} seconds\n")
   end
 end
 

data/modules/mruby/test/bintest.rb

@@ -0,0 +1,10 @@
+$:.unshift File.dirname(File.dirname(File.expand_path(__FILE__)))
+require 'test/assert.rb'
+
+ARGV.each do |gem|
+  Dir["#{gem}/bintest/*.rb"].each do |file|
+    load file
+  end
+end
+
+load 'test/report.rb'

data/modules/mruby/test/driver.c

@@ -10,12 +10,13 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include <mruby.h>
-#include <mruby/proc.h>
-#include <mruby/data.h>
-#include <mruby/compile.h>
-#include <mruby/string.h>
-#include <mruby/variable.h>
+#include "mruby.h"
+#include "mruby/proc.h"
+#include "mruby/data.h"
+#include "mruby/compile.h"
+#include "mruby/string.h"
+#include "mruby/variable.h"
+#include "mruby/array.h"
 
 void
 mrb_init_mrbtest(mrb_state *);
@@ -24,9 +25,7 @@ mrb_init_mrbtest(mrb_state *);
 static void
 print_hint(void)
 {
-  printf("mrbtest - Embeddable Ruby Test\n");
-  printf("\nThis is a very early version, please test and report errors.\n");
-  printf("Thanks :)\n\n");
+  printf("mrbtest - Embeddable Ruby Test\n\n");
 }
 
 static int
@@ -34,8 +33,8 @@ check_error(mrb_state *mrb)
 {
   /* Error check */
   /* $ko_test and $kill_test should be 0 */
-  mrb_value ko_test = mrb_gv_get(mrb, mrb_intern(mrb, "$ko_test", 8));
-  mrb_value kill_test = mrb_gv_get(mrb, mrb_intern(mrb, "$kill_test", 10));
+  mrb_value ko_test = mrb_gv_get(mrb, mrb_intern_lit(mrb, "$ko_test"));
+  mrb_value kill_test = mrb_gv_get(mrb, mrb_intern_lit(mrb, "$kill_test"));
 
   return mrb_fixnum_p(ko_test) && mrb_fixnum(ko_test) == 0 && mrb_fixnum_p(kill_test) && mrb_fixnum(kill_test) == 0;
 }
@@ -43,14 +42,13 @@ check_error(mrb_state *mrb)
 static int
 eval_test(mrb_state *mrb)
 {
-  mrb_value return_value;
   const char *prog = "report()";
 
   /* evaluate the test */
-  return_value = mrb_load_string(mrb, prog);
+  mrb_load_string(mrb, prog);
   /* did an exception occur? */
   if (mrb->exc) {
-    mrb_p(mrb, return_value);
+    mrb_print_error(mrb);
     mrb->exc = 0;
     return EXIT_FAILURE;
   }
@@ -63,14 +61,12 @@ eval_test(mrb_state *mrb)
 static void
 t_printstr(mrb_state *mrb, mrb_value obj)
 {
-  struct RString *str;
   char *s;
   int len;
-   
+
   if (mrb_string_p(obj)) {
-    str = mrb_str_ptr(obj);
-    s = str->ptr;
-    len = str->len;
+    s = RSTRING_PTR(obj);
+    len = RSTRING_LEN(obj);
     fwrite(s, len, 1, stdout);
   }
 }
@@ -86,12 +82,68 @@ mrb_t_printstr(mrb_state *mrb, mrb_value self)
   return argv;
 }
 
+void
+mrb_init_test_driver(mrb_state *mrb, mrb_bool verbose)
+{
+  struct RClass *krn, *mrbtest;
+
+  krn = mrb->kernel_module;
+  mrb_define_method(mrb, krn, "__t_printstr__", mrb_t_printstr, MRB_ARGS_REQ(1));
+
+  mrbtest = mrb_define_module(mrb, "Mrbtest");
+
+  mrb_define_const(mrb, mrbtest, "FIXNUM_MAX", mrb_fixnum_value(MRB_INT_MAX));
+  mrb_define_const(mrb, mrbtest, "FIXNUM_MIN", mrb_fixnum_value(MRB_INT_MIN));
+  mrb_define_const(mrb, mrbtest, "FIXNUM_BIT", mrb_fixnum_value(MRB_INT_BIT));
+
+  if (verbose) {
+    mrb_gv_set(mrb, mrb_intern_lit(mrb, "$mrbtest_verbose"), mrb_true_value());
+  }
+}
+
+void
+mrb_t_pass_result(mrb_state *mrb_dst, mrb_state *mrb_src)
+{
+  mrb_value res_src;
+
+  if (mrb_src->exc) {
+    mrb_print_error(mrb_src);
+    exit(EXIT_FAILURE);
+  }
+
+#define TEST_COUNT_PASS(name)                                           \
+  do {                                                                  \
+    res_src = mrb_gv_get(mrb_src, mrb_intern_lit(mrb_src, "$" #name));  \
+    if (mrb_fixnum_p(res_src)) {                                        \
+      mrb_value res_dst = mrb_gv_get(mrb_dst, mrb_intern_lit(mrb_dst, "$" #name)); \
+      mrb_gv_set(mrb_dst, mrb_intern_lit(mrb_dst, "$" #name), mrb_fixnum_value(mrb_fixnum(res_dst) + mrb_fixnum(res_src))); \
+    }                                                                   \
+  } while (FALSE)                                                       \
+
+  TEST_COUNT_PASS(ok_test);
+  TEST_COUNT_PASS(ko_test);
+  TEST_COUNT_PASS(kill_test);
+
+#undef TEST_COUNT_PASS
+
+  res_src = mrb_gv_get(mrb_src, mrb_intern_lit(mrb_src, "$asserts"));
+
+  if (mrb_array_p(res_src)) {
+    mrb_int i;
+    mrb_value res_dst = mrb_gv_get(mrb_dst, mrb_intern_lit(mrb_dst, "$asserts"));
+    for (i = 0; i < RARRAY_LEN(res_src); ++i) {
+      mrb_value val_src = RARRAY_PTR(res_src)[i];
+      mrb_ary_push(mrb_dst, res_dst, mrb_str_new(mrb_dst, RSTRING_PTR(val_src), RSTRING_LEN(val_src)));
+    }
+  }
+}
+
 int
 main(int argc, char **argv)
 {
   mrb_state *mrb;
-  struct RClass *krn;
   int ret;
+  mrb_bool verbose = FALSE;
 
   print_hint();
 
@@ -104,12 +156,10 @@ main(int argc, char **argv)
 
   if (argc == 2 && argv[1][0] == '-' && argv[1][1] == 'v') {
     printf("verbose mode: enable\n\n");
-    mrb_gv_set(mrb, mrb_intern(mrb, "$mrbtest_verbose", 16), mrb_true_value());
+    verbose = TRUE;
   }
 
-  krn = mrb->kernel_module;
-  mrb_define_method(mrb, krn, "__t_printstr__", mrb_t_printstr, MRB_ARGS_REQ(1));
-
+  mrb_init_test_driver(mrb, verbose);
   mrb_init_mrbtest(mrb);
   ret = eval_test(mrb);
   mrb_close(mrb);

data/modules/mruby/test/init_mrbtest.c

@@ -1,21 +1,40 @@
 #include <stdlib.h>
 #include "mruby.h"
 #include "mruby/irep.h"
+#include "mruby/variable.h"
 
+extern const uint8_t mrbtest_assert_irep[];
 extern const uint8_t mrbtest_irep[];
 
 void mrbgemtest_init(mrb_state* mrb);
+void mrb_init_test_driver(mrb_state* mrb, mrb_bool verbose);
+void mrb_t_pass_result(mrb_state *mrb_dst, mrb_state *mrb_src);
 
 void
 mrb_init_mrbtest(mrb_state *mrb)
 {
-  mrb_load_irep(mrb, mrbtest_irep);
+  mrb_state *core_test;
+
+  mrb_load_irep(mrb, mrbtest_assert_irep);
+
+  core_test = mrb_open_core(mrb_default_allocf, NULL);
+  if (core_test == NULL) {
+    fprintf(stderr, "Invalid mrb_state, exiting %s", __FUNCTION__);
+    exit(EXIT_FAILURE);
+  }
+  mrb_init_test_driver(core_test, mrb_test(mrb_gv_get(mrb, mrb_intern_lit(mrb, "$mrbtest_verbose"))));
+  mrb_load_irep(core_test, mrbtest_assert_irep);
+  mrb_load_irep(core_test, mrbtest_irep);
+  mrb_t_pass_result(mrb, core_test);
+
 #ifndef DISABLE_GEMS
   mrbgemtest_init(mrb);
 #endif
+
   if (mrb->exc) {
-    mrb_p(mrb, mrb_obj_value(mrb->exc));
+    mrb_print_error(mrb);
     exit(EXIT_FAILURE);
   }
+  mrb_close(core_test);
 }
 

data/modules/mruby/test/mrbtest.rake

@@ -8,10 +8,15 @@ MRuby.each_target do
   mlib = clib.ext(exts.object)
   mrbs = Dir.glob("#{current_dir}/t/*.rb")
   init = "#{current_dir}/init_mrbtest.c"
-  asslib = "#{current_dir}/assert.rb"
+  ass_c = "#{current_build_dir}/assert.c"
+  ass_lib = ass_c.ext(exts.object)
 
   mrbtest_lib = libfile("#{current_build_dir}/mrbtest")
-  file mrbtest_lib => [mlib, gems.map(&:test_objs), gems.map { |g| g.test_rbireps.ext(exts.object) }].flatten do |t|
+  mrbtest_objs = [mlib, ass_lib]
+  gems.each do |v|
+    mrbtest_objs.concat v.test_objs
+  end
+  file mrbtest_lib => mrbtest_objs do |t|
     archiver.run t.name, t.prerequisites
   end
 
@@ -27,13 +32,30 @@ MRuby.each_target do
     end
   end
 
-  file mlib => [clib]
-  file clib => [mrbcfile, init, asslib] + mrbs do |t|
+  file ass_lib => ass_c
+  file ass_c => ["#{current_dir}/assert.rb", __FILE__] do |t|
+    FileUtils.mkdir_p File.dirname t.name
+    open(t.name, 'w') do |f|
+      mrbc.run f, [t.prerequisites.first], 'mrbtest_assert_irep'
+    end
+  end
+
+  file mlib => clib
+  file clib => [mrbcfile, init, __FILE__] + mrbs do |t|
     _pp "GEN", "*.rb", "#{clib.relative_path}"
     FileUtils.mkdir_p File.dirname(clib)
     open(clib, 'w') do |f|
+      f.puts %Q[/*]
+      f.puts %Q[ * This file contains a list of all]
+      f.puts %Q[ * test functions.]
+      f.puts %Q[ *]
+      f.puts %Q[ * IMPORTANT:]
+      f.puts %Q[ *   This file was generated!]
+      f.puts %Q[ *   All manual changes will get lost.]
+      f.puts %Q[ */]
+      f.puts %Q[]
       f.puts IO.read(init)
-      mrbc.run f, [asslib] + mrbs, 'mrbtest_irep'
+      mrbc.run f, mrbs, 'mrbtest_irep'
       gems.each do |g|
         f.puts %Q[void GENERATED_TMP_mrb_#{g.funcname}_gem_test(mrb_state *mrb);]
       end

data/modules/mruby/test/t/argumenterror.rb

@@ -14,8 +14,3 @@ assert('ArgumentError', '15.2.24') do
   assert_equal(Class, ArgumentError.class)
   assert_equal(ArgumentError, e2.class)
 end
-
-assert('ArgumentError superclass', '15.2.24.2') do
-  assert_equal(StandardError, ArgumentError.superclass)
-end
-

data/modules/mruby/test/t/array.rb

@@ -5,10 +5,6 @@ assert('Array', '15.2.12') do
   assert_equal(Class, Array.class)
 end
 
-assert('Array superclass', '15.2.12.2') do
-  assert_equal(Object, Array.superclass)
-end
-
 assert('Array inclueded modules', '15.2.12.3') do
   assert_true(Array.include?(Enumerable))
 end
@@ -49,6 +45,11 @@ assert('Array#[]', '15.2.12.5.4') do
   assert_equal(nil, [1,2,3].[](4))
   assert_equal(3, [1,2,3].[](-1))
   assert_equal(nil, [1,2,3].[](-4))
+
+  a = [ "a", "b", "c", "d", "e" ]
+  assert_equal("b", a[1.1])
+  assert_equal(["b", "c"], a[1,2])
+  assert_equal(["b", "c", "d"], a[1..-2])
 end
 
 assert('Array#[]=', '15.2.12.5.5') do
@@ -61,9 +62,26 @@ assert('Array#[]=', '15.2.12.5.5') do
     # this will cause an exception due to the wrong arguments
     a.[]=(1,2,3,4)
   end
+  assert_raise(IndexError) do
+    # this will cause an exception due to the wrong arguments
+    a = [1,2,3,4,5]
+    a[1, -1] = 10
+  end
 
   assert_equal(4, [1,2,3].[]=(1,4))
   assert_equal(3, [1,2,3].[]=(1,2,3))
+
+  a = [1,2,3,4,5]
+  a[3..-1] = 6
+  assert_equal([1,2,3,6], a)
+
+  a = [1,2,3,4,5]
+  a[3..-1] = []
+  assert_equal([1,2,3], a)
+
+  a = [1,2,3,4,5]
+  a[2...4] = 6
+  assert_equal([1,2,6,5], a)
 end
 
 assert('Array#clear', '15.2.12.5.6') do
@@ -301,6 +319,7 @@ assert('Array#hash', '15.2.12.5.35') do
   a = [ 1, 2, 3 ]
 
   assert_true(a.hash.is_a? Integer)
+  assert_equal([1,2].hash, [1,2].hash)
 end
 
 assert('Array#<=>', '15.2.12.5.36') do
@@ -328,6 +347,3 @@ assert("Array (Longish inline array)") do
   ary.each {|p| h[p.class] += 1}
   assert_equal({Array=>200}, h)
 end
-
-
-

data/modules/mruby/test/t/bs_block.rb

@@ -487,3 +487,35 @@ assert("BS Block 35") do
   end
   assert_equal :ok, TestReturnFromNestedBlock_BSBlock35.test
 end
+
+assert('BS Block 36') do
+  def iter
+    yield 1, 2, 3, 4, 5
+  end
+
+  assert_equal([1, 2, [3, 4], 5]) do
+    iter{|a, b, *c, d|
+      [a, b, c, d]
+    }
+  end
+end
+
+assert('BS Block 37') do
+  def iter
+    yield 1, 2, 3
+  end
+
+  assert_equal([1, 2, [], 3]) do
+    iter{|a, b, *c, d|
+      [a, b, c, d]
+    }
+  end
+end
+
+assert('BS Block 38') do
+  def iter
+    yield 1,2,3,4,5,6
+  end
+
+  assert_equal [1,2,3,4,5], iter{|a,b,c=:c,d,e| [a,b,c,d,e]}
+end