From f962890a928b566c0f5ca7fdff5ef4ce19207e65 Mon Sep 17 00:00:00 2001
From: Blaž Hrastnik <blaz.hrast@gmail.com>
Date: Thu, 9 Jul 2015 23:46:54 +0200
Subject: Implement Module#prepend.

---
 test/t/module.rb | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

(limited to 'test')

diff --git a/test/t/module.rb b/test/t/module.rb
index ecb969475..9faaf6e2c 100644
--- a/test/t/module.rb
+++ b/test/t/module.rb
@@ -474,6 +474,39 @@ end
 
 # Not ISO specified
 
+assert('Module#prepend') do
+  module M0
+    def m1; [:M0] end
+  end
+  module M1
+    def m1; [:M1, super, :M1] end
+  end
+  module M2
+    def m1; [:M2, super, :M2] end
+  end
+  M3 = Module.new do
+    def m1; [:M3, super, :M3] end
+  end
+  module M4
+    def m1; [:M4, super, :M4] end
+  end
+
+  class C0
+    include M0
+    prepend M1
+    def m1; [:C0, super, :C0] end
+  end
+  class C1 < C0
+    prepend M2, M3
+    include M4
+    def m1; [:C1, super, :C1] end
+  end
+
+  obj = C1.new
+  expected = [:M2,[:M3,[:C1,[:M4,[:M1,[:C0,[:M0],:C0],:M1],:M4],:C1],:M3],:M2]
+  assert_equal(expected, obj.m1)
+end
+
 assert('Module#to_s') do
   module Test4to_sModules
   end
-- 
cgit v1.2.3


From d046814d8bec1f3be1994918d60f9345a50a0e23 Mon Sep 17 00:00:00 2001
From: Blaž Hrastnik <blaz.hrast@gmail.com>
Date: Fri, 10 Jul 2015 20:17:16 +0200
Subject: Rename classes because of conflicts

---
 test/t/module.rb | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'test')

diff --git a/test/t/module.rb b/test/t/module.rb
index 9faaf6e2c..3c87c122b 100644
--- a/test/t/module.rb
+++ b/test/t/module.rb
@@ -491,18 +491,18 @@ assert('Module#prepend') do
     def m1; [:M4, super, :M4] end
   end
 
-  class C0
+  class P0
     include M0
     prepend M1
     def m1; [:C0, super, :C0] end
   end
-  class C1 < C0
+  class P1 < P0
     prepend M2, M3
     include M4
     def m1; [:C1, super, :C1] end
   end
 
-  obj = C1.new
+  obj = P1.new
   expected = [:M2,[:M3,[:C1,[:M4,[:M1,[:C0,[:M0],:C0],:M1],:M4],:C1],:M3],:M2]
   assert_equal(expected, obj.m1)
 end
-- 
cgit v1.2.3


From 99aff17075905738a8e45d8b213b92a291588053 Mon Sep 17 00:00:00 2001
From: Corey Powell <mistdragon100@gmail.com>
Date: Sat, 11 Jul 2015 11:09:52 -0500
Subject: Ported a bit more of the MRI Module#prepend tests over

Currently kind_of fails miserably, still looking for the reason
---
 test/t/module.rb | 94 ++++++++++++++++++++++++++++++++++++++++----------------
 1 file changed, 68 insertions(+), 26 deletions(-)

(limited to 'test')

diff --git a/test/t/module.rb b/test/t/module.rb
index 3c87c122b..6fa22e8b4 100644
--- a/test/t/module.rb
+++ b/test/t/module.rb
@@ -474,38 +474,80 @@ end
 
 # Not ISO specified
 
+# @!group prepend
 assert('Module#prepend') do
-  module M0
-    def m1; [:M0] end
-  end
-  module M1
-    def m1; [:M1, super, :M1] end
-  end
-  module M2
-    def m1; [:M2, super, :M2] end
-  end
-  M3 = Module.new do
-    def m1; [:M3, super, :M3] end
-  end
-  module M4
-    def m1; [:M4, super, :M4] end
-  end
+  assert('test_prepend') do
+    module M0
+      def m1; [:M0] end
+    end
+    module M1
+      def m1; [:M1, super, :M1] end
+    end
+    module M2
+      def m1; [:M2, super, :M2] end
+    end
+    M3 = Module.new do
+      def m1; [:M3, super, :M3] end
+    end
+    module M4
+      def m1; [:M4, super, :M4] end
+    end
 
-  class P0
-    include M0
-    prepend M1
-    def m1; [:C0, super, :C0] end
+    class P0
+      include M0
+      prepend M1
+      def m1; [:C0, super, :C0] end
+    end
+    class P1 < P0
+      prepend M2, M3
+      include M4
+      def m1; [:C1, super, :C1] end
+    end
+
+    obj = P1.new
+    expected = [:M2,[:M3,[:C1,[:M4,[:M1,[:C0,[:M0],:C0],:M1],:M4],:C1],:M3],:M2]
+    assert_equal(expected, obj.m1)
   end
-  class P1 < P0
-    prepend M2, M3
-    include M4
-    def m1; [:C1, super, :C1] end
+
+  # mruby shouldn't be affected by this since there is
+  # no visibility control (yet)
+  assert('test_public_prepend') do
+    assert_nothing_raised('ruby/ruby #8846') do
+      Class.new.prepend(Module.new)
+    end
   end
 
-  obj = P1.new
-  expected = [:M2,[:M3,[:C1,[:M4,[:M1,[:C0,[:M0],:C0],:M1],:M4],:C1],:M3],:M2]
-  assert_equal(expected, obj.m1)
+  assert('test_prepend_inheritance') do
+    bug6654 = '[ruby-core:45914]'
+    a = Module.new
+    b = Module.new { include a }
+    c = Module.new { prepend b }
+
+    assert bug6654 do
+      # the Module#< operator should be used here instead, but we don't have it
+      assert_include(c.ancestors, a)
+      assert_include(c.ancestors, b)
+    end
+
+    bug8357 = '[ruby-core:54736] [Bug #8357]'
+    b = Module.new { prepend a }
+    c = Class.new { include b }
+
+    assert bug8357 do
+      # the Module#< operator should be used here instead, but we don't have it
+      assert_include(c.ancestors, a)
+      assert_include(c.ancestors, b)
+    end
+
+    bug8357 = '[ruby-core:54742] [Bug #8357]'
+    t_print c.new.kind_of?(b)
+    t_print "\n"
+    t_print [b, b.ancestors, c, c.ancestors].inspect
+    t_print "\n"
+    assert_kind_of(b, c.new, bug8357)
+  end
 end
+# @!endgroup prepend
 
 assert('Module#to_s') do
   module Test4to_sModules
-- 
cgit v1.2.3


From 319553f0ef310b4f098773db713e7fcee18f69be Mon Sep 17 00:00:00 2001
From: Corey Powell <mistdragon100@gmail.com>
Date: Sat, 11 Jul 2015 11:11:12 -0500
Subject: Removed some debug prints from the test

---
 test/t/module.rb | 4 ----
 1 file changed, 4 deletions(-)

(limited to 'test')

diff --git a/test/t/module.rb b/test/t/module.rb
index 6fa22e8b4..5baaadd2e 100644
--- a/test/t/module.rb
+++ b/test/t/module.rb
@@ -540,10 +540,6 @@ assert('Module#prepend') do
     end
 
     bug8357 = '[ruby-core:54742] [Bug #8357]'
-    t_print c.new.kind_of?(b)
-    t_print "\n"
-    t_print [b, b.ancestors, c, c.ancestors].inspect
-    t_print "\n"
     assert_kind_of(b, c.new, bug8357)
   end
 end
-- 
cgit v1.2.3


From 47264bf2898fbfa5cae6709074b5e5564dbbe99c Mon Sep 17 00:00:00 2001
From: Corey Powell <mistdragon100@gmail.com>
Date: Sat, 11 Jul 2015 11:32:20 -0500
Subject: Ported all MRI prepend tests

And of course, some of them fail miserably
---
 test/t/module.rb | 231 +++++++++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 226 insertions(+), 5 deletions(-)

(limited to 'test')

diff --git a/test/t/module.rb b/test/t/module.rb
index 5baaadd2e..7314d140f 100644
--- a/test/t/module.rb
+++ b/test/t/module.rb
@@ -1,6 +1,26 @@
 ##
 # Module ISO Test
 
+def labeled_module(name, &block)
+  Module.new do
+    singleton_class.class_eval do
+      define_method(:to_s) { name }
+      alias_method :inspect, :to_s
+    end
+    class_eval(&block) if block
+  end
+end
+
+def labeled_class(name, supklass = Object, &block)
+  Class.new(supklass) do
+    singleton_class.class_eval do
+      define_method(:to_s) { name }
+      alias_method :inspect, :to_s
+    end
+    class_eval(&block) if block
+  end
+end
+
 assert('Module', '15.2.2') do
   assert_equal Class, Module.class
 end
@@ -519,9 +539,9 @@ assert('Module#prepend') do
 
   assert('test_prepend_inheritance') do
     bug6654 = '[ruby-core:45914]'
-    a = Module.new
-    b = Module.new { include a }
-    c = Module.new { prepend b }
+    a = labeled_module('a')
+    b = labeled_module('b') { include a }
+    c = labeled_module('c') { prepend b }
 
     assert bug6654 do
       # the Module#< operator should be used here instead, but we don't have it
@@ -530,8 +550,8 @@ assert('Module#prepend') do
     end
 
     bug8357 = '[ruby-core:54736] [Bug #8357]'
-    b = Module.new { prepend a }
-    c = Class.new { include b }
+    b = labeled_module('b') { prepend a }
+    c = labeled_class('c') { include b }
 
     assert bug8357 do
       # the Module#< operator should be used here instead, but we don't have it
@@ -542,6 +562,207 @@ assert('Module#prepend') do
     bug8357 = '[ruby-core:54742] [Bug #8357]'
     assert_kind_of(b, c.new, bug8357)
   end
+
+  assert('test_prepend_instance_methods') do
+    bug6655 = '[ruby-core:45915]'
+    assert_equal(Object.instance_methods, Class.new {prepend Module.new}.instance_methods, bug6655)
+  end
+
+  assert 'test_prepend_singleton_methods' do
+    o = Object.new
+    o.singleton_class.class_eval {prepend Module.new}
+    assert_equal([], o.singleton_methods)
+  end
+
+  assert 'test_prepend_remove_method' do
+    c = Class.new do
+      prepend Module.new { def foo; end }
+    end
+    assert_raise(NameError) do
+      c.class_eval do
+        remove_method(:foo)
+      end
+    end
+    c.class_eval do
+      def foo; end
+    end
+    removed = nil
+    c.singleton_class.class_eval do
+      define_method(:method_removed) {|id| removed = id}
+    end
+    assert_nothing_raised(NoMethodError, NameError, '[Bug #7843]') do
+      c.class_eval do
+        remove_method(:foo)
+      end
+    end
+    assert_equal(:foo, removed)
+  end
+
+  assert 'test_prepend_class_ancestors' do
+    bug6658 = '[ruby-core:45919]'
+    m = labeled_module("m")
+    c = labeled_class("c") {prepend m}
+    assert_equal([m, c], c.ancestors[0, 2], bug6658)
+
+    bug6662 = '[ruby-dev:45868]'
+    c2 = labeled_class("c2", c)
+    anc = c2.ancestors
+    assert_equal([c2, m, c, Object], anc[0..anc.index(Object)], bug6662)
+  end
+
+  # this assertion causes the mrbtest to segfault
+  #assert 'test_prepend_module_ancestors' do
+  #  bug6659 = '[ruby-dev:45861]'
+  #  m0 = labeled_module("m0") { def x; [:m0, *super] end }
+  #  m1 = labeled_module("m1") { def x; [:m1, *super] end; prepend m0 }
+  #  m2 = labeled_module("m2") { def x; [:m2, *super] end; prepend m1 }
+  #  c0 = labeled_class("c0") { def x; [:c0] end }
+  #  c1 = labeled_class("c1") { def x; [:c1] end; prepend m2 }
+  #  c2 = labeled_class("c2", c0) { def x; [:c2, *super] end; include m2 }
+  #  #
+  #  assert_equal([m0, m1], m1.ancestors, bug6659)
+  #  #
+  #  bug6662 = '[ruby-dev:45868]'
+  #  assert_equal([m0, m1, m2], m2.ancestors, bug6662)
+  #  assert_equal([m0, m1, m2, c1], c1.ancestors[0, 4], bug6662)
+  #  assert_equal([:m0, :m1, :m2, :c1], c1.new.x)
+  #  assert_equal([c2, m0, m1, m2, c0], c2.ancestors[0, 5], bug6662)
+  #  assert_equal([:c2, :m0, :m1, :m2, :c0], c2.new.x)
+  #  #
+  #  m3 = labeled_module("m3") { include m1; prepend m1 }
+  #  assert_equal([m3, m0, m1], m3.ancestors)
+  #  m3 = labeled_module("m3") { prepend m1; include m1 }
+  #  assert_equal([m0, m1, m3], m3.ancestors)
+  #  m3 = labeled_module("m3") { prepend m1; prepend m1 }
+  #  assert_equal([m0, m1, m3], m3.ancestors)
+  #  m3 = labeled_module("m3") { include m1; include m1 }
+  #  assert_equal([m3, m0, m1], m3.ancestors)
+  #end
+
+  assert 'test_prepend_instance_methods_false' do
+    bug6660 = '[ruby-dev:45863]'
+    assert_equal([:m1], Class.new{ prepend Module.new; def m1; end }.instance_methods(false), bug6660)
+    assert_equal([:m1], Class.new(Class.new{def m2;end}){ prepend Module.new; def m1; end }.instance_methods(false), bug6660)
+  end
+
+  assert 'test_cyclic_prepend' do
+    bug7841 = '[ruby-core:52205] [Bug #7841]'
+    m1 = Module.new
+    m2 = Module.new
+    m1.instance_eval { prepend(m2) }
+    assert_raise(ArgumentError, bug7841) do
+      m2.instance_eval { prepend(m1) }
+    end
+  end
+
+  # these assertions will not run without a #assert_seperately method
+  #assert 'test_prepend_optmethod' do
+  #  bug7983 = '[ruby-dev:47124] [Bug #7983]'
+  #  assert_separately [], %{
+  #    module M
+  #      def /(other)
+  #        to_f / other
+  #      end
+  #    end
+  #    Fixnum.send(:prepend, M)
+  #    assert_equal(0.5, 1 / 2, "#{bug7983}")
+  #  }
+  #  assert_equal(0, 1 / 2)
+  #end
+
+  #assert 'test_prepend_visibility' do
+  #  bug8005 = '[ruby-core:53106] [Bug #8005]'
+  #  c = Class.new do
+  #    prepend Module.new {}
+  #    def foo() end
+  #    protected :foo
+  #  end
+  #  a = c.new
+  #  assert_respond_to a, [:foo, true], bug8005
+  #  assert_nothing_raised(NoMethodError, bug8005) {a.send :foo}
+  #end
+
+  #assert 'test_prepend_visibility_inherited' do
+  #  bug8238 = '[ruby-core:54105] [Bug #8238]'
+  #  assert_separately [], <<-"end;", timeout: 20
+  #    class A
+  #      def foo() A; end
+  #      private :foo
+  #    end
+  #    class B < A
+  #      public :foo
+  #      prepend Module.new
+  #    end
+  #    assert_equal(A, B.new.foo, "#{bug8238}")
+  #  end;
+  #end
+
+  assert 'test_prepend_included_modules' do
+    bug8025 = '[ruby-core:53158] [Bug #8025]'
+    mixin = labeled_module("mixin")
+    c = labeled_module("c") {prepend mixin}
+    im = c.included_modules
+    assert_not_include(im, c, bug8025)
+    assert_include(im, mixin, bug8025)
+    c1 = labeled_class("c1") {prepend mixin}
+    c2 = labeled_class("c2", c1)
+    im = c2.included_modules
+    assert_not_include(im, c1, bug8025)
+    assert_not_include(im, c2, bug8025)
+    assert_include(im, mixin, bug8025)
+  end
+
+  assert 'test_prepend_super_in_alias' do
+    bug7842 = '[Bug #7842]'
+
+    p = labeled_module("P") do
+      def m; "P"+super; end
+    end
+    a = labeled_class("A") do
+      def m; "A"; end
+    end
+    b = labeled_class("B", a) do
+      def m; "B"+super; end
+      alias m2 m
+      prepend p
+      alias m3 m
+    end
+    assert_equal("BA", b.new.m2, bug7842)
+    assert_equal("PBA", b.new.m3, bug7842)
+  end
+
+  assert 'test_prepend_each_classes' do
+    m = labeled_module("M")
+    c1 = labeled_class("C1") {prepend m}
+    c2 = labeled_class("C2", c1) {prepend m}
+    assert_equal([m, c2, m, c1], c2.ancestors[0, 4], "should be able to prepend each classes")
+  end
+
+  assert 'test_prepend_no_duplication' do
+    m = labeled_module("M")
+    c = labeled_class("C") {prepend m; prepend m}
+    assert_equal([m, c], c.ancestors[0, 2], "should never duplicate")
+  end
+
+  assert 'test_prepend_in_superclass' do
+    m = labeled_module("M")
+    c1 = labeled_class("C1")
+    c2 = labeled_class("C2", c1) {prepend m}
+    c1.class_eval {prepend m}
+    assert_equal([m, c2, m, c1], c2.ancestors[0, 4], "should accesisble prepended module in superclass")
+  end
+
+  # requires #assert_seperately
+  #assert 'test_prepend_call_super' do
+  #  assert_separately([], <<-'end;') #do
+  #    bug10847 = '[ruby-core:68093] [Bug #10847]'
+  #    module M; end
+  #    Float.prepend M
+  #    assert_nothing_raised(SystemStackError, bug10847) do
+  #      0.3.numerator
+  #    end
+  #  end;
+  #end
 end
 # @!endgroup prepend
 
-- 
cgit v1.2.3


From 11dad715784a61174b68fba57f6dc6c5311e22e3 Mon Sep 17 00:00:00 2001
From: Blaž Hrastnik <blaz.hrast@gmail.com>
Date: Sun, 12 Jul 2015 22:57:29 +0200
Subject: Enable visibility prepend tests again

---
 test/t/module.rb | 54 ++++++++++++++++++++++++++++--------------------------
 1 file changed, 28 insertions(+), 26 deletions(-)

(limited to 'test')

diff --git a/test/t/module.rb b/test/t/module.rb
index 7314d140f..89cc257a6 100644
--- a/test/t/module.rb
+++ b/test/t/module.rb
@@ -670,32 +670,34 @@ assert('Module#prepend') do
   #  assert_equal(0, 1 / 2)
   #end
 
-  #assert 'test_prepend_visibility' do
-  #  bug8005 = '[ruby-core:53106] [Bug #8005]'
-  #  c = Class.new do
-  #    prepend Module.new {}
-  #    def foo() end
-  #    protected :foo
-  #  end
-  #  a = c.new
-  #  assert_respond_to a, [:foo, true], bug8005
-  #  assert_nothing_raised(NoMethodError, bug8005) {a.send :foo}
-  #end
-
-  #assert 'test_prepend_visibility_inherited' do
-  #  bug8238 = '[ruby-core:54105] [Bug #8238]'
-  #  assert_separately [], <<-"end;", timeout: 20
-  #    class A
-  #      def foo() A; end
-  #      private :foo
-  #    end
-  #    class B < A
-  #      public :foo
-  #      prepend Module.new
-  #    end
-  #    assert_equal(A, B.new.foo, "#{bug8238}")
-  #  end;
-  #end
+  # mruby has no visibility control
+  assert 'test_prepend_visibility' do
+    bug8005 = '[ruby-core:53106] [Bug #8005]'
+    c = Class.new do
+      prepend Module.new {}
+      def foo() end
+      protected :foo
+    end
+    a = c.new
+    assert_true a.respond_to?(:foo), bug8005
+    assert_nothing_raised(NoMethodError, bug8005) {a.send :foo}
+  end
+
+  # mruby has no visibility control
+  assert 'test_prepend_visibility_inherited' do
+    bug8238 = '[ruby-core:54105] [Bug #8238]'
+    module Test4PrependVisibilityInherited
+      class A
+        def foo() A; end
+        private :foo
+      end
+      class B < A
+        public :foo
+        prepend Module.new
+      end
+    end
+    assert_equal(Test4PrependVisibilityInherited::A, Test4PrependVisibilityInherited::B.new.foo, "#{bug8238}")
+  end
 
   assert 'test_prepend_included_modules' do
     bug8025 = '[ruby-core:53158] [Bug #8025]'
-- 
cgit v1.2.3


From 11cb41770dc7b36edac0af1e6784bd40d1c8243c Mon Sep 17 00:00:00 2001
From: Corey Powell <mistdragon100@gmail.com>
Date: Mon, 13 Jul 2015 10:42:33 -0500
Subject: Space out test_prepend_super_in_alias assert

Also tried to fix it, however the problem lies with how aliased methods
are done and their internal structure.

mruby simply aliases methods by grabbing the RProc and giving it a new name,
super then determines the original method to call by using the name

so a method called m, aliased as m2, will call the m2 super method instead of m
---
 test/t/module.rb | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

(limited to 'test')

diff --git a/test/t/module.rb b/test/t/module.rb
index 89cc257a6..605ca28a7 100644
--- a/test/t/module.rb
+++ b/test/t/module.rb
@@ -720,17 +720,25 @@ assert('Module#prepend') do
     p = labeled_module("P") do
       def m; "P"+super; end
     end
+
     a = labeled_class("A") do
       def m; "A"; end
     end
+
     b = labeled_class("B", a) do
       def m; "B"+super; end
       alias m2 m
       prepend p
       alias m3 m
     end
-    assert_equal("BA", b.new.m2, bug7842)
-    assert_equal("PBA", b.new.m3, bug7842)
+
+    assert_nothing_raised do
+      assert_equal("BA", b.new.m2, bug7842)
+    end
+
+    assert_nothing_raised do
+      assert_equal("PBA", b.new.m3, bug7842)
+    end
   end
 
   assert 'test_prepend_each_classes' do
-- 
cgit v1.2.3


From b0fb9ccfd8cb5986ea153142687cfbed1a876d6b Mon Sep 17 00:00:00 2001
From: Blaž Hrastnik <blaz.hrast@gmail.com>
Date: Mon, 13 Jul 2015 23:25:01 +0200
Subject: Enable test_prepend_module_ancestors because it seems to pass.

---
 test/t/module.rb | 54 +++++++++++++++++++++++++++---------------------------
 1 file changed, 27 insertions(+), 27 deletions(-)

(limited to 'test')

diff --git a/test/t/module.rb b/test/t/module.rb
index 605ca28a7..7b4a8fec7 100644
--- a/test/t/module.rb
+++ b/test/t/module.rb
@@ -611,33 +611,33 @@ assert('Module#prepend') do
   end
 
   # this assertion causes the mrbtest to segfault
-  #assert 'test_prepend_module_ancestors' do
-  #  bug6659 = '[ruby-dev:45861]'
-  #  m0 = labeled_module("m0") { def x; [:m0, *super] end }
-  #  m1 = labeled_module("m1") { def x; [:m1, *super] end; prepend m0 }
-  #  m2 = labeled_module("m2") { def x; [:m2, *super] end; prepend m1 }
-  #  c0 = labeled_class("c0") { def x; [:c0] end }
-  #  c1 = labeled_class("c1") { def x; [:c1] end; prepend m2 }
-  #  c2 = labeled_class("c2", c0) { def x; [:c2, *super] end; include m2 }
-  #  #
-  #  assert_equal([m0, m1], m1.ancestors, bug6659)
-  #  #
-  #  bug6662 = '[ruby-dev:45868]'
-  #  assert_equal([m0, m1, m2], m2.ancestors, bug6662)
-  #  assert_equal([m0, m1, m2, c1], c1.ancestors[0, 4], bug6662)
-  #  assert_equal([:m0, :m1, :m2, :c1], c1.new.x)
-  #  assert_equal([c2, m0, m1, m2, c0], c2.ancestors[0, 5], bug6662)
-  #  assert_equal([:c2, :m0, :m1, :m2, :c0], c2.new.x)
-  #  #
-  #  m3 = labeled_module("m3") { include m1; prepend m1 }
-  #  assert_equal([m3, m0, m1], m3.ancestors)
-  #  m3 = labeled_module("m3") { prepend m1; include m1 }
-  #  assert_equal([m0, m1, m3], m3.ancestors)
-  #  m3 = labeled_module("m3") { prepend m1; prepend m1 }
-  #  assert_equal([m0, m1, m3], m3.ancestors)
-  #  m3 = labeled_module("m3") { include m1; include m1 }
-  #  assert_equal([m3, m0, m1], m3.ancestors)
-  #end
+  assert 'test_prepend_module_ancestors' do
+    bug6659 = '[ruby-dev:45861]'
+    m0 = labeled_module("m0") { def x; [:m0, *super] end }
+    m1 = labeled_module("m1") { def x; [:m1, *super] end; prepend m0 }
+    m2 = labeled_module("m2") { def x; [:m2, *super] end; prepend m1 }
+    c0 = labeled_class("c0") { def x; [:c0] end }
+    c1 = labeled_class("c1") { def x; [:c1] end; prepend m2 }
+    c2 = labeled_class("c2", c0) { def x; [:c2, *super] end; include m2 }
+    #
+    assert_equal([m0, m1], m1.ancestors, bug6659)
+    #
+    bug6662 = '[ruby-dev:45868]'
+    assert_equal([m0, m1, m2], m2.ancestors, bug6662)
+    assert_equal([m0, m1, m2, c1], c1.ancestors[0, 4], bug6662)
+    assert_equal([:m0, :m1, :m2, :c1], c1.new.x)
+    assert_equal([c2, m0, m1, m2, c0], c2.ancestors[0, 5], bug6662)
+    assert_equal([:c2, :m0, :m1, :m2, :c0], c2.new.x)
+    #
+    m3 = labeled_module("m3") { include m1; prepend m1 }
+    assert_equal([m3, m0, m1], m3.ancestors)
+    m3 = labeled_module("m3") { prepend m1; include m1 }
+    assert_equal([m0, m1, m3], m3.ancestors)
+    m3 = labeled_module("m3") { prepend m1; prepend m1 }
+    assert_equal([m0, m1, m3], m3.ancestors)
+    m3 = labeled_module("m3") { include m1; include m1 }
+    assert_equal([m3, m0, m1], m3.ancestors)
+  end
 
   assert 'test_prepend_instance_methods_false' do
     bug6660 = '[ruby-dev:45863]'
-- 
cgit v1.2.3


From 8c13e2b7c6e6c1c02771e4f9e5aebda109892503 Mon Sep 17 00:00:00 2001
From: Blaž Hrastnik <blaz.hrast@gmail.com>
Date: Mon, 13 Jul 2015 23:35:30 +0200
Subject: Set origin when doing kind_of? comparisons

---
 src/object.c     | 1 +
 test/t/module.rb | 8 ++++----
 2 files changed, 5 insertions(+), 4 deletions(-)

(limited to 'test')

diff --git a/src/object.c b/src/object.c
index f8f41bfe8..c834ee04f 100644
--- a/src/object.c
+++ b/src/object.c
@@ -487,6 +487,7 @@ mrb_obj_is_kind_of(mrb_state *mrb, mrb_value obj, struct RClass *c)
       mrb_raise(mrb, E_TYPE_ERROR, "class or module required");
   }
 
+  c = c->origin;
   while (cl) {
     if (cl == c || cl->mt == c->mt)
       return TRUE;
diff --git a/test/t/module.rb b/test/t/module.rb
index 7b4a8fec7..a1996f5f6 100644
--- a/test/t/module.rb
+++ b/test/t/module.rb
@@ -543,21 +543,21 @@ assert('Module#prepend') do
     b = labeled_module('b') { include a }
     c = labeled_module('c') { prepend b }
 
-    assert bug6654 do
+    #assert bug6654 do
       # the Module#< operator should be used here instead, but we don't have it
       assert_include(c.ancestors, a)
       assert_include(c.ancestors, b)
-    end
+    #end
 
     bug8357 = '[ruby-core:54736] [Bug #8357]'
     b = labeled_module('b') { prepend a }
     c = labeled_class('c') { include b }
 
-    assert bug8357 do
+    #assert bug8357 do
       # the Module#< operator should be used here instead, but we don't have it
       assert_include(c.ancestors, a)
       assert_include(c.ancestors, b)
-    end
+    #end
 
     bug8357 = '[ruby-core:54742] [Bug #8357]'
     assert_kind_of(b, c.new, bug8357)
-- 
cgit v1.2.3


From 8c4da7accd98fb36e3f1f5f9e4ea069244345858 Mon Sep 17 00:00:00 2001
From: Blaž Hrastnik <blaz.hrast@gmail.com>
Date: Mon, 13 Jul 2015 23:38:37 +0200
Subject: assert() cannot be nested

---
 test/t/module.rb | 2 --
 1 file changed, 2 deletions(-)

(limited to 'test')

diff --git a/test/t/module.rb b/test/t/module.rb
index a1996f5f6..5aba53c46 100644
--- a/test/t/module.rb
+++ b/test/t/module.rb
@@ -495,7 +495,6 @@ end
 # Not ISO specified
 
 # @!group prepend
-assert('Module#prepend') do
   assert('test_prepend') do
     module M0
       def m1; [:M0] end
@@ -773,7 +772,6 @@ assert('Module#prepend') do
   #    end
   #  end;
   #end
-end
 # @!endgroup prepend
 
 assert('Module#to_s') do
-- 
cgit v1.2.3


From 78462c9181ccbc92d26a466c5a3f06aec2d2f714 Mon Sep 17 00:00:00 2001
From: Blaž Hrastnik <blaz.hrast@gmail.com>
Date: Mon, 13 Jul 2015 23:46:25 +0200
Subject: Clean up tests

---
 test/t/module.rb | 40 ++++++++++++++++++++--------------------
 1 file changed, 20 insertions(+), 20 deletions(-)

(limited to 'test')

diff --git a/test/t/module.rb b/test/t/module.rb
index 5aba53c46..4bde20fbe 100644
--- a/test/t/module.rb
+++ b/test/t/module.rb
@@ -495,7 +495,7 @@ end
 # Not ISO specified
 
 # @!group prepend
-  assert('test_prepend') do
+  assert('Module#prepend') do
     module M0
       def m1; [:M0] end
     end
@@ -530,13 +530,13 @@ end
 
   # mruby shouldn't be affected by this since there is
   # no visibility control (yet)
-  assert('test_public_prepend') do
+  assert('Module#prepend public') do
     assert_nothing_raised('ruby/ruby #8846') do
       Class.new.prepend(Module.new)
     end
   end
 
-  assert('test_prepend_inheritance') do
+  assert('Module#prepend inheritance') do
     bug6654 = '[ruby-core:45914]'
     a = labeled_module('a')
     b = labeled_module('b') { include a }
@@ -562,18 +562,18 @@ end
     assert_kind_of(b, c.new, bug8357)
   end
 
-  assert('test_prepend_instance_methods') do
+  assert('Moduler#prepend + #instance_methods') do
     bug6655 = '[ruby-core:45915]'
     assert_equal(Object.instance_methods, Class.new {prepend Module.new}.instance_methods, bug6655)
   end
 
-  assert 'test_prepend_singleton_methods' do
+  assert 'Module#prepend + #singleton_methods' do
     o = Object.new
     o.singleton_class.class_eval {prepend Module.new}
     assert_equal([], o.singleton_methods)
   end
 
-  assert 'test_prepend_remove_method' do
+  assert 'Module#prepend + #remove_method' do
     c = Class.new do
       prepend Module.new { def foo; end }
     end
@@ -597,7 +597,7 @@ end
     assert_equal(:foo, removed)
   end
 
-  assert 'test_prepend_class_ancestors' do
+  assert 'Module#prepend + Class#ancestors' do
     bug6658 = '[ruby-core:45919]'
     m = labeled_module("m")
     c = labeled_class("c") {prepend m}
@@ -609,8 +609,7 @@ end
     assert_equal([c2, m, c, Object], anc[0..anc.index(Object)], bug6662)
   end
 
-  # this assertion causes the mrbtest to segfault
-  assert 'test_prepend_module_ancestors' do
+  assert 'Module#prepend + Module#ancestors' do
     bug6659 = '[ruby-dev:45861]'
     m0 = labeled_module("m0") { def x; [:m0, *super] end }
     m1 = labeled_module("m1") { def x; [:m1, *super] end; prepend m0 }
@@ -638,13 +637,13 @@ end
     assert_equal([m3, m0, m1], m3.ancestors)
   end
 
-  assert 'test_prepend_instance_methods_false' do
+  assert 'Module#prepend #instance_methods(false)' do
     bug6660 = '[ruby-dev:45863]'
     assert_equal([:m1], Class.new{ prepend Module.new; def m1; end }.instance_methods(false), bug6660)
     assert_equal([:m1], Class.new(Class.new{def m2;end}){ prepend Module.new; def m1; end }.instance_methods(false), bug6660)
   end
 
-  assert 'test_cyclic_prepend' do
+  assert 'cyclic Module#prepend' do
     bug7841 = '[ruby-core:52205] [Bug #7841]'
     m1 = Module.new
     m2 = Module.new
@@ -670,7 +669,7 @@ end
   #end
 
   # mruby has no visibility control
-  assert 'test_prepend_visibility' do
+  assert 'Module#prepend visibility' do
     bug8005 = '[ruby-core:53106] [Bug #8005]'
     c = Class.new do
       prepend Module.new {}
@@ -683,7 +682,7 @@ end
   end
 
   # mruby has no visibility control
-  assert 'test_prepend_visibility_inherited' do
+  assert 'Module#prepend inherited visibility' do
     bug8238 = '[ruby-core:54105] [Bug #8238]'
     module Test4PrependVisibilityInherited
       class A
@@ -698,7 +697,7 @@ end
     assert_equal(Test4PrependVisibilityInherited::A, Test4PrependVisibilityInherited::B.new.foo, "#{bug8238}")
   end
 
-  assert 'test_prepend_included_modules' do
+  assert 'Module#prepend + #included_modules' do
     bug8025 = '[ruby-core:53158] [Bug #8025]'
     mixin = labeled_module("mixin")
     c = labeled_module("c") {prepend mixin}
@@ -713,7 +712,8 @@ end
     assert_include(im, mixin, bug8025)
   end
 
-  assert 'test_prepend_super_in_alias' do
+  assert 'Module#prepend super in alias' do
+    skip "super does not currently work in aliased methods"
     bug7842 = '[Bug #7842]'
 
     p = labeled_module("P") do
@@ -740,20 +740,20 @@ end
     end
   end
 
-  assert 'test_prepend_each_classes' do
+  assert 'Module#prepend each class' do
     m = labeled_module("M")
     c1 = labeled_class("C1") {prepend m}
     c2 = labeled_class("C2", c1) {prepend m}
-    assert_equal([m, c2, m, c1], c2.ancestors[0, 4], "should be able to prepend each classes")
+    assert_equal([m, c2, m, c1], c2.ancestors[0, 4], "should be able to prepend each class")
   end
 
-  assert 'test_prepend_no_duplication' do
+  assert 'Module#prepend no duplication' do
     m = labeled_module("M")
     c = labeled_class("C") {prepend m; prepend m}
     assert_equal([m, c], c.ancestors[0, 2], "should never duplicate")
   end
 
-  assert 'test_prepend_in_superclass' do
+  assert 'Module#prepend in superclass' do
     m = labeled_module("M")
     c1 = labeled_class("C1")
     c2 = labeled_class("C2", c1) {prepend m}
@@ -762,7 +762,7 @@ end
   end
 
   # requires #assert_seperately
-  #assert 'test_prepend_call_super' do
+  #assert 'Module#prepend call super' do
   #  assert_separately([], <<-'end;') #do
   #    bug10847 = '[ruby-core:68093] [Bug #10847]'
   #    module M; end
-- 
cgit v1.2.3