* sprintf.c (rb_str_format): allow %c to print one character

  string (e.g. ?x).

* lib/tempfile.rb (Tempfile::make_tmpname): put dot between
  basename and pid.  [ruby-talk:196272]
* parse.y (do_block): remove -> style block.

* parse.y (parser_yylex): remove tLAMBDA_ARG.

* eval.c (rb_call0): binding for the return event hook should have
  consistent scope.  [ruby-core:07928]

* eval.c (proc_invoke): return behavior should depend whether it
  is surrounded by a lambda or a mere block.

* eval.c (formal_assign): handles post splat arguments.

* eval.c (rb_call0): ditto.

* st.c (strhash): use FNV-1a hash.

* parse.y (parser_yylex): removed experimental ';;' terminator.

* eval.c (rb_node_arity): should be aware of post splat arguments.

* eval.c (rb_proc_arity): ditto.

* parse.y (f_args): syntax rule enhanced to support arguments
  after the splat.

* parse.y (block_param): ditto for block parameters.

* parse.y (f_post_arg): mandatory formal arguments after the splat
  argument.

* parse.y (new_args_gen): generate nodes for mandatory formal
  arguments after the splat argument.

* eval.c (rb_eval): dispatch mandatory formal arguments after the
  splat argument.

* parse.y (args): allow more than one splat in the argument list.

* parse.y (method_call): allow aref [] to accept all kind of
  method argument, including assocs, splat, and block argument.

* eval.c (SETUP_ARGS0): prepare block argument as well.

* lib/mathn.rb (Integer): remove Integer#gcd2. [ruby-core:07931]

* eval.c (error_line): print receivers true/false/nil specially.

* eval.c (rb_proc_yield): handles parameters in yield semantics.

* eval.c (nil_yield): gives LocalJumpError to denote no block
  error.

* io.c (rb_io_getc): now takes one-character string.

* string.c (rb_str_hash): use FNV-1a hash from Fowler/Noll/Vo
  hashing algorithm.

* string.c (rb_str_aref): str[0] now returns 1 character string,
  instead of a fixnum.	[Ruby2]

* parse.y (parser_yylex): ?c now returns 1 character string,
  instead of a fixnum.	[Ruby2]

* string.c (rb_str_aset): no longer support fixnum insertion.

* eval.c (umethod_bind): should not update original class.
  [ruby-dev:28636]

* eval.c (ev_const_get): should support constant access from
  within instance_eval().  [ruby-dev:28327]

* time.c (time_timeval): should round for usec floating
  number.  [ruby-core:07896]

* time.c (time_add): ditto.

* dir.c (sys_warning): should not call a vararg function
  rb_sys_warning() indirectly.	[ruby-core:07886]

* numeric.c (flo_divmod): the first element of Float#divmod should
  be an integer. [ruby-dev:28589]

* test/ruby/test_float.rb: add tests for divmod, div, modulo and remainder.

* re.c (rb_reg_initialize): should not allow modifying literal
  regexps.  frozen check moved from rb_reg_initialize_m as well.

* re.c (rb_reg_initialize): should not modify untainted objects in
  safe levels higher than 3.

* re.c (rb_memcmp): type change from char* to const void*.

* dir.c (dir_close): should not close untainted dir stream.

* dir.c (GetDIR): add tainted/frozen check for each dir operation.

* lib/rdoc/parsers/parse_rb.rb (RDoc::RubyParser::parse_symbol_arg):
  typo fixed.  a patch from Florian Gross <florg at florg.net>.

* eval.c (EXEC_EVENT_HOOK): trace_func may remove itself from
  event_hooks.	no guarantee for arbitrary hook deletion.
  [ruby-dev:28632]

* util.c (ruby_strtod): differ addition to minimize error.
  [ruby-dev:28619]

* util.c (ruby_strtod): should not raise ERANGE when the input
  string does not have any digits.  [ruby-dev:28629]

* eval.c (proc_invoke): should restore old ruby_frame->block.
  thanks to ts <decoux at moulon.inra.fr>.  [ruby-core:07833]
  also fix [ruby-dev:28614] as well.

* signal.c (trap): sig should be less then NSIG.  Coverity found
  this bug.  a patch from Kevin Tew <tewk at tewk.com>.
  [ruby-core:07823]

* math.c (math_log2): add new method inspired by
  [ruby-talk:191237].

* math.c (math_log): add optional base argument to Math::log().
  [ruby-talk:191308]

* ext/syck/emitter.c (syck_scan_scalar): avoid accessing
  uninitialized array element.	a patch from Pat Eyler
  <rubypate at gmail.com>.  [ruby-core:07809]

* array.c (rb_ary_fill): initialize local variables first.  a
  patch from Pat Eyler <rubypate at gmail.com>.	 [ruby-core:07810]

* ext/syck/yaml2byte.c (syck_yaml2byte_handler): need to free
  type_tag.  a patch from Pat Eyler <rubypate at gmail.com>.
  [ruby-core:07808]

* ext/socket/socket.c (make_hostent_internal): accept ai_family
  check from Sam Roberts <sroberts at uniserve.com>.
  [ruby-core:07691]

* util.c (ruby_strtod): should not cut off 18 digits for no
  reason.  [ruby-core:07796]

* array.c (rb_ary_fill): internalize local variable "beg" to
  pacify Coverity.  [ruby-core:07770]

* pack.c (pack_unpack): now supports CRLF newlines.  a patch from
  <tommy at tmtm.org>.	[ruby-dev:28601]

* applied code clean-up patch from Stefan Huehner
  <stefan at huehner.org>.  [ruby-core:07764]

* lib/jcode.rb (String::tr_s): should have translated non
  squeezing character sequence (i.e. a character) as well.  thanks
  to Hiroshi Ichikawa <gimite at gimite.ddo.jp> [ruby-list:42090]

* ext/socket/socket.c: document update patch from Sam Roberts
  <sroberts at uniserve.com>.  [ruby-core:07701]

* lib/mathn.rb (Integer): need not to remove gcd2.  a patch from
  NARUSE, Yui <naruse at airemix.com>.	[ruby-dev:28570]

* parse.y (arg): too much NEW_LIST()

* eval.c (SETUP_ARGS0): remove unnecessary access to nd_alen.

* eval.c (rb_eval): use ARGSCAT for NODE_OP_ASGN1.
  [ruby-dev:28585]

* parse.y (arg): use NODE_ARGSCAT for placeholder.

* lib/getoptlong.rb (GetoptLong::get): RDoc update patch from
  mathew <meta at pobox.com>.  [ruby-core:07738]

* variable.c (rb_const_set): raise error when no target klass is
  supplied.  [ruby-dev:28582]

* prec.c (prec_prec_f): documentation patch from
  <gerardo.santana at gmail.com>.  [ruby-core:07689]

* bignum.c (rb_big_pow): second operand may be too big even if
  it's a Fixnum.  [ruby-talk:187984]

* README.EXT: update symbol description.  [ruby-talk:188104]

* COPYING: explicitly note GPLv2.  [ruby-talk:187922]

* parse.y: remove some obsolete syntax rules (unparenthesized
  method calls in argument list).

* eval.c (rb_call0): insecure calling should be checked for non
  NODE_SCOPE method invocations too.

* eval.c (rb_alias): should preserve the current safe level as
  well as method definition.

* process.c (rb_f_sleep): remove RDoc description about SIGALRM
  which is not valid on the current implementation. [ruby-dev:28464]

 Thu Mar 23 21:40:47 2006  K.Kosako  <sndgk393 AT ybb.ne.jp>

* eval.c (method_missing): should support argument splat in
  super.  a bug in combination of super, splat and
  method_missing.  [ruby-talk:185438]

* configure.in: Solaris SunPro compiler -rapth patch from
  <kuwa at labs.fujitsu.com>.  [ruby-dev:28443]

* configure.in: remove enable_rpath=no for Solaris.
  [ruby-dev:28440]

* ext/win32ole/win32ole.c (ole_val2olevariantdata): change behavior
  of converting  OLE Variant object with VT_ARRAY|VT_UI1 and Ruby
  String object.

* ruby.1: a clarification patch from David Lutterkort
  <dlutter at redhat.com>.  [ruby-core:7508]

* lib/rdoc/ri/ri_paths.rb (RI::Paths): adding paths from rubygems
  directories.	a patch from Eric Hodel <drbrain at segment7.net>.
  [ruby-core:07423]

* eval.c (rb_clear_cache_by_class): clearing wrong cache.

* ext/extmk.rb: use :remove_destination to install extension libraries
  to avoid SEGV.  [ruby-dev:28417]

* eval.c (rb_thread_fd_writable): should not re-schedule output
  from KILLED thread (must be error printing).

* array.c (rb_ary_flatten_bang): allow specifying recursion
  level.  [ruby-talk:182170]

* array.c (rb_ary_flatten): ditto.

* gc.c (add_heap): a heap_slots may overflow.  a patch from Stefan
  Weil <weil at mail.berlios.de>.

* eval.c (rb_call): use separate cache for fcall/vcall
  invocation.

* eval.c (rb_eval): NODE_FCALL, NODE_VCALL can call local
  functions.

* eval.c (rb_mod_local): a new method to specify newly added
  visibility "local".

* eval.c (search_method): search for local methods which are
  visible only from the current class.

* class.c (rb_class_local_methods): a method to list local methods.

* object.c (Init_Object): add BasicObject class as a top level
  BlankSlate class.

* ruby.h (SYM2ID): should not cast to signed long.
  [ruby-core:07414]

* class.c (rb_include_module): allow module duplication.


git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@10235 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

7 files changed, 140 insertions, 112 deletions

diff --git a/test/ruby/test_assignment.rb b/test/ruby/test_assignment.rb
index 5a0e06478f..0e11d6bad6 100644
--- a/test/ruby/test_assignment.rb
+++ b/test/ruby/test_assignment.rb
@@ -29,25 +29,25 @@ class TestAssignment < Test::Unit::TestCase
     a = [*[1]]; assert_equal([1], a)
     a = [*[1,2]]; assert_equal([1,2], a)
 
-    a = *[]; assert_nil(a)
-    a = *[1]; assert_equal(1, a)
-    a = *[nil]; assert_nil(a)
-    a = *[[]]; assert_equal([], a)
+    a = *[]; assert_equal([], a)
+    a = *[1]; assert_equal([1], a)
+    a = *[nil]; assert_equal([nil], a)
+    a = *[[]]; assert_equal([[]], a)
     a = *[1,2]; assert_equal([1,2], a)
-    a = *[*[]]; assert_nil(a)
-    a = *[*[1]]; assert_equal(1, a)
+    a = *[*[]]; assert_equal([], a)
+    a = *[*[1]]; assert_equal([1], a)
     a = *[*[1,2]]; assert_equal([1,2], a)
 
     *a = nil; assert_equal([nil], a)
     *a = 1; assert_equal([1], a)
-    *a = []; assert_equal([[]], a)
-    *a = [1]; assert_equal([[1]], a)
-    *a = [nil]; assert_equal([[nil]], a)
-    *a = [[]]; assert_equal([[[]]], a)
-    *a = [1,2]; assert_equal([[1,2]], a)
-    *a = [*[]]; assert_equal([[]], a)
-    *a = [*[1]]; assert_equal([[1]], a)
-    *a = [*[1,2]]; assert_equal([[1,2]], a)
+    *a = []; assert_equal([], a)
+    *a = [1]; assert_equal([1], a)
+    *a = [nil]; assert_equal([nil], a)
+    *a = [[]]; assert_equal([[]], a)
+    *a = [1,2]; assert_equal([1,2], a)
+    *a = [*[]]; assert_equal([], a)
+    *a = [*[1]]; assert_equal([1], a)
+    *a = [*[1,2]]; assert_equal([1,2], a)
 
     *a = *[]; assert_equal([], a)
     *a = *[1]; assert_equal([1], a)
@@ -82,13 +82,13 @@ class TestAssignment < Test::Unit::TestCase
   def test_yield
     def f; yield(nil); end; f {|a| assert_nil(a)}; undef f
     def f; yield(1); end; f {|a| assert_equal(1, a)}; undef f
-    def f; yield([]); end; f {|a| assert_equal([], a)}; undef f
-    def f; yield([1]); end; f {|a| assert_equal([1], a)}; undef f
-    def f; yield([nil]); end; f {|a| assert_equal([nil], a)}; undef f
-    def f; yield([[]]); end; f {|a| assert_equal([[]], a)}; undef f
-    def f; yield([*[]]); end; f {|a| assert_equal([], a)}; undef f
-    def f; yield([*[1]]); end; f {|a| assert_equal([1], a)}; undef f
-    def f; yield([*[1,2]]); end; f {|a| assert_equal([1,2], a)}; undef f
+    def f; yield([]); end; f {|a| assert_equal(nil, a)}; undef f
+    def f; yield([1]); end; f {|a| assert_equal(1, a)}; undef f
+    def f; yield([nil]); end; f {|a| assert_equal(nil, a)}; undef f
+    def f; yield([[]]); end; f {|a| assert_equal([], a)}; undef f
+    def f; yield([*[]]); end; f {|a| assert_equal(nil, a)}; undef f
+    def f; yield([*[1]]); end; f {|a| assert_equal(1, a)}; undef f
+    def f; yield([*[1,2]]); end; f {|a| assert_equal(1, a)}; undef f
 
     def f; yield(*[1]); end; f {|a| assert_equal(1, a)}; undef f
     def f; yield(*[nil]); end; f {|a| assert_nil(a)}; undef f
@@ -98,14 +98,14 @@ class TestAssignment < Test::Unit::TestCase
     def f; yield; end; f {|*a| assert_equal([], a)}; undef f
     def f; yield(nil); end; f {|*a| assert_equal([nil], a)}; undef f
     def f; yield(1); end; f {|*a| assert_equal([1], a)}; undef f
-    def f; yield([]); end; f {|*a| assert_equal([[]], a)}; undef f
-    def f; yield([1]); end; f {|*a| assert_equal([[1]], a)}; undef f
-    def f; yield([nil]); end; f {|*a| assert_equal([[nil]], a)}; undef f
-    def f; yield([[]]); end; f {|*a| assert_equal([[[]]], a)}; undef f
-    def f; yield([1,2]); end; f {|*a| assert_equal([[1,2]], a)}; undef f
-    def f; yield([*[]]); end; f {|*a| assert_equal([[]], a)}; undef f
-    def f; yield([*[1]]); end; f {|*a| assert_equal([[1]], a)}; undef f
-    def f; yield([*[1,2]]); end; f {|*a| assert_equal([[1,2]], a)}; undef f
+    def f; yield([]); end; f {|*a| assert_equal([], a)}; undef f
+    def f; yield([1]); end; f {|*a| assert_equal([1], a)}; undef f
+    def f; yield([nil]); end; f {|*a| assert_equal([nil], a)}; undef f
+    def f; yield([[]]); end; f {|*a| assert_equal([[]], a)}; undef f
+    def f; yield([1,2]); end; f {|*a| assert_equal([1,2], a)}; undef f
+    def f; yield([*[]]); end; f {|*a| assert_equal([], a)}; undef f
+    def f; yield([*[1]]); end; f {|*a| assert_equal([1], a)}; undef f
+    def f; yield([*[1,2]]); end; f {|*a| assert_equal([1,2], a)}; undef f
 
     def f; yield(*[]); end; f {|*a| assert_equal([], a)}; undef f
     def f; yield(*[1]); end; f {|*a| assert_equal([1], a)}; undef f
@@ -147,39 +147,39 @@ class TestAssignment < Test::Unit::TestCase
     def r; return [*[1]]; end; a = r(); assert_equal([1], a); undef r
     def r; return [*[1,2]]; end; a = r(); assert_equal([1,2], a); undef r
 
-    def r; return *[]; end; a = r(); assert_nil(a); undef r
-    def r; return *[1]; end; a = r(); assert_equal(1, a); undef r
-    def r; return *[nil]; end; a = r(); assert_nil(a); undef r
-    def r; return *[[]]; end; a = r(); assert_equal([], a); undef r
-    def r; return *[*[]]; end; a = r(); assert_nil(a); undef r
-    def r; return *[*[1]]; end; a = r(); assert_equal(1, a); undef r
+    def r; return *[]; end; a = r(); assert_equal([], a); undef r
+    def r; return *[1]; end; a = r(); assert_equal([1], a); undef r
+    def r; return *[nil]; end; a = r(); assert_equal([nil], a); undef r
+    def r; return *[[]]; end; a = r(); assert_equal([[]], a); undef r
+    def r; return *[*[]]; end; a = r(); assert_equal([], a); undef r
+    def r; return *[*[1]]; end; a = r(); assert_equal([1], a); undef r
     def r; return *[*[1,2]]; end; a = r(); assert_equal([1,2], a); undef r
 
-    def r; return *[[]]; end; a = *r(); assert_nil(a); undef r
+    def r; return *[[]]; end; a = *r(); assert_equal([[]], a); undef r
     def r; return *[*[1,2]]; end; a = *r(); assert_equal([1,2], a); undef r
 
     def r; return; end; *a = r(); assert_equal([nil], a); undef r
     def r; return nil; end; *a = r(); assert_equal([nil], a); undef r
     def r; return 1; end; *a = r(); assert_equal([1], a); undef r
-    def r; return []; end; *a = r(); assert_equal([[]], a); undef r
-    def r; return [1]; end; *a = r(); assert_equal([[1]], a); undef r
-    def r; return [nil]; end; *a = r(); assert_equal([[nil]], a); undef r
-    def r; return [[]]; end; *a = r(); assert_equal([[[]]], a); undef r
-    def r; return [1,2]; end; *a = r(); assert_equal([[1,2]], a); undef r
-    def r; return [*[]]; end; *a = r(); assert_equal([[]], a); undef r
-    def r; return [*[1]]; end; *a = r(); assert_equal([[1]], a); undef r
-    def r; return [*[1,2]]; end; *a = r(); assert_equal([[1,2]], a); undef r
-
-    def r; return *[]; end; *a = r(); assert_equal([nil], a); undef r
+    def r; return []; end; *a = r(); assert_equal([], a); undef r
+    def r; return [1]; end; *a = r(); assert_equal([1], a); undef r
+    def r; return [nil]; end; *a = r(); assert_equal([nil], a); undef r
+    def r; return [[]]; end; *a = r(); assert_equal([[]], a); undef r
+    def r; return [1,2]; end; *a = r(); assert_equal([1,2], a); undef r
+    def r; return [*[]]; end; *a = r(); assert_equal([], a); undef r
+    def r; return [*[1]]; end; *a = r(); assert_equal([1], a); undef r
+    def r; return [*[1,2]]; end; *a = r(); assert_equal([1,2], a); undef r
+
+    def r; return *[]; end; *a = r(); assert_equal([], a); undef r
     def r; return *[1]; end; *a = r(); assert_equal([1], a); undef r
     def r; return *[nil]; end; *a = r(); assert_equal([nil], a); undef r
     def r; return *[[]]; end; *a = r(); assert_equal([[]], a); undef r
-    def r; return *[1,2]; end; *a = r(); assert_equal([[1,2]], a); undef r
-    def r; return *[*[]]; end; *a = r(); assert_equal([nil], a); undef r
+    def r; return *[1,2]; end; *a = r(); assert_equal([1,2], a); undef r
+    def r; return *[*[]]; end; *a = r(); assert_equal([], a); undef r
     def r; return *[*[1]]; end; *a = r(); assert_equal([1], a); undef r
-    def r; return *[*[1,2]]; end; *a = r(); assert_equal([[1,2]], a); undef r
+    def r; return *[*[1,2]]; end; *a = r(); assert_equal([1,2], a); undef r
 
-    def r; return *[[]]; end; *a = *r(); assert_equal([], a); undef r
+    def r; return *[[]]; end; *a = *r(); assert_equal([[]], a); undef r
     def r; return *[1,2]; end; *a = *r(); assert_equal([1,2], a); undef r
     def r; return *[*[1,2]]; end; *a = *r(); assert_equal([1,2], a); undef r
 
@@ -198,7 +198,7 @@ class TestAssignment < Test::Unit::TestCase
     def r; return *[]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]); undef r
     def r; return *[1]; end; a,b,*c = r(); assert_equal([1,nil,[]], [a,b,c]); undef r
     def r; return *[nil]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]); undef r
-    def r; return *[[]]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]); undef r
+    def r; return *[[]]; end; a,b,*c = r(); assert_equal([[],nil,[]], [a,b,c]); undef r
     def r; return *[1,2]; end; a,b,*c = r(); assert_equal([1,2,[]], [a,b,c]); undef r
     def r; return *[*[]]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]); undef r
     def r; return *[*[1]]; end; a,b,*c = r(); assert_equal([1,nil,[]], [a,b,c]); undef r
@@ -260,36 +260,36 @@ class TestAssignment < Test::Unit::TestCase
     a = loop do break [*[1]]; end; assert_equal([1], a)
     a = loop do break [*[1,2]]; end; assert_equal([1,2], a)
 
-    a = loop do break *[]; end; assert_nil(a)
-    a = loop do break *[1]; end; assert_equal(1, a)
-    a = loop do break *[nil]; end; assert_nil(a)
-    a = loop do break *[[]]; end; assert_equal([], a)
-    a = loop do break *[*[]]; end; assert_nil(a)
-    a = loop do break *[*[1]]; end; assert_equal(1, a)
+    a = loop do break *[]; end; assert_equal([], a)
+    a = loop do break *[1]; end; assert_equal([1], a)
+    a = loop do break *[nil]; end; assert_equal([nil], a)
+    a = loop do break *[[]]; end; assert_equal([[]], a)
+    a = loop do break *[*[]]; end; assert_equal([], a)
+    a = loop do break *[*[1]]; end; assert_equal([1], a)
     a = loop do break *[*[1,2]]; end; assert_equal([1,2], a)
 
     *a = loop do break; end; assert_equal([nil], a)
     *a = loop do break nil; end; assert_equal([nil], a)
     *a = loop do break 1; end; assert_equal([1], a)
-    *a = loop do break []; end; assert_equal([[]], a)
-    *a = loop do break [1]; end; assert_equal([[1]], a)
-    *a = loop do break [nil]; end; assert_equal([[nil]], a)
-    *a = loop do break [[]]; end; assert_equal([[[]]], a)
-    *a = loop do break [1,2]; end; assert_equal([[1,2]], a)
-    *a = loop do break [*[]]; end; assert_equal([[]], a)
-    *a = loop do break [*[1]]; end; assert_equal([[1]], a)
-    *a = loop do break [*[1,2]]; end; assert_equal([[1,2]], a)
-
-    *a = loop do break *[]; end; assert_equal([nil], a)
+    *a = loop do break []; end; assert_equal([], a)
+    *a = loop do break [1]; end; assert_equal([1], a)
+    *a = loop do break [nil]; end; assert_equal([nil], a)
+    *a = loop do break [[]]; end; assert_equal([[]], a)
+    *a = loop do break [1,2]; end; assert_equal([1,2], a)
+    *a = loop do break [*[]]; end; assert_equal([], a)
+    *a = loop do break [*[1]]; end; assert_equal([1], a)
+    *a = loop do break [*[1,2]]; end; assert_equal([1,2], a)
+
+    *a = loop do break *[]; end; assert_equal([], a)
     *a = loop do break *[1]; end; assert_equal([1], a)
     *a = loop do break *[nil]; end; assert_equal([nil], a)
     *a = loop do break *[[]]; end; assert_equal([[]], a)
-    *a = loop do break *[1,2]; end; assert_equal([[1,2]], a)
-    *a = loop do break *[*[]]; end; assert_equal([nil], a)
+    *a = loop do break *[1,2]; end; assert_equal([1,2], a)
+    *a = loop do break *[*[]]; end; assert_equal([], a)
     *a = loop do break *[*[1]]; end; assert_equal([1], a)
-    *a = loop do break *[*[1,2]]; end; assert_equal([[1,2]], a)
+    *a = loop do break *[*[1,2]]; end; assert_equal([1,2], a)
 
-    *a = *loop do break *[[]]; end; assert_equal([], a)
+    *a = *loop do break *[[]]; end; assert_equal([[]], a)
     *a = *loop do break *[1,2]; end; assert_equal([1,2], a)
     *a = *loop do break *[*[1,2]]; end; assert_equal([1,2], a)
 
@@ -308,7 +308,7 @@ class TestAssignment < Test::Unit::TestCase
     a,b,*c = loop do break *[]; end; assert_equal([nil,nil,[]], [a,b,c])
     a,b,*c = loop do break *[1]; end; assert_equal([1,nil,[]], [a,b,c])
     a,b,*c = loop do break *[nil]; end; assert_equal([nil,nil,[]], [a,b,c])
-    a,b,*c = loop do break *[[]]; end; assert_equal([nil,nil,[]], [a,b,c])
+    a,b,*c = loop do break *[[]]; end; assert_equal([[],nil,[]], [a,b,c])
     a,b,*c = loop do break *[1,2]; end; assert_equal([1,2,[]], [a,b,c])
     a,b,*c = loop do break *[*[]]; end; assert_equal([nil,nil,[]], [a,b,c])
     a,b,*c = loop do break *[*[1]]; end; assert_equal([1,nil,[]], [a,b,c])
@@ -328,12 +328,12 @@ class TestAssignment < Test::Unit::TestCase
     r([1]){next [*[1]]}
     r([1,2]){next [*[1,2]]}
 
-    r(nil){next *[]}
-    r(1){next *[1]}
-    r(nil){next *[nil]}
-    r([]){next *[[]]}
-    r(nil){next *[*[]]}
-    r(1){next *[*[1]]}
+    r([]){next *[]}
+    r([1]){next *[1]}
+    r([nil]){next *[nil]}
+    r([[]]){next *[[]]}
+    r([]){next *[*[]]}
+    r([1]){next *[*[1]]}
     r([1,2]){next *[*[1,2]]}
     undef r
 
@@ -341,18 +341,18 @@ class TestAssignment < Test::Unit::TestCase
     r([nil]){next}
     r([nil]){next nil}
     r([1]){next 1}
-    r([[]]){next []}
-    r([[1]]){next [1]}
-    r([[nil]]){next [nil]}
-    r([[[]]]){next [[]]}
-    r([[1,2]]){next [1,2]}
-    r([[]]){next [*[]]}
-    r([[1]]){next [*[1]]}
-    r([[1,2]]){next [*[1,2]]}
+    r([]){next []}
+    r([1]){next [1]}
+    r([nil]){next [nil]}
+    r([[]]){next [[]]}
+    r([1,2]){next [1,2]}
+    r([]){next [*[]]}
+    r([1]){next [*[1]]}
+    r([1,2]){next [*[1,2]]}
     undef r
 
     def r(val); *a = *yield(); assert_equal(val, a); end
-    r([]){next *[[]]}
+    r([[]]){next *[[]]}
     r([1,2]){next *[1,2]}
     r([1,2]){next *[*[1,2]]}
     undef r
@@ -372,7 +372,7 @@ class TestAssignment < Test::Unit::TestCase
     undef r
 
     def r(val); a,b,*c = *yield(); assert_equal(val, [a,b,c]); end
-    r([nil,nil,[]]){next *[[]]}
+    r([[],nil,[]]){next *[[]]}
     r([1,2,[]]){next *[1,2]}
     r([1,2,[]]){next *[*[1,2]]}
     undef r
diff --git a/test/ruby/test_clone.rb b/test/ruby/test_clone.rb
index 43c0cffa1d..67d79fb8a5 100644
--- a/test/ruby/test_clone.rb
+++ b/test/ruby/test_clone.rb
@@ -23,6 +23,6 @@ class TestClone < Test::Unit::TestCase
 
     assert_raises(NoMethodError) {foo.test2}
 
-    assert_equal([M003, M002, M001], M003.ancestors)
+    assert_equal([M003, M002, M001, M002], M003.ancestors)
   end
 end
diff --git a/test/ruby/test_dir.rb b/test/ruby/test_dir.rb
index 09685bee8f..7887d37670 100644
--- a/test/ruby/test_dir.rb
+++ b/test/ruby/test_dir.rb
@@ -31,9 +31,9 @@ class TestDir < Test::Unit::TestCase
         break unless name = dir.read
         cache << [pos, name]
       end
-      for x in cache.sort_by {|x| x[0] % 3 } # shuffle
-        dir.seek(x[0])
-        assert_equal(x[1], dir.read)
+      for x,y in cache.sort_by {|x| x[0] % 3 } # shuffle
+        dir.seek(x)
+        assert_equal(y, dir.read)
       end
     ensure
       dir.close
diff --git a/test/ruby/test_file.rb b/test/ruby/test_file.rb
index 4947e081c5..e326b97b07 100644
--- a/test/ruby/test_file.rb
+++ b/test/ruby/test_file.rb
@@ -88,7 +88,7 @@ class TestFile < Test::Unit::TestCase
     assert_nil(f.getc)
     open(f.path, "w") {|g| g.print "a" }
     result = []
-    f.each_byte {|b| result << b }
+    f.each_byte {|b| result << b.chr }
     assert_equal([?a], result)
   end
 
diff --git a/test/ruby/test_float.rb b/test/ruby/test_float.rb
index 63979b5be0..c2e5041a21 100644
--- a/test/ruby/test_float.rb
+++ b/test/ruby/test_float.rb
@@ -87,4 +87,32 @@ class TestFloat < Test::Unit::TestCase
     assert_raise(ArgumentError){Float("1e")}
     # add expected behaviour here.
   end
+
+  def test_divmod
+    assert_equal([2, 3.5], 11.5.divmod(4))
+    assert_equal([-3, -0.5], 11.5.divmod(-4))
+    assert_equal([-3, 0.5], (-11.5).divmod(4))
+    assert_equal([2, -3.5], (-11.5).divmod(-4))
+  end
+
+  def test_div
+    assert_equal(2, 11.5.div(4))
+    assert_equal(-3, 11.5.div(-4))
+    assert_equal(-3, (-11.5).div(4))
+    assert_equal(2, (-11.5).div(-4))
+  end
+
+  def test_modulo
+    assert_equal(3.5, 11.5.modulo(4))
+    assert_equal(-0.5, 11.5.modulo(-4))
+    assert_equal(0.5, (-11.5).modulo(4))
+    assert_equal(-3.5, (-11.5).modulo(-4))
+  end
+
+  def test_remainder
+    assert_equal(3.5, 11.5.remainder(4))
+    assert_equal(3.5, 11.5.remainder(-4))
+    assert_equal(-3.5, (-11.5).remainder(4))
+    assert_equal(-3.5, (-11.5).remainder(-4))
+  end
 end
diff --git a/test/ruby/test_iterator.rb b/test/ruby/test_iterator.rb
index 81f02263a8..65e2967e62 100644
--- a/test/ruby/test_iterator.rb
+++ b/test/ruby/test_iterator.rb
@@ -151,21 +151,21 @@ class TestIterator < Test::Unit::TestCase
     IterTest.new([2]).each2 {|x| assert_equal([2], x)}
     IterTest.new([4]).each4 {|x| assert_equal(4, x)}
     IterTest.new([5]).each5 {|x| assert_equal(5, x)}
-    IterTest.new([6]).each6 {|x| assert_equal([6], x)}
+    IterTest.new([6]).each6 {|x| assert_equal(6, x)}
     IterTest.new([8]).each8 {|x| assert_equal(8, x)}
 
-    IterTest.new([[0]]).each0 {|x| assert_equal([0], x)}
-    IterTest.new([[1]]).each1 {|x| assert_equal([1], x)}
-    IterTest.new([[2]]).each2 {|x| assert_equal([[2]], x)}
+    IterTest.new([[0]]).each0 {|x| assert_equal(0, x)}
+    IterTest.new([[1]]).each1 {|x| assert_equal(1, x)}
+    IterTest.new([[2]]).each2 {|x| assert_equal([2], x)}
     IterTest.new([[3]]).each3 {|x| assert_equal(3, x)}
-    IterTest.new([[4]]).each4 {|x| assert_equal([4], x)}
-    IterTest.new([[5]]).each5 {|x| assert_equal([5], x)}
-    IterTest.new([[6]]).each6 {|x| assert_equal([[6]], x)}
+    IterTest.new([[4]]).each4 {|x| assert_equal(4, x)}
+    IterTest.new([[5]]).each5 {|x| assert_equal(5, x)}
+    IterTest.new([[6]]).each6 {|x| assert_equal(6, x)}
     IterTest.new([[7]]).each7 {|x| assert_equal(7, x)}
-    IterTest.new([[8]]).each8 {|x| assert_equal([8], x)}
+    IterTest.new([[8]]).each8 {|x| assert_equal(8, x)}
 
-    IterTest.new([[0,0]]).each0 {|x| assert_equal([0,0], x)}
-    IterTest.new([[8,8]]).each8 {|x| assert_equal([8,8], x)}
+    IterTest.new([[0,0]]).each0 {|*x| assert_equal([0,0], x)}
+    IterTest.new([[8,8]]).each8 {|*x| assert_equal([8], x)}
   end
 
   def m(var)
@@ -346,10 +346,10 @@ class TestIterator < Test::Unit::TestCase
   end
 
   def foo
-    yield([:key, :value])
+    yield(:key, :value)
   end
   def bar(&blk)
-    blk.call([:key, :value])
+    blk.call(:key, :value)
   end
 
   def test_yield_vs_call
@@ -359,14 +359,14 @@ class TestIterator < Test::Unit::TestCase
 
   class H
     def each
-      yield [:key, :value]
+      yield :key, :value
     end
   end
 
   def test_assoc_yield
     [{:key=>:value}, H.new].each {|h|
-      h.each{|a| assert_equal([:key, :value], a)}
-      h.each{|*a| assert_equal([[:key, :value]], a)}
+      h.each{|a| assert_equal(:key, a)}
+      h.each{|*a| assert_equal([:key, :value], a)}
       h.each{|k,v| assert_equal([:key, :value], [k,v])}
     }
   end
diff --git a/test/ruby/test_stringchar.rb b/test/ruby/test_stringchar.rb
index 34934e87bd..c128181b2f 100644
--- a/test/ruby/test_stringchar.rb
+++ b/test/ruby/test_stringchar.rb
@@ -68,9 +68,9 @@ END
     # character constants(assumes ASCII)
     assert_equal(?a, "a"[0])
     assert_equal(?a, ?a)
-    assert_equal(1, ?\C-a)
-    assert_equal(225, ?\M-a)
-    assert_equal(129, ?\M-\C-a)
+    assert_equal("\1", ?\C-a)
+    assert_equal("\341", ?\M-a)
+    assert_equal("\201", ?\M-\C-a)
     assert_equal(?A, "a".upcase![0])
     assert_equal(?a, "A".downcase![0])
     assert_equal("ABC", "abc".tr!("a-z", "A-Z"))
@@ -82,7 +82,7 @@ END
     $y = [ ?a, ?b, ?c, ?d, ?e, ?f ]
     $bad = false
     $x.each_byte {|i|
-      if i != $y.shift
+      if i.chr != $y.shift
         $bad = true
         break
       end