1 files changed, 80 insertions, 47 deletions

diff --git a/spec/ruby/core/struct/new_spec.rb b/spec/ruby/core/struct/new_spec.rb
index cbbec829d7..b3ece2efed 100644
--- a/spec/ruby/core/struct/new_spec.rb
+++ b/spec/ruby/core/struct/new_spec.rb
@@ -6,6 +6,8 @@ describe "Struct.new" do
     struct = Struct.new('Animal', :name, :legs, :eyeballs)
     struct.should == Struct::Animal
     struct.name.should == "Struct::Animal"
+  ensure
+    Struct.send(:remove_const, :Animal)
   end
 
   it "overwrites previously defined constants with string as first argument" do
@@ -19,6 +21,8 @@ describe "Struct.new" do
     second.should == Struct::Person
 
     first.members.should_not == second.members
+  ensure
+    Struct.send(:remove_const, :Person)
   end
 
   it "calls to_str on its first argument (constant name)" do
@@ -27,58 +31,71 @@ describe "Struct.new" do
     struct = Struct.new(obj)
     struct.should == Struct::Foo
     struct.name.should == "Struct::Foo"
+  ensure
+    Struct.send(:remove_const, :Foo)
   end
 
   it "creates a new anonymous class with nil first argument" do
     struct = Struct.new(nil, :foo)
     struct.new("bar").foo.should == "bar"
-    struct.should be_kind_of(Class)
-    struct.name.should be_nil
+    struct.should.is_a?(Class)
+    struct.name.should == nil
   end
 
   it "creates a new anonymous class with symbol arguments" do
     struct = Struct.new(:make, :model)
-    struct.should be_kind_of(Class)
+    struct.should.is_a?(Class)
     struct.name.should == nil
   end
 
   it "does not create a constant with symbol as first argument" do
     Struct.new(:Animal2, :name, :legs, :eyeballs)
-    Struct.const_defined?("Animal2").should be_false
+    Struct.const_defined?("Animal2").should == false
   end
 
+  it "allows non-ASCII member name" do
+    name = "r\xe9sum\xe9".dup.force_encoding(Encoding::ISO_8859_1).to_sym
+    struct = Struct.new(name)
+    struct.new("foo").send(name).should == "foo"
+  end
 
   it "fails with invalid constant name as first argument" do
-    -> { Struct.new('animal', :name, :legs, :eyeballs) }.should raise_error(NameError)
+    -> { Struct.new('animal', :name, :legs, :eyeballs) }.should.raise(NameError)
   end
 
   it "raises a TypeError if object doesn't respond to to_sym" do
-    -> { Struct.new(:animal, mock('giraffe'))      }.should raise_error(TypeError)
-    -> { Struct.new(:animal, 1.0)                  }.should raise_error(TypeError)
-    -> { Struct.new(:animal, Time.now)             }.should raise_error(TypeError)
-    -> { Struct.new(:animal, Class)                }.should raise_error(TypeError)
-    -> { Struct.new(:animal, nil)                  }.should raise_error(TypeError)
-    -> { Struct.new(:animal, true)                 }.should raise_error(TypeError)
-    -> { Struct.new(:animal, ['chris', 'evan'])    }.should raise_error(TypeError)
+    -> { Struct.new(:animal, mock('giraffe'))      }.should.raise(TypeError)
+    -> { Struct.new(:animal, 1.0)                  }.should.raise(TypeError)
+    -> { Struct.new(:animal, Time.now)             }.should.raise(TypeError)
+    -> { Struct.new(:animal, Class)                }.should.raise(TypeError)
+    -> { Struct.new(:animal, nil)                  }.should.raise(TypeError)
+    -> { Struct.new(:animal, true)                 }.should.raise(TypeError)
+    -> { Struct.new(:animal, ['chris', 'evan'])    }.should.raise(TypeError)
+  end
+
+  it "raises a TypeError if passed a Hash with an unknown key" do
+    -> { Struct.new(:animal, { name: 'chris' }) }.should.raise(TypeError)
   end
 
-  it "raises a ArgumentError if passed a Hash with an unknown key" do
-    -> { Struct.new(:animal, { name: 'chris' }) }.should raise_error(ArgumentError)
+  it "works when not provided any arguments" do
+    c = Struct.new
+    c.should.is_a?(Class)
+    c.superclass.should == Struct
   end
 
   it "raises ArgumentError when there is a duplicate member" do
-    -> { Struct.new(:foo, :foo) }.should raise_error(ArgumentError, "duplicate member: foo")
+    -> { Struct.new(:foo, :foo) }.should.raise(ArgumentError, "duplicate member: foo")
   end
 
   it "raises a TypeError if object is not a Symbol" do
     obj = mock(':ruby')
     def obj.to_sym() :ruby end
-    -> { Struct.new(:animal, obj) }.should raise_error(TypeError)
+    -> { Struct.new(:animal, obj) }.should.raise(TypeError)
   end
 
   it "processes passed block with instance_eval" do
     klass = Struct.new(:something) { @something_else = 'something else entirely!' }
-    klass.instance_variables.should include(:@something_else)
+    klass.instance_variables.should.include?(:@something_else)
   end
 
   context "with a block" do
@@ -99,7 +116,7 @@ describe "Struct.new" do
       klass = Struct.new(:attr) do |block_parameter|
         given = block_parameter
       end
-      klass.should equal(given)
+      klass.should.equal?(given)
     end
   end
 
@@ -107,6 +124,8 @@ describe "Struct.new" do
     it "creates a constant in subclass' namespace" do
       struct = StructClasses::Apple.new('Computer', :size)
       struct.should == StructClasses::Apple::Computer
+    ensure
+      StructClasses::Apple.send(:remove_const, :Computer)
     end
 
     it "creates an instance" do
@@ -114,42 +133,56 @@ describe "Struct.new" do
     end
 
     it "creates reader methods" do
-      StructClasses::Ruby.new.should have_method(:version)
-      StructClasses::Ruby.new.should have_method(:platform)
+      StructClasses::Ruby.new.should.respond_to?(:version)
+      StructClasses::Ruby.new.should.respond_to?(:platform)
     end
 
     it "creates writer methods" do
-      StructClasses::Ruby.new.should have_method(:version=)
-      StructClasses::Ruby.new.should have_method(:platform=)
+      StructClasses::Ruby.new.should.respond_to?(:version=)
+      StructClasses::Ruby.new.should.respond_to?(:platform=)
     end
 
     it "fails with too many arguments" do
-      -> { StructClasses::Ruby.new('2.0', 'i686', true) }.should raise_error(ArgumentError)
+      -> { StructClasses::Ruby.new('2.0', 'i686', true) }.should.raise(ArgumentError)
     end
 
-    ruby_version_is ''...'3.1' do
-      it "passes a hash as a normal argument" do
-        type = Struct.new(:args)
+    it "accepts keyword arguments to initialize" do
+      type = Struct.new(:args)
 
-        obj = suppress_warning {type.new(keyword: :arg)}
-        obj2 = type.new(*[{keyword: :arg}])
+      obj = type.new(args: 42)
+      obj2 = type.new(42)
 
-        obj.should == obj2
-        obj.args.should == {keyword: :arg}
-        obj2.args.should == {keyword: :arg}
-      end
+      obj.should == obj2
+      obj.args.should == 42
+      obj2.args.should == 42
     end
 
-    ruby_version_is '3.2' do
-      it "accepts keyword arguments to initialize" do
-        type = Struct.new(:args)
+    context "given positional and keyword arguments" do
+      it "treats keyword arguments as a positional parameter" do
+        type = Struct.new(:a, :b)
+        s = type.new("a", b: "b")
+        s.a.should == "a"
+        s.b.should == {b: "b"}
+
+        type = Struct.new(:a, :b, :c)
+        s = type.new("a", b: "b", c: "c")
+        s.a.should == "a"
+        s.b.should == {b: "b", c: "c"}
+        s.c.should == nil
+      end
+
+      it "ignores empty keyword arguments" do
+        type = Struct.new(:a, :b)
+        h = {}
+        s = type.new("a", **h)
 
-        obj = type.new(args: 42)
-        obj2 = type.new(42)
+        s.a.should == "a"
+        s.b.should == nil
+      end
 
-        obj.should == obj2
-        obj.args.should == 42
-        obj2.args.should == 42
+      it "raises ArgumentError when all struct attribute values are specified" do
+        type = Struct.new(:a, :b)
+        -> { type.new("a", "b", c: "c") }.should.raise(ArgumentError, "struct size differs")
       end
     end
   end
@@ -166,7 +199,7 @@ describe "Struct.new" do
     end
 
     it "raises when there is a duplicate member" do
-      -> { Struct.new(:foo, :foo, keyword_init: true) }.should raise_error(ArgumentError, "duplicate member: foo")
+      -> { Struct.new(:foo, :foo, keyword_init: true) }.should.raise(ArgumentError, "duplicate member: foo")
     end
 
     describe "new class instantiation" do
@@ -179,31 +212,31 @@ describe "Struct.new" do
       it "allows missing arguments" do
         obj = @struct_with_kwa.new(name: "elefant")
         obj.name.should == "elefant"
-        obj.legs.should be_nil
+        obj.legs.should == nil
       end
 
       it "allows no arguments" do
         obj = @struct_with_kwa.new
-        obj.name.should be_nil
-        obj.legs.should be_nil
+        obj.name.should == nil
+        obj.legs.should == nil
       end
 
       it "raises ArgumentError when passed not declared keyword argument" do
         -> {
           @struct_with_kwa.new(name: "elefant", legs: 4, foo: "bar")
-        }.should raise_error(ArgumentError, /unknown keywords: foo/)
+        }.should.raise(ArgumentError, /unknown keywords: foo/)
       end
 
       it "raises ArgumentError when passed a list of arguments" do
         -> {
           @struct_with_kwa.new("elefant", 4)
-        }.should raise_error(ArgumentError, /wrong number of arguments/)
+        }.should.raise(ArgumentError, /wrong number of arguments/)
       end
 
       it "raises ArgumentError when passed a single non-hash argument" do
         -> {
           @struct_with_kwa.new("elefant")
-        }.should raise_error(ArgumentError, /wrong number of arguments/)
+        }.should.raise(ArgumentError, /wrong number of arguments/)
       end
     end
   end