1 files changed, 0 insertions, 434 deletions
diff --git a/test/ostruct/test_ostruct.rb b/test/ostruct/test_ostruct.rb
deleted file mode 100644
index 19bb606145..0000000000
--- a/test/ostruct/test_ostruct.rb
+++ /dev/null
@@ -1,434 +0,0 @@
-# frozen_string_literal: true
-require 'test/unit'
-require 'ostruct'
-require 'yaml'
-
-class TC_OpenStruct < Test::Unit::TestCase
-  def test_initialize
-    h = {name: "John Smith", age: 70, pension: 300}
-    assert_equal h, OpenStruct.new(h).to_h
-    assert_equal h, OpenStruct.new(OpenStruct.new(h)).to_h
-    assert_equal h, OpenStruct.new(Struct.new(*h.keys).new(*h.values)).to_h
-  end
-
-  def test_respond_to
-    o = OpenStruct.new
-    o.a = 1
-    assert_respond_to(o, :a)
-    assert_respond_to(o, :a=)
-  end
-
-  def test_respond_to_with_lazy_getter
-    o = OpenStruct.new a: 1
-    assert_respond_to(o, :a)
-    assert_respond_to(o, :a=)
-  end
-
-  def test_respond_to_allocated
-    assert_not_respond_to(OpenStruct.allocate, :a)
-  end
-
-  def test_equality
-    o1 = OpenStruct.new
-    o2 = OpenStruct.new
-    assert_equal(o1, o2)
-
-    o1.a = 'a'
-    assert_not_equal(o1, o2)
-
-    o2.a = 'a'
-    assert_equal(o1, o2)
-
-    o1.a = 'b'
-    assert_not_equal(o1, o2)
-
-    o2 = Object.new
-    o2.instance_eval{@table = {:a => 'b'}}
-    assert_not_equal(o1, o2)
-  end
-
-  def test_inspect
-    foo = OpenStruct.new
-    assert_equal("#<OpenStruct>", foo.inspect)
-    foo.bar = 1
-    foo.baz = 2
-    assert_equal("#<OpenStruct bar=1, baz=2>", foo.inspect)
-    assert_equal(false, foo.inspect.frozen?)
-
-    foo = OpenStruct.new
-    foo.bar = OpenStruct.new
-    assert_equal('#<OpenStruct bar=#<OpenStruct>>', foo.inspect)
-    foo.bar.foo = foo
-    assert_equal('#<OpenStruct bar=#<OpenStruct foo=#<OpenStruct ...>>>', foo.inspect)
-    assert_equal(false, foo.inspect.frozen?)
-  end
-
-  def test_frozen
-    o = OpenStruct.new(foo: 42)
-    o.a = 'a'
-    o.freeze
-    assert_raise(FrozenError) {o.b = 'b'}
-    assert_not_respond_to(o, :b)
-    assert_raise(FrozenError) {o.a = 'z'}
-    assert_equal('a', o.a)
-    assert_equal(42, o.foo)
-    o = OpenStruct.new :a => 42
-    def o.frozen?; nil end
-    o.freeze
-    assert_raise(FrozenError, '[ruby-core:22559]') {o.a = 1764}
-  end
-
-  def test_delete_field
-    bug = '[ruby-core:33010]'
-    o = OpenStruct.new
-    assert_not_respond_to(o, :a)
-    assert_not_respond_to(o, :a=)
-    o.a = 'a'
-    assert_respond_to(o, :a)
-    assert_respond_to(o, :a=)
-    a = o.delete_field :a
-    assert_not_respond_to(o, :a, bug)
-    assert_not_respond_to(o, :a=, bug)
-    assert_equal('a', a)
-    s = Object.new
-    def s.to_sym
-      :foo
-    end
-    o[s] = true
-    assert_respond_to(o, :foo)
-    assert_respond_to(o, :foo=)
-    o.delete_field s
-    assert_not_respond_to(o, :foo)
-    assert_not_respond_to(o, :foo=)
-
-    assert_raise(NameError) { o.delete_field(s) }
-    assert_equal(:bar, o.delete_field(s) { :bar })
-
-    o[s] = :foobar
-    assert_respond_to(o, :foo)
-    assert_respond_to(o, :foo=)
-    assert_equal(:foobar, o.delete_field(s) { :baz })
-
-    assert_equal(42, OpenStruct.new(foo: 42).delete_field(:foo) { :bug })
-
-    o = OpenStruct.new(block_given?: 42)
-    assert_raise(NameError) { o.delete_field(:foo) }
-  end
-
-  def test_setter
-    os = OpenStruct.new
-    os[:foo] = :bar
-    assert_equal :bar, os.foo
-    os['foo'] = :baz
-    assert_equal :baz, os.foo
-  end
-
-  def test_getter
-    os = OpenStruct.new
-    os.foo = :bar
-    assert_equal :bar, os[:foo]
-    assert_equal :bar, os['foo']
-  end
-
-  def test_dig
-    os1 = OpenStruct.new
-    os2 = OpenStruct.new
-    os1.child = os2
-    os2.foo = :bar
-    os2.child = [42]
-    assert_equal :bar, os1.dig("child", :foo)
-    assert_nil os1.dig("parent", :foo)
-    assert_raise(TypeError) { os1.dig("child", 0) }
-  end
-
-  def test_to_h
-    h = {name: "John Smith", age: 70, pension: 300}
-    os = OpenStruct.new(h)
-    to_h = os.to_h
-    assert_equal(h, to_h)
-
-    to_h[:age] = 71
-    assert_equal(70, os.age)
-    assert_equal(70, h[:age])
-
-    assert_equal(h, OpenStruct.new("name" => "John Smith", "age" => 70, pension: 300).to_h)
-  end
-
-  def test_to_h_with_block
-    os = OpenStruct.new("country" => "Australia", :capital => "Canberra")
-    assert_equal({"country" => "AUSTRALIA", "capital" => "CANBERRA" },
-                 os.to_h {|name, value| [name.to_s, value.upcase]})
-    assert_equal("Australia", os.country)
-  end
-
-  def test_each_pair
-    h = {name: "John Smith", age: 70, pension: 300}
-    os = OpenStruct.new(h)
-    assert_same os, os.each_pair{ }
-    assert_equal '#<Enumerator: #<OpenStruct name="John Smith", age=70, pension=300>:each_pair>', os.each_pair.inspect
-    assert_equal [[:name, "John Smith"], [:age, 70], [:pension, 300]], os.each_pair.to_a
-    assert_equal 3, os.each_pair.size
-  end
-
-  def test_eql_and_hash
-    os1 = OpenStruct.new age: 70
-    os2 = OpenStruct.new age: 70.0
-    assert_equal os1, os2
-    assert_equal false, os1.eql?(os2)
-    assert_not_equal os1.hash, os2.hash
-    assert_equal true, os1.eql?(os1.dup)
-    assert_equal os1.hash, os1.dup.hash
-  end
-
-  def test_method_missing
-    os = OpenStruct.new
-    e = assert_raise(NoMethodError) { os.foo true }
-    assert_equal :foo, e.name
-    assert_equal [true], e.args
-    assert_match(/#{__callee__}/, e.backtrace[0])
-    e = assert_raise(ArgumentError) { os.send :foo=, true, true }
-    assert_match(/#{__callee__}/, e.backtrace[0])
-  end
-
-  def test_accessor_defines_method
-    os = OpenStruct.new(foo: 42)
-    assert_respond_to(os, :foo)
-    assert_equal(42, os.foo)
-    assert_equal([:foo, :foo=], os.singleton_methods.sort)
-  end
-
-  def test_does_not_redefine
-    $VERBOSE, verbose_bak = nil, $VERBOSE
-    os = OpenStruct.new(foo: 42)
-    def os.foo
-      43
-    end
-    os.foo = 44
-    assert_equal(43, os.foo)
-  ensure
-    $VERBOSE = verbose_bak
-  end
-
-  def test_allocate_subclass
-    bug = '[ruby-core:80292] [Bug #13358] allocate should not call initialize'
-    c = Class.new(OpenStruct) {
-      def initialize(x,y={})super(y);end
-    }
-    os = assert_nothing_raised(ArgumentError, bug) {c.allocate}
-    assert_instance_of(c, os)
-  end
-
-  def test_initialize_subclass
-    c = Class.new(OpenStruct) {
-      def initialize(x,y={})super(y);end
-    }
-    o = c.new(1, {a: 42})
-    assert_equal(42, o.dup.a)
-    assert_equal(42, o.clone.a)
-  end
-
-  def test_private_method
-    os = OpenStruct.new
-    class << os
-      private
-      def foo
-      end
-    end
-    assert_raise_with_message(NoMethodError, /private method/) do
-      os.foo true, true
-    end
-  end
-
-  def test_protected_method
-    os = OpenStruct.new
-    class << os
-      protected
-      def foo
-      end
-    end
-    assert_raise_with_message(NoMethodError, /protected method/) do
-      os.foo true, true
-    end
-  end
-
-  def test_access_undefined
-    os = OpenStruct.new
-    assert_nil os.foo
-  end
-
-  def test_overridden_private_methods
-    os = OpenStruct.new(puts: :foo, format: :bar)
-    assert_equal(:foo, os.puts)
-    assert_equal(:bar, os.format)
-  end
-
-  def test_super
-    c = Class.new(OpenStruct) {
-      def foo; super; end
-    }
-    os = c.new(foo: :bar)
-    assert_equal(:bar, os.foo)
-  end
-
-  def test_overridden_public_methods
-    os = OpenStruct.new(method: :foo, class: :bar)
-    assert_equal(:foo, os.method)
-    assert_equal(:bar, os.class)
-  end
-
-  def test_access_original_methods
-    os = OpenStruct.new(method: :foo, hash: 42)
-    assert_equal(os.object_id, os.method!(:object_id).call)
-    assert_not_equal(42, os.hash!)
-    refute os.methods.include?(:"!~!")
-  end
-
-  def test_override_subclass
-    c = Class.new(OpenStruct) {
-      def foo; :protect_me; end
-      private def bar; :protect_me; end
-      def inspect; 'protect me'; end
-    }
-    o = c.new(
-      foo: 1, bar: 2, inspect: '3', # in subclass: protected
-      table!: 4, # bang method: protected
-      each_pair: 5, to_s: 'hello', # others: not protected
-    )
-    # protected:
-    assert_equal(:protect_me, o.foo)
-    assert_equal(:protect_me, o.send(:bar))
-    assert_equal('protect me', o.inspect)
-    assert_not_equal(4, o.send(:table!))
-    # not protected:
-    assert_equal(5, o.each_pair)
-    assert_equal('hello', o.to_s)
-  end
-
-  def test_override_submodule
-    m = Module.new {
-      def foo; :protect_me; end
-      private def bar; :protect_me; end
-      def inspect; 'protect me'; end
-    }
-    m2 = Module.new {
-      def added_to_all_open_struct; :override_me; end
-    }
-    OpenStruct.class_eval do
-      include m2
-      # prepend case tbd
-      def added_to_all_open_struct_2; :override_me; end
-    end
-    c = Class.new(OpenStruct) { include m }
-    o = c.new(
-      foo: 1, bar: 2, inspect: '3', # in subclass: protected
-      table!: 4, # bang method: protected
-      each_pair: 5, to_s: 'hello', # others: not protected
-                                   # including those added by the user:
-      added_to_all_open_struct: 6, added_to_all_open_struct_2: 7,
-    )
-    # protected:
-    assert_equal(:protect_me, o.foo)
-    assert_equal(:protect_me, o.send(:bar))
-    assert_equal('protect me', o.inspect)
-    assert_not_equal(4, o.send(:table!))
-    # not protected:
-    assert_equal(5, o.each_pair)
-    assert_equal('hello', o.to_s)
-    assert_equal(6, o.added_to_all_open_struct)
-    assert_equal(7, o.added_to_all_open_struct_2)
-  end
-
-  def test_mistaken_subclass
-    sub = Class.new(OpenStruct) do
-      def [](k)
-        __send__(k)
-        super
-      end
-
-      def []=(k, v)
-        @item_set = true
-        __send__("#{k}=", v)
-        super
-      end
-    end
-    o = sub.new
-    o.foo = 42
-    assert_equal 42, o.foo
-  end
-
-  def test_ractor
-    assert_ractor(<<~RUBY, require: 'ostruct')
-      obj1 = OpenStruct.new(a: 42, b: 42)
-      obj1.c = 42
-      obj1.freeze
-
-      obj2 = Ractor.new obj1 do |obj|
-        obj
-      end.take
-      assert obj1.object_id == obj2.object_id
-    RUBY
-  end if defined?(Ractor)
-
-  def test_access_methods_from_different_ractor
-    assert_ractor(<<~RUBY, require: 'ostruct')
-      os = OpenStruct.new
-      os.value = 100
-      r = Ractor.new(os) do |x|
-        v = x.value
-        Ractor.yield v
-      end
-      assert 100 == r.take
-    RUBY
-  end if defined?(Ractor)
-
-  def test_legacy_yaml
-    s = "--- !ruby/object:OpenStruct\ntable:\n  :foo: 42\n"
-    o = YAML.safe_load(s, permitted_classes: [Symbol, OpenStruct])
-    assert_equal(42, o.foo)
-
-    o = OpenStruct.new(table: {foo: 42})
-    assert_equal({foo: 42}, YAML.safe_load(YAML.dump(o), permitted_classes: [Symbol, OpenStruct]).table)
-  end if RUBY_VERSION >= '2.6'
-
-  def test_yaml
-    h = {name: "John Smith", age: 70, pension: 300.42}
-    yaml = "--- !ruby/object:OpenStruct\nname: John Smith\nage: 70\npension: 300.42\n"
-    os1 = OpenStruct.new(h)
-    os2 = YAML.safe_load(os1.to_yaml, permitted_classes: [Symbol, OpenStruct])
-    assert_equal yaml, os1.to_yaml
-    assert_equal os1, os2
-    assert_equal true, os1.eql?(os2)
-    assert_equal 300.42, os2.pension
-  end if RUBY_VERSION >= '2.6'
-
-  def test_marshal
-    o = OpenStruct.new(name: "John Smith", age: 70, pension: 300.42)
-    o2 = Marshal.load(Marshal.dump(o))
-    assert_equal o, o2
-  end
-
-  def test_class
-    os = OpenStruct.new(class: 'my-class', method: 'post')
-    assert_equal('my-class', os.class)
-    assert_equal(OpenStruct, os.class!)
-  end
-
-  has_performance_warnings = begin
-    Warning[:performance]
-    true
-  rescue NoMethodError, ArgumentError
-    false
-  end
-
-  if has_performance_warnings
-    def test_performance_warning
-      assert_in_out_err(
-        %w(-Ilib -rostruct -w -W:performance -e) + ['OpenStruct.new(a: 1)'],
-        "",
-        [],
-        ["-e:1: warning: OpenStruct use is discouraged for performance reasons"],
-        success: true,
-      )
-    end
-  end
-end