From fcbf63e62c627deae76c1b8cb8c0876c536ed811 Mon Sep 17 00:00:00 2001 From: Jari Vetoniemi Date: Mon, 16 Mar 2020 18:49:26 +0900 Subject: Fresh start --- jni/ruby/test/test_delegate.rb | 240 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 240 insertions(+) create mode 100644 jni/ruby/test/test_delegate.rb (limited to 'jni/ruby/test/test_delegate.rb') diff --git a/jni/ruby/test/test_delegate.rb b/jni/ruby/test/test_delegate.rb new file mode 100644 index 0000000..6270cc6 --- /dev/null +++ b/jni/ruby/test/test_delegate.rb @@ -0,0 +1,240 @@ +require 'test/unit' +require 'delegate' + +class TestDelegateClass < Test::Unit::TestCase + module M + attr_reader :m + end + + def test_extend + obj = DelegateClass(Array).new([]) + obj.instance_eval { @m = :m } + obj.extend M + assert_equal(:m, obj.m, "[ruby-dev:33116]") + end + + def test_systemcallerror_eq + e = SystemCallError.new(0) + assert((SimpleDelegator.new(e) == e) == (e == SimpleDelegator.new(e)), "[ruby-dev:34808]") + end + + class Myclass < DelegateClass(Array);end + + def test_delegateclass_class + myclass=Myclass.new([]) + assert_equal(Myclass,myclass.class) + assert_equal(Myclass,myclass.dup.class,'[ruby-dev:40313]') + assert_equal(Myclass,myclass.clone.class,'[ruby-dev:40313]') + end + + def test_simpledelegator_class + simple=SimpleDelegator.new([]) + assert_equal(SimpleDelegator,simple.class) + assert_equal(SimpleDelegator,simple.dup.class) + assert_equal(SimpleDelegator,simple.clone.class) + end + + class Object + def m + :o + end + private + def delegate_test_m + :o + end + end + + class Foo + def m + :m + end + def delegate_test_m + :m + end + end + + class Bar < DelegateClass(Foo) + end + + def test_override + foo = Foo.new + foo2 = SimpleDelegator.new(foo) + bar = Bar.new(foo) + assert_equal(:o, Object.new.m) + assert_equal(:m, foo.m) + assert_equal(:m, foo2.m) + assert_equal(:m, bar.m) + bug = '[ruby-dev:39154]' + assert_equal(:m, foo2.send(:delegate_test_m), bug) + assert_equal(:m, bar.send(:delegate_test_m), bug) + end + + class IV < DelegateClass(Integer) + attr_accessor :var + + def initialize + @var = 1 + super(0) + end + end + + def test_marshal + bug1744 = '[ruby-core:24211]' + c = IV.new + assert_equal(1, c.var) + d = Marshal.load(Marshal.dump(c)) + assert_equal(1, d.var, bug1744) + end + + def test_copy_frozen + bug2679 = '[ruby-dev:40242]' + a = [42, :hello].freeze + d = SimpleDelegator.new(a) + assert_nothing_raised(bug2679) {d.dup[0] += 1} + assert_raise(RuntimeError) {d.clone[0] += 1} + d.freeze + assert(d.clone.frozen?) + assert(!d.dup.frozen?) + end + + def test_frozen + d = SimpleDelegator.new([1, :foo]) + d.freeze + assert_raise(RuntimeError, '[ruby-dev:40314]#1') {d.__setobj__("foo")} + assert_equal([1, :foo], d) + end + + def test_instance_method + s = SimpleDelegator.new("foo") + m = s.method("upcase") + s.__setobj__([1,2,3]) + assert_raise(NoMethodError, '[ruby-dev:40314]#3') {m.call} + end + + def test_methods + s = SimpleDelegator.new("foo") + assert_equal([], s.methods(false)) + def s.bar; end + assert_equal([:bar], s.methods(false)) + end + + class Foo + private + def delegate_test_private + :m + end + end + + def test_private_method + foo = Foo.new + d = SimpleDelegator.new(foo) + assert_raise(NoMethodError) {foo.delegate_test_private} + assert_equal(:m, foo.send(:delegate_test_private)) + assert_raise(NoMethodError, '[ruby-dev:40314]#4') {d.delegate_test_private} + assert_raise(NoMethodError, '[ruby-dev:40314]#5') {d.send(:delegate_test_private)} + end + + def test_global_function + klass = Class.new do + def open + end + end + obj = klass.new + d = SimpleDelegator.new(obj) + assert_nothing_raised(ArgumentError) {obj.open} + assert_nothing_raised(ArgumentError) {d.open} + assert_nothing_raised(ArgumentError) {d.send(:open)} + end + + def test_send_method_in_delegator + d = Class.new(SimpleDelegator) do + def foo + "foo" + end + end.new(Object.new) + assert_equal("foo", d.send(:foo)) + end + + def test_unset_simple_delegator + d = SimpleDelegator.allocate + assert_raise_with_message(ArgumentError, /not delegated/) { + d.__getobj__ + } + end + + def test_unset_delegate_class + d = IV.allocate + assert_raise_with_message(ArgumentError, /not delegated/) { + d.__getobj__ + } + end + + class Bug9155 < DelegateClass(Integer) + def initialize(value) + super(Integer(value)) + end + end + + def test_global_method_if_no_target + bug9155 = '[ruby-core:58572] [Bug #9155]' + x = assert_nothing_raised(ArgumentError, bug9155) {break Bug9155.new(1)} + assert_equal(1, x.to_i, bug9155) + end + + class Bug9403 + Name = '[ruby-core:59718] [Bug #9403]' + SD = SimpleDelegator.new(new) + class << SD + def method_name + __method__ + end + def callee_name + __callee__ + end + alias aliased_name callee_name + def dir_name + __dir__ + end + end + dc = DelegateClass(self) + dc.class_eval do + def method_name + __method__ + end + def callee_name + __callee__ + end + alias aliased_name callee_name + def dir_name + __dir__ + end + end + DC = dc.new(new) + end + + def test_method_in_simple_delegator + assert_equal(:method_name, Bug9403::SD.method_name, Bug9403::Name) + end + + def test_callee_in_simple_delegator + assert_equal(:callee_name, Bug9403::SD.callee_name, Bug9403::Name) + assert_equal(:aliased_name, Bug9403::SD.aliased_name, Bug9403::Name) + end + + def test_dir_in_simple_delegator + assert_equal(__dir__, Bug9403::SD.dir_name, Bug9403::Name) + end + + def test_method_in_delegator_class + assert_equal(:method_name, Bug9403::DC.method_name, Bug9403::Name) + end + + def test_callee_in_delegator_class + assert_equal(:callee_name, Bug9403::DC.callee_name, Bug9403::Name) + assert_equal(:aliased_name, Bug9403::DC.aliased_name, Bug9403::Name) + end + + def test_dir_in_delegator_class + assert_equal(__dir__, Bug9403::DC.dir_name, Bug9403::Name) + end +end -- cgit v1.2.3