2 files changed, 234 insertions, 37 deletions
diff --git a/spec/ruby/shared/kernel/complex.rb b/spec/ruby/shared/kernel/complex.rb
new file mode 100644
index 0000000000..98ee0b2b3f
--- /dev/null
+++ b/spec/ruby/shared/kernel/complex.rb
@@ -0,0 +1,133 @@
+# Specs shared by Kernel#Complex() and String#to_c()
+describe :kernel_complex, shared: true do
+
+  it "returns a Complex object" do
+    @object.send(@method, '9').should be_an_instance_of(Complex)
+  end
+
+  it "understands integers" do
+    @object.send(@method, '20').should == Complex(20)
+  end
+
+  it "understands negative integers" do
+    @object.send(@method, '-3').should == Complex(-3)
+  end
+
+  it "understands fractions (numerator/denominator) for the real part" do
+    @object.send(@method, '2/3').should == Complex(Rational(2, 3))
+  end
+
+  it "understands fractions (numerator/denominator) for the imaginary part" do
+    @object.send(@method, '4+2/3i').should == Complex(4, Rational(2, 3))
+  end
+
+  it "understands negative fractions (-numerator/denominator) for the real part" do
+    @object.send(@method, '-2/3').should == Complex(Rational(-2, 3))
+  end
+
+  it "understands negative fractions (-numerator/denominator) for the imaginary part" do
+    @object.send(@method, '7-2/3i').should == Complex(7, Rational(-2, 3))
+  end
+
+  it "understands floats (a.b) for the real part" do
+    @object.send(@method, '2.3').should == Complex(2.3)
+  end
+
+  it "understands floats (a.b) for the imaginary part" do
+    @object.send(@method, '4+2.3i').should == Complex(4, 2.3)
+  end
+
+  it "understands negative floats (-a.b) for the real part" do
+    @object.send(@method, '-2.33').should == Complex(-2.33)
+  end
+
+  it "understands negative floats (-a.b) for the imaginary part" do
+    @object.send(@method, '7-28.771i').should == Complex(7, -28.771)
+  end
+
+  it "understands an integer followed by 'i' to mean that integer is the imaginary part" do
+    @object.send(@method, '35i').should == Complex(0,35)
+  end
+
+  it "understands a negative integer followed by 'i' to mean that negative integer is the imaginary part" do
+    @object.send(@method, '-29i').should == Complex(0,-29)
+  end
+
+  it "understands an 'i' by itself as denoting a complex number with an imaginary part of 1" do
+    @object.send(@method, 'i').should == Complex(0,1)
+  end
+
+  it "understands a '-i' by itself as denoting a complex number with an imaginary part of -1" do
+    @object.send(@method, '-i').should == Complex(0,-1)
+  end
+
+  it "understands 'a+bi' to mean a complex number with 'a' as the real part, 'b' as the imaginary" do
+    @object.send(@method, '79+4i').should == Complex(79,4)
+  end
+
+  it "understands 'a-bi' to mean a complex number with 'a' as the real part, '-b' as the imaginary" do
+    @object.send(@method, '79-4i').should == Complex(79,-4)
+  end
+
+  it "understands 'a+i' to mean a complex number with 'a' as the real part, 1i as the imaginary" do
+    @object.send(@method, '79+i').should == Complex(79, 1)
+  end
+
+  it "understands 'a-i' to mean a complex number with 'a' as the real part, -1i as the imaginary" do
+    @object.send(@method, '79-i').should == Complex(79, -1)
+  end
+
+  it "understands i, I, j, and J imaginary units" do
+    @object.send(@method, '79+4i').should == Complex(79, 4)
+    @object.send(@method, '79+4I').should == Complex(79, 4)
+    @object.send(@method, '79+4j').should == Complex(79, 4)
+    @object.send(@method, '79+4J').should == Complex(79, 4)
+  end
+
+  it "understands scientific notation for the real part" do
+    @object.send(@method, '2e3+4i').should == Complex(2e3,4)
+  end
+
+  it "understands negative scientific notation for the real part" do
+    @object.send(@method, '-2e3+4i').should == Complex(-2e3,4)
+  end
+
+  it "understands scientific notation for the imaginary part" do
+    @object.send(@method, '4+2e3i').should == Complex(4, 2e3)
+  end
+
+  it "understands negative scientific notation for the imaginary part" do
+    @object.send(@method, '4-2e3i').should == Complex(4, -2e3)
+  end
+
+  it "understands scientific notation for the real and imaginary part in the same String" do
+    @object.send(@method, '2e3+2e4i').should == Complex(2e3,2e4)
+  end
+
+  it "understands negative scientific notation for the real and imaginary part in the same String" do
+    @object.send(@method, '-2e3-2e4i').should == Complex(-2e3,-2e4)
+  end
+
+  it "understands scientific notation with e and E" do
+    @object.send(@method, '2e3+2e4i').should == Complex(2e3, 2e4)
+    @object.send(@method, '2E3+2E4i').should == Complex(2e3, 2e4)
+  end
+
+  it "understands 'm@a' to mean a complex number in polar form with 'm' as the modulus, 'a' as the argument" do
+    @object.send(@method, '79@4').should == Complex.polar(79, 4)
+    @object.send(@method, '-79@4').should == Complex.polar(-79, 4)
+    @object.send(@method, '79@-4').should == Complex.polar(79, -4)
+  end
+
+  it "ignores leading whitespaces" do
+    @object.send(@method, '  79+4i').should == Complex(79, 4)
+  end
+
+  it "ignores trailing whitespaces" do
+    @object.send(@method, '79+4i  ').should == Complex(79, 4)
+  end
+
+  it "understands _" do
+    @object.send(@method, '7_9+4_0i').should == Complex(79, 40)
+  end
+end
diff --git a/spec/ruby/shared/kernel/raise.rb b/spec/ruby/shared/kernel/raise.rb
index 3cff55ac6e..82fb0333c8 100644
--- a/spec/ruby/shared/kernel/raise.rb
+++ b/spec/ruby/shared/kernel/raise.rb
@@ -4,7 +4,7 @@ describe :kernel_raise, shared: true do
   end
 
   it "aborts execution" do
-    lambda do
+    -> do
       @object.raise Exception, "abort"
       ScratchPad.record :no_abort
     end.should raise_error(Exception, "abort")
@@ -12,73 +12,137 @@ describe :kernel_raise, shared: true do
     ScratchPad.recorded.should be_nil
   end
 
+  it "accepts an exception that implements to_hash" do
+    custom_error = Class.new(StandardError) do
+      def to_hash
+        {}
+      end
+    end
+    error = custom_error.new
+    -> { @object.raise(error) }.should raise_error(custom_error)
+  end
+
+  it "allows the message parameter to be a hash" do
+    data_error = Class.new(StandardError) do
+      attr_reader :data
+      def initialize(data)
+        @data = data
+      end
+    end
+
+    -> { @object.raise(data_error, {data: 42}) }.should raise_error(data_error) do |ex|
+      ex.data.should == {data: 42}
+    end
+  end
+
+  # https://bugs.ruby-lang.org/issues/8257#note-36
+  it "allows extra keyword arguments for compatibility" do
+    data_error = Class.new(StandardError) do
+      attr_reader :data
+      def initialize(data)
+        @data = data
+      end
+    end
+
+    -> { @object.raise(data_error, data: 42) }.should raise_error(data_error) do |ex|
+      ex.data.should == {data: 42}
+    end
+  end
+
+  it "does not allow message and extra keyword arguments" do
+    data_error = Class.new(StandardError) do
+      attr_reader :data
+      def initialize(data)
+        @data = data
+      end
+    end
+
+    -> { @object.raise(data_error, {a: 1}, b: 2) }.should raise_error(StandardError) do |e|
+      [TypeError, ArgumentError].should.include?(e.class)
+    end
+
+    -> { @object.raise(data_error, {a: 1}, [], b: 2) }.should raise_error(ArgumentError)
+  end
+
   it "raises RuntimeError if no exception class is given" do
-    lambda { @object.raise }.should raise_error(RuntimeError)
+    -> { @object.raise }.should raise_error(RuntimeError, "")
   end
 
   it "raises a given Exception instance" do
     error = RuntimeError.new
-    lambda { @object.raise(error) }.should raise_error(error)
+    -> { @object.raise(error) }.should raise_error(error)
   end
 
   it "raises a RuntimeError if string given" do
-    lambda { @object.raise("a bad thing") }.should raise_error(RuntimeError)
+    -> { @object.raise("a bad thing") }.should raise_error(RuntimeError)
+  end
+
+  it "passes no arguments to the constructor when given only an exception class" do
+    klass = Class.new(Exception) do
+      def initialize
+      end
+    end
+    -> { @object.raise(klass) }.should raise_error(klass) { |e| e.message.should == klass.to_s }
   end
 
   it "raises a TypeError when passed a non-Exception object" do
-    lambda { @object.raise(Object.new) }.should raise_error(TypeError)
+    -> { @object.raise(Object.new) }.should raise_error(TypeError)
   end
 
   it "raises a TypeError when passed true" do
-    lambda { @object.raise(true) }.should raise_error(TypeError)
+    -> { @object.raise(true) }.should raise_error(TypeError)
   end
 
   it "raises a TypeError when passed false" do
-    lambda { @object.raise(false) }.should raise_error(TypeError)
+    -> { @object.raise(false) }.should raise_error(TypeError)
   end
 
   it "raises a TypeError when passed nil" do
-    lambda { @object.raise(nil) }.should raise_error(TypeError)
+    -> { @object.raise(nil) }.should raise_error(TypeError)
   end
 
-  it "re-raises the previously rescued exception if no exception is specified" do
-    lambda do
-      begin
-        @object.raise Exception, "outer"
-        ScratchPad.record :no_abort
-      rescue
+  it "re-raises a previously rescued exception without overwriting the backtrace" do
+    # This spec is written using #backtrace and matching the line number
+    # from the string, as backtrace_locations is a more advanced
+    # method that is not always supported by implementations.
+    #
+    initial_raise_line = nil
+    raise_again_line = nil
+    raised_again = nil
+
+    if defined?(FiberSpecs::NewFiberToRaise) and @object == FiberSpecs::NewFiberToRaise
+      fiber = Fiber.new do
         begin
-          @object.raise StandardError, "inner"
-        rescue
+          initial_raise_line = __LINE__; Fiber.yield
+        rescue => raised
+          begin
+            raise_again_line = __LINE__; Fiber.yield raised
+          rescue => raised_again
+            raised_again
+          end
         end
-
-        @object.raise
-        ScratchPad.record :no_reraise
       end
-    end.should raise_error(Exception, "outer")
-
-    ScratchPad.recorded.should be_nil
-  end
-
-  it "re-raises a previously rescued exception without overwriting the backtrace" do
-    begin
-      initial_raise_line = __LINE__; @object.raise 'raised'
-    rescue => raised
+      fiber.resume
+      raised = fiber.raise 'raised'
+      raised_again = fiber.raise raised
+    else
       begin
-        raise_again_line = __LINE__; @object.raise raised
-      rescue => raised_again
-        # This spec is written using #backtrace and matching the line number
-        # from the string, as backtrace_locations is a more advanced
-        # method that is not always supported by implementations.
-
-        raised_again.backtrace.first.should include("#{__FILE__}:#{initial_raise_line}:")
-        raised_again.backtrace.first.should_not include("#{__FILE__}:#{raise_again_line}:")
+        initial_raise_line = __LINE__; @object.raise 'raised'
+      rescue => raised
+        begin
+          raise_again_line = __LINE__; @object.raise raised
+        rescue => raised_again
+          raised_again
+        end
       end
     end
+
+    raised_again.backtrace.first.should include("#{__FILE__}:#{initial_raise_line}:")
+    raised_again.backtrace.first.should_not include("#{__FILE__}:#{raise_again_line}:")
   end
 
   it "allows Exception, message, and backtrace parameters" do
-    lambda do
+    -> do
       @object.raise(ArgumentError, "message", caller)
     end.should raise_error(ArgumentError, "message")
   end