spec/mspec/tool/wrap_with_guard.rb 'ruby_version_is ""..."4.1"' spec/ruby/library/net-ftp/**/*.rb

65 files changed, 2829 insertions, 2643 deletions

diff --git a/spec/ruby/library/net-ftp/FTPError_spec.rb b/spec/ruby/library/net-ftp/FTPError_spec.rb
index 0c31b65dcc..b447e50546 100644
--- a/spec/ruby/library/net-ftp/FTPError_spec.rb
+++ b/spec/ruby/library/net-ftp/FTPError_spec.rb
@@ -1,8 +1,11 @@
 require_relative '../../spec_helper'
-require 'net/ftp'
 
-describe "Net::FTPError" do
-  it "is an Exception" do
-    Net::FTPError.should < Exception
+ruby_version_is ""..."4.1" do
+  require 'net/ftp'
+
+  describe "Net::FTPError" do
+    it "is an Exception" do
+      Net::FTPError.should < Exception
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/FTPPermError_spec.rb b/spec/ruby/library/net-ftp/FTPPermError_spec.rb
index b43e12c503..b9a2d93aef 100644
--- a/spec/ruby/library/net-ftp/FTPPermError_spec.rb
+++ b/spec/ruby/library/net-ftp/FTPPermError_spec.rb
@@ -1,12 +1,15 @@
 require_relative '../../spec_helper'
-require 'net/ftp'
 
-describe "Net::FTPPermError" do
-  it "is an Exception" do
-    Net::FTPPermError.should < Exception
-  end
+ruby_version_is ""..."4.1" do
+  require 'net/ftp'
+
+  describe "Net::FTPPermError" do
+    it "is an Exception" do
+      Net::FTPPermError.should < Exception
+    end
 
-  it "is a subclass of Net::FTPError" do
-    Net::FTPPermError.should < Net::FTPError
+    it "is a subclass of Net::FTPError" do
+      Net::FTPPermError.should < Net::FTPError
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/FTPProtoError_spec.rb b/spec/ruby/library/net-ftp/FTPProtoError_spec.rb
index e7abbc0dd8..a1d9e44d63 100644
--- a/spec/ruby/library/net-ftp/FTPProtoError_spec.rb
+++ b/spec/ruby/library/net-ftp/FTPProtoError_spec.rb
@@ -1,12 +1,15 @@
 require_relative '../../spec_helper'
-require 'net/ftp'
 
-describe "Net::FTPProtoError" do
-  it "is an Exception" do
-    Net::FTPProtoError.should < Exception
-  end
+ruby_version_is ""..."4.1" do
+  require 'net/ftp'
+
+  describe "Net::FTPProtoError" do
+    it "is an Exception" do
+      Net::FTPProtoError.should < Exception
+    end
 
-  it "is a subclass of Net::FTPError" do
-    Net::FTPPermError.should < Net::FTPError
+    it "is a subclass of Net::FTPError" do
+      Net::FTPPermError.should < Net::FTPError
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/FTPReplyError_spec.rb b/spec/ruby/library/net-ftp/FTPReplyError_spec.rb
index fcc7501fc1..c9e6468323 100644
--- a/spec/ruby/library/net-ftp/FTPReplyError_spec.rb
+++ b/spec/ruby/library/net-ftp/FTPReplyError_spec.rb
@@ -1,12 +1,15 @@
 require_relative '../../spec_helper'
-require 'net/ftp'
 
-describe "Net::FTPReplyError" do
-  it "is an Exception" do
-    Net::FTPReplyError.should < Exception
-  end
+ruby_version_is ""..."4.1" do
+  require 'net/ftp'
+
+  describe "Net::FTPReplyError" do
+    it "is an Exception" do
+      Net::FTPReplyError.should < Exception
+    end
 
-  it "is a subclass of Net::FTPError" do
-    Net::FTPPermError.should < Net::FTPError
+    it "is a subclass of Net::FTPError" do
+      Net::FTPPermError.should < Net::FTPError
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/FTPTempError_spec.rb b/spec/ruby/library/net-ftp/FTPTempError_spec.rb
index f4b045dfb5..c0953cb0f2 100644
--- a/spec/ruby/library/net-ftp/FTPTempError_spec.rb
+++ b/spec/ruby/library/net-ftp/FTPTempError_spec.rb
@@ -1,12 +1,15 @@
 require_relative '../../spec_helper'
-require 'net/ftp'
 
-describe "Net::FTPTempError" do
-  it "is an Exception" do
-    Net::FTPTempError.should < Exception
-  end
+ruby_version_is ""..."4.1" do
+  require 'net/ftp'
+
+  describe "Net::FTPTempError" do
+    it "is an Exception" do
+      Net::FTPTempError.should < Exception
+    end
 
-  it "is a subclass of Net::FTPError" do
-    Net::FTPPermError.should < Net::FTPError
+    it "is a subclass of Net::FTPError" do
+      Net::FTPPermError.should < Net::FTPError
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/abort_spec.rb b/spec/ruby/library/net-ftp/abort_spec.rb
index 335d056512..d9fed45653 100644
--- a/spec/ruby/library/net-ftp/abort_spec.rb
+++ b/spec/ruby/library/net-ftp/abort_spec.rb
@@ -1,62 +1,65 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
 
-describe "Net::FTP#abort" do
-  before :each do
-    @server = NetFTPSpecs::DummyFTP.new
-    @server.serve_once
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
 
-    @ftp = Net::FTP.new
-    @ftp.connect(@server.hostname, @server.server_port)
-  end
+  describe "Net::FTP#abort" do
+    before :each do
+      @server = NetFTPSpecs::DummyFTP.new
+      @server.serve_once
 
-  after :each do
-    @ftp.quit rescue nil
-    @ftp.close
-    @server.stop
-  end
+      @ftp = Net::FTP.new
+      @ftp.connect(@server.hostname, @server.server_port)
+    end
 
-  it "sends the ABOR command to the server" do
-    -> { @ftp.abort }.should_not raise_error
-  end
+    after :each do
+      @ftp.quit rescue nil
+      @ftp.close
+      @server.stop
+    end
 
-  it "ignores the response" do
-    @ftp.abort
-    @ftp.last_response.should == "220 Dummy FTP Server ready!\n"
-  end
+    it "sends the ABOR command to the server" do
+      -> { @ftp.abort }.should_not raise_error
+    end
 
-  it "returns the full response" do
-    @ftp.abort.should == "226 Closing data connection. (ABOR)\n"
-  end
+    it "ignores the response" do
+      @ftp.abort
+      @ftp.last_response.should == "220 Dummy FTP Server ready!\n"
+    end
 
-  it "does not raise any error when the response code is 225" do
-    @server.should_receive(:abor).and_respond("225 Data connection open; no transfer in progress.")
-    -> { @ftp.abort }.should_not raise_error
-  end
+    it "returns the full response" do
+      @ftp.abort.should == "226 Closing data connection. (ABOR)\n"
+    end
 
-  it "does not raise any error when the response code is 226" do
-    @server.should_receive(:abor).and_respond("226 Closing data connection.")
-    -> { @ftp.abort }.should_not raise_error
-  end
+    it "does not raise any error when the response code is 225" do
+      @server.should_receive(:abor).and_respond("225 Data connection open; no transfer in progress.")
+      -> { @ftp.abort }.should_not raise_error
+    end
 
-  it "raises a Net::FTPProtoError when the response code is 500" do
-    @server.should_receive(:abor).and_respond("500 Syntax error, command unrecognized.")
-    -> { @ftp.abort }.should raise_error(Net::FTPProtoError)
-  end
+    it "does not raise any error when the response code is 226" do
+      @server.should_receive(:abor).and_respond("226 Closing data connection.")
+      -> { @ftp.abort }.should_not raise_error
+    end
 
-  it "raises a Net::FTPProtoError when the response code is 501" do
-    @server.should_receive(:abor).and_respond("501 Syntax error in parameters or arguments.")
-    -> { @ftp.abort }.should raise_error(Net::FTPProtoError)
-  end
+    it "raises a Net::FTPProtoError when the response code is 500" do
+      @server.should_receive(:abor).and_respond("500 Syntax error, command unrecognized.")
+      -> { @ftp.abort }.should raise_error(Net::FTPProtoError)
+    end
 
-  it "raises a Net::FTPProtoError when the response code is 502" do
-    @server.should_receive(:abor).and_respond("502 Command not implemented.")
-    -> { @ftp.abort }.should raise_error(Net::FTPProtoError)
-  end
+    it "raises a Net::FTPProtoError when the response code is 501" do
+      @server.should_receive(:abor).and_respond("501 Syntax error in parameters or arguments.")
+      -> { @ftp.abort }.should raise_error(Net::FTPProtoError)
+    end
+
+    it "raises a Net::FTPProtoError when the response code is 502" do
+      @server.should_receive(:abor).and_respond("502 Command not implemented.")
+      -> { @ftp.abort }.should raise_error(Net::FTPProtoError)
+    end
 
-  it "raises a Net::FTPProtoError when the response code is 421" do
-    @server.should_receive(:abor).and_respond("421 Service not available, closing control connection.")
-    -> { @ftp.abort }.should raise_error(Net::FTPProtoError)
+    it "raises a Net::FTPProtoError when the response code is 421" do
+      @server.should_receive(:abor).and_respond("421 Service not available, closing control connection.")
+      -> { @ftp.abort }.should raise_error(Net::FTPProtoError)
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/acct_spec.rb b/spec/ruby/library/net-ftp/acct_spec.rb
index ab093448a2..93214a84d7 100644
--- a/spec/ruby/library/net-ftp/acct_spec.rb
+++ b/spec/ruby/library/net-ftp/acct_spec.rb
@@ -1,58 +1,61 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
 
-describe "Net::FTP#acct" do
-  before :each do
-    @server = NetFTPSpecs::DummyFTP.new
-    @server.serve_once
-
-    @ftp = Net::FTP.new
-    @ftp.connect(@server.hostname, @server.server_port)
-  end
-
-  after :each do
-    @ftp.quit rescue nil
-    @ftp.close
-    @server.stop
-  end
-
-  it "writes the ACCT command to the server" do
-    @ftp.acct("my_account")
-    @ftp.last_response.should == "230 User 'my_account' logged in, proceed. (ACCT)\n"
-  end
-
-  it "returns nil" do
-    @ftp.acct("my_account").should == nil
-  end
-
-  it "does not raise any error when the response code is 230" do
-    @server.should_receive(:acct).and_respond("230 User logged in, proceed.")
-    -> { @ftp.acct("my_account") }.should_not raise_error
-  end
-
-  it "raises a Net::FTPPermError when the response code is 530" do
-    @server.should_receive(:acct).and_respond("530 Not logged in.")
-    -> { @ftp.acct("my_account") }.should raise_error(Net::FTPPermError)
-  end
-
-  it "raises a Net::FTPPermError when the response code is 500" do
-    @server.should_receive(:acct).and_respond("500 Syntax error, command unrecognized.")
-    -> { @ftp.acct("my_account") }.should raise_error(Net::FTPPermError)
-  end
-
-  it "raises a Net::FTPPermError when the response code is 501" do
-    @server.should_receive(:acct).and_respond("501 Syntax error in parameters or arguments.")
-    -> { @ftp.acct("my_account") }.should raise_error(Net::FTPPermError)
-  end
-
-  it "raises a Net::FTPPermError when the response code is 503" do
-    @server.should_receive(:acct).and_respond("503 Bad sequence of commands.")
-    -> { @ftp.acct("my_account") }.should raise_error(Net::FTPPermError)
-  end
-
-  it "raises a Net::FTPTempError when the response code is 421" do
-    @server.should_receive(:acct).and_respond("421 Service not available, closing control connection.")
-    -> { @ftp.acct("my_account") }.should raise_error(Net::FTPTempError)
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
+
+  describe "Net::FTP#acct" do
+    before :each do
+      @server = NetFTPSpecs::DummyFTP.new
+      @server.serve_once
+
+      @ftp = Net::FTP.new
+      @ftp.connect(@server.hostname, @server.server_port)
+    end
+
+    after :each do
+      @ftp.quit rescue nil
+      @ftp.close
+      @server.stop
+    end
+
+    it "writes the ACCT command to the server" do
+      @ftp.acct("my_account")
+      @ftp.last_response.should == "230 User 'my_account' logged in, proceed. (ACCT)\n"
+    end
+
+    it "returns nil" do
+      @ftp.acct("my_account").should == nil
+    end
+
+    it "does not raise any error when the response code is 230" do
+      @server.should_receive(:acct).and_respond("230 User logged in, proceed.")
+      -> { @ftp.acct("my_account") }.should_not raise_error
+    end
+
+    it "raises a Net::FTPPermError when the response code is 530" do
+      @server.should_receive(:acct).and_respond("530 Not logged in.")
+      -> { @ftp.acct("my_account") }.should raise_error(Net::FTPPermError)
+    end
+
+    it "raises a Net::FTPPermError when the response code is 500" do
+      @server.should_receive(:acct).and_respond("500 Syntax error, command unrecognized.")
+      -> { @ftp.acct("my_account") }.should raise_error(Net::FTPPermError)
+    end
+
+    it "raises a Net::FTPPermError when the response code is 501" do
+      @server.should_receive(:acct).and_respond("501 Syntax error in parameters or arguments.")
+      -> { @ftp.acct("my_account") }.should raise_error(Net::FTPPermError)
+    end
+
+    it "raises a Net::FTPPermError when the response code is 503" do
+      @server.should_receive(:acct).and_respond("503 Bad sequence of commands.")
+      -> { @ftp.acct("my_account") }.should raise_error(Net::FTPPermError)
+    end
+
+    it "raises a Net::FTPTempError when the response code is 421" do
+      @server.should_receive(:acct).and_respond("421 Service not available, closing control connection.")
+      -> { @ftp.acct("my_account") }.should raise_error(Net::FTPTempError)
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/binary_spec.rb b/spec/ruby/library/net-ftp/binary_spec.rb
index 1e0585b795..22a5fe65ab 100644
--- a/spec/ruby/library/net-ftp/binary_spec.rb
+++ b/spec/ruby/library/net-ftp/binary_spec.rb
@@ -1,24 +1,27 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
 
-describe "Net::FTP#binary" do
-  it "returns true when self is in binary mode" do
-    ftp = Net::FTP.new
-    ftp.binary.should be_true
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
 
-    ftp.binary = false
-    ftp.binary.should be_false
+  describe "Net::FTP#binary" do
+    it "returns true when self is in binary mode" do
+      ftp = Net::FTP.new
+      ftp.binary.should be_true
+
+      ftp.binary = false
+      ftp.binary.should be_false
+    end
   end
-end
 
-describe "Net::FTP#binary=" do
-  it "sets self to binary mode when passed true" do
-    ftp = Net::FTP.new
+  describe "Net::FTP#binary=" do
+    it "sets self to binary mode when passed true" do
+      ftp = Net::FTP.new
 
-    ftp.binary = true
-    ftp.binary.should be_true
+      ftp.binary = true
+      ftp.binary.should be_true
 
-    ftp.binary = false
-    ftp.binary.should be_false
+      ftp.binary = false
+      ftp.binary.should be_false
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/chdir_spec.rb b/spec/ruby/library/net-ftp/chdir_spec.rb
index cc129b5e42..46eda09d1d 100644
--- a/spec/ruby/library/net-ftp/chdir_spec.rb
+++ b/spec/ruby/library/net-ftp/chdir_spec.rb
@@ -1,99 +1,102 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
 
-describe "Net::FTP#chdir" do
-  before :each do
-    @server = NetFTPSpecs::DummyFTP.new
-    @server.serve_once
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
 
-    @ftp = Net::FTP.new
-    @ftp.connect(@server.hostname, @server.server_port)
-  end
+  describe "Net::FTP#chdir" do
+    before :each do
+      @server = NetFTPSpecs::DummyFTP.new
+      @server.serve_once
 
-  after :each do
-    @ftp.quit rescue nil
-    @ftp.close
-    @server.stop
-  end
+      @ftp = Net::FTP.new
+      @ftp.connect(@server.hostname, @server.server_port)
+    end
+
+    after :each do
+      @ftp.quit rescue nil
+      @ftp.close
+      @server.stop
+    end
+
+    describe "when switching to the parent directory" do
+      it "sends the 'CDUP' command to the server" do
+        @ftp.chdir("..")
+        @ftp.last_response.should == "200 Command okay. (CDUP)\n"
+      end
+
+      it "returns nil" do
+        @ftp.chdir("..").should be_nil
+      end
+
+      it "does not raise a Net::FTPPermError when the response code is 500" do
+        @server.should_receive(:cdup).and_respond("500 Syntax error, command unrecognized.")
+        -> { @ftp.chdir("..") }.should_not raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 501" do
+        @server.should_receive(:cdup).and_respond("501 Syntax error in parameters or arguments.")
+        -> { @ftp.chdir("..") }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 502" do
+        @server.should_receive(:cdup).and_respond("502 Command not implemented.")
+        -> { @ftp.chdir("..") }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPTempError when the response code is 421" do
+        @server.should_receive(:cdup).and_respond("421 Service not available, closing control connection.")
+        -> { @ftp.chdir("..") }.should raise_error(Net::FTPTempError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 530" do
+        @server.should_receive(:cdup).and_respond("530 Not logged in.")
+        -> { @ftp.chdir("..") }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 550" do
+        @server.should_receive(:cdup).and_respond("550 Requested action not taken.")
+        -> { @ftp.chdir("..") }.should raise_error(Net::FTPPermError)
+      end
+    end
 
-  describe "when switching to the parent directory" do
-    it "sends the 'CDUP' command to the server" do
-      @ftp.chdir("..")
-      @ftp.last_response.should == "200 Command okay. (CDUP)\n"
+    it "writes the 'CWD' command with the passed directory to the socket" do
+      @ftp.chdir("test")
+      @ftp.last_response.should == "200 Command okay. (CWD test)\n"
     end
 
     it "returns nil" do
-      @ftp.chdir("..").should be_nil
+      @ftp.chdir("test").should be_nil
     end
 
-    it "does not raise a Net::FTPPermError when the response code is 500" do
-      @server.should_receive(:cdup).and_respond("500 Syntax error, command unrecognized.")
-      -> { @ftp.chdir("..") }.should_not raise_error(Net::FTPPermError)
+    it "raises a Net::FTPPermError when the response code is 500" do
+      @server.should_receive(:cwd).and_respond("500 Syntax error, command unrecognized.")
+      -> { @ftp.chdir("test") }.should raise_error(Net::FTPPermError)
     end
 
     it "raises a Net::FTPPermError when the response code is 501" do
-      @server.should_receive(:cdup).and_respond("501 Syntax error in parameters or arguments.")
-      -> { @ftp.chdir("..") }.should raise_error(Net::FTPPermError)
+      @server.should_receive(:cwd).and_respond("501 Syntax error in parameters or arguments.")
+      -> { @ftp.chdir("test") }.should raise_error(Net::FTPPermError)
     end
 
     it "raises a Net::FTPPermError when the response code is 502" do
-      @server.should_receive(:cdup).and_respond("502 Command not implemented.")
-      -> { @ftp.chdir("..") }.should raise_error(Net::FTPPermError)
+      @server.should_receive(:cwd).and_respond("502 Command not implemented.")
+      -> { @ftp.chdir("test") }.should raise_error(Net::FTPPermError)
     end
 
     it "raises a Net::FTPTempError when the response code is 421" do
-      @server.should_receive(:cdup).and_respond("421 Service not available, closing control connection.")
-      -> { @ftp.chdir("..") }.should raise_error(Net::FTPTempError)
+      @server.should_receive(:cwd).and_respond("421 Service not available, closing control connection.")
+      -> { @ftp.chdir("test") }.should raise_error(Net::FTPTempError)
     end
 
     it "raises a Net::FTPPermError when the response code is 530" do
-      @server.should_receive(:cdup).and_respond("530 Not logged in.")
-      -> { @ftp.chdir("..") }.should raise_error(Net::FTPPermError)
+      @server.should_receive(:cwd).and_respond("530 Not logged in.")
+      -> { @ftp.chdir("test") }.should raise_error(Net::FTPPermError)
     end
 
     it "raises a Net::FTPPermError when the response code is 550" do
-      @server.should_receive(:cdup).and_respond("550 Requested action not taken.")
-      -> { @ftp.chdir("..") }.should raise_error(Net::FTPPermError)
+      @server.should_receive(:cwd).and_respond("550 Requested action not taken.")
+      -> { @ftp.chdir("test") }.should raise_error(Net::FTPPermError)
     end
   end
-
-  it "writes the 'CWD' command with the passed directory to the socket" do
-    @ftp.chdir("test")
-    @ftp.last_response.should == "200 Command okay. (CWD test)\n"
-  end
-
-  it "returns nil" do
-    @ftp.chdir("test").should be_nil
-  end
-
-  it "raises a Net::FTPPermError when the response code is 500" do
-    @server.should_receive(:cwd).and_respond("500 Syntax error, command unrecognized.")
-    -> { @ftp.chdir("test") }.should raise_error(Net::FTPPermError)
-  end
-
-  it "raises a Net::FTPPermError when the response code is 501" do
-    @server.should_receive(:cwd).and_respond("501 Syntax error in parameters or arguments.")
-    -> { @ftp.chdir("test") }.should raise_error(Net::FTPPermError)
-  end
-
-  it "raises a Net::FTPPermError when the response code is 502" do
-    @server.should_receive(:cwd).and_respond("502 Command not implemented.")
-    -> { @ftp.chdir("test") }.should raise_error(Net::FTPPermError)
-  end
-
-  it "raises a Net::FTPTempError when the response code is 421" do
-    @server.should_receive(:cwd).and_respond("421 Service not available, closing control connection.")
-    -> { @ftp.chdir("test") }.should raise_error(Net::FTPTempError)
-  end
-
-  it "raises a Net::FTPPermError when the response code is 530" do
-    @server.should_receive(:cwd).and_respond("530 Not logged in.")
-    -> { @ftp.chdir("test") }.should raise_error(Net::FTPPermError)
-  end
-
-  it "raises a Net::FTPPermError when the response code is 550" do
-    @server.should_receive(:cwd).and_respond("550 Requested action not taken.")
-    -> { @ftp.chdir("test") }.should raise_error(Net::FTPPermError)
-  end
 end
diff --git a/spec/ruby/library/net-ftp/close_spec.rb b/spec/ruby/library/net-ftp/close_spec.rb
index 183f14a84b..57d06cc3e6 100644
--- a/spec/ruby/library/net-ftp/close_spec.rb
+++ b/spec/ruby/library/net-ftp/close_spec.rb
@@ -1,30 +1,33 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
 
-describe "Net::FTP#close" do
-  before :each do
-    @socket = mock("Socket")
-    @socket.stub!(:closed?).and_return(false)
-    @socket.stub!(:read_timeout).and_return(60)
-    @socket.stub!(:read_timeout=).and_return(3)
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
 
-    @ftp = Net::FTP.new
-    @ftp.instance_variable_set(:@sock, @socket)
-  end
+  describe "Net::FTP#close" do
+    before :each do
+      @socket = mock("Socket")
+      @socket.stub!(:closed?).and_return(false)
+      @socket.stub!(:read_timeout).and_return(60)
+      @socket.stub!(:read_timeout=).and_return(3)
 
-  it "closes the socket" do
-    @socket.should_receive(:close)
-    @ftp.close.should be_nil
-  end
+      @ftp = Net::FTP.new
+      @ftp.instance_variable_set(:@sock, @socket)
+    end
 
-  it "does not try to close the socket if it has already been closed" do
-    @socket.should_receive(:closed?).and_return(true)
-    @socket.should_not_receive(:close)
-    @ftp.close.should be_nil
-  end
+    it "closes the socket" do
+      @socket.should_receive(:close)
+      @ftp.close.should be_nil
+    end
+
+    it "does not try to close the socket if it has already been closed" do
+      @socket.should_receive(:closed?).and_return(true)
+      @socket.should_not_receive(:close)
+      @ftp.close.should be_nil
+    end
 
-  it "does not try to close the socket if it is nil" do
-    @ftp.instance_variable_set(:@sock, nil)
-    @ftp.close.should be_nil
+    it "does not try to close the socket if it is nil" do
+      @ftp.instance_variable_set(:@sock, nil)
+      @ftp.close.should be_nil
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/closed_spec.rb b/spec/ruby/library/net-ftp/closed_spec.rb
index 84001cdc0f..3dd0025aee 100644
--- a/spec/ruby/library/net-ftp/closed_spec.rb
+++ b/spec/ruby/library/net-ftp/closed_spec.rb
@@ -1,21 +1,24 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
 
-describe "Net::FTP#closed?" do
-  before :each do
-    @socket = mock("Socket")
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
 
-    @ftp = Net::FTP.new
-    @ftp.instance_variable_set(:@sock, @socket)
-  end
+  describe "Net::FTP#closed?" do
+    before :each do
+      @socket = mock("Socket")
 
-  it "returns true when the socket is closed" do
-    @socket.should_receive(:closed?).and_return(true)
-    @ftp.closed?.should be_true
-  end
+      @ftp = Net::FTP.new
+      @ftp.instance_variable_set(:@sock, @socket)
+    end
+
+    it "returns true when the socket is closed" do
+      @socket.should_receive(:closed?).and_return(true)
+      @ftp.closed?.should be_true
+    end
 
-  it "returns true when the socket is nil" do
-    @ftp.instance_variable_set(:@sock, nil)
-    @ftp.closed?.should be_true
+    it "returns true when the socket is nil" do
+      @ftp.instance_variable_set(:@sock, nil)
+      @ftp.closed?.should be_true
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/connect_spec.rb b/spec/ruby/library/net-ftp/connect_spec.rb
index e606b11e2a..31d64ca758 100644
--- a/spec/ruby/library/net-ftp/connect_spec.rb
+++ b/spec/ruby/library/net-ftp/connect_spec.rb
@@ -1,43 +1,46 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
 
-# TODO: Add specs for using the SOCKSSocket
-describe "Net::FTP#connect" do
-  before :each do
-    @server = NetFTPSpecs::DummyFTP.new
-    @server.serve_once
-
-    @ftp = Net::FTP.new
-  end
-
-  after :each do
-    @server.connect_message = nil
-    @ftp.quit rescue nil
-    @ftp.close
-    @server.stop
-  end
-
-  it "tries to connect to the FTP Server on the given host and port" do
-    -> { @ftp.connect(@server.hostname, @server.server_port) }.should_not raise_error
-  end
-
-  it "returns nil" do
-    @ftp.connect(@server.hostname, @server.server_port).should be_nil
-  end
-
-  it "does not raise any error when the response code is 220" do
-    @server.connect_message = "220 Dummy FTP Server ready!"
-    -> { @ftp.connect(@server.hostname, @server.server_port) }.should_not raise_error
-  end
-
-  it "raises a Net::FTPReplyError when the response code is 120" do
-    @server.connect_message = "120 Service ready in nnn minutes."
-    -> { @ftp.connect(@server.hostname, @server.server_port) }.should raise_error(Net::FTPReplyError)
-  end
-
-  it "raises a Net::FTPTempError when the response code is 421" do
-    @server.connect_message = "421 Service not available, closing control connection."
-    -> { @ftp.connect(@server.hostname, @server.server_port) }.should raise_error(Net::FTPTempError)
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
+
+  # TODO: Add specs for using the SOCKSSocket
+  describe "Net::FTP#connect" do
+    before :each do
+      @server = NetFTPSpecs::DummyFTP.new
+      @server.serve_once
+
+      @ftp = Net::FTP.new
+    end
+
+    after :each do
+      @server.connect_message = nil
+      @ftp.quit rescue nil
+      @ftp.close
+      @server.stop
+    end
+
+    it "tries to connect to the FTP Server on the given host and port" do
+      -> { @ftp.connect(@server.hostname, @server.server_port) }.should_not raise_error
+    end
+
+    it "returns nil" do
+      @ftp.connect(@server.hostname, @server.server_port).should be_nil
+    end
+
+    it "does not raise any error when the response code is 220" do
+      @server.connect_message = "220 Dummy FTP Server ready!"
+      -> { @ftp.connect(@server.hostname, @server.server_port) }.should_not raise_error
+    end
+
+    it "raises a Net::FTPReplyError when the response code is 120" do
+      @server.connect_message = "120 Service ready in nnn minutes."
+      -> { @ftp.connect(@server.hostname, @server.server_port) }.should raise_error(Net::FTPReplyError)
+    end
+
+    it "raises a Net::FTPTempError when the response code is 421" do
+      @server.connect_message = "421 Service not available, closing control connection."
+      -> { @ftp.connect(@server.hostname, @server.server_port) }.should raise_error(Net::FTPTempError)
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/debug_mode_spec.rb b/spec/ruby/library/net-ftp/debug_mode_spec.rb
index f2ef53c089..2a26e689e7 100644
--- a/spec/ruby/library/net-ftp/debug_mode_spec.rb
+++ b/spec/ruby/library/net-ftp/debug_mode_spec.rb
@@ -1,23 +1,26 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
 
-describe "Net::FTP#debug_mode" do
-  it "returns true when self is in debug mode" do
-    ftp = Net::FTP.new
-    ftp.debug_mode.should be_false
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
 
-    ftp.debug_mode = true
-    ftp.debug_mode.should be_true
+  describe "Net::FTP#debug_mode" do
+    it "returns true when self is in debug mode" do
+      ftp = Net::FTP.new
+      ftp.debug_mode.should be_false
+
+      ftp.debug_mode = true
+      ftp.debug_mode.should be_true
+    end
   end
-end
 
-describe "Net::FTP#debug_mode=" do
-  it "sets self into debug mode when passed true" do
-    ftp = Net::FTP.new
-    ftp.debug_mode = true
-    ftp.debug_mode.should be_true
+  describe "Net::FTP#debug_mode=" do
+    it "sets self into debug mode when passed true" do
+      ftp = Net::FTP.new
+      ftp.debug_mode = true
+      ftp.debug_mode.should be_true
 
-    ftp.debug_mode = false
-    ftp.debug_mode.should be_false
+      ftp.debug_mode = false
+      ftp.debug_mode.should be_false
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/default_passive_spec.rb b/spec/ruby/library/net-ftp/default_passive_spec.rb
index 3f14f6187e..b47b4e9782 100644
--- a/spec/ruby/library/net-ftp/default_passive_spec.rb
+++ b/spec/ruby/library/net-ftp/default_passive_spec.rb
@@ -1,8 +1,11 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
 
-describe "Net::FTP#default_passive" do
-  it "is true by default" do
-    ruby_exe(fixture(__FILE__, "default_passive.rb")).should == "true\ntrue\n"
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+
+  describe "Net::FTP#default_passive" do
+    it "is true by default" do
+      ruby_exe(fixture(__FILE__, "default_passive.rb")).should == "true\ntrue\n"
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/delete_spec.rb b/spec/ruby/library/net-ftp/delete_spec.rb
index bfb7da1ffe..117ffd93bc 100644
--- a/spec/ruby/library/net-ftp/delete_spec.rb
+++ b/spec/ruby/library/net-ftp/delete_spec.rb
@@ -1,59 +1,62 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
 
-describe "Net::FTP#delete" do
-  before :each do
-    @server = NetFTPSpecs::DummyFTP.new
-    @server.serve_once
-
-    @ftp = Net::FTP.new
-    @ftp.connect(@server.hostname, @server.server_port)
-  end
-
-  after :each do
-    @ftp.quit rescue nil
-    @ftp.close
-    @server.stop
-  end
-
-  it "sends the DELE command with the passed filename to the server" do
-    @ftp.delete("test.file")
-    @ftp.last_response.should == "250 Requested file action okay, completed. (DELE test.file)\n"
-  end
-
-  it "raises a Net::FTPTempError when the response code is 450" do
-    @server.should_receive(:dele).and_respond("450 Requested file action not taken.")
-    -> { @ftp.delete("test.file") }.should raise_error(Net::FTPTempError)
-  end
-
-  it "raises a Net::FTPPermError when the response code is 550" do
-    @server.should_receive(:dele).and_respond("550 Requested action not taken.")
-    -> { @ftp.delete("test.file") }.should raise_error(Net::FTPPermError)
-  end
-
-  it "raises a Net::FTPPermError when the response code is 500" do
-    @server.should_receive(:dele).and_respond("500 Syntax error, command unrecognized.")
-    -> { @ftp.delete("test.file") }.should raise_error(Net::FTPPermError)
-  end
-
-  it "raises a Net::FTPPermError when the response code is 501" do
-    @server.should_receive(:dele).and_respond("501 Syntax error in parameters or arguments.")
-    -> { @ftp.delete("test.file") }.should raise_error(Net::FTPPermError)
-  end
-
-  it "raises a Net::FTPPermError when the response code is 502" do
-    @server.should_receive(:dele).and_respond("502 Command not implemented.")
-    -> { @ftp.delete("test.file") }.should raise_error(Net::FTPPermError)
-  end
-
-  it "raises a Net::FTPTempError when the response code is 421" do
-    @server.should_receive(:dele).and_respond("421 Service not available, closing control connection.")
-    -> { @ftp.delete("test.file") }.should raise_error(Net::FTPTempError)
-  end
-
-  it "raises a Net::FTPPermError when the response code is 530" do
-    @server.should_receive(:dele).and_respond("530 Not logged in.")
-    -> { @ftp.delete("test.file") }.should raise_error(Net::FTPPermError)
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
+
+  describe "Net::FTP#delete" do
+    before :each do
+      @server = NetFTPSpecs::DummyFTP.new
+      @server.serve_once
+
+      @ftp = Net::FTP.new
+      @ftp.connect(@server.hostname, @server.server_port)
+    end
+
+    after :each do
+      @ftp.quit rescue nil
+      @ftp.close
+      @server.stop
+    end
+
+    it "sends the DELE command with the passed filename to the server" do
+      @ftp.delete("test.file")
+      @ftp.last_response.should == "250 Requested file action okay, completed. (DELE test.file)\n"
+    end
+
+    it "raises a Net::FTPTempError when the response code is 450" do
+      @server.should_receive(:dele).and_respond("450 Requested file action not taken.")
+      -> { @ftp.delete("test.file") }.should raise_error(Net::FTPTempError)
+    end
+
+    it "raises a Net::FTPPermError when the response code is 550" do
+      @server.should_receive(:dele).and_respond("550 Requested action not taken.")
+      -> { @ftp.delete("test.file") }.should raise_error(Net::FTPPermError)
+    end
+
+    it "raises a Net::FTPPermError when the response code is 500" do
+      @server.should_receive(:dele).and_respond("500 Syntax error, command unrecognized.")
+      -> { @ftp.delete("test.file") }.should raise_error(Net::FTPPermError)
+    end
+
+    it "raises a Net::FTPPermError when the response code is 501" do
+      @server.should_receive(:dele).and_respond("501 Syntax error in parameters or arguments.")
+      -> { @ftp.delete("test.file") }.should raise_error(Net::FTPPermError)
+    end
+
+    it "raises a Net::FTPPermError when the response code is 502" do
+      @server.should_receive(:dele).and_respond("502 Command not implemented.")
+      -> { @ftp.delete("test.file") }.should raise_error(Net::FTPPermError)
+    end
+
+    it "raises a Net::FTPTempError when the response code is 421" do
+      @server.should_receive(:dele).and_respond("421 Service not available, closing control connection.")
+      -> { @ftp.delete("test.file") }.should raise_error(Net::FTPTempError)
+    end
+
+    it "raises a Net::FTPPermError when the response code is 530" do
+      @server.should_receive(:dele).and_respond("530 Not logged in.")
+      -> { @ftp.delete("test.file") }.should raise_error(Net::FTPPermError)
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/dir_spec.rb b/spec/ruby/library/net-ftp/dir_spec.rb
index 894f03dd7b..af38724fad 100644
--- a/spec/ruby/library/net-ftp/dir_spec.rb
+++ b/spec/ruby/library/net-ftp/dir_spec.rb
@@ -1,8 +1,11 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
-require_relative 'shared/list'
 
-describe "Net::FTP#dir" do
-  it_behaves_like :net_ftp_list, :dir
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
+  require_relative 'shared/list'
+
+  describe "Net::FTP#dir" do
+    it_behaves_like :net_ftp_list, :dir
+  end
 end
diff --git a/spec/ruby/library/net-ftp/fixtures/server.rb b/spec/ruby/library/net-ftp/fixtures/server.rb
index 8b34d3f8bd..9fc2beb57b 100644
--- a/spec/ruby/library/net-ftp/fixtures/server.rb
+++ b/spec/ruby/library/net-ftp/fixtures/server.rb
@@ -1,277 +1,279 @@
-module NetFTPSpecs
-  class DummyFTP
-    attr_accessor :connect_message
-    attr_reader :login_user, :login_pass, :login_acct
-
-    # hostname or IP address
-    attr_reader :hostname
-    # port number
-    attr_reader :server_port
-
-    def initialize
-      @hostname = "127.0.0.1"
-      @server = TCPServer.new(@hostname, 0)
-      @server_port = @server.addr[1]
-
-      @handlers = {}
-      @commands = []
-      @connect_message = nil
-    end
+ruby_version_is ""..."4.1" do
+  module NetFTPSpecs
+    class DummyFTP
+      attr_accessor :connect_message
+      attr_reader :login_user, :login_pass, :login_acct
+
+      # hostname or IP address
+      attr_reader :hostname
+      # port number
+      attr_reader :server_port
+
+      def initialize
+        @hostname = "127.0.0.1"
+        @server = TCPServer.new(@hostname, 0)
+        @server_port = @server.addr[1]
+
+        @handlers = {}
+        @commands = []
+        @connect_message = nil
+      end
 
-    def serve_once
-      @thread = Thread.new do
-        @socket = @server.accept
-        @socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_OOBINLINE, 1)
-        begin
-          handle_request
-        ensure
-          @socket.close
+      def serve_once
+        @thread = Thread.new do
+          @socket = @server.accept
+          @socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_OOBINLINE, 1)
+          begin
+            handle_request
+          ensure
+            @socket.close
+          end
         end
       end
-    end
-
-    def handle_request
-      # Send out the welcome message.
-      response @connect_message || "220 Dummy FTP Server ready!"
 
-      begin
-        while command = @socket.gets
-          command, argument = command.chomp.split(" ", 2)
+      def handle_request
+        # Send out the welcome message.
+        response @connect_message || "220 Dummy FTP Server ready!"
 
-          if command == "QUIT"
-            self.response("221 OK, bye")
-            break
-          elsif proc_handler = @handlers[command.downcase.to_sym]
-            if argument.nil?
-              proc_handler.call(self)
-            else
-              proc_handler.call(self, argument)
-            end
-          else
-            if argument.nil?
-              self.send(command.downcase.to_sym)
+        begin
+          while command = @socket.gets
+            command, argument = command.chomp.split(" ", 2)
+
+            if command == "QUIT"
+              self.response("221 OK, bye")
+              break
+            elsif proc_handler = @handlers[command.downcase.to_sym]
+              if argument.nil?
+                proc_handler.call(self)
+              else
+                proc_handler.call(self, argument)
+              end
             else
-              self.send(command.downcase.to_sym, argument)
+              if argument.nil?
+                self.send(command.downcase.to_sym)
+              else
+                self.send(command.downcase.to_sym, argument)
+              end
             end
           end
+        rescue => e
+          self.error_response("Exception: #{e} #{e.backtrace.inspect}")
         end
-      rescue => e
-        self.error_response("Exception: #{e} #{e.backtrace.inspect}")
       end
-    end
 
-    def error_response(text)
-      self.response("451 #{text}")
-    end
+      def error_response(text)
+        self.response("451 #{text}")
+      end
 
-    def response(text)
-      @socket.puts(text) unless @socket.closed?
-    end
+      def response(text)
+        @socket.puts(text) unless @socket.closed?
+      end
 
-    def stop
-      @datasocket.close unless @datasocket.nil? || @datasocket.closed?
-      @server.close
-      @thread.join
-    end
+      def stop
+        @datasocket.close unless @datasocket.nil? || @datasocket.closed?
+        @server.close
+        @thread.join
+      end
 
 
-    ##
-    def handle(sym, &block)
-      @handlers[sym] = block
-    end
+      ##
+      def handle(sym, &block)
+        @handlers[sym] = block
+      end
 
-    def should_receive(method)
-      @handler_for = method
-      self
-    end
+      def should_receive(method)
+        @handler_for = method
+        self
+      end
 
-    def and_respond(text)
-      @handlers[@handler_for] = -> s, *args { s.response(text) }
-    end
+      def and_respond(text)
+        @handlers[@handler_for] = -> s, *args { s.response(text) }
+      end
 
-    ##
-    # FTP methods
-    ##
+      ##
+      # FTP methods
+      ##
 
-    def abor
-      self.response("226 Closing data connection. (ABOR)")
-    end
+      def abor
+        self.response("226 Closing data connection. (ABOR)")
+      end
 
-    def acct(account)
-      @login_acct = account
-      self.response("230 User '#{account}' logged in, proceed. (ACCT)")
-    end
+      def acct(account)
+        @login_acct = account
+        self.response("230 User '#{account}' logged in, proceed. (ACCT)")
+      end
 
-    def cdup
-      self.response("200 Command okay. (CDUP)")
-    end
+      def cdup
+        self.response("200 Command okay. (CDUP)")
+      end
 
-    def cwd(dir)
-      self.response("200 Command okay. (CWD #{dir})")
-    end
+      def cwd(dir)
+        self.response("200 Command okay. (CWD #{dir})")
+      end
 
-    def dele(file)
-      self.response("250 Requested file action okay, completed. (DELE #{file})")
-    end
+      def dele(file)
+        self.response("250 Requested file action okay, completed. (DELE #{file})")
+      end
 
-    def eprt(arg)
-      _, _, host, port = arg.split("|")
+      def eprt(arg)
+        _, _, host, port = arg.split("|")
 
-      @datasocket = TCPSocket.new(host, port)
-      self.response("200 port opened")
-    end
+        @datasocket = TCPSocket.new(host, port)
+        self.response("200 port opened")
+      end
 
-    def help(param = :default)
-      if param == :default
-        self.response("211 System status, or system help reply. (HELP)")
-      else
-        self.response("211 System status, or system help reply. (HELP #{param})")
+      def help(param = :default)
+        if param == :default
+          self.response("211 System status, or system help reply. (HELP)")
+        else
+          self.response("211 System status, or system help reply. (HELP #{param})")
+        end
       end
-    end
 
-    def list(folder)
-      self.response("150 opening ASCII connection for file list")
-      @datasocket.puts("-rw-r--r--  1 spec  staff  507 17 Jul 18:41 last_response_code.rb")
-      @datasocket.puts("-rw-r--r--  1 spec  staff   50 17 Jul 18:41 list.rb")
-      @datasocket.puts("-rw-r--r--  1 spec  staff   48 17 Jul 18:41 pwd.rb")
-      @datasocket.close()
-      self.response("226 transfer complete (LIST #{folder})")
-    end
+      def list(folder)
+        self.response("150 opening ASCII connection for file list")
+        @datasocket.puts("-rw-r--r--  1 spec  staff  507 17 Jul 18:41 last_response_code.rb")
+        @datasocket.puts("-rw-r--r--  1 spec  staff   50 17 Jul 18:41 list.rb")
+        @datasocket.puts("-rw-r--r--  1 spec  staff   48 17 Jul 18:41 pwd.rb")
+        @datasocket.close()
+        self.response("226 transfer complete (LIST #{folder})")
+      end
 
-    def mdtm(filename)
-      self.response("213 19980705132316")
-    end
+      def mdtm(filename)
+        self.response("213 19980705132316")
+      end
 
-    def mkd(foldername)
-      self.response(%Q{257 "#{foldername.gsub('"', '""')}" created.})
-    end
+      def mkd(foldername)
+        self.response(%Q{257 "#{foldername.gsub('"', '""')}" created.})
+      end
 
-    def nlst(folder = nil)
-      self.response("150 opening ASCII connection for file list")
-      @datasocket.puts("last_response_code.rb")
-      @datasocket.puts("list.rb")
-      @datasocket.puts("pwd.rb")
-      @datasocket.close()
-      self.response("226 transfer complete (NLST#{folder ? " #{folder}" : ""})")
-    end
+      def nlst(folder = nil)
+        self.response("150 opening ASCII connection for file list")
+        @datasocket.puts("last_response_code.rb")
+        @datasocket.puts("list.rb")
+        @datasocket.puts("pwd.rb")
+        @datasocket.close()
+        self.response("226 transfer complete (NLST#{folder ? " #{folder}" : ""})")
+      end
 
-    def noop
-      self.response("200 Command okay. (NOOP)")
-    end
+      def noop
+        self.response("200 Command okay. (NOOP)")
+      end
 
-    def pass(password)
-      @login_pass = password
-      self.response("230 User logged in, proceed. (PASS #{password})")
-    end
+      def pass(password)
+        @login_pass = password
+        self.response("230 User logged in, proceed. (PASS #{password})")
+      end
 
-    def port(arg)
-      nums = arg.split(",")
+      def port(arg)
+        nums = arg.split(",")
+
+        if nums[0] == "::1"
+          # IPv6
+          port = nums[1].to_i * 256 + nums[2].to_i
+          host = nums[0]
+        else
+          # IPv4
+          port = nums[4].to_i * 256 + nums[5].to_i
+          host = nums[0..3].join(".")
+        end
 
-      if nums[0] == "::1"
-        # IPv6
-        port = nums[1].to_i * 256 + nums[2].to_i
-        host = nums[0]
-      else
-        # IPv4
-        port = nums[4].to_i * 256 + nums[5].to_i
-        host = nums[0..3].join(".")
+        @datasocket = TCPSocket.new(host, port)
+        self.response("200 port opened")
       end
 
-      @datasocket = TCPSocket.new(host, port)
-      self.response("200 port opened")
-    end
-
-    def pwd
-      self.response('257 "/some/dir/" - current directory')
-    end
+      def pwd
+        self.response('257 "/some/dir/" - current directory')
+      end
 
-    def retr(file)
-      self.response("125 Data transfer starting")
-      if @restart_at && @restart_at == 20
-        @datasocket.puts("of the file named '#{file}'.")
-        @restart_at = nil
-      else
-        @datasocket.puts("This is the content")
-        @datasocket.puts("of the file named '#{file}'.")
-      end
-      @datasocket.close()
-      self.response("226 Closing data connection. (RETR #{file})")
-    end
+      def retr(file)
+        self.response("125 Data transfer starting")
+        if @restart_at && @restart_at == 20
+          @datasocket.puts("of the file named '#{file}'.")
+          @restart_at = nil
+        else
+          @datasocket.puts("This is the content")
+          @datasocket.puts("of the file named '#{file}'.")
+        end
+        @datasocket.close()
+        self.response("226 Closing data connection. (RETR #{file})")
+      end
 
-    def rest(at_bytes)
-      @restart_at = at_bytes.to_i
-      self.response("350 Requested file action pending further information. (REST)")
-    end
+      def rest(at_bytes)
+        @restart_at = at_bytes.to_i
+        self.response("350 Requested file action pending further information. (REST)")
+      end
 
-    def rmd(folder)
-      self.response("250 Requested file action okay, completed. (RMD #{folder})")
-    end
+      def rmd(folder)
+        self.response("250 Requested file action okay, completed. (RMD #{folder})")
+      end
 
-    def rnfr(from)
-      @rename_from = from
-      self.response("350 Requested file action pending further information.")
-    end
+      def rnfr(from)
+        @rename_from = from
+        self.response("350 Requested file action pending further information.")
+      end
 
-    def rnto(to)
-      self.response("250 Requested file action okay, completed. (Renamed #{@rename_from} to #{to})")
-      @rename_from = nil
-    end
+      def rnto(to)
+        self.response("250 Requested file action okay, completed. (Renamed #{@rename_from} to #{to})")
+        @rename_from = nil
+      end
 
-    def site(param)
-      self.response("200 Command okay. (SITE #{param})")
-    end
+      def site(param)
+        self.response("200 Command okay. (SITE #{param})")
+      end
 
-    def size(filename)
-      if filename == "binary"
-        self.response("213 24")
-      else
-        self.response("213 1024")
+      def size(filename)
+        if filename == "binary"
+          self.response("213 24")
+        else
+          self.response("213 1024")
+        end
       end
-    end
 
-    def stat(param = :default)
-      if param == :default
-        self.response("211 System status, or system help reply. (STAT)")
-      else
-        self.response("211 System status, or system help reply. (STAT #{param})")
+      def stat(param = :default)
+        if param == :default
+          self.response("211 System status, or system help reply. (STAT)")
+        else
+          self.response("211 System status, or system help reply. (STAT #{param})")
+        end
       end
-    end
 
-    def stor(file)
-      tmp_file = tmp("#{file}file", false)
+      def stor(file)
+        tmp_file = tmp("#{file}file", false)
 
-      self.response("125 Data transfer starting.")
+        self.response("125 Data transfer starting.")
 
-      mode = @restart_at ? "a" : "w"
+        mode = @restart_at ? "a" : "w"
 
-      File.open(tmp_file, mode + "b") do |f|
-        loop do
-          data = @datasocket.recv(1024)
-          break if !data || data.empty?
-          f << data
+        File.open(tmp_file, mode + "b") do |f|
+          loop do
+            data = @datasocket.recv(1024)
+            break if !data || data.empty?
+            f << data
+          end
         end
-      end
 
-      @datasocket.close()
-      self.response("200 OK, Data received. (STOR #{file})")
-    end
+        @datasocket.close()
+        self.response("200 OK, Data received. (STOR #{file})")
+      end
 
-    def appe(file)
-      @restart_at = true
-      stor(file)
-    end
+      def appe(file)
+        @restart_at = true
+        stor(file)
+      end
 
-    def syst
-      self.response("215 FTP Dummy Server (SYST)")
-    end
+      def syst
+        self.response("215 FTP Dummy Server (SYST)")
+      end
 
-    def type(type)
-      self.response("200 TYPE switched to #{type}")
-    end
+      def type(type)
+        self.response("200 TYPE switched to #{type}")
+      end
 
-    def user(name)
-      @login_user = name
-      self.response("230 User logged in, proceed. (USER #{name})")
+      def user(name)
+        @login_user = name
+        self.response("230 User logged in, proceed. (USER #{name})")
+      end
     end
   end
 end
diff --git a/spec/ruby/library/net-ftp/get_spec.rb b/spec/ruby/library/net-ftp/get_spec.rb
index 1bc1bd744b..6a8aa3e206 100644
--- a/spec/ruby/library/net-ftp/get_spec.rb
+++ b/spec/ruby/library/net-ftp/get_spec.rb
@@ -1,21 +1,24 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
-require_relative 'shared/gettextfile'
-require_relative 'shared/getbinaryfile'
 
-describe "Net::FTP#get (binary mode)" do
-  before :each do
-    @binary_mode = true
-  end
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
+  require_relative 'shared/gettextfile'
+  require_relative 'shared/getbinaryfile'
 
-  it_behaves_like :net_ftp_getbinaryfile, :get
-end
+  describe "Net::FTP#get (binary mode)" do
+    before :each do
+      @binary_mode = true
+    end
 
-describe "Net::FTP#get (text mode)" do
-  before :each do
-    @binary_mode = false
+    it_behaves_like :net_ftp_getbinaryfile, :get
   end
 
-  it_behaves_like :net_ftp_gettextfile, :get
+  describe "Net::FTP#get (text mode)" do
+    before :each do
+      @binary_mode = false
+    end
+
+    it_behaves_like :net_ftp_gettextfile, :get
+  end
 end
diff --git a/spec/ruby/library/net-ftp/getbinaryfile_spec.rb b/spec/ruby/library/net-ftp/getbinaryfile_spec.rb
index e9898fccc7..6b2d38edf5 100644
--- a/spec/ruby/library/net-ftp/getbinaryfile_spec.rb
+++ b/spec/ruby/library/net-ftp/getbinaryfile_spec.rb
@@ -1,8 +1,11 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
-require_relative 'shared/getbinaryfile'
 
-describe "Net::FTP#getbinaryfile" do
-  it_behaves_like :net_ftp_getbinaryfile, :getbinaryfile
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
+  require_relative 'shared/getbinaryfile'
+
+  describe "Net::FTP#getbinaryfile" do
+    it_behaves_like :net_ftp_getbinaryfile, :getbinaryfile
+  end
 end
diff --git a/spec/ruby/library/net-ftp/getdir_spec.rb b/spec/ruby/library/net-ftp/getdir_spec.rb
index 756d6a23af..2ff62d399d 100644
--- a/spec/ruby/library/net-ftp/getdir_spec.rb
+++ b/spec/ruby/library/net-ftp/getdir_spec.rb
@@ -1,7 +1,10 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'shared/pwd'
 
-describe "Net::FTP#getdir" do
-  it_behaves_like :net_ftp_pwd, :getdir
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'shared/pwd'
+
+  describe "Net::FTP#getdir" do
+    it_behaves_like :net_ftp_pwd, :getdir
+  end
 end
diff --git a/spec/ruby/library/net-ftp/gettextfile_spec.rb b/spec/ruby/library/net-ftp/gettextfile_spec.rb
index cdd1b4c797..3bb037663b 100644
--- a/spec/ruby/library/net-ftp/gettextfile_spec.rb
+++ b/spec/ruby/library/net-ftp/gettextfile_spec.rb
@@ -1,8 +1,11 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
-require_relative 'shared/gettextfile'
 
-describe "Net::FTP#gettextfile" do
-  it_behaves_like :net_ftp_gettextfile, :gettextfile
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
+  require_relative 'shared/gettextfile'
+
+  describe "Net::FTP#gettextfile" do
+    it_behaves_like :net_ftp_gettextfile, :gettextfile
+  end
 end
diff --git a/spec/ruby/library/net-ftp/help_spec.rb b/spec/ruby/library/net-ftp/help_spec.rb
index c562be50b2..442d8aa93d 100644
--- a/spec/ruby/library/net-ftp/help_spec.rb
+++ b/spec/ruby/library/net-ftp/help_spec.rb
@@ -1,66 +1,69 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
 
-describe "Net::FTP#help" do
-  def with_connection
-    yield
-  end
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
 
-  before :each do
-    @server = NetFTPSpecs::DummyFTP.new
-    @server.serve_once
+  describe "Net::FTP#help" do
+    def with_connection
+      yield
+    end
 
-    @ftp = Net::FTP.new
-    @ftp.connect(@server.hostname, @server.server_port)
-  end
+    before :each do
+      @server = NetFTPSpecs::DummyFTP.new
+      @server.serve_once
 
-  after :each do
-    @ftp.quit rescue nil
-    @ftp.close
-    @server.stop
-  end
+      @ftp = Net::FTP.new
+      @ftp.connect(@server.hostname, @server.server_port)
+    end
 
-  it "writes the HELP command to the server" do
-    @ftp.help
-    @ftp.last_response.should == "211 System status, or system help reply. (HELP)\n"
-  end
+    after :each do
+      @ftp.quit rescue nil
+      @ftp.close
+      @server.stop
+    end
 
-  it "returns the server's response" do
-    @ftp.help.should == "211 System status, or system help reply. (HELP)\n"
-  end
+    it "writes the HELP command to the server" do
+      @ftp.help
+      @ftp.last_response.should == "211 System status, or system help reply. (HELP)\n"
+    end
 
-  it "writes the HELP command with an optional parameter to the socket" do
-    @ftp.help("some parameter").should == "211 System status, or system help reply. (HELP some parameter)\n"
-  end
+    it "returns the server's response" do
+      @ftp.help.should == "211 System status, or system help reply. (HELP)\n"
+    end
 
-  it "does not raise any error when the response code is 211" do
-    @server.should_receive(:help).and_respond("211 System status, or system help reply.")
-    -> { @ftp.help }.should_not raise_error
-  end
+    it "writes the HELP command with an optional parameter to the socket" do
+      @ftp.help("some parameter").should == "211 System status, or system help reply. (HELP some parameter)\n"
+    end
 
-  it "does not raise any error when the response code is 214" do
-    @server.should_receive(:help).and_respond("214 Help message.")
-    -> { @ftp.help }.should_not raise_error
-  end
+    it "does not raise any error when the response code is 211" do
+      @server.should_receive(:help).and_respond("211 System status, or system help reply.")
+      -> { @ftp.help }.should_not raise_error
+    end
 
-  it "raises a Net::FTPPermError when the response code is 500" do
-    @server.should_receive(:help).and_respond("500 Syntax error, command unrecognized.")
-    -> { @ftp.help }.should raise_error(Net::FTPPermError)
-  end
+    it "does not raise any error when the response code is 214" do
+      @server.should_receive(:help).and_respond("214 Help message.")
+      -> { @ftp.help }.should_not raise_error
+    end
 
-  it "raises a Net::FTPPermError when the response code is 501" do
-    @server.should_receive(:help).and_respond("501 Syntax error in parameters or arguments.")
-    -> { @ftp.help }.should raise_error(Net::FTPPermError)
-  end
+    it "raises a Net::FTPPermError when the response code is 500" do
+      @server.should_receive(:help).and_respond("500 Syntax error, command unrecognized.")
+      -> { @ftp.help }.should raise_error(Net::FTPPermError)
+    end
 
-  it "raises a Net::FTPPermError when the response code is 502" do
-    @server.should_receive(:help).and_respond("502 Command not implemented.")
-    -> { @ftp.help }.should raise_error(Net::FTPPermError)
-  end
+    it "raises a Net::FTPPermError when the response code is 501" do
+      @server.should_receive(:help).and_respond("501 Syntax error in parameters or arguments.")
+      -> { @ftp.help }.should raise_error(Net::FTPPermError)
+    end
+
+    it "raises a Net::FTPPermError when the response code is 502" do
+      @server.should_receive(:help).and_respond("502 Command not implemented.")
+      -> { @ftp.help }.should raise_error(Net::FTPPermError)
+    end
 
-  it "raises a Net::FTPTempError when the response code is 421" do
-    @server.should_receive(:help).and_respond("421 Service not available, closing control connection.")
-    -> { @ftp.help }.should raise_error(Net::FTPTempError)
+    it "raises a Net::FTPTempError when the response code is 421" do
+      @server.should_receive(:help).and_respond("421 Service not available, closing control connection.")
+      -> { @ftp.help }.should raise_error(Net::FTPTempError)
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/initialize_spec.rb b/spec/ruby/library/net-ftp/initialize_spec.rb
index 4d775e8dc1..8a22e58842 100644
--- a/spec/ruby/library/net-ftp/initialize_spec.rb
+++ b/spec/ruby/library/net-ftp/initialize_spec.rb
@@ -1,402 +1,405 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-
-describe "Net::FTP#initialize" do
-  before :each do
-    @ftp = Net::FTP.allocate
-    @ftp.stub!(:connect)
-    @port_args = []
-    @port_args << 21
-  end
 
-  it "is private" do
-    Net::FTP.should have_private_instance_method(:initialize)
-  end
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
 
-  it "sets self into binary mode" do
-    @ftp.binary.should be_nil
-    @ftp.send(:initialize)
-    @ftp.binary.should be_true
-  end
-
-  it "sets self into active mode" do
-    @ftp.passive.should be_nil
-    @ftp.send(:initialize)
-    @ftp.passive.should be_false
-  end
+  describe "Net::FTP#initialize" do
+    before :each do
+      @ftp = Net::FTP.allocate
+      @ftp.stub!(:connect)
+      @port_args = []
+      @port_args << 21
+    end
 
-  it "sets self into non-debug mode" do
-    @ftp.debug_mode.should be_nil
-    @ftp.send(:initialize)
-    @ftp.debug_mode.should be_false
-  end
+    it "is private" do
+      Net::FTP.should have_private_instance_method(:initialize)
+    end
 
-  it "sets self to not resume file uploads/downloads" do
-    @ftp.resume.should be_nil
-    @ftp.send(:initialize)
-    @ftp.resume.should be_false
-  end
+    it "sets self into binary mode" do
+      @ftp.binary.should be_nil
+      @ftp.send(:initialize)
+      @ftp.binary.should be_true
+    end
 
-  describe "when passed no arguments" do
-    it "does not try to connect" do
-      @ftp.should_not_receive(:connect)
+    it "sets self into active mode" do
+      @ftp.passive.should be_nil
       @ftp.send(:initialize)
+      @ftp.passive.should be_false
     end
-  end
 
-  describe "when passed host" do
-    it "tries to connect to the passed host" do
-      @ftp.should_receive(:connect).with("localhost", *@port_args)
-      @ftp.send(:initialize, "localhost")
+    it "sets self into non-debug mode" do
+      @ftp.debug_mode.should be_nil
+      @ftp.send(:initialize)
+      @ftp.debug_mode.should be_false
     end
-  end
 
-  describe "when passed host, user" do
-    it "tries to connect to the passed host" do
-      @ftp.should_receive(:connect).with("localhost", *@port_args)
-      @ftp.send(:initialize, "localhost")
+    it "sets self to not resume file uploads/downloads" do
+      @ftp.resume.should be_nil
+      @ftp.send(:initialize)
+      @ftp.resume.should be_false
     end
 
-    it "tries to login with the passed username" do
-      @ftp.should_receive(:login).with("rubyspec", nil, nil)
-      @ftp.send(:initialize, "localhost", "rubyspec")
+    describe "when passed no arguments" do
+      it "does not try to connect" do
+        @ftp.should_not_receive(:connect)
+        @ftp.send(:initialize)
+      end
     end
-  end
 
-  describe "when passed host, user, password" do
-    it "tries to connect to the passed host" do
-      @ftp.should_receive(:connect).with("localhost", *@port_args)
-      @ftp.send(:initialize, "localhost")
+    describe "when passed host" do
+      it "tries to connect to the passed host" do
+        @ftp.should_receive(:connect).with("localhost", *@port_args)
+        @ftp.send(:initialize, "localhost")
+      end
     end
 
-    it "tries to login with the passed username and password" do
-      @ftp.should_receive(:login).with("rubyspec", "rocks", nil)
-      @ftp.send(:initialize, "localhost", "rubyspec", "rocks")
+    describe "when passed host, user" do
+      it "tries to connect to the passed host" do
+        @ftp.should_receive(:connect).with("localhost", *@port_args)
+        @ftp.send(:initialize, "localhost")
+      end
+
+      it "tries to login with the passed username" do
+        @ftp.should_receive(:login).with("rubyspec", nil, nil)
+        @ftp.send(:initialize, "localhost", "rubyspec")
+      end
     end
-  end
 
-  describe "when passed host, user" do
-    it "tries to connect to the passed host" do
-      @ftp.should_receive(:connect).with("localhost", *@port_args)
-      @ftp.send(:initialize, "localhost")
+    describe "when passed host, user, password" do
+      it "tries to connect to the passed host" do
+        @ftp.should_receive(:connect).with("localhost", *@port_args)
+        @ftp.send(:initialize, "localhost")
+      end
+
+      it "tries to login with the passed username and password" do
+        @ftp.should_receive(:login).with("rubyspec", "rocks", nil)
+        @ftp.send(:initialize, "localhost", "rubyspec", "rocks")
+      end
     end
 
-    it "tries to login with the passed username, password and account" do
-      @ftp.should_receive(:login).with("rubyspec", "rocks", "account")
-      @ftp.send(:initialize, "localhost", "rubyspec", "rocks", "account")
+    describe "when passed host, user" do
+      it "tries to connect to the passed host" do
+        @ftp.should_receive(:connect).with("localhost", *@port_args)
+        @ftp.send(:initialize, "localhost")
+      end
+
+      it "tries to login with the passed username, password and account" do
+        @ftp.should_receive(:login).with("rubyspec", "rocks", "account")
+        @ftp.send(:initialize, "localhost", "rubyspec", "rocks", "account")
+      end
     end
-  end
 
-  before :each do
-    @ftp.stub!(:login)
-  end
+    before :each do
+      @ftp.stub!(:login)
+    end
 
-  describe 'when the host' do
-    describe 'is set' do
-      describe 'and port option' do
-        describe 'is set' do
-          it 'tries to connect to the host on the specified port' do
-            options = mock('ftp initialize options')
-            options.should_receive(:to_hash).and_return({ port: 8080 })
-            @ftp.should_receive(:connect).with('localhost', 8080)
+    describe 'when the host' do
+      describe 'is set' do
+        describe 'and port option' do
+          describe 'is set' do
+            it 'tries to connect to the host on the specified port' do
+              options = mock('ftp initialize options')
+              options.should_receive(:to_hash).and_return({ port: 8080 })
+              @ftp.should_receive(:connect).with('localhost', 8080)
 
-            @ftp.send(:initialize, 'localhost', options)
+              @ftp.send(:initialize, 'localhost', options)
+            end
           end
-        end
 
-        describe 'is not set' do
-          it 'tries to connect to the host without a port' do
-            @ftp.should_receive(:connect).with("localhost", *@port_args)
+          describe 'is not set' do
+            it 'tries to connect to the host without a port' do
+              @ftp.should_receive(:connect).with("localhost", *@port_args)
 
-            @ftp.send(:initialize, 'localhost')
+              @ftp.send(:initialize, 'localhost')
+            end
           end
         end
-      end
 
-      describe 'when the username option' do
-        describe 'is set' do
-          describe 'and the password option' do
-            describe 'is set' do
-              describe 'and the account option' do
-                describe 'is set' do
-                  it 'tries to log in with the supplied parameters' do
-                    options = mock('ftp initialize options')
-                    options.should_receive(:to_hash).and_return({ username: 'a', password: 'topsecret', account: 'b' })
-                    @ftp.should_receive(:login).with('a', 'topsecret', 'b')
-
-                    @ftp.send(:initialize, 'localhost', options)
+        describe 'when the username option' do
+          describe 'is set' do
+            describe 'and the password option' do
+              describe 'is set' do
+                describe 'and the account option' do
+                  describe 'is set' do
+                    it 'tries to log in with the supplied parameters' do
+                      options = mock('ftp initialize options')
+                      options.should_receive(:to_hash).and_return({ username: 'a', password: 'topsecret', account: 'b' })
+                      @ftp.should_receive(:login).with('a', 'topsecret', 'b')
+
+                      @ftp.send(:initialize, 'localhost', options)
+                    end
                   end
-                end
 
-                describe 'is unset' do
-                  it 'tries to log in with the supplied parameters' do
-                    options = mock('ftp initialize options')
-                    options.should_receive(:to_hash).and_return({ username: 'a', password: 'topsecret' })
-                    @ftp.should_receive(:login).with('a', 'topsecret', nil)
+                  describe 'is unset' do
+                    it 'tries to log in with the supplied parameters' do
+                      options = mock('ftp initialize options')
+                      options.should_receive(:to_hash).and_return({ username: 'a', password: 'topsecret' })
+                      @ftp.should_receive(:login).with('a', 'topsecret', nil)
 
-                    @ftp.send(:initialize, 'localhost', options)
+                      @ftp.send(:initialize, 'localhost', options)
+                    end
                   end
                 end
               end
-            end
 
-            describe 'is unset' do
-              describe 'and the account option' do
-                describe 'is set' do
-                  it 'tries to log in with the supplied parameters' do
-                    options = mock('ftp initialize options')
-                    options.should_receive(:to_hash).and_return({ username: 'a', account: 'b' })
-                    @ftp.should_receive(:login).with('a', nil, 'b')
+              describe 'is unset' do
+                describe 'and the account option' do
+                  describe 'is set' do
+                    it 'tries to log in with the supplied parameters' do
+                      options = mock('ftp initialize options')
+                      options.should_receive(:to_hash).and_return({ username: 'a', account: 'b' })
+                      @ftp.should_receive(:login).with('a', nil, 'b')
 
-                    @ftp.send(:initialize, 'localhost', options)
+                      @ftp.send(:initialize, 'localhost', options)
+                    end
                   end
-                end
 
-                describe 'is unset' do
-                  it 'tries to log in with the supplied parameters' do
-                    options = mock('ftp initialize options')
-                    options.should_receive(:to_hash).and_return({ username: 'a'})
-                    @ftp.should_receive(:login).with('a', nil, nil)
+                  describe 'is unset' do
+                    it 'tries to log in with the supplied parameters' do
+                      options = mock('ftp initialize options')
+                      options.should_receive(:to_hash).and_return({ username: 'a'})
+                      @ftp.should_receive(:login).with('a', nil, nil)
 
-                    @ftp.send(:initialize, 'localhost', options)
+                      @ftp.send(:initialize, 'localhost', options)
+                    end
                   end
                 end
               end
             end
           end
-        end
 
-        describe 'is not set' do
-          it 'does not try to log in' do
-            options = mock('ftp initialize options')
-            options.should_receive(:to_hash).and_return({})
-            @ftp.should_not_receive(:login)
+          describe 'is not set' do
+            it 'does not try to log in' do
+              options = mock('ftp initialize options')
+              options.should_receive(:to_hash).and_return({})
+              @ftp.should_not_receive(:login)
 
-            @ftp.send(:initialize, 'localhost', options)
+              @ftp.send(:initialize, 'localhost', options)
+            end
           end
         end
       end
-    end
 
-    describe 'is unset' do
-      it 'does not try to connect' do
-        @ftp.should_not_receive(:connect)
+      describe 'is unset' do
+        it 'does not try to connect' do
+          @ftp.should_not_receive(:connect)
 
-        @ftp.send(:initialize)
-      end
+          @ftp.send(:initialize)
+        end
 
-      it 'does not try to log in' do
-        @ftp.should_not_receive(:login)
+        it 'does not try to log in' do
+          @ftp.should_not_receive(:login)
 
-        @ftp.send(:initialize)
+          @ftp.send(:initialize)
+        end
       end
     end
-  end
 
-  describe 'when the passive option' do
-    describe 'is set' do
-      describe 'to true' do
-        it 'sets passive to true' do
-          options = mock('ftp initialize options')
-          options.should_receive(:to_hash).and_return({ passive: true })
+    describe 'when the passive option' do
+      describe 'is set' do
+        describe 'to true' do
+          it 'sets passive to true' do
+            options = mock('ftp initialize options')
+            options.should_receive(:to_hash).and_return({ passive: true })
 
-          @ftp.send(:initialize, nil, options)
-          @ftp.passive.should == true
+            @ftp.send(:initialize, nil, options)
+            @ftp.passive.should == true
+          end
+        end
+
+        describe 'to false' do
+          it 'sets passive to false' do
+            options = mock('ftp initialize options')
+            options.should_receive(:to_hash).and_return({ passive: false })
+
+            @ftp.send(:initialize, nil, options)
+            @ftp.passive.should == false
+          end
         end
       end
 
-      describe 'to false' do
+      describe 'is unset' do
         it 'sets passive to false' do
-          options = mock('ftp initialize options')
-          options.should_receive(:to_hash).and_return({ passive: false })
-
-          @ftp.send(:initialize, nil, options)
+          @ftp.send(:initialize)
           @ftp.passive.should == false
         end
       end
     end
 
-    describe 'is unset' do
-      it 'sets passive to false' do
-        @ftp.send(:initialize)
-        @ftp.passive.should == false
-      end
-    end
-  end
+    describe 'when the debug_mode option' do
+      describe 'is set' do
+        describe 'to true' do
+          it 'sets debug_mode to true' do
+            options = mock('ftp initialize options')
+            options.should_receive(:to_hash).and_return({ debug_mode: true })
 
-  describe 'when the debug_mode option' do
-    describe 'is set' do
-      describe 'to true' do
-        it 'sets debug_mode to true' do
-          options = mock('ftp initialize options')
-          options.should_receive(:to_hash).and_return({ debug_mode: true })
+            @ftp.send(:initialize, nil, options)
+            @ftp.debug_mode.should == true
+          end
+        end
 
-          @ftp.send(:initialize, nil, options)
-          @ftp.debug_mode.should == true
+        describe 'to false' do
+          it 'sets debug_mode to false' do
+            options = mock('ftp initialize options')
+            options.should_receive(:to_hash).and_return({ debug_mode: false })
+
+            @ftp.send(:initialize, nil, options)
+            @ftp.debug_mode.should == false
+          end
         end
       end
 
-      describe 'to false' do
+      describe 'is unset' do
         it 'sets debug_mode to false' do
-          options = mock('ftp initialize options')
-          options.should_receive(:to_hash).and_return({ debug_mode: false })
-
-          @ftp.send(:initialize, nil, options)
+          @ftp.send(:initialize)
           @ftp.debug_mode.should == false
         end
       end
     end
 
-    describe 'is unset' do
-      it 'sets debug_mode to false' do
-        @ftp.send(:initialize)
-        @ftp.debug_mode.should == false
-      end
-    end
-  end
-
-  describe 'when the open_timeout option' do
-    describe 'is set' do
-      it 'sets open_timeout to the specified value' do
-        options = mock('ftp initialize options')
-        options.should_receive(:to_hash).and_return({ open_timeout: 42 })
+    describe 'when the open_timeout option' do
+      describe 'is set' do
+        it 'sets open_timeout to the specified value' do
+          options = mock('ftp initialize options')
+          options.should_receive(:to_hash).and_return({ open_timeout: 42 })
 
-        @ftp.send(:initialize, nil, options)
-        @ftp.open_timeout.should == 42
+          @ftp.send(:initialize, nil, options)
+          @ftp.open_timeout.should == 42
+        end
       end
-    end
 
-    describe 'is not set' do
-      it 'sets open_timeout to nil' do
-        @ftp.send(:initialize)
-        @ftp.open_timeout.should == nil
+      describe 'is not set' do
+        it 'sets open_timeout to nil' do
+          @ftp.send(:initialize)
+          @ftp.open_timeout.should == nil
+        end
       end
     end
-  end
 
-  describe 'when the read_timeout option' do
-    describe 'is set' do
-      it 'sets read_timeout to the specified value' do
-        options = mock('ftp initialize options')
-        options.should_receive(:to_hash).and_return({ read_timeout: 100 })
+    describe 'when the read_timeout option' do
+      describe 'is set' do
+        it 'sets read_timeout to the specified value' do
+          options = mock('ftp initialize options')
+          options.should_receive(:to_hash).and_return({ read_timeout: 100 })
 
-        @ftp.send(:initialize, nil, options)
-        @ftp.read_timeout.should == 100
+          @ftp.send(:initialize, nil, options)
+          @ftp.read_timeout.should == 100
+        end
       end
-    end
 
-    describe 'is not set' do
-      it 'sets read_timeout to the default value' do
-        @ftp.send(:initialize)
-        @ftp.read_timeout.should == 60
+      describe 'is not set' do
+        it 'sets read_timeout to the default value' do
+          @ftp.send(:initialize)
+          @ftp.read_timeout.should == 60
+        end
       end
     end
-  end
 
-  describe 'when the ssl_handshake_timeout option' do
-    describe 'is set' do
-      it 'sets ssl_handshake_timeout to the specified value' do
-        options = mock('ftp initialize options')
-        options.should_receive(:to_hash).and_return({ ssl_handshake_timeout: 23 })
+    describe 'when the ssl_handshake_timeout option' do
+      describe 'is set' do
+        it 'sets ssl_handshake_timeout to the specified value' do
+          options = mock('ftp initialize options')
+          options.should_receive(:to_hash).and_return({ ssl_handshake_timeout: 23 })
 
-        @ftp.send(:initialize, nil, options)
-        @ftp.ssl_handshake_timeout.should == 23
+          @ftp.send(:initialize, nil, options)
+          @ftp.ssl_handshake_timeout.should == 23
+        end
       end
-    end
 
-    describe 'is not set' do
-      it 'sets ssl_handshake_timeout to nil' do
-        @ftp.send(:initialize)
-        @ftp.ssl_handshake_timeout.should == nil
+      describe 'is not set' do
+        it 'sets ssl_handshake_timeout to nil' do
+          @ftp.send(:initialize)
+          @ftp.ssl_handshake_timeout.should == nil
+        end
       end
     end
-  end
 
-  describe 'when the ssl option' do
-    describe 'is set' do
-      describe "and the ssl option's value is true" do
-        it 'initializes ssl_context to a blank SSLContext object' do
-          options = mock('ftp initialize options')
-          options.should_receive(:to_hash).and_return({ ssl: true })
+    describe 'when the ssl option' do
+      describe 'is set' do
+        describe "and the ssl option's value is true" do
+          it 'initializes ssl_context to a blank SSLContext object' do
+            options = mock('ftp initialize options')
+            options.should_receive(:to_hash).and_return({ ssl: true })
 
-          ssl_context = OpenSSL::SSL::SSLContext.allocate
-          ssl_context.stub!(:set_params)
+            ssl_context = OpenSSL::SSL::SSLContext.allocate
+            ssl_context.stub!(:set_params)
 
-          OpenSSL::SSL::SSLContext.should_receive(:new).and_return(ssl_context)
-          ssl_context.should_receive(:set_params).with({})
+            OpenSSL::SSL::SSLContext.should_receive(:new).and_return(ssl_context)
+            ssl_context.should_receive(:set_params).with({})
 
-          @ftp.send(:initialize, nil, options)
-          @ftp.instance_variable_get(:@ssl_context).should == ssl_context
+            @ftp.send(:initialize, nil, options)
+            @ftp.instance_variable_get(:@ssl_context).should == ssl_context
+          end
         end
-      end
 
-      describe "and the ssl option's value is a hash" do
-        it 'initializes ssl_context to a configured SSLContext object' do
-          options = mock('ftp initialize options')
-          options.should_receive(:to_hash).and_return({ ssl: {key: 'value'} })
+        describe "and the ssl option's value is a hash" do
+          it 'initializes ssl_context to a configured SSLContext object' do
+            options = mock('ftp initialize options')
+            options.should_receive(:to_hash).and_return({ ssl: {key: 'value'} })
 
-          ssl_context = OpenSSL::SSL::SSLContext.allocate
-          ssl_context.stub!(:set_params)
+            ssl_context = OpenSSL::SSL::SSLContext.allocate
+            ssl_context.stub!(:set_params)
 
-          OpenSSL::SSL::SSLContext.should_receive(:new).and_return(ssl_context)
-          ssl_context.should_receive(:set_params).with({key: 'value'})
+            OpenSSL::SSL::SSLContext.should_receive(:new).and_return(ssl_context)
+            ssl_context.should_receive(:set_params).with({key: 'value'})
 
-          @ftp.send(:initialize, nil, options)
-          @ftp.instance_variable_get(:@ssl_context).should == ssl_context
+            @ftp.send(:initialize, nil, options)
+            @ftp.instance_variable_get(:@ssl_context).should == ssl_context
+          end
         end
-      end
 
-      describe 'and private_data_connection' do
-        describe 'is set' do
-          it 'sets private_data_connection to that value' do
-            options = mock('ftp initialize options')
-            options.should_receive(:to_hash).and_return({ ssl: true, private_data_connection: 'true' })
+        describe 'and private_data_connection' do
+          describe 'is set' do
+            it 'sets private_data_connection to that value' do
+              options = mock('ftp initialize options')
+              options.should_receive(:to_hash).and_return({ ssl: true, private_data_connection: 'true' })
 
-            @ftp.send(:initialize, nil, options)
-            @ftp.instance_variable_get(:@private_data_connection).should == 'true'
+              @ftp.send(:initialize, nil, options)
+              @ftp.instance_variable_get(:@private_data_connection).should == 'true'
+            end
           end
-        end
 
-        describe 'is not set' do
-          it 'sets private_data_connection to nil' do
-            options = mock('ftp initialize options')
-            options.should_receive(:to_hash).and_return({ ssl: true })
+          describe 'is not set' do
+            it 'sets private_data_connection to nil' do
+              options = mock('ftp initialize options')
+              options.should_receive(:to_hash).and_return({ ssl: true })
 
-            @ftp.send(:initialize, nil, options)
-            @ftp.instance_variable_get(:@private_data_connection).should == true
+              @ftp.send(:initialize, nil, options)
+              @ftp.instance_variable_get(:@private_data_connection).should == true
+            end
           end
         end
       end
-    end
 
-    describe 'is not set' do
-      it 'sets ssl_context to nil' do
-        options = mock('ftp initialize options')
-        options.should_receive(:to_hash).and_return({})
+      describe 'is not set' do
+        it 'sets ssl_context to nil' do
+          options = mock('ftp initialize options')
+          options.should_receive(:to_hash).and_return({})
 
-        @ftp.send(:initialize, nil, options)
-        @ftp.instance_variable_get(:@ssl_context).should == nil
-      end
+          @ftp.send(:initialize, nil, options)
+          @ftp.instance_variable_get(:@ssl_context).should == nil
+        end
 
-      describe 'private_data_connection' do
-        describe 'is set' do
-          it 'raises an ArgumentError' do
-            options = mock('ftp initialize options')
-            options.should_receive(:to_hash).and_return({ private_data_connection: true })
+        describe 'private_data_connection' do
+          describe 'is set' do
+            it 'raises an ArgumentError' do
+              options = mock('ftp initialize options')
+              options.should_receive(:to_hash).and_return({ private_data_connection: true })
 
-            -> {
-              @ftp.send(:initialize, nil, options)
-            }.should raise_error(ArgumentError, /private_data_connection can be set to true only when ssl is enabled/)
+              -> {
+                @ftp.send(:initialize, nil, options)
+              }.should raise_error(ArgumentError, /private_data_connection can be set to true only when ssl is enabled/)
+            end
           end
-        end
 
-        describe 'is not set' do
-          it 'sets private_data_connection to false' do
-            options = mock('ftp initialize options')
-            options.should_receive(:to_hash).and_return({})
+          describe 'is not set' do
+            it 'sets private_data_connection to false' do
+              options = mock('ftp initialize options')
+              options.should_receive(:to_hash).and_return({})
 
-            @ftp.send(:initialize, nil, options)
-            @ftp.instance_variable_get(:@private_data_connection).should == false
+              @ftp.send(:initialize, nil, options)
+              @ftp.instance_variable_get(:@private_data_connection).should == false
+            end
           end
         end
       end
diff --git a/spec/ruby/library/net-ftp/last_response_code_spec.rb b/spec/ruby/library/net-ftp/last_response_code_spec.rb
index c17c28f0f8..03329758b5 100644
--- a/spec/ruby/library/net-ftp/last_response_code_spec.rb
+++ b/spec/ruby/library/net-ftp/last_response_code_spec.rb
@@ -1,8 +1,11 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'shared/last_response_code'
-require_relative 'fixtures/server'
 
-describe "Net::FTP#last_response_code" do
-  it_behaves_like :net_ftp_last_response_code, :last_response_code
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'shared/last_response_code'
+  require_relative 'fixtures/server'
+
+  describe "Net::FTP#last_response_code" do
+    it_behaves_like :net_ftp_last_response_code, :last_response_code
+  end
 end
diff --git a/spec/ruby/library/net-ftp/last_response_spec.rb b/spec/ruby/library/net-ftp/last_response_spec.rb
index c9d9d70f35..7cda9fa7a4 100644
--- a/spec/ruby/library/net-ftp/last_response_spec.rb
+++ b/spec/ruby/library/net-ftp/last_response_spec.rb
@@ -1,25 +1,28 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
 
-describe "Net::FTP#last_response" do
-  before :each do
-    @server = NetFTPSpecs::DummyFTP.new
-    @server.serve_once
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
 
-    @ftp = Net::FTP.new
-    @ftp.connect(@server.hostname, @server.server_port)
-  end
+  describe "Net::FTP#last_response" do
+    before :each do
+      @server = NetFTPSpecs::DummyFTP.new
+      @server.serve_once
 
-  after :each do
-    @ftp.quit rescue nil
-    @ftp.close
-    @server.stop
-  end
+      @ftp = Net::FTP.new
+      @ftp.connect(@server.hostname, @server.server_port)
+    end
+
+    after :each do
+      @ftp.quit rescue nil
+      @ftp.close
+      @server.stop
+    end
 
-  it "returns the last response" do
-    @ftp.last_response.should == "220 Dummy FTP Server ready!\n"
-    @ftp.help
-    @ftp.last_response.should == "211 System status, or system help reply. (HELP)\n"
+    it "returns the last response" do
+      @ftp.last_response.should == "220 Dummy FTP Server ready!\n"
+      @ftp.help
+      @ftp.last_response.should == "211 System status, or system help reply. (HELP)\n"
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/lastresp_spec.rb b/spec/ruby/library/net-ftp/lastresp_spec.rb
index e0c1b862a0..c373670ec4 100644
--- a/spec/ruby/library/net-ftp/lastresp_spec.rb
+++ b/spec/ruby/library/net-ftp/lastresp_spec.rb
@@ -1,8 +1,11 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'shared/last_response_code'
-require_relative 'fixtures/server'
 
-describe "Net::FTP#lastresp" do
-  it_behaves_like :net_ftp_last_response_code, :lastresp
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'shared/last_response_code'
+  require_relative 'fixtures/server'
+
+  describe "Net::FTP#lastresp" do
+    it_behaves_like :net_ftp_last_response_code, :lastresp
+  end
 end
diff --git a/spec/ruby/library/net-ftp/list_spec.rb b/spec/ruby/library/net-ftp/list_spec.rb
index 6cb1bbc4b8..297d100dd9 100644
--- a/spec/ruby/library/net-ftp/list_spec.rb
+++ b/spec/ruby/library/net-ftp/list_spec.rb
@@ -1,8 +1,11 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
-require_relative 'shared/list'
 
-describe "Net::FTP#list" do
-  it_behaves_like :net_ftp_list, :list
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
+  require_relative 'shared/list'
+
+  describe "Net::FTP#list" do
+    it_behaves_like :net_ftp_list, :list
+  end
 end
diff --git a/spec/ruby/library/net-ftp/login_spec.rb b/spec/ruby/library/net-ftp/login_spec.rb
index 0de2f5cc63..0959bbb191 100644
--- a/spec/ruby/library/net-ftp/login_spec.rb
+++ b/spec/ruby/library/net-ftp/login_spec.rb
@@ -1,195 +1,198 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
 
-describe "Net::FTP#login" do
-  before :each do
-    @server = NetFTPSpecs::DummyFTP.new
-    @server.serve_once
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
 
-    @ftp = Net::FTP.new
-    @ftp.connect(@server.hostname, @server.server_port)
-  end
-
-  after :each do
-    @ftp.quit rescue nil
-    @ftp.close
-    @server.stop
-  end
-
-  describe "when passed no arguments" do
-    it "sends the USER command with 'anonymous' as name to the server" do
-      @ftp.login
-      @server.login_user.should == "anonymous"
-    end
-
-    it "sends 'anonymous@' as a password when required" do
-      @server.should_receive(:user).and_respond("331 User name okay, need password.")
-      @ftp.login
-      @server.login_pass.should == "anonymous@"
-    end
-
-    it "raises a Net::FTPReplyError when the server requests an account" do
-      @server.should_receive(:user).and_respond("331 User name okay, need password.")
-      @server.should_receive(:pass).and_respond("332 Need account for login.")
-      -> { @ftp.login }.should raise_error(Net::FTPReplyError)
-    end
-  end
-
-  describe "when passed name" do
-    it "sends the USER command with the passed name to the server" do
-      @ftp.login("rubyspec")
-      @server.login_user.should == "rubyspec"
-    end
-
-    it "raises a Net::FTPReplyError when the server requests a password, but none was given" do
-      @server.should_receive(:user).and_respond("331 User name okay, need password.")
-      -> { @ftp.login("rubyspec") }.should raise_error(Net::FTPReplyError)
-    end
-
-    it "raises a Net::FTPReplyError when the server requests an account, but none was given" do
-      @server.should_receive(:user).and_respond("331 User name okay, need password.")
-      @server.should_receive(:pass).and_respond("332 Need account for login.")
-      -> { @ftp.login("rubyspec") }.should raise_error(Net::FTPReplyError)
-    end
-  end
-
-  describe "when passed name, password" do
-    it "sends the USER command with the passed name to the server" do
-      @ftp.login("rubyspec", "rocks")
-      @server.login_user.should == "rubyspec"
-    end
-
-    it "sends the passed password when required" do
-      @server.should_receive(:user).and_respond("331 User name okay, need password.")
-      @ftp.login("rubyspec", "rocks")
-      @server.login_pass.should == "rocks"
-    end
-
-    it "raises a Net::FTPReplyError when the server requests an account" do
-      @server.should_receive(:user).and_respond("331 User name okay, need password.")
-      @server.should_receive(:pass).and_respond("332 Need account for login.")
-      -> { @ftp.login("rubyspec", "rocks") }.should raise_error(Net::FTPReplyError)
-    end
-  end
-
-  describe "when passed name, password, account" do
-    it "sends the USER command with the passed name to the server" do
-      @ftp.login("rubyspec", "rocks", "account")
-      @server.login_user.should == "rubyspec"
-    end
-
-    it "sends the passed password when required" do
-      @server.should_receive(:user).and_respond("331 User name okay, need password.")
-      @ftp.login("rubyspec", "rocks", "account")
-      @server.login_pass.should == "rocks"
-    end
-
-    it "sends the passed account when required" do
-      @server.should_receive(:user).and_respond("331 User name okay, need password.")
-      @server.should_receive(:pass).and_respond("332 Need account for login.")
-      @ftp.login("rubyspec", "rocks", "account")
-      @server.login_acct.should == "account"
-    end
-  end
-
-  describe "when the USER command fails" do
-    it "raises a Net::FTPPermError when the response code is 500" do
-      @server.should_receive(:user).and_respond("500 Syntax error, command unrecognized.")
-      -> { @ftp.login("rubyspec", "rocks", "account") }.should raise_error(Net::FTPPermError)
-    end
-
-    it "raises a Net::FTPPermError when the response code is 501" do
-      @server.should_receive(:user).and_respond("501 Syntax error in parameters or arguments.")
-      -> { @ftp.login("rubyspec", "rocks", "account") }.should raise_error(Net::FTPPermError)
-    end
-
-    it "raises a Net::FTPPermError when the response code is 502" do
-      @server.should_receive(:user).and_respond("502 Command not implemented.")
-      -> { @ftp.login("rubyspec", "rocks", "account") }.should raise_error(Net::FTPPermError)
-    end
-
-    it "raises a Net::FTPTempError when the response code is 421" do
-      @server.should_receive(:user).and_respond("421 Service not available, closing control connection.")
-      -> { @ftp.login("rubyspec", "rocks", "account") }.should raise_error(Net::FTPTempError)
-    end
-
-    it "raises a Net::FTPPermError when the response code is 530" do
-      @server.should_receive(:user).and_respond("530 Not logged in.")
-      -> { @ftp.login("rubyspec", "rocks", "account") }.should raise_error(Net::FTPPermError)
-    end
-  end
-
-  describe "when the PASS command fails" do
+  describe "Net::FTP#login" do
     before :each do
-      @server.should_receive(:user).and_respond("331 User name okay, need password.")
-    end
-
-    it "does not raise an Error when the response code is 202" do
-      @server.should_receive(:pass).and_respond("202 Command not implemented, superfluous at this site.")
-      -> { @ftp.login("rubyspec", "rocks", "account") }.should_not raise_error
-    end
-
-    it "raises a Net::FTPPermError when the response code is 500" do
-      @server.should_receive(:pass).and_respond("500 Syntax error, command unrecognized.")
-      -> { @ftp.login("rubyspec", "rocks", "account") }.should raise_error(Net::FTPPermError)
-    end
-
-    it "raises a Net::FTPPermError when the response code is 501" do
-      @server.should_receive(:pass).and_respond("501 Syntax error in parameters or arguments.")
-      -> { @ftp.login("rubyspec", "rocks", "account") }.should raise_error(Net::FTPPermError)
-    end
-
-    it "raises a Net::FTPPermError when the response code is 502" do
-      @server.should_receive(:pass).and_respond("502 Command not implemented.")
-      -> { @ftp.login("rubyspec", "rocks", "account") }.should raise_error(Net::FTPPermError)
-    end
-
-    it "raises a Net::FTPTempError when the response code is 421" do
-      @server.should_receive(:pass).and_respond("421 Service not available, closing control connection.")
-      -> { @ftp.login("rubyspec", "rocks", "account") }.should raise_error(Net::FTPTempError)
-    end
-
-    it "raises a Net::FTPPermError when the response code is 530" do
-      @server.should_receive(:pass).and_respond("530 Not logged in.")
-      -> { @ftp.login("rubyspec", "rocks", "account") }.should raise_error(Net::FTPPermError)
-    end
-  end
-
-  describe "when the ACCT command fails" do
-    before :each do
-      @server.should_receive(:user).and_respond("331 User name okay, need password.")
-      @server.should_receive(:pass).and_respond("332 Need account for login.")
-    end
-
-    it "does not raise an Error when the response code is 202" do
-      @server.should_receive(:acct).and_respond("202 Command not implemented, superfluous at this site.")
-      -> { @ftp.login("rubyspec", "rocks", "account") }.should_not raise_error
-    end
-
-    it "raises a Net::FTPPermError when the response code is 500" do
-      @server.should_receive(:acct).and_respond("500 Syntax error, command unrecognized.")
-      -> { @ftp.login("rubyspec", "rocks", "account") }.should raise_error(Net::FTPPermError)
-    end
-
-    it "raises a Net::FTPPermError when the response code is 501" do
-      @server.should_receive(:acct).and_respond("501 Syntax error in parameters or arguments.")
-      -> { @ftp.login("rubyspec", "rocks", "account") }.should raise_error(Net::FTPPermError)
-    end
-
-    it "raises a Net::FTPPermError when the response code is 502" do
-      @server.should_receive(:acct).and_respond("502 Command not implemented.")
-      -> { @ftp.login("rubyspec", "rocks", "account") }.should raise_error(Net::FTPPermError)
-    end
-
-    it "raises a Net::FTPTempError when the response code is 421" do
-      @server.should_receive(:acct).and_respond("421 Service not available, closing control connection.")
-      -> { @ftp.login("rubyspec", "rocks", "account") }.should raise_error(Net::FTPTempError)
-    end
-
-    it "raises a Net::FTPPermError when the response code is 530" do
-      @server.should_receive(:acct).and_respond("530 Not logged in.")
-      -> { @ftp.login("rubyspec", "rocks", "account") }.should raise_error(Net::FTPPermError)
+      @server = NetFTPSpecs::DummyFTP.new
+      @server.serve_once
+
+      @ftp = Net::FTP.new
+      @ftp.connect(@server.hostname, @server.server_port)
+    end
+
+    after :each do
+      @ftp.quit rescue nil
+      @ftp.close
+      @server.stop
+    end
+
+    describe "when passed no arguments" do
+      it "sends the USER command with 'anonymous' as name to the server" do
+        @ftp.login
+        @server.login_user.should == "anonymous"
+      end
+
+      it "sends 'anonymous@' as a password when required" do
+        @server.should_receive(:user).and_respond("331 User name okay, need password.")
+        @ftp.login
+        @server.login_pass.should == "anonymous@"
+      end
+
+      it "raises a Net::FTPReplyError when the server requests an account" do
+        @server.should_receive(:user).and_respond("331 User name okay, need password.")
+        @server.should_receive(:pass).and_respond("332 Need account for login.")
+        -> { @ftp.login }.should raise_error(Net::FTPReplyError)
+      end
+    end
+
+    describe "when passed name" do
+      it "sends the USER command with the passed name to the server" do
+        @ftp.login("rubyspec")
+        @server.login_user.should == "rubyspec"
+      end
+
+      it "raises a Net::FTPReplyError when the server requests a password, but none was given" do
+        @server.should_receive(:user).and_respond("331 User name okay, need password.")
+        -> { @ftp.login("rubyspec") }.should raise_error(Net::FTPReplyError)
+      end
+
+      it "raises a Net::FTPReplyError when the server requests an account, but none was given" do
+        @server.should_receive(:user).and_respond("331 User name okay, need password.")
+        @server.should_receive(:pass).and_respond("332 Need account for login.")
+        -> { @ftp.login("rubyspec") }.should raise_error(Net::FTPReplyError)
+      end
+    end
+
+    describe "when passed name, password" do
+      it "sends the USER command with the passed name to the server" do
+        @ftp.login("rubyspec", "rocks")
+        @server.login_user.should == "rubyspec"
+      end
+
+      it "sends the passed password when required" do
+        @server.should_receive(:user).and_respond("331 User name okay, need password.")
+        @ftp.login("rubyspec", "rocks")
+        @server.login_pass.should == "rocks"
+      end
+
+      it "raises a Net::FTPReplyError when the server requests an account" do
+        @server.should_receive(:user).and_respond("331 User name okay, need password.")
+        @server.should_receive(:pass).and_respond("332 Need account for login.")
+        -> { @ftp.login("rubyspec", "rocks") }.should raise_error(Net::FTPReplyError)
+      end
+    end
+
+    describe "when passed name, password, account" do
+      it "sends the USER command with the passed name to the server" do
+        @ftp.login("rubyspec", "rocks", "account")
+        @server.login_user.should == "rubyspec"
+      end
+
+      it "sends the passed password when required" do
+        @server.should_receive(:user).and_respond("331 User name okay, need password.")
+        @ftp.login("rubyspec", "rocks", "account")
+        @server.login_pass.should == "rocks"
+      end
+
+      it "sends the passed account when required" do
+        @server.should_receive(:user).and_respond("331 User name okay, need password.")
+        @server.should_receive(:pass).and_respond("332 Need account for login.")
+        @ftp.login("rubyspec", "rocks", "account")
+        @server.login_acct.should == "account"
+      end
+    end
+
+    describe "when the USER command fails" do
+      it "raises a Net::FTPPermError when the response code is 500" do
+        @server.should_receive(:user).and_respond("500 Syntax error, command unrecognized.")
+        -> { @ftp.login("rubyspec", "rocks", "account") }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 501" do
+        @server.should_receive(:user).and_respond("501 Syntax error in parameters or arguments.")
+        -> { @ftp.login("rubyspec", "rocks", "account") }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 502" do
+        @server.should_receive(:user).and_respond("502 Command not implemented.")
+        -> { @ftp.login("rubyspec", "rocks", "account") }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPTempError when the response code is 421" do
+        @server.should_receive(:user).and_respond("421 Service not available, closing control connection.")
+        -> { @ftp.login("rubyspec", "rocks", "account") }.should raise_error(Net::FTPTempError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 530" do
+        @server.should_receive(:user).and_respond("530 Not logged in.")
+        -> { @ftp.login("rubyspec", "rocks", "account") }.should raise_error(Net::FTPPermError)
+      end
+    end
+
+    describe "when the PASS command fails" do
+      before :each do
+        @server.should_receive(:user).and_respond("331 User name okay, need password.")
+      end
+
+      it "does not raise an Error when the response code is 202" do
+        @server.should_receive(:pass).and_respond("202 Command not implemented, superfluous at this site.")
+        -> { @ftp.login("rubyspec", "rocks", "account") }.should_not raise_error
+      end
+
+      it "raises a Net::FTPPermError when the response code is 500" do
+        @server.should_receive(:pass).and_respond("500 Syntax error, command unrecognized.")
+        -> { @ftp.login("rubyspec", "rocks", "account") }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 501" do
+        @server.should_receive(:pass).and_respond("501 Syntax error in parameters or arguments.")
+        -> { @ftp.login("rubyspec", "rocks", "account") }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 502" do
+        @server.should_receive(:pass).and_respond("502 Command not implemented.")
+        -> { @ftp.login("rubyspec", "rocks", "account") }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPTempError when the response code is 421" do
+        @server.should_receive(:pass).and_respond("421 Service not available, closing control connection.")
+        -> { @ftp.login("rubyspec", "rocks", "account") }.should raise_error(Net::FTPTempError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 530" do
+        @server.should_receive(:pass).and_respond("530 Not logged in.")
+        -> { @ftp.login("rubyspec", "rocks", "account") }.should raise_error(Net::FTPPermError)
+      end
+    end
+
+    describe "when the ACCT command fails" do
+      before :each do
+        @server.should_receive(:user).and_respond("331 User name okay, need password.")
+        @server.should_receive(:pass).and_respond("332 Need account for login.")
+      end
+
+      it "does not raise an Error when the response code is 202" do
+        @server.should_receive(:acct).and_respond("202 Command not implemented, superfluous at this site.")
+        -> { @ftp.login("rubyspec", "rocks", "account") }.should_not raise_error
+      end
+
+      it "raises a Net::FTPPermError when the response code is 500" do
+        @server.should_receive(:acct).and_respond("500 Syntax error, command unrecognized.")
+        -> { @ftp.login("rubyspec", "rocks", "account") }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 501" do
+        @server.should_receive(:acct).and_respond("501 Syntax error in parameters or arguments.")
+        -> { @ftp.login("rubyspec", "rocks", "account") }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 502" do
+        @server.should_receive(:acct).and_respond("502 Command not implemented.")
+        -> { @ftp.login("rubyspec", "rocks", "account") }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPTempError when the response code is 421" do
+        @server.should_receive(:acct).and_respond("421 Service not available, closing control connection.")
+        -> { @ftp.login("rubyspec", "rocks", "account") }.should raise_error(Net::FTPTempError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 530" do
+        @server.should_receive(:acct).and_respond("530 Not logged in.")
+        -> { @ftp.login("rubyspec", "rocks", "account") }.should raise_error(Net::FTPPermError)
+      end
     end
   end
 end
diff --git a/spec/ruby/library/net-ftp/ls_spec.rb b/spec/ruby/library/net-ftp/ls_spec.rb
index acd7e9e523..f8fdb10e8f 100644
--- a/spec/ruby/library/net-ftp/ls_spec.rb
+++ b/spec/ruby/library/net-ftp/ls_spec.rb
@@ -1,8 +1,11 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
-require_relative 'shared/list'
 
-describe "Net::FTP#ls" do
-  it_behaves_like :net_ftp_list, :ls
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
+  require_relative 'shared/list'
+
+  describe "Net::FTP#ls" do
+    it_behaves_like :net_ftp_list, :ls
+  end
 end
diff --git a/spec/ruby/library/net-ftp/mdtm_spec.rb b/spec/ruby/library/net-ftp/mdtm_spec.rb
index a504507c84..4334833215 100644
--- a/spec/ruby/library/net-ftp/mdtm_spec.rb
+++ b/spec/ruby/library/net-ftp/mdtm_spec.rb
@@ -1,38 +1,41 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
 
-describe "Net::FTP#mdtm" do
-  before :each do
-    @server = NetFTPSpecs::DummyFTP.new
-    @server.serve_once
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
 
-    @ftp = Net::FTP.new
-    @ftp.connect(@server.hostname, @server.server_port)
-  end
+  describe "Net::FTP#mdtm" do
+    before :each do
+      @server = NetFTPSpecs::DummyFTP.new
+      @server.serve_once
 
-  after :each do
-    @ftp.quit rescue nil
-    @ftp.close
-    @server.stop
-  end
+      @ftp = Net::FTP.new
+      @ftp.connect(@server.hostname, @server.server_port)
+    end
 
-  it "sends the MDTM with the passed filename command to the server" do
-    @ftp.mdtm("test.file")
-    @ftp.last_response.should == "213 19980705132316\n"
-  end
+    after :each do
+      @ftp.quit rescue nil
+      @ftp.close
+      @server.stop
+    end
 
-  it "returns the last modification time of the passed file" do
-    @ftp.mdtm("test.file").should == "19980705132316"
-  end
+    it "sends the MDTM with the passed filename command to the server" do
+      @ftp.mdtm("test.file")
+      @ftp.last_response.should == "213 19980705132316\n"
+    end
 
-  it "raises a Net::FTPPermError when the response code is 550" do
-    @server.should_receive(:mdtm).and_respond("550 Requested action not taken.")
-    -> { @ftp.mdtm("test.file") }.should raise_error(Net::FTPPermError)
-  end
+    it "returns the last modification time of the passed file" do
+      @ftp.mdtm("test.file").should == "19980705132316"
+    end
+
+    it "raises a Net::FTPPermError when the response code is 550" do
+      @server.should_receive(:mdtm).and_respond("550 Requested action not taken.")
+      -> { @ftp.mdtm("test.file") }.should raise_error(Net::FTPPermError)
+    end
 
-  it "raises a Net::FTPTempError when the response code is 421" do
-    @server.should_receive(:mdtm).and_respond("421 Service not available, closing control connection.")
-    -> { @ftp.mdtm("test.file") }.should raise_error(Net::FTPTempError)
+    it "raises a Net::FTPTempError when the response code is 421" do
+      @server.should_receive(:mdtm).and_respond("421 Service not available, closing control connection.")
+      -> { @ftp.mdtm("test.file") }.should raise_error(Net::FTPTempError)
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/mkdir_spec.rb b/spec/ruby/library/net-ftp/mkdir_spec.rb
index 8cc6ae785e..9fdaa62ae3 100644
--- a/spec/ruby/library/net-ftp/mkdir_spec.rb
+++ b/spec/ruby/library/net-ftp/mkdir_spec.rb
@@ -1,61 +1,64 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
 
-describe "Net::FTP#mkdir" do
-  before :each do
-    @server = NetFTPSpecs::DummyFTP.new
-    @server.serve_once
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
 
-    @ftp = Net::FTP.new
-    @ftp.connect(@server.hostname, @server.server_port)
-  end
+  describe "Net::FTP#mkdir" do
+    before :each do
+      @server = NetFTPSpecs::DummyFTP.new
+      @server.serve_once
 
-  after :each do
-    @ftp.quit rescue nil
-    @ftp.close
-    @server.stop
-  end
+      @ftp = Net::FTP.new
+      @ftp.connect(@server.hostname, @server.server_port)
+    end
 
-  it "sends the MKD command with the passed pathname to the server" do
-    @ftp.mkdir("test.folder")
-    @ftp.last_response.should == %{257 "test.folder" created.\n}
-  end
+    after :each do
+      @ftp.quit rescue nil
+      @ftp.close
+      @server.stop
+    end
 
-  it "returns the path to the newly created directory" do
-    @ftp.mkdir("test.folder").should == "test.folder"
-    @ftp.mkdir("/absolute/path/to/test.folder").should == "/absolute/path/to/test.folder"
-    @ftp.mkdir("relative/path/to/test.folder").should == "relative/path/to/test.folder"
-    @ftp.mkdir('/usr/dm/foo"bar').should == '/usr/dm/foo"bar'
-  end
+    it "sends the MKD command with the passed pathname to the server" do
+      @ftp.mkdir("test.folder")
+      @ftp.last_response.should == %{257 "test.folder" created.\n}
+    end
 
-  it "raises a Net::FTPPermError when the response code is 500" do
-    @server.should_receive(:mkd).and_respond("500 Syntax error, command unrecognized.")
-    -> { @ftp.mkdir("test.folder") }.should raise_error(Net::FTPPermError)
-  end
+    it "returns the path to the newly created directory" do
+      @ftp.mkdir("test.folder").should == "test.folder"
+      @ftp.mkdir("/absolute/path/to/test.folder").should == "/absolute/path/to/test.folder"
+      @ftp.mkdir("relative/path/to/test.folder").should == "relative/path/to/test.folder"
+      @ftp.mkdir('/usr/dm/foo"bar').should == '/usr/dm/foo"bar'
+    end
 
-  it "raises a Net::FTPPermError when the response code is 501" do
-    @server.should_receive(:mkd).and_respond("501 Syntax error in parameters or arguments.")
-    -> { @ftp.mkdir("test.folder") }.should raise_error(Net::FTPPermError)
-  end
+    it "raises a Net::FTPPermError when the response code is 500" do
+      @server.should_receive(:mkd).and_respond("500 Syntax error, command unrecognized.")
+      -> { @ftp.mkdir("test.folder") }.should raise_error(Net::FTPPermError)
+    end
 
-  it "raises a Net::FTPPermError when the response code is 502" do
-    @server.should_receive(:mkd).and_respond("502 Command not implemented.")
-    -> { @ftp.mkdir("test.folder") }.should raise_error(Net::FTPPermError)
-  end
+    it "raises a Net::FTPPermError when the response code is 501" do
+      @server.should_receive(:mkd).and_respond("501 Syntax error in parameters or arguments.")
+      -> { @ftp.mkdir("test.folder") }.should raise_error(Net::FTPPermError)
+    end
 
-  it "raises a Net::FTPTempError when the response code is 421" do
-    @server.should_receive(:mkd).and_respond("421 Service not available, closing control connection.")
-    -> { @ftp.mkdir("test.folder") }.should raise_error(Net::FTPTempError)
-  end
+    it "raises a Net::FTPPermError when the response code is 502" do
+      @server.should_receive(:mkd).and_respond("502 Command not implemented.")
+      -> { @ftp.mkdir("test.folder") }.should raise_error(Net::FTPPermError)
+    end
 
-  it "raises a Net::FTPPermError when the response code is 530" do
-    @server.should_receive(:mkd).and_respond("530 Not logged in.")
-    -> { @ftp.mkdir("test.folder") }.should raise_error(Net::FTPPermError)
-  end
+    it "raises a Net::FTPTempError when the response code is 421" do
+      @server.should_receive(:mkd).and_respond("421 Service not available, closing control connection.")
+      -> { @ftp.mkdir("test.folder") }.should raise_error(Net::FTPTempError)
+    end
+
+    it "raises a Net::FTPPermError when the response code is 530" do
+      @server.should_receive(:mkd).and_respond("530 Not logged in.")
+      -> { @ftp.mkdir("test.folder") }.should raise_error(Net::FTPPermError)
+    end
 
-  it "raises a Net::FTPPermError when the response code is 550" do
-    @server.should_receive(:mkd).and_respond("550 Requested action not taken.")
-    -> { @ftp.mkdir("test.folder") }.should raise_error(Net::FTPPermError)
+    it "raises a Net::FTPPermError when the response code is 550" do
+      @server.should_receive(:mkd).and_respond("550 Requested action not taken.")
+      -> { @ftp.mkdir("test.folder") }.should raise_error(Net::FTPPermError)
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/mtime_spec.rb b/spec/ruby/library/net-ftp/mtime_spec.rb
index 9dde1278a8..01b68ea674 100644
--- a/spec/ruby/library/net-ftp/mtime_spec.rb
+++ b/spec/ruby/library/net-ftp/mtime_spec.rb
@@ -1,50 +1,53 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
 
-describe "Net::FTP#mtime" do
-  before :each do
-    @server = NetFTPSpecs::DummyFTP.new
-    @server.serve_once
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
 
-    @ftp = Net::FTP.new
-    @ftp.connect(@server.hostname, @server.server_port)
-  end
+  describe "Net::FTP#mtime" do
+    before :each do
+      @server = NetFTPSpecs::DummyFTP.new
+      @server.serve_once
 
-  after :each do
-    @ftp.quit rescue nil
-    @ftp.close
-    @server.stop
-  end
+      @ftp = Net::FTP.new
+      @ftp.connect(@server.hostname, @server.server_port)
+    end
 
-  it "sends the MDTM with the passed filename command to the server" do
-    @ftp.mtime("test.file")
-    @ftp.last_response.should == "213 19980705132316\n"
-  end
+    after :each do
+      @ftp.quit rescue nil
+      @ftp.close
+      @server.stop
+    end
 
-  describe "when passed filename" do
-    it "returns the last modification time of the passed file as a Time object in the local time" do
-      @ftp.mtime("test.file").should == Time.gm("1998", "07", "05", "13", "23", "16")
+    it "sends the MDTM with the passed filename command to the server" do
+      @ftp.mtime("test.file")
+      @ftp.last_response.should == "213 19980705132316\n"
     end
-  end
 
-  describe "when passed filename, local_time" do
-    it "returns the last modification time as a Time object in UTC when local_time is true" do
-      @ftp.mtime("test.file", true).should == Time.local("1998", "07", "05", "13", "23", "16")
+    describe "when passed filename" do
+      it "returns the last modification time of the passed file as a Time object in the local time" do
+        @ftp.mtime("test.file").should == Time.gm("1998", "07", "05", "13", "23", "16")
+      end
     end
 
-    it "returns the last modification time as a Time object in the local time when local_time is false" do
-      @ftp.mtime("test.file", false).should == Time.gm("1998", "07", "05", "13", "23", "16")
+    describe "when passed filename, local_time" do
+      it "returns the last modification time as a Time object in UTC when local_time is true" do
+        @ftp.mtime("test.file", true).should == Time.local("1998", "07", "05", "13", "23", "16")
+      end
+
+      it "returns the last modification time as a Time object in the local time when local_time is false" do
+        @ftp.mtime("test.file", false).should == Time.gm("1998", "07", "05", "13", "23", "16")
+      end
     end
-  end
 
-  it "raises a Net::FTPPermError when the response code is 550" do
-    @server.should_receive(:mdtm).and_respond("550 Requested action not taken.")
-    -> { @ftp.mtime("test.file") }.should raise_error(Net::FTPPermError)
-  end
+    it "raises a Net::FTPPermError when the response code is 550" do
+      @server.should_receive(:mdtm).and_respond("550 Requested action not taken.")
+      -> { @ftp.mtime("test.file") }.should raise_error(Net::FTPPermError)
+    end
 
-  it "raises a Net::FTPTempError when the response code is 421" do
-    @server.should_receive(:mdtm).and_respond("421 Service not available, closing control connection.")
-    -> { @ftp.mtime("test.file") }.should raise_error(Net::FTPTempError)
+    it "raises a Net::FTPTempError when the response code is 421" do
+      @server.should_receive(:mdtm).and_respond("421 Service not available, closing control connection.")
+      -> { @ftp.mtime("test.file") }.should raise_error(Net::FTPTempError)
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/nlst_spec.rb b/spec/ruby/library/net-ftp/nlst_spec.rb
index 2f22543af6..c78717259f 100644
--- a/spec/ruby/library/net-ftp/nlst_spec.rb
+++ b/spec/ruby/library/net-ftp/nlst_spec.rb
@@ -1,92 +1,95 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
 
-describe "Net::FTP#nlst" do
-  before :each do
-    @server = NetFTPSpecs::DummyFTP.new
-    @server.serve_once
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
 
-    @ftp = Net::FTP.new
-    @ftp.passive = false
-    @ftp.connect(@server.hostname, @server.server_port)
-  end
-
-  after :each do
-    @ftp.quit rescue nil
-    @ftp.close
-    @server.stop
-  end
+  describe "Net::FTP#nlst" do
+    before :each do
+      @server = NetFTPSpecs::DummyFTP.new
+      @server.serve_once
 
-  describe "when passed no arguments" do
-    it "returns an Array containing a list of files in the current dir" do
-      @ftp.nlst.should == ["last_response_code.rb", "list.rb", "pwd.rb"]
-      @ftp.last_response.should == "226 transfer complete (NLST)\n"
+      @ftp = Net::FTP.new
+      @ftp.passive = false
+      @ftp.connect(@server.hostname, @server.server_port)
     end
-  end
 
-  describe "when passed dir" do
-    it "returns an Array containing a list of files in the passed dir" do
-      @ftp.nlst("test.folder").should == ["last_response_code.rb", "list.rb", "pwd.rb"]
-      @ftp.last_response.should == "226 transfer complete (NLST test.folder)\n"
+    after :each do
+      @ftp.quit rescue nil
+      @ftp.close
+      @server.stop
     end
-  end
 
-  describe "when the NLST command fails" do
-    it "raises a Net::FTPTempError when the response code is 450" do
-      @server.should_receive(:nlst).and_respond("450 Requested file action not taken..")
-      -> { @ftp.nlst }.should raise_error(Net::FTPTempError)
+    describe "when passed no arguments" do
+      it "returns an Array containing a list of files in the current dir" do
+        @ftp.nlst.should == ["last_response_code.rb", "list.rb", "pwd.rb"]
+        @ftp.last_response.should == "226 transfer complete (NLST)\n"
+      end
     end
 
-    it "raises a Net::FTPPermError when the response code is 500" do
-      @server.should_receive(:nlst).and_respond("500 Syntax error, command unrecognized.")
-      -> { @ftp.nlst }.should raise_error(Net::FTPPermError)
+    describe "when passed dir" do
+      it "returns an Array containing a list of files in the passed dir" do
+        @ftp.nlst("test.folder").should == ["last_response_code.rb", "list.rb", "pwd.rb"]
+        @ftp.last_response.should == "226 transfer complete (NLST test.folder)\n"
+      end
     end
 
-    it "raises a Net::FTPPermError when the response code is 501" do
-      @server.should_receive(:nlst).and_respond("501 Syntax error, command unrecognized.")
-      -> { @ftp.nlst }.should raise_error(Net::FTPPermError)
-    end
+    describe "when the NLST command fails" do
+      it "raises a Net::FTPTempError when the response code is 450" do
+        @server.should_receive(:nlst).and_respond("450 Requested file action not taken..")
+        -> { @ftp.nlst }.should raise_error(Net::FTPTempError)
+      end
 
-    it "raises a Net::FTPPermError when the response code is 502" do
-      @server.should_receive(:nlst).and_respond("502 Command not implemented.")
-      -> { @ftp.nlst }.should raise_error(Net::FTPPermError)
-    end
+      it "raises a Net::FTPPermError when the response code is 500" do
+        @server.should_receive(:nlst).and_respond("500 Syntax error, command unrecognized.")
+        -> { @ftp.nlst }.should raise_error(Net::FTPPermError)
+      end
 
-    it "raises a Net::FTPTempError when the response code is 421" do
-      @server.should_receive(:nlst).and_respond("421 Service not available, closing control connection.")
-      -> { @ftp.nlst }.should raise_error(Net::FTPTempError)
-    end
+      it "raises a Net::FTPPermError when the response code is 501" do
+        @server.should_receive(:nlst).and_respond("501 Syntax error, command unrecognized.")
+        -> { @ftp.nlst }.should raise_error(Net::FTPPermError)
+      end
 
-    it "raises a Net::FTPPermError when the response code is 530" do
-      @server.should_receive(:nlst).and_respond("530 Not logged in.")
-      -> { @ftp.nlst }.should raise_error(Net::FTPPermError)
-    end
-  end
+      it "raises a Net::FTPPermError when the response code is 502" do
+        @server.should_receive(:nlst).and_respond("502 Command not implemented.")
+        -> { @ftp.nlst }.should raise_error(Net::FTPPermError)
+      end
 
-  describe "when opening the data port fails" do
-    it "raises a Net::FTPPermError when the response code is 500" do
-      @server.should_receive(:eprt).and_respond("500 Syntax error, command unrecognized.")
-      @server.should_receive(:port).and_respond("500 Syntax error, command unrecognized.")
-      -> { @ftp.nlst }.should raise_error(Net::FTPPermError)
-    end
+      it "raises a Net::FTPTempError when the response code is 421" do
+        @server.should_receive(:nlst).and_respond("421 Service not available, closing control connection.")
+        -> { @ftp.nlst }.should raise_error(Net::FTPTempError)
+      end
 
-    it "raises a Net::FTPPermError when the response code is 501" do
-      @server.should_receive(:eprt).and_respond("501 Syntax error in parameters or arguments.")
-      @server.should_receive(:port).and_respond("501 Syntax error in parameters or arguments.")
-      -> { @ftp.nlst }.should raise_error(Net::FTPPermError)
+      it "raises a Net::FTPPermError when the response code is 530" do
+        @server.should_receive(:nlst).and_respond("530 Not logged in.")
+        -> { @ftp.nlst }.should raise_error(Net::FTPPermError)
+      end
     end
 
-    it "raises a Net::FTPTempError when the response code is 421" do
-      @server.should_receive(:eprt).and_respond("421 Service not available, closing control connection.")
-      @server.should_receive(:port).and_respond("421 Service not available, closing control connection.")
-      -> { @ftp.nlst }.should raise_error(Net::FTPTempError)
-    end
+    describe "when opening the data port fails" do
+      it "raises a Net::FTPPermError when the response code is 500" do
+        @server.should_receive(:eprt).and_respond("500 Syntax error, command unrecognized.")
+        @server.should_receive(:port).and_respond("500 Syntax error, command unrecognized.")
+        -> { @ftp.nlst }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 501" do
+        @server.should_receive(:eprt).and_respond("501 Syntax error in parameters or arguments.")
+        @server.should_receive(:port).and_respond("501 Syntax error in parameters or arguments.")
+        -> { @ftp.nlst }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPTempError when the response code is 421" do
+        @server.should_receive(:eprt).and_respond("421 Service not available, closing control connection.")
+        @server.should_receive(:port).and_respond("421 Service not available, closing control connection.")
+        -> { @ftp.nlst }.should raise_error(Net::FTPTempError)
+      end
 
-    it "raises a Net::FTPPermError when the response code is 530" do
-      @server.should_receive(:eprt).and_respond("530 Not logged in.")
-      @server.should_receive(:port).and_respond("530 Not logged in.")
-      -> { @ftp.nlst }.should raise_error(Net::FTPPermError)
+      it "raises a Net::FTPPermError when the response code is 530" do
+        @server.should_receive(:eprt).and_respond("530 Not logged in.")
+        @server.should_receive(:port).and_respond("530 Not logged in.")
+        -> { @ftp.nlst }.should raise_error(Net::FTPPermError)
+      end
     end
   end
 end
diff --git a/spec/ruby/library/net-ftp/noop_spec.rb b/spec/ruby/library/net-ftp/noop_spec.rb
index 4743a39ef6..4995e78174 100644
--- a/spec/ruby/library/net-ftp/noop_spec.rb
+++ b/spec/ruby/library/net-ftp/noop_spec.rb
@@ -1,38 +1,41 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
 
-describe "Net::FTP#noop" do
-  before :each do
-    @server = NetFTPSpecs::DummyFTP.new
-    @server.serve_once
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
 
-    @ftp = Net::FTP.new
-    @ftp.connect(@server.hostname, @server.server_port)
-  end
+  describe "Net::FTP#noop" do
+    before :each do
+      @server = NetFTPSpecs::DummyFTP.new
+      @server.serve_once
 
-  after :each do
-    @ftp.quit rescue nil
-    @ftp.close
-    @server.stop
-  end
+      @ftp = Net::FTP.new
+      @ftp.connect(@server.hostname, @server.server_port)
+    end
 
-  it "sends the NOOP command to the server" do
-    @ftp.noop
-    @ftp.last_response.should == "200 Command okay. (NOOP)\n"
-  end
+    after :each do
+      @ftp.quit rescue nil
+      @ftp.close
+      @server.stop
+    end
 
-  it "returns nil" do
-    @ftp.noop.should be_nil
-  end
+    it "sends the NOOP command to the server" do
+      @ftp.noop
+      @ftp.last_response.should == "200 Command okay. (NOOP)\n"
+    end
 
-  it "raises a Net::FTPPermError when the response code is 500" do
-    @server.should_receive(:noop).and_respond("500 Syntax error, command unrecognized.")
-    -> { @ftp.noop }.should raise_error(Net::FTPPermError)
-  end
+    it "returns nil" do
+      @ftp.noop.should be_nil
+    end
+
+    it "raises a Net::FTPPermError when the response code is 500" do
+      @server.should_receive(:noop).and_respond("500 Syntax error, command unrecognized.")
+      -> { @ftp.noop }.should raise_error(Net::FTPPermError)
+    end
 
-  it "raises a Net::FTPTempError when the response code is 421" do
-    @server.should_receive(:noop).and_respond("421 Service not available, closing control connection.")
-    -> { @ftp.noop }.should raise_error(Net::FTPTempError)
+    it "raises a Net::FTPTempError when the response code is 421" do
+      @server.should_receive(:noop).and_respond("421 Service not available, closing control connection.")
+      -> { @ftp.noop }.should raise_error(Net::FTPTempError)
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/open_spec.rb b/spec/ruby/library/net-ftp/open_spec.rb
index e59496dc3c..7678cee459 100644
--- a/spec/ruby/library/net-ftp/open_spec.rb
+++ b/spec/ruby/library/net-ftp/open_spec.rb
@@ -1,55 +1,58 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
 
-describe "Net::FTP.open" do
-  before :each do
-    @ftp = mock("Net::FTP instance")
-    Net::FTP.stub!(:new).and_return(@ftp)
-  end
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
 
-  describe "when passed no block" do
-    it "returns a new Net::FTP instance" do
-      Net::FTP.open("localhost").should equal(@ftp)
+  describe "Net::FTP.open" do
+    before :each do
+      @ftp = mock("Net::FTP instance")
+      Net::FTP.stub!(:new).and_return(@ftp)
     end
 
-    it "passes the passed arguments down to Net::FTP.new" do
-      Net::FTP.should_receive(:new).with("localhost", "user", "password", "account")
-      Net::FTP.open("localhost", "user", "password", "account")
-    end
-  end
+    describe "when passed no block" do
+      it "returns a new Net::FTP instance" do
+        Net::FTP.open("localhost").should equal(@ftp)
+      end
 
-  describe "when passed a block" do
-    before :each do
-      @ftp.stub!(:close)
+      it "passes the passed arguments down to Net::FTP.new" do
+        Net::FTP.should_receive(:new).with("localhost", "user", "password", "account")
+        Net::FTP.open("localhost", "user", "password", "account")
+      end
     end
 
-    it "yields a new Net::FTP instance to the passed block" do
-      yielded = false
-      Net::FTP.open("localhost") do |ftp|
-        yielded = true
-        ftp.should equal(@ftp)
+    describe "when passed a block" do
+      before :each do
+        @ftp.stub!(:close)
       end
-      yielded.should be_true
-    end
 
-    it "closes the Net::FTP instance after yielding" do
-      Net::FTP.open("localhost") do |ftp|
-        ftp.should_receive(:close)
+      it "yields a new Net::FTP instance to the passed block" do
+        yielded = false
+        Net::FTP.open("localhost") do |ftp|
+          yielded = true
+          ftp.should equal(@ftp)
+        end
+        yielded.should be_true
       end
-    end
 
-    it "closes the Net::FTP instance even if an exception is raised while yielding" do
-      begin
+      it "closes the Net::FTP instance after yielding" do
         Net::FTP.open("localhost") do |ftp|
           ftp.should_receive(:close)
-          raise ArgumentError, "some exception"
         end
-      rescue ArgumentError
       end
-    end
 
-    it "returns the block's return value" do
-      Net::FTP.open("localhost") { :test }.should == :test
+      it "closes the Net::FTP instance even if an exception is raised while yielding" do
+        begin
+          Net::FTP.open("localhost") do |ftp|
+            ftp.should_receive(:close)
+            raise ArgumentError, "some exception"
+          end
+        rescue ArgumentError
+        end
+      end
+
+      it "returns the block's return value" do
+        Net::FTP.open("localhost") { :test }.should == :test
+      end
     end
   end
 end
diff --git a/spec/ruby/library/net-ftp/passive_spec.rb b/spec/ruby/library/net-ftp/passive_spec.rb
index 97659f1b68..29351846f9 100644
--- a/spec/ruby/library/net-ftp/passive_spec.rb
+++ b/spec/ruby/library/net-ftp/passive_spec.rb
@@ -1,28 +1,31 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
 
-describe "Net::FTP#passive" do
-  it "returns true when self is in passive mode" do
-    ftp = Net::FTP.new
-    ftp.passive.should be_false
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
 
-    ftp.passive = true
-    ftp.passive.should be_true
-  end
+  describe "Net::FTP#passive" do
+    it "returns true when self is in passive mode" do
+      ftp = Net::FTP.new
+      ftp.passive.should be_false
+
+      ftp.passive = true
+      ftp.passive.should be_true
+    end
 
-  it "is the value of Net::FTP.default_value by default" do
-    ruby_exe(fixture(__FILE__, "passive.rb")).should == "true"
+    it "is the value of Net::FTP.default_value by default" do
+      ruby_exe(fixture(__FILE__, "passive.rb")).should == "true"
+    end
   end
-end
 
-describe "Net::FTP#passive=" do
-  it "sets self to passive mode when passed true" do
-    ftp = Net::FTP.new
+  describe "Net::FTP#passive=" do
+    it "sets self to passive mode when passed true" do
+      ftp = Net::FTP.new
 
-    ftp.passive = true
-    ftp.passive.should be_true
+      ftp.passive = true
+      ftp.passive.should be_true
 
-    ftp.passive = false
-    ftp.passive.should be_false
+      ftp.passive = false
+      ftp.passive.should be_false
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/put_spec.rb b/spec/ruby/library/net-ftp/put_spec.rb
index 6d40d3d5b9..603409e283 100644
--- a/spec/ruby/library/net-ftp/put_spec.rb
+++ b/spec/ruby/library/net-ftp/put_spec.rb
@@ -1,21 +1,24 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
-require_relative 'shared/puttextfile'
-require_relative 'shared/putbinaryfile'
 
-describe "Net::FTP#put (binary mode)" do
-  before :each do
-    @binary_mode = true
-  end
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
+  require_relative 'shared/puttextfile'
+  require_relative 'shared/putbinaryfile'
 
-  it_behaves_like :net_ftp_putbinaryfile, :put
-end
+  describe "Net::FTP#put (binary mode)" do
+    before :each do
+      @binary_mode = true
+    end
 
-describe "Net::FTP#put (text mode)" do
-  before :each do
-    @binary_mode = false
+    it_behaves_like :net_ftp_putbinaryfile, :put
   end
 
-  it_behaves_like :net_ftp_puttextfile, :put
+  describe "Net::FTP#put (text mode)" do
+    before :each do
+      @binary_mode = false
+    end
+
+    it_behaves_like :net_ftp_puttextfile, :put
+  end
 end
diff --git a/spec/ruby/library/net-ftp/putbinaryfile_spec.rb b/spec/ruby/library/net-ftp/putbinaryfile_spec.rb
index d0398229e5..ce8a6f0473 100644
--- a/spec/ruby/library/net-ftp/putbinaryfile_spec.rb
+++ b/spec/ruby/library/net-ftp/putbinaryfile_spec.rb
@@ -1,8 +1,11 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
-require_relative 'shared/putbinaryfile'
 
-describe "Net::FTP#putbinaryfile" do
-  it_behaves_like :net_ftp_putbinaryfile, :putbinaryfile
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
+  require_relative 'shared/putbinaryfile'
+
+  describe "Net::FTP#putbinaryfile" do
+    it_behaves_like :net_ftp_putbinaryfile, :putbinaryfile
+  end
 end
diff --git a/spec/ruby/library/net-ftp/puttextfile_spec.rb b/spec/ruby/library/net-ftp/puttextfile_spec.rb
index b8bcac33df..b4ab86aab1 100644
--- a/spec/ruby/library/net-ftp/puttextfile_spec.rb
+++ b/spec/ruby/library/net-ftp/puttextfile_spec.rb
@@ -1,8 +1,11 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
-require_relative 'shared/puttextfile'
 
-describe "Net::FTP#puttextfile" do
-  it_behaves_like :net_ftp_puttextfile, :puttextfile
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
+  require_relative 'shared/puttextfile'
+
+  describe "Net::FTP#puttextfile" do
+    it_behaves_like :net_ftp_puttextfile, :puttextfile
+  end
 end
diff --git a/spec/ruby/library/net-ftp/pwd_spec.rb b/spec/ruby/library/net-ftp/pwd_spec.rb
index 992e2c4ed2..8358c68310 100644
--- a/spec/ruby/library/net-ftp/pwd_spec.rb
+++ b/spec/ruby/library/net-ftp/pwd_spec.rb
@@ -1,53 +1,56 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
 
-describe "Net::FTP#pwd" do
-  before :each do
-    @server = NetFTPSpecs::DummyFTP.new
-    @server.serve_once
-
-    @ftp = Net::FTP.new
-    @ftp.connect(@server.hostname, @server.server_port)
-  end
-
-  after :each do
-    @ftp.quit rescue nil
-    @ftp.close
-    @server.stop
-  end
-
-  it "sends the PWD command to the server" do
-    @ftp.pwd
-    @ftp.last_response.should == "257 \"/some/dir/\" - current directory\n"
-  end
-
-  it "returns the current directory" do
-    @ftp.pwd.should == "/some/dir/"
-  end
-
-  it "raises a Net::FTPPermError when the response code is 500" do
-    @server.should_receive(:pwd).and_respond("500 Syntax error, command unrecognized.")
-    -> { @ftp.pwd }.should raise_error(Net::FTPPermError)
-  end
-
-  it "raises a Net::FTPPermError when the response code is 501" do
-    @server.should_receive(:pwd).and_respond("501 Syntax error in parameters or arguments.")
-    -> { @ftp.pwd }.should raise_error(Net::FTPPermError)
-  end
-
-  it "raises a Net::FTPPermError when the response code is 502" do
-    @server.should_receive(:pwd).and_respond("502 Command not implemented.")
-    -> { @ftp.pwd }.should raise_error(Net::FTPPermError)
-  end
-
-  it "raises a Net::FTPTempError when the response code is 421" do
-    @server.should_receive(:pwd).and_respond("421 Service not available, closing control connection.")
-    -> { @ftp.pwd }.should raise_error(Net::FTPTempError)
-  end
-
-  it "raises a Net::FTPPermError when the response code is 550" do
-    @server.should_receive(:pwd).and_respond("550 Requested action not taken.")
-    -> { @ftp.pwd }.should raise_error(Net::FTPPermError)
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
+
+  describe "Net::FTP#pwd" do
+    before :each do
+      @server = NetFTPSpecs::DummyFTP.new
+      @server.serve_once
+
+      @ftp = Net::FTP.new
+      @ftp.connect(@server.hostname, @server.server_port)
+    end
+
+    after :each do
+      @ftp.quit rescue nil
+      @ftp.close
+      @server.stop
+    end
+
+    it "sends the PWD command to the server" do
+      @ftp.pwd
+      @ftp.last_response.should == "257 \"/some/dir/\" - current directory\n"
+    end
+
+    it "returns the current directory" do
+      @ftp.pwd.should == "/some/dir/"
+    end
+
+    it "raises a Net::FTPPermError when the response code is 500" do
+      @server.should_receive(:pwd).and_respond("500 Syntax error, command unrecognized.")
+      -> { @ftp.pwd }.should raise_error(Net::FTPPermError)
+    end
+
+    it "raises a Net::FTPPermError when the response code is 501" do
+      @server.should_receive(:pwd).and_respond("501 Syntax error in parameters or arguments.")
+      -> { @ftp.pwd }.should raise_error(Net::FTPPermError)
+    end
+
+    it "raises a Net::FTPPermError when the response code is 502" do
+      @server.should_receive(:pwd).and_respond("502 Command not implemented.")
+      -> { @ftp.pwd }.should raise_error(Net::FTPPermError)
+    end
+
+    it "raises a Net::FTPTempError when the response code is 421" do
+      @server.should_receive(:pwd).and_respond("421 Service not available, closing control connection.")
+      -> { @ftp.pwd }.should raise_error(Net::FTPTempError)
+    end
+
+    it "raises a Net::FTPPermError when the response code is 550" do
+      @server.should_receive(:pwd).and_respond("550 Requested action not taken.")
+      -> { @ftp.pwd }.should raise_error(Net::FTPPermError)
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/quit_spec.rb b/spec/ruby/library/net-ftp/quit_spec.rb
index c5352ceada..4a52f06963 100644
--- a/spec/ruby/library/net-ftp/quit_spec.rb
+++ b/spec/ruby/library/net-ftp/quit_spec.rb
@@ -1,33 +1,36 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
 
-describe "Net::FTP#quit" do
-  before :each do
-    @server = NetFTPSpecs::DummyFTP.new
-    @server.serve_once
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
 
-    @ftp = Net::FTP.new
-    @ftp.connect(@server.hostname, @server.server_port)
-  end
+  describe "Net::FTP#quit" do
+    before :each do
+      @server = NetFTPSpecs::DummyFTP.new
+      @server.serve_once
 
-  after :each do
-    @ftp.quit rescue nil
-    @ftp.close
-    @server.stop
-  end
+      @ftp = Net::FTP.new
+      @ftp.connect(@server.hostname, @server.server_port)
+    end
 
-  it "sends the QUIT command to the server" do
-    @ftp.quit
-    @ftp.last_response.should == "221 OK, bye\n"
-  end
+    after :each do
+      @ftp.quit rescue nil
+      @ftp.close
+      @server.stop
+    end
 
-  it "does not close the socket automatically" do
-    @ftp.quit
-    @ftp.closed?.should be_false
-  end
+    it "sends the QUIT command to the server" do
+      @ftp.quit
+      @ftp.last_response.should == "221 OK, bye\n"
+    end
+
+    it "does not close the socket automatically" do
+      @ftp.quit
+      @ftp.closed?.should be_false
+    end
 
-  it "returns nil" do
-    @ftp.quit.should be_nil
+    it "returns nil" do
+      @ftp.quit.should be_nil
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/rename_spec.rb b/spec/ruby/library/net-ftp/rename_spec.rb
index 48f81b7deb..85f97757bc 100644
--- a/spec/ruby/library/net-ftp/rename_spec.rb
+++ b/spec/ruby/library/net-ftp/rename_spec.rb
@@ -1,94 +1,97 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
 
-describe "Net::FTP#rename" do
-  before :each do
-    @server = NetFTPSpecs::DummyFTP.new
-    @server.serve_once
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
 
-    @ftp = Net::FTP.new
-    @ftp.connect(@server.hostname, @server.server_port)
-  end
-
-  after :each do
-    @ftp.quit rescue nil
-    @ftp.close
-    @server.stop
-  end
-
-  describe "when passed from_name, to_name" do
-    it "sends the RNFR command with the passed from_name and the RNTO command with the passed to_name to the server" do
-      @ftp.rename("from.file", "to.file")
-      @ftp.last_response.should == "250 Requested file action okay, completed. (Renamed from.file to to.file)\n"
-    end
-
-    it "returns something" do
-      @ftp.rename("from.file", "to.file").should be_nil
-    end
-  end
-
-  describe "when the RNFR command fails" do
-    it "raises a Net::FTPTempError when the response code is 450" do
-      @server.should_receive(:rnfr).and_respond("450 Requested file action not taken.")
-      -> { @ftp.rename("from.file", "to.file") }.should raise_error(Net::FTPTempError)
-    end
-
-    it "raises a Net::FTPPermError when the response code is 550" do
-      @server.should_receive(:rnfr).and_respond("550 Requested action not taken.")
-      -> { @ftp.rename("from.file", "to.file") }.should raise_error(Net::FTPPermError)
-    end
-
-    it "raises a Net::FTPPermError when the response code is 501" do
-      @server.should_receive(:rnfr).and_respond("501 Syntax error in parameters or arguments.")
-      -> { @ftp.rename("from.file", "to.file") }.should raise_error(Net::FTPPermError)
-    end
+  describe "Net::FTP#rename" do
+    before :each do
+      @server = NetFTPSpecs::DummyFTP.new
+      @server.serve_once
 
-    it "raises a Net::FTPPermError when the response code is 502" do
-      @server.should_receive(:rnfr).and_respond("502 Command not implemented.")
-      -> { @ftp.rename("from.file", "to.file") }.should raise_error(Net::FTPPermError)
+      @ftp = Net::FTP.new
+      @ftp.connect(@server.hostname, @server.server_port)
     end
 
-    it "raises a Net::FTPTempError when the response code is 421" do
-      @server.should_receive(:rnfr).and_respond("421 Service not available, closing control connection.")
-      -> { @ftp.rename("from.file", "to.file") }.should raise_error(Net::FTPTempError)
+    after :each do
+      @ftp.quit rescue nil
+      @ftp.close
+      @server.stop
     end
 
-    it "raises a Net::FTPPermError when the response code is 530" do
-      @server.should_receive(:rnfr).and_respond("530 Not logged in.")
-      -> { @ftp.rename("from.file", "to.file") }.should raise_error(Net::FTPPermError)
-    end
-  end
-
-  describe "when the RNTO command fails" do
-    it "raises a Net::FTPPermError when the response code is 532" do
-      @server.should_receive(:rnfr).and_respond("532 Need account for storing files.")
-      -> { @ftp.rename("from.file", "to.file") }.should raise_error(Net::FTPPermError)
-    end
-
-    it "raises a Net::FTPPermError when the response code is 553" do
-      @server.should_receive(:rnto).and_respond("553 Requested action not taken.")
-      -> { @ftp.rename("from.file", "to.file") }.should raise_error(Net::FTPPermError)
-    end
-
-    it "raises a Net::FTPPermError when the response code is 501" do
-      @server.should_receive(:rnto).and_respond("501 Syntax error in parameters or arguments.")
-      -> { @ftp.rename("from.file", "to.file") }.should raise_error(Net::FTPPermError)
-    end
+    describe "when passed from_name, to_name" do
+      it "sends the RNFR command with the passed from_name and the RNTO command with the passed to_name to the server" do
+        @ftp.rename("from.file", "to.file")
+        @ftp.last_response.should == "250 Requested file action okay, completed. (Renamed from.file to to.file)\n"
+      end
 
-    it "raises a Net::FTPPermError when the response code is 502" do
-      @server.should_receive(:rnto).and_respond("502 Command not implemented.")
-      -> { @ftp.rename("from.file", "to.file") }.should raise_error(Net::FTPPermError)
+      it "returns something" do
+        @ftp.rename("from.file", "to.file").should be_nil
+      end
     end
 
-    it "raises a Net::FTPTempError when the response code is 421" do
-      @server.should_receive(:rnto).and_respond("421 Service not available, closing control connection.")
-      -> { @ftp.rename("from.file", "to.file") }.should raise_error(Net::FTPTempError)
+    describe "when the RNFR command fails" do
+      it "raises a Net::FTPTempError when the response code is 450" do
+        @server.should_receive(:rnfr).and_respond("450 Requested file action not taken.")
+        -> { @ftp.rename("from.file", "to.file") }.should raise_error(Net::FTPTempError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 550" do
+        @server.should_receive(:rnfr).and_respond("550 Requested action not taken.")
+        -> { @ftp.rename("from.file", "to.file") }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 501" do
+        @server.should_receive(:rnfr).and_respond("501 Syntax error in parameters or arguments.")
+        -> { @ftp.rename("from.file", "to.file") }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 502" do
+        @server.should_receive(:rnfr).and_respond("502 Command not implemented.")
+        -> { @ftp.rename("from.file", "to.file") }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPTempError when the response code is 421" do
+        @server.should_receive(:rnfr).and_respond("421 Service not available, closing control connection.")
+        -> { @ftp.rename("from.file", "to.file") }.should raise_error(Net::FTPTempError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 530" do
+        @server.should_receive(:rnfr).and_respond("530 Not logged in.")
+        -> { @ftp.rename("from.file", "to.file") }.should raise_error(Net::FTPPermError)
+      end
     end
 
-    it "raises a Net::FTPPermError when the response code is 530" do
-      @server.should_receive(:rnto).and_respond("530 Not logged in.")
-      -> { @ftp.rename("from.file", "to.file") }.should raise_error(Net::FTPPermError)
+    describe "when the RNTO command fails" do
+      it "raises a Net::FTPPermError when the response code is 532" do
+        @server.should_receive(:rnfr).and_respond("532 Need account for storing files.")
+        -> { @ftp.rename("from.file", "to.file") }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 553" do
+        @server.should_receive(:rnto).and_respond("553 Requested action not taken.")
+        -> { @ftp.rename("from.file", "to.file") }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 501" do
+        @server.should_receive(:rnto).and_respond("501 Syntax error in parameters or arguments.")
+        -> { @ftp.rename("from.file", "to.file") }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 502" do
+        @server.should_receive(:rnto).and_respond("502 Command not implemented.")
+        -> { @ftp.rename("from.file", "to.file") }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPTempError when the response code is 421" do
+        @server.should_receive(:rnto).and_respond("421 Service not available, closing control connection.")
+        -> { @ftp.rename("from.file", "to.file") }.should raise_error(Net::FTPTempError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 530" do
+        @server.should_receive(:rnto).and_respond("530 Not logged in.")
+        -> { @ftp.rename("from.file", "to.file") }.should raise_error(Net::FTPPermError)
+      end
     end
   end
 end
diff --git a/spec/ruby/library/net-ftp/resume_spec.rb b/spec/ruby/library/net-ftp/resume_spec.rb
index 6592fc5bb0..079878d24b 100644
--- a/spec/ruby/library/net-ftp/resume_spec.rb
+++ b/spec/ruby/library/net-ftp/resume_spec.rb
@@ -1,23 +1,26 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
 
-describe "Net::FTP#resume" do
-  it "returns true when self is set to resume uploads/downloads" do
-    ftp = Net::FTP.new
-    ftp.resume.should be_false
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
 
-    ftp.resume = true
-    ftp.resume.should be_true
+  describe "Net::FTP#resume" do
+    it "returns true when self is set to resume uploads/downloads" do
+      ftp = Net::FTP.new
+      ftp.resume.should be_false
+
+      ftp.resume = true
+      ftp.resume.should be_true
+    end
   end
-end
 
-describe "Net::FTP#resume=" do
-  it "sets self to resume uploads/downloads when set to true" do
-    ftp = Net::FTP.new
-    ftp.resume = true
-    ftp.resume.should be_true
+  describe "Net::FTP#resume=" do
+    it "sets self to resume uploads/downloads when set to true" do
+      ftp = Net::FTP.new
+      ftp.resume = true
+      ftp.resume.should be_true
 
-    ftp.resume = false
-    ftp.resume.should be_false
+      ftp.resume = false
+      ftp.resume.should be_false
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/retrbinary_spec.rb b/spec/ruby/library/net-ftp/retrbinary_spec.rb
index de024208aa..ff8c8098a4 100644
--- a/spec/ruby/library/net-ftp/retrbinary_spec.rb
+++ b/spec/ruby/library/net-ftp/retrbinary_spec.rb
@@ -1,30 +1,33 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
 
-describe "Net::FTP#retrbinary" do
-  before :each do
-    @server = NetFTPSpecs::DummyFTP.new
-    @server.serve_once
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
 
-    @ftp = Net::FTP.new
-    @ftp.connect(@server.hostname, @server.server_port)
-  end
+  describe "Net::FTP#retrbinary" do
+    before :each do
+      @server = NetFTPSpecs::DummyFTP.new
+      @server.serve_once
 
-  after :each do
-    @ftp.quit rescue nil
-    @ftp.close
-    @server.stop
-  end
+      @ftp = Net::FTP.new
+      @ftp.connect(@server.hostname, @server.server_port)
+    end
 
-  it "sends the passed command to the server" do
-    @ftp.retrbinary("RETR test", 4096) {}
-    @ftp.last_response.should == "226 Closing data connection. (RETR test)\n"
-  end
+    after :each do
+      @ftp.quit rescue nil
+      @ftp.close
+      @server.stop
+    end
+
+    it "sends the passed command to the server" do
+      @ftp.retrbinary("RETR test", 4096) {}
+      @ftp.last_response.should == "226 Closing data connection. (RETR test)\n"
+    end
 
-  it "yields the received content as binary blocks of the passed size" do
-    res = []
-    @ftp.retrbinary("RETR test", 10) { |bin| res << bin }
-    res.should == [ "This is th", "e content\n", "of the fil", "e named 't", "est'.\n" ]
+    it "yields the received content as binary blocks of the passed size" do
+      res = []
+      @ftp.retrbinary("RETR test", 10) { |bin| res << bin }
+      res.should == [ "This is th", "e content\n", "of the fil", "e named 't", "est'.\n" ]
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/retrlines_spec.rb b/spec/ruby/library/net-ftp/retrlines_spec.rb
index 866ecb5f40..2963da14f7 100644
--- a/spec/ruby/library/net-ftp/retrlines_spec.rb
+++ b/spec/ruby/library/net-ftp/retrlines_spec.rb
@@ -1,34 +1,37 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
 
-describe "Net::FTP#retrlines" do
-  before :each do
-    @server = NetFTPSpecs::DummyFTP.new
-    @server.serve_once
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
 
-    @ftp = Net::FTP.new
-    @ftp.connect(@server.hostname, @server.server_port)
-  end
+  describe "Net::FTP#retrlines" do
+    before :each do
+      @server = NetFTPSpecs::DummyFTP.new
+      @server.serve_once
 
-  after :each do
-    @ftp.quit rescue nil
-    @ftp.close
-    @server.stop
-  end
+      @ftp = Net::FTP.new
+      @ftp.connect(@server.hostname, @server.server_port)
+    end
 
-  it "sends the passed command over the socket" do
-    @ftp.retrlines("LIST test.dir") {}
-    @ftp.last_response.should == "226 transfer complete (LIST test.dir)\n"
-  end
+    after :each do
+      @ftp.quit rescue nil
+      @ftp.close
+      @server.stop
+    end
+
+    it "sends the passed command over the socket" do
+      @ftp.retrlines("LIST test.dir") {}
+      @ftp.last_response.should == "226 transfer complete (LIST test.dir)\n"
+    end
 
-  it "yields each received line to the passed block" do
-    res = []
-    @ftp.retrlines("LIST test.dir") { |x| res << x }
-    res.should == [
-      "-rw-r--r--  1 spec  staff  507 17 Jul 18:41 last_response_code.rb",
-      "-rw-r--r--  1 spec  staff   50 17 Jul 18:41 list.rb",
-      "-rw-r--r--  1 spec  staff   48 17 Jul 18:41 pwd.rb"
-    ]
+    it "yields each received line to the passed block" do
+      res = []
+      @ftp.retrlines("LIST test.dir") { |x| res << x }
+      res.should == [
+        "-rw-r--r--  1 spec  staff  507 17 Jul 18:41 last_response_code.rb",
+        "-rw-r--r--  1 spec  staff   50 17 Jul 18:41 list.rb",
+        "-rw-r--r--  1 spec  staff   48 17 Jul 18:41 pwd.rb"
+      ]
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/return_code_spec.rb b/spec/ruby/library/net-ftp/return_code_spec.rb
index 35a6232f7e..fcf5a32aa7 100644
--- a/spec/ruby/library/net-ftp/return_code_spec.rb
+++ b/spec/ruby/library/net-ftp/return_code_spec.rb
@@ -1,24 +1,27 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
 
-describe "Net::FTP#return_code" do
-  before :each do
-    @ftp = Net::FTP.new
-  end
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
 
-  it "outputs a warning and returns a newline" do
-    -> do
-      @ftp.return_code.should == "\n"
-    end.should complain(/warning: Net::FTP#return_code is obsolete and do nothing/)
-  end
-end
+  describe "Net::FTP#return_code" do
+    before :each do
+      @ftp = Net::FTP.new
+    end
 
-describe "Net::FTP#return_code=" do
-  before :each do
-    @ftp = Net::FTP.new
+    it "outputs a warning and returns a newline" do
+      -> do
+        @ftp.return_code.should == "\n"
+      end.should complain(/warning: Net::FTP#return_code is obsolete and do nothing/)
+    end
   end
 
-  it "outputs a warning" do
-    -> { @ftp.return_code = 123 }.should complain(/warning: Net::FTP#return_code= is obsolete and do nothing/)
+  describe "Net::FTP#return_code=" do
+    before :each do
+      @ftp = Net::FTP.new
+    end
+
+    it "outputs a warning" do
+      -> { @ftp.return_code = 123 }.should complain(/warning: Net::FTP#return_code= is obsolete and do nothing/)
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/rmdir_spec.rb b/spec/ruby/library/net-ftp/rmdir_spec.rb
index 400874d60d..0b52b53782 100644
--- a/spec/ruby/library/net-ftp/rmdir_spec.rb
+++ b/spec/ruby/library/net-ftp/rmdir_spec.rb
@@ -1,58 +1,61 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
 
-describe "Net::FTP#rmdir" do
-  before :each do
-    @server = NetFTPSpecs::DummyFTP.new
-    @server.serve_once
-
-    @ftp = Net::FTP.new
-    @ftp.connect(@server.hostname, @server.server_port)
-  end
-
-  after :each do
-    @ftp.quit rescue nil
-    @ftp.close
-    @server.stop
-  end
-
-  it "sends the RMD command with the passed pathname to the server" do
-    @ftp.rmdir("test.folder")
-    @ftp.last_response.should == "250 Requested file action okay, completed. (RMD test.folder)\n"
-  end
-
-  it "returns nil" do
-    @ftp.rmdir("test.folder").should be_nil
-  end
-
-  it "raises a Net::FTPPermError when the response code is 500" do
-    @server.should_receive(:rmd).and_respond("500 Syntax error, command unrecognized.")
-    -> { @ftp.rmdir("test.folder") }.should raise_error(Net::FTPPermError)
-  end
-
-  it "raises a Net::FTPPermError when the response code is 501" do
-    @server.should_receive(:rmd).and_respond("501 Syntax error in parameters or arguments.")
-    -> { @ftp.rmdir("test.folder") }.should raise_error(Net::FTPPermError)
-  end
-
-  it "raises a Net::FTPPermError when the response code is 502" do
-    @server.should_receive(:rmd).and_respond("502 Command not implemented.")
-    -> { @ftp.rmdir("test.folder") }.should raise_error(Net::FTPPermError)
-  end
-
-  it "raises a Net::FTPTempError when the response code is 421" do
-    @server.should_receive(:rmd).and_respond("421 Service not available, closing control connection.")
-    -> { @ftp.rmdir("test.folder") }.should raise_error(Net::FTPTempError)
-  end
-
-  it "raises a Net::FTPPermError when the response code is 530" do
-    @server.should_receive(:rmd).and_respond("530 Not logged in.")
-    -> { @ftp.rmdir("test.folder") }.should raise_error(Net::FTPPermError)
-  end
-
-  it "raises a Net::FTPPermError when the response code is 550" do
-    @server.should_receive(:rmd).and_respond("550 Requested action not taken.")
-    -> { @ftp.rmdir("test.folder") }.should raise_error(Net::FTPPermError)
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
+
+  describe "Net::FTP#rmdir" do
+    before :each do
+      @server = NetFTPSpecs::DummyFTP.new
+      @server.serve_once
+
+      @ftp = Net::FTP.new
+      @ftp.connect(@server.hostname, @server.server_port)
+    end
+
+    after :each do
+      @ftp.quit rescue nil
+      @ftp.close
+      @server.stop
+    end
+
+    it "sends the RMD command with the passed pathname to the server" do
+      @ftp.rmdir("test.folder")
+      @ftp.last_response.should == "250 Requested file action okay, completed. (RMD test.folder)\n"
+    end
+
+    it "returns nil" do
+      @ftp.rmdir("test.folder").should be_nil
+    end
+
+    it "raises a Net::FTPPermError when the response code is 500" do
+      @server.should_receive(:rmd).and_respond("500 Syntax error, command unrecognized.")
+      -> { @ftp.rmdir("test.folder") }.should raise_error(Net::FTPPermError)
+    end
+
+    it "raises a Net::FTPPermError when the response code is 501" do
+      @server.should_receive(:rmd).and_respond("501 Syntax error in parameters or arguments.")
+      -> { @ftp.rmdir("test.folder") }.should raise_error(Net::FTPPermError)
+    end
+
+    it "raises a Net::FTPPermError when the response code is 502" do
+      @server.should_receive(:rmd).and_respond("502 Command not implemented.")
+      -> { @ftp.rmdir("test.folder") }.should raise_error(Net::FTPPermError)
+    end
+
+    it "raises a Net::FTPTempError when the response code is 421" do
+      @server.should_receive(:rmd).and_respond("421 Service not available, closing control connection.")
+      -> { @ftp.rmdir("test.folder") }.should raise_error(Net::FTPTempError)
+    end
+
+    it "raises a Net::FTPPermError when the response code is 530" do
+      @server.should_receive(:rmd).and_respond("530 Not logged in.")
+      -> { @ftp.rmdir("test.folder") }.should raise_error(Net::FTPPermError)
+    end
+
+    it "raises a Net::FTPPermError when the response code is 550" do
+      @server.should_receive(:rmd).and_respond("550 Requested action not taken.")
+      -> { @ftp.rmdir("test.folder") }.should raise_error(Net::FTPPermError)
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/sendcmd_spec.rb b/spec/ruby/library/net-ftp/sendcmd_spec.rb
index c50b373869..5deca804b2 100644
--- a/spec/ruby/library/net-ftp/sendcmd_spec.rb
+++ b/spec/ruby/library/net-ftp/sendcmd_spec.rb
@@ -1,54 +1,57 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
 
-describe "Net::FTP#sendcmd" do
-  before :each do
-    @server = NetFTPSpecs::DummyFTP.new
-    @server.serve_once
-
-    @ftp = Net::FTP.new
-    @ftp.connect(@server.hostname, @server.server_port)
-  end
-
-  after :each do
-    @ftp.quit rescue nil
-    @ftp.close
-    @server.stop
-  end
-
-  it "sends the passed command to the server" do
-    @ftp.sendcmd("HELP")
-    @ftp.last_response.should == "211 System status, or system help reply. (HELP)\n"
-  end
-
-  it "returns the server's response" do
-    @ftp.sendcmd("HELP").should == "211 System status, or system help reply. (HELP)\n"
-  end
-
-  it "raises no error when the response code is 1xx, 2xx or 3xx" do
-    @server.should_receive(:help).and_respond("120 Service ready in nnn minutes.")
-    -> { @ftp.sendcmd("HELP") }.should_not raise_error
-
-    @server.should_receive(:help).and_respond("200 Command okay.")
-    -> { @ftp.sendcmd("HELP") }.should_not raise_error
-
-    @server.should_receive(:help).and_respond("350 Requested file action pending further information.")
-    -> { @ftp.sendcmd("HELP") }.should_not raise_error
-  end
-
-  it "raises a Net::FTPTempError when the response code is 4xx" do
-    @server.should_receive(:help).and_respond("421 Service not available, closing control connection.")
-    -> { @ftp.sendcmd("HELP") }.should raise_error(Net::FTPTempError)
-  end
-
-  it "raises a Net::FTPPermError when the response code is 5xx" do
-    @server.should_receive(:help).and_respond("500 Syntax error, command unrecognized.")
-    -> { @ftp.sendcmd("HELP") }.should raise_error(Net::FTPPermError)
-  end
-
-  it "raises a Net::FTPProtoError when the response code is not between 1xx-5xx" do
-    @server.should_receive(:help).and_respond("999 Invalid response.")
-    -> { @ftp.sendcmd("HELP") }.should raise_error(Net::FTPProtoError)
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
+
+  describe "Net::FTP#sendcmd" do
+    before :each do
+      @server = NetFTPSpecs::DummyFTP.new
+      @server.serve_once
+
+      @ftp = Net::FTP.new
+      @ftp.connect(@server.hostname, @server.server_port)
+    end
+
+    after :each do
+      @ftp.quit rescue nil
+      @ftp.close
+      @server.stop
+    end
+
+    it "sends the passed command to the server" do
+      @ftp.sendcmd("HELP")
+      @ftp.last_response.should == "211 System status, or system help reply. (HELP)\n"
+    end
+
+    it "returns the server's response" do
+      @ftp.sendcmd("HELP").should == "211 System status, or system help reply. (HELP)\n"
+    end
+
+    it "raises no error when the response code is 1xx, 2xx or 3xx" do
+      @server.should_receive(:help).and_respond("120 Service ready in nnn minutes.")
+      -> { @ftp.sendcmd("HELP") }.should_not raise_error
+
+      @server.should_receive(:help).and_respond("200 Command okay.")
+      -> { @ftp.sendcmd("HELP") }.should_not raise_error
+
+      @server.should_receive(:help).and_respond("350 Requested file action pending further information.")
+      -> { @ftp.sendcmd("HELP") }.should_not raise_error
+    end
+
+    it "raises a Net::FTPTempError when the response code is 4xx" do
+      @server.should_receive(:help).and_respond("421 Service not available, closing control connection.")
+      -> { @ftp.sendcmd("HELP") }.should raise_error(Net::FTPTempError)
+    end
+
+    it "raises a Net::FTPPermError when the response code is 5xx" do
+      @server.should_receive(:help).and_respond("500 Syntax error, command unrecognized.")
+      -> { @ftp.sendcmd("HELP") }.should raise_error(Net::FTPPermError)
+    end
+
+    it "raises a Net::FTPProtoError when the response code is not between 1xx-5xx" do
+      @server.should_receive(:help).and_respond("999 Invalid response.")
+      -> { @ftp.sendcmd("HELP") }.should raise_error(Net::FTPProtoError)
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/set_socket_spec.rb b/spec/ruby/library/net-ftp/set_socket_spec.rb
index 8182dd8b33..ad83dfcc4f 100644
--- a/spec/ruby/library/net-ftp/set_socket_spec.rb
+++ b/spec/ruby/library/net-ftp/set_socket_spec.rb
@@ -1,8 +1,11 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
 
-describe "Net::FTP#set_socket" do
-  # TODO: I won't spec this method, as it is not used
-  #       anywhere and it should be private anyway.
-  it "needs to be reviewed for spec completeness"
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+
+  describe "Net::FTP#set_socket" do
+    # TODO: I won't spec this method, as it is not used
+    #       anywhere and it should be private anyway.
+    it "needs to be reviewed for spec completeness"
+  end
 end
diff --git a/spec/ruby/library/net-ftp/shared/getbinaryfile.rb b/spec/ruby/library/net-ftp/shared/getbinaryfile.rb
index ceec8e7cd5..a5bf693fdc 100644
--- a/spec/ruby/library/net-ftp/shared/getbinaryfile.rb
+++ b/spec/ruby/library/net-ftp/shared/getbinaryfile.rb
@@ -1,150 +1,152 @@
-describe :net_ftp_getbinaryfile, shared: true do
-  before :each do
-    @fixture_file = __dir__ + "/../fixtures/getbinaryfile"
-    @tmp_file = tmp("getbinaryfile")
+ruby_version_is ""..."4.1" do
+  describe :net_ftp_getbinaryfile, shared: true do
+    before :each do
+      @fixture_file = __dir__ + "/../fixtures/getbinaryfile"
+      @tmp_file = tmp("getbinaryfile")
 
-    @server = NetFTPSpecs::DummyFTP.new
-    @server.serve_once
+      @server = NetFTPSpecs::DummyFTP.new
+      @server.serve_once
 
-    @ftp = Net::FTP.new
-    @ftp.connect(@server.hostname, @server.server_port)
-    @ftp.binary = @binary_mode
-  end
+      @ftp = Net::FTP.new
+      @ftp.connect(@server.hostname, @server.server_port)
+      @ftp.binary = @binary_mode
+    end
 
-  after :each do
-    @ftp.quit rescue nil
-    @ftp.close
-    @server.stop
+    after :each do
+      @ftp.quit rescue nil
+      @ftp.close
+      @server.stop
 
-    rm_r @tmp_file
-  end
+      rm_r @tmp_file
+    end
 
-  it "sends the RETR command to the server" do
-    @ftp.send(@method, "test", @tmp_file)
-    @ftp.last_response.should == "226 Closing data connection. (RETR test)\n"
-  end
+    it "sends the RETR command to the server" do
+      @ftp.send(@method, "test", @tmp_file)
+      @ftp.last_response.should == "226 Closing data connection. (RETR test)\n"
+    end
 
-  it "returns nil" do
-    @ftp.send(@method, "test", @tmp_file).should be_nil
-  end
+    it "returns nil" do
+      @ftp.send(@method, "test", @tmp_file).should be_nil
+    end
 
-  it "saves the contents of the passed remote file to the passed local file" do
-    @ftp.send(@method, "test", @tmp_file)
-    File.read(@tmp_file).should == "This is the content\nof the file named 'test'.\n"
-  end
+    it "saves the contents of the passed remote file to the passed local file" do
+      @ftp.send(@method, "test", @tmp_file)
+      File.read(@tmp_file).should == "This is the content\nof the file named 'test'.\n"
+    end
 
-  describe "when passed a block" do
-    it "yields the received content as binary blocks of the passed size" do
-      res = []
-      @ftp.send(@method, "test", @tmp_file, 10) { |bin| res << bin }
-      res.should == [ "This is th", "e content\n", "of the fil", "e named 't", "est'.\n" ]
+    describe "when passed a block" do
+      it "yields the received content as binary blocks of the passed size" do
+        res = []
+        @ftp.send(@method, "test", @tmp_file, 10) { |bin| res << bin }
+        res.should == [ "This is th", "e content\n", "of the fil", "e named 't", "est'.\n" ]
+      end
     end
-  end
 
-  describe "when resuming an existing file" do
-    before :each do
-      @tmp_file = tmp("getbinaryfile_resume")
+    describe "when resuming an existing file" do
+      before :each do
+        @tmp_file = tmp("getbinaryfile_resume")
 
-      File.open(@tmp_file, "wb") do |f|
-        f << "This is the content\n"
+        File.open(@tmp_file, "wb") do |f|
+          f << "This is the content\n"
+        end
+
+        @ftp.resume = true
       end
 
-      @ftp.resume = true
-    end
+      it "saves the remaining content of the passed remote file to the passed local file" do
+        @ftp.send(@method, "test", @tmp_file)
+        File.read(@tmp_file).should == "This is the content\nof the file named 'test'.\n"
+      end
 
-    it "saves the remaining content of the passed remote file to the passed local file" do
-      @ftp.send(@method, "test", @tmp_file)
-      File.read(@tmp_file).should == "This is the content\nof the file named 'test'.\n"
+      describe "and the REST command fails" do
+        it "raises a Net::FTPProtoError when the response code is 550" do
+          @server.should_receive(:rest).and_respond("Requested action not taken.")
+          -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPProtoError)
+        end
+
+        it "raises a Net::FTPPermError when the response code is 500" do
+          @server.should_receive(:rest).and_respond("500 Syntax error, command unrecognized.")
+          -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPPermError)
+        end
+
+        it "raises a Net::FTPPermError when the response code is 501" do
+          @server.should_receive(:rest).and_respond("501 Syntax error, command unrecognized.")
+          -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPPermError)
+        end
+
+        it "raises a Net::FTPPermError when the response code is 502" do
+          @server.should_receive(:rest).and_respond("502 Command not implemented.")
+          -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPPermError)
+        end
+
+        it "raises a Net::FTPTempError when the response code is 421" do
+          @server.should_receive(:rest).and_respond("421 Service not available, closing control connection.")
+          -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPTempError)
+        end
+
+        it "raises a Net::FTPPermError when the response code is 530" do
+          @server.should_receive(:rest).and_respond("530 Not logged in.")
+          -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPPermError)
+        end
+      end
     end
 
-    describe "and the REST command fails" do
+    describe "when the RETR command fails" do
+      it "raises a Net::FTPTempError when the response code is 450" do
+        @server.should_receive(:retr).and_respond("450 Requested file action not taken.")
+        -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPTempError)
+      end
+
       it "raises a Net::FTPProtoError when the response code is 550" do
-        @server.should_receive(:rest).and_respond("Requested action not taken.")
+        @server.should_receive(:retr).and_respond("Requested action not taken.")
         -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPProtoError)
       end
 
       it "raises a Net::FTPPermError when the response code is 500" do
-        @server.should_receive(:rest).and_respond("500 Syntax error, command unrecognized.")
+        @server.should_receive(:retr).and_respond("500 Syntax error, command unrecognized.")
         -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPPermError)
       end
 
       it "raises a Net::FTPPermError when the response code is 501" do
-        @server.should_receive(:rest).and_respond("501 Syntax error, command unrecognized.")
-        -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPPermError)
-      end
-
-      it "raises a Net::FTPPermError when the response code is 502" do
-        @server.should_receive(:rest).and_respond("502 Command not implemented.")
+        @server.should_receive(:retr).and_respond("501 Syntax error, command unrecognized.")
         -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPPermError)
       end
 
       it "raises a Net::FTPTempError when the response code is 421" do
-        @server.should_receive(:rest).and_respond("421 Service not available, closing control connection.")
+        @server.should_receive(:retr).and_respond("421 Service not available, closing control connection.")
         -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPTempError)
       end
 
       it "raises a Net::FTPPermError when the response code is 530" do
-        @server.should_receive(:rest).and_respond("530 Not logged in.")
+        @server.should_receive(:retr).and_respond("530 Not logged in.")
         -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPPermError)
       end
     end
-  end
-
-  describe "when the RETR command fails" do
-    it "raises a Net::FTPTempError when the response code is 450" do
-      @server.should_receive(:retr).and_respond("450 Requested file action not taken.")
-      -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPTempError)
-    end
-
-    it "raises a Net::FTPProtoError when the response code is 550" do
-      @server.should_receive(:retr).and_respond("Requested action not taken.")
-      -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPProtoError)
-    end
-
-    it "raises a Net::FTPPermError when the response code is 500" do
-      @server.should_receive(:retr).and_respond("500 Syntax error, command unrecognized.")
-      -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPPermError)
-    end
 
-    it "raises a Net::FTPPermError when the response code is 501" do
-      @server.should_receive(:retr).and_respond("501 Syntax error, command unrecognized.")
-      -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPPermError)
-    end
-
-    it "raises a Net::FTPTempError when the response code is 421" do
-      @server.should_receive(:retr).and_respond("421 Service not available, closing control connection.")
-      -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPTempError)
-    end
-
-    it "raises a Net::FTPPermError when the response code is 530" do
-      @server.should_receive(:retr).and_respond("530 Not logged in.")
-      -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPPermError)
-    end
-  end
-
-  describe "when opening the data port fails" do
-    it "raises a Net::FTPPermError when the response code is 500" do
-      @server.should_receive(:eprt).and_respond("500 Syntax error, command unrecognized.")
-      @server.should_receive(:port).and_respond("500 Syntax error, command unrecognized.")
-      -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPPermError)
-    end
+    describe "when opening the data port fails" do
+      it "raises a Net::FTPPermError when the response code is 500" do
+        @server.should_receive(:eprt).and_respond("500 Syntax error, command unrecognized.")
+        @server.should_receive(:port).and_respond("500 Syntax error, command unrecognized.")
+        -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPPermError)
+      end
 
-    it "raises a Net::FTPPermError when the response code is 501" do
-      @server.should_receive(:eprt).and_respond("501 Syntax error in parameters or arguments.")
-      @server.should_receive(:port).and_respond("501 Syntax error in parameters or arguments.")
-      -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPPermError)
-    end
+      it "raises a Net::FTPPermError when the response code is 501" do
+        @server.should_receive(:eprt).and_respond("501 Syntax error in parameters or arguments.")
+        @server.should_receive(:port).and_respond("501 Syntax error in parameters or arguments.")
+        -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPPermError)
+      end
 
-    it "raises a Net::FTPTempError when the response code is 421" do
-      @server.should_receive(:eprt).and_respond("421 Service not available, closing control connection.")
-      @server.should_receive(:port).and_respond("421 Service not available, closing control connection.")
-      -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPTempError)
-    end
+      it "raises a Net::FTPTempError when the response code is 421" do
+        @server.should_receive(:eprt).and_respond("421 Service not available, closing control connection.")
+        @server.should_receive(:port).and_respond("421 Service not available, closing control connection.")
+        -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPTempError)
+      end
 
-    it "raises a Net::FTPPermError when the response code is 530" do
-      @server.should_receive(:eprt).and_respond("530 Not logged in.")
-      @server.should_receive(:port).and_respond("530 Not logged in.")
-      -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPPermError)
+      it "raises a Net::FTPPermError when the response code is 530" do
+        @server.should_receive(:eprt).and_respond("530 Not logged in.")
+        @server.should_receive(:port).and_respond("530 Not logged in.")
+        -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPPermError)
+      end
     end
   end
 end
diff --git a/spec/ruby/library/net-ftp/shared/gettextfile.rb b/spec/ruby/library/net-ftp/shared/gettextfile.rb
index 7fe14f7dfb..4b40c3e5c2 100644
--- a/spec/ruby/library/net-ftp/shared/gettextfile.rb
+++ b/spec/ruby/library/net-ftp/shared/gettextfile.rb
@@ -1,100 +1,102 @@
-describe :net_ftp_gettextfile, shared: true do
-  before :each do
-    @tmp_file = tmp("gettextfile")
+ruby_version_is ""..."4.1" do
+  describe :net_ftp_gettextfile, shared: true do
+    before :each do
+      @tmp_file = tmp("gettextfile")
 
-    @server = NetFTPSpecs::DummyFTP.new
-    @server.serve_once
+      @server = NetFTPSpecs::DummyFTP.new
+      @server.serve_once
 
-    @ftp = Net::FTP.new
-    @ftp.connect(@server.hostname, @server.server_port)
-    @ftp.binary = @binary_mode
-  end
-
-  after :each do
-    @ftp.quit rescue nil
-    @ftp.close
-    @server.stop
-
-    rm_r @tmp_file
-  end
-
-  it "sends the RETR command to the server" do
-    @ftp.send(@method, "test", @tmp_file)
-    @ftp.last_response.should == "226 Closing data connection. (RETR test)\n"
-  end
-
-  it "returns nil" do
-    @ftp.send(@method, "test", @tmp_file).should be_nil
-  end
-
-  it "saves the contents of the passed remote file to the passed local file" do
-    @ftp.send(@method, "test", @tmp_file)
-    File.read(@tmp_file).should == "This is the content\nof the file named 'test'.\n"
-  end
-
-  describe "when passed a block" do
-    it "yields each line of the retrieved file to the passed block" do
-      res = []
-      @ftp.send(@method, "test", @tmp_file) { |line| res << line }
-      res.should == [ "This is the content", "of the file named 'test'."]
+      @ftp = Net::FTP.new
+      @ftp.connect(@server.hostname, @server.server_port)
+      @ftp.binary = @binary_mode
     end
-  end
 
-  describe "when the RETR command fails" do
-    it "raises a Net::FTPTempError when the response code is 450" do
-      @server.should_receive(:retr).and_respond("450 Requested file action not taken.")
-      -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPTempError)
-    end
+    after :each do
+      @ftp.quit rescue nil
+      @ftp.close
+      @server.stop
 
-    it "raises a Net::FTPProtoError when the response code is 550" do
-      @server.should_receive(:retr).and_respond("Requested action not taken.")
-      -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPProtoError)
+      rm_r @tmp_file
     end
 
-    it "raises a Net::FTPPermError when the response code is 500" do
-      @server.should_receive(:retr).and_respond("500 Syntax error, command unrecognized.")
-      -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPPermError)
+    it "sends the RETR command to the server" do
+      @ftp.send(@method, "test", @tmp_file)
+      @ftp.last_response.should == "226 Closing data connection. (RETR test)\n"
     end
 
-    it "raises a Net::FTPPermError when the response code is 501" do
-      @server.should_receive(:retr).and_respond("501 Syntax error, command unrecognized.")
-      -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPPermError)
+    it "returns nil" do
+      @ftp.send(@method, "test", @tmp_file).should be_nil
     end
 
-    it "raises a Net::FTPTempError when the response code is 421" do
-      @server.should_receive(:retr).and_respond("421 Service not available, closing control connection.")
-      -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPTempError)
-    end
-
-    it "raises a Net::FTPPermError when the response code is 530" do
-      @server.should_receive(:retr).and_respond("530 Not logged in.")
-      -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPPermError)
-    end
-  end
-
-  describe "when opening the data port fails" do
-    it "raises a Net::FTPPermError when the response code is 500" do
-      @server.should_receive(:eprt).and_respond("500 Syntax error, command unrecognized.")
-      @server.should_receive(:port).and_respond("500 Syntax error, command unrecognized.")
-      -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPPermError)
+    it "saves the contents of the passed remote file to the passed local file" do
+      @ftp.send(@method, "test", @tmp_file)
+      File.read(@tmp_file).should == "This is the content\nof the file named 'test'.\n"
     end
 
-    it "raises a Net::FTPPermError when the response code is 501" do
-      @server.should_receive(:eprt).and_respond("501 Syntax error in parameters or arguments.")
-      @server.should_receive(:port).and_respond("501 Syntax error in parameters or arguments.")
-      -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPPermError)
+    describe "when passed a block" do
+      it "yields each line of the retrieved file to the passed block" do
+        res = []
+        @ftp.send(@method, "test", @tmp_file) { |line| res << line }
+        res.should == [ "This is the content", "of the file named 'test'."]
+      end
     end
 
-    it "raises a Net::FTPTempError when the response code is 421" do
-      @server.should_receive(:eprt).and_respond("421 Service not available, closing control connection.")
-      @server.should_receive(:port).and_respond("421 Service not available, closing control connection.")
-      -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPTempError)
+    describe "when the RETR command fails" do
+      it "raises a Net::FTPTempError when the response code is 450" do
+        @server.should_receive(:retr).and_respond("450 Requested file action not taken.")
+        -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPTempError)
+      end
+
+      it "raises a Net::FTPProtoError when the response code is 550" do
+        @server.should_receive(:retr).and_respond("Requested action not taken.")
+        -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPProtoError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 500" do
+        @server.should_receive(:retr).and_respond("500 Syntax error, command unrecognized.")
+        -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 501" do
+        @server.should_receive(:retr).and_respond("501 Syntax error, command unrecognized.")
+        -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPTempError when the response code is 421" do
+        @server.should_receive(:retr).and_respond("421 Service not available, closing control connection.")
+        -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPTempError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 530" do
+        @server.should_receive(:retr).and_respond("530 Not logged in.")
+        -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPPermError)
+      end
     end
 
-    it "raises a Net::FTPPermError when the response code is 530" do
-      @server.should_receive(:eprt).and_respond("530 Not logged in.")
-      @server.should_receive(:port).and_respond("530 Not logged in.")
-      -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPPermError)
+    describe "when opening the data port fails" do
+      it "raises a Net::FTPPermError when the response code is 500" do
+        @server.should_receive(:eprt).and_respond("500 Syntax error, command unrecognized.")
+        @server.should_receive(:port).and_respond("500 Syntax error, command unrecognized.")
+        -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 501" do
+        @server.should_receive(:eprt).and_respond("501 Syntax error in parameters or arguments.")
+        @server.should_receive(:port).and_respond("501 Syntax error in parameters or arguments.")
+        -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPTempError when the response code is 421" do
+        @server.should_receive(:eprt).and_respond("421 Service not available, closing control connection.")
+        @server.should_receive(:port).and_respond("421 Service not available, closing control connection.")
+        -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPTempError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 530" do
+        @server.should_receive(:eprt).and_respond("530 Not logged in.")
+        @server.should_receive(:port).and_respond("530 Not logged in.")
+        -> { @ftp.send(@method, "test", @tmp_file) }.should raise_error(Net::FTPPermError)
+      end
     end
   end
 end
diff --git a/spec/ruby/library/net-ftp/shared/last_response_code.rb b/spec/ruby/library/net-ftp/shared/last_response_code.rb
index 4fe53677db..9d36e37f0c 100644
--- a/spec/ruby/library/net-ftp/shared/last_response_code.rb
+++ b/spec/ruby/library/net-ftp/shared/last_response_code.rb
@@ -1,25 +1,27 @@
-describe :net_ftp_last_response_code, shared: true do
-  before :each do
-    @server = NetFTPSpecs::DummyFTP.new
-    @server.serve_once
+ruby_version_is ""..."4.1" do
+  describe :net_ftp_last_response_code, shared: true do
+    before :each do
+      @server = NetFTPSpecs::DummyFTP.new
+      @server.serve_once
 
-    @ftp = Net::FTP.new
-    @ftp.connect(@server.hostname, @server.server_port)
-  end
+      @ftp = Net::FTP.new
+      @ftp.connect(@server.hostname, @server.server_port)
+    end
 
-  after :each do
-    @ftp.quit rescue nil
-    @ftp.close
-    @server.stop
-  end
+    after :each do
+      @ftp.quit rescue nil
+      @ftp.close
+      @server.stop
+    end
 
-  it "returns the response code for the last response" do
-    @server.should_receive(:help).and_respond("200 Command okay.")
-    @ftp.help
-    @ftp.send(@method).should == "200"
+    it "returns the response code for the last response" do
+      @server.should_receive(:help).and_respond("200 Command okay.")
+      @ftp.help
+      @ftp.send(@method).should == "200"
 
-    @server.should_receive(:help).and_respond("212 Directory status.")
-    @ftp.help
-    @ftp.send(@method).should == "212"
+      @server.should_receive(:help).and_respond("212 Directory status.")
+      @ftp.help
+      @ftp.send(@method).should == "212"
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/shared/list.rb b/spec/ruby/library/net-ftp/shared/list.rb
index adc3fa59c1..72cfed178d 100644
--- a/spec/ruby/library/net-ftp/shared/list.rb
+++ b/spec/ruby/library/net-ftp/shared/list.rb
@@ -1,104 +1,106 @@
-describe :net_ftp_list, shared: true do
-  before :each do
-    @server = NetFTPSpecs::DummyFTP.new
-    @server.serve_once
-
-    @ftp = Net::FTP.new
-    @ftp.passive = false
-    @ftp.connect(@server.hostname, @server.server_port)
-  end
-
-  after :each do
-    @ftp.quit rescue nil
-    @ftp.close
-    @server.stop
-  end
-
-  describe "when passed a block" do
-    it "yields each file in the list of files in the passed dir" do
-      expected = [
-        "-rw-r--r--  1 spec  staff  507 17 Jul 18:41 last_response_code.rb",
-        "-rw-r--r--  1 spec  staff   50 17 Jul 18:41 list.rb",
-        "-rw-r--r--  1 spec  staff   48 17 Jul 18:41 pwd.rb"
-      ]
-
-      res = []
-      @ftp.send(@method, "test.folder") { |line| res << line}
-      res.should == expected
-
-      @ftp.last_response.should == "226 transfer complete (LIST test.folder)\n"
+ruby_version_is ""..."4.1" do
+  describe :net_ftp_list, shared: true do
+    before :each do
+      @server = NetFTPSpecs::DummyFTP.new
+      @server.serve_once
+
+      @ftp = Net::FTP.new
+      @ftp.passive = false
+      @ftp.connect(@server.hostname, @server.server_port)
     end
-  end
-
-  describe "when passed no block" do
-    it "returns an Array containing a list of files in the passed dir" do
-      expected = [
-        "-rw-r--r--  1 spec  staff  507 17 Jul 18:41 last_response_code.rb",
-        "-rw-r--r--  1 spec  staff   50 17 Jul 18:41 list.rb",
-        "-rw-r--r--  1 spec  staff   48 17 Jul 18:41 pwd.rb"
-      ]
 
-      @ftp.send(@method, "test.folder").should == expected
-
-      @ftp.last_response.should == "226 transfer complete (LIST test.folder)\n"
+    after :each do
+      @ftp.quit rescue nil
+      @ftp.close
+      @server.stop
     end
-  end
 
-  describe "when the LIST command fails" do
-    it "raises a Net::FTPTempError when the response code is 450" do
-      @server.should_receive(:list).and_respond("450 Requested file action not taken..")
-      -> { @ftp.send(@method) }.should raise_error(Net::FTPTempError)
-    end
+    describe "when passed a block" do
+      it "yields each file in the list of files in the passed dir" do
+        expected = [
+          "-rw-r--r--  1 spec  staff  507 17 Jul 18:41 last_response_code.rb",
+          "-rw-r--r--  1 spec  staff   50 17 Jul 18:41 list.rb",
+          "-rw-r--r--  1 spec  staff   48 17 Jul 18:41 pwd.rb"
+        ]
 
-    it "raises a Net::FTPPermError when the response code is 500" do
-      @server.should_receive(:list).and_respond("500 Syntax error, command unrecognized.")
-      -> { @ftp.send(@method) }.should raise_error(Net::FTPPermError)
-    end
+        res = []
+        @ftp.send(@method, "test.folder") { |line| res << line}
+        res.should == expected
 
-    it "raises a Net::FTPPermError when the response code is 501" do
-      @server.should_receive(:list).and_respond("501 Syntax error, command unrecognized.")
-      -> { @ftp.send(@method) }.should raise_error(Net::FTPPermError)
+        @ftp.last_response.should == "226 transfer complete (LIST test.folder)\n"
+      end
     end
 
-    it "raises a Net::FTPPermError when the response code is 502" do
-      @server.should_receive(:list).and_respond("502 Command not implemented.")
-      -> { @ftp.send(@method) }.should raise_error(Net::FTPPermError)
-    end
-
-    it "raises a Net::FTPTempError when the response code is 421" do
-      @server.should_receive(:list).and_respond("421 Service not available, closing control connection.")
-      -> { @ftp.send(@method) }.should raise_error(Net::FTPTempError)
-    end
+    describe "when passed no block" do
+      it "returns an Array containing a list of files in the passed dir" do
+        expected = [
+          "-rw-r--r--  1 spec  staff  507 17 Jul 18:41 last_response_code.rb",
+          "-rw-r--r--  1 spec  staff   50 17 Jul 18:41 list.rb",
+          "-rw-r--r--  1 spec  staff   48 17 Jul 18:41 pwd.rb"
+        ]
 
-    it "raises a Net::FTPPermError when the response code is 530" do
-      @server.should_receive(:list).and_respond("530 Not logged in.")
-      -> { @ftp.send(@method) }.should raise_error(Net::FTPPermError)
-    end
-  end
-
-  describe "when opening the data port fails" do
-    it "raises a Net::FTPPermError when the response code is 500" do
-      @server.should_receive(:eprt).and_respond("500 Syntax error, command unrecognized.")
-      @server.should_receive(:port).and_respond("500 Syntax error, command unrecognized.")
-      -> { @ftp.send(@method) }.should raise_error(Net::FTPPermError)
-    end
+        @ftp.send(@method, "test.folder").should == expected
 
-    it "raises a Net::FTPPermError when the response code is 501" do
-      @server.should_receive(:eprt).and_respond("501 Syntax error in parameters or arguments.")
-      @server.should_receive(:port).and_respond("501 Syntax error in parameters or arguments.")
-      -> { @ftp.send(@method) }.should raise_error(Net::FTPPermError)
+        @ftp.last_response.should == "226 transfer complete (LIST test.folder)\n"
+      end
     end
 
-    it "raises a Net::FTPTempError when the response code is 421" do
-      @server.should_receive(:eprt).and_respond("421 Service not available, closing control connection.")
-      @server.should_receive(:port).and_respond("421 Service not available, closing control connection.")
-      -> { @ftp.send(@method) }.should raise_error(Net::FTPTempError)
+    describe "when the LIST command fails" do
+      it "raises a Net::FTPTempError when the response code is 450" do
+        @server.should_receive(:list).and_respond("450 Requested file action not taken..")
+        -> { @ftp.send(@method) }.should raise_error(Net::FTPTempError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 500" do
+        @server.should_receive(:list).and_respond("500 Syntax error, command unrecognized.")
+        -> { @ftp.send(@method) }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 501" do
+        @server.should_receive(:list).and_respond("501 Syntax error, command unrecognized.")
+        -> { @ftp.send(@method) }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 502" do
+        @server.should_receive(:list).and_respond("502 Command not implemented.")
+        -> { @ftp.send(@method) }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPTempError when the response code is 421" do
+        @server.should_receive(:list).and_respond("421 Service not available, closing control connection.")
+        -> { @ftp.send(@method) }.should raise_error(Net::FTPTempError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 530" do
+        @server.should_receive(:list).and_respond("530 Not logged in.")
+        -> { @ftp.send(@method) }.should raise_error(Net::FTPPermError)
+      end
     end
 
-    it "raises a Net::FTPPermError when the response code is 530" do
-      @server.should_receive(:eprt).and_respond("530 Not logged in.")
-      @server.should_receive(:port).and_respond("530 Not logged in.")
-      -> { @ftp.send(@method) }.should raise_error(Net::FTPPermError)
+    describe "when opening the data port fails" do
+      it "raises a Net::FTPPermError when the response code is 500" do
+        @server.should_receive(:eprt).and_respond("500 Syntax error, command unrecognized.")
+        @server.should_receive(:port).and_respond("500 Syntax error, command unrecognized.")
+        -> { @ftp.send(@method) }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 501" do
+        @server.should_receive(:eprt).and_respond("501 Syntax error in parameters or arguments.")
+        @server.should_receive(:port).and_respond("501 Syntax error in parameters or arguments.")
+        -> { @ftp.send(@method) }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPTempError when the response code is 421" do
+        @server.should_receive(:eprt).and_respond("421 Service not available, closing control connection.")
+        @server.should_receive(:port).and_respond("421 Service not available, closing control connection.")
+        -> { @ftp.send(@method) }.should raise_error(Net::FTPTempError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 530" do
+        @server.should_receive(:eprt).and_respond("530 Not logged in.")
+        @server.should_receive(:port).and_respond("530 Not logged in.")
+        -> { @ftp.send(@method) }.should raise_error(Net::FTPPermError)
+      end
     end
   end
 end
diff --git a/spec/ruby/library/net-ftp/shared/putbinaryfile.rb b/spec/ruby/library/net-ftp/shared/putbinaryfile.rb
index 45f53adc2a..2024f384fd 100644
--- a/spec/ruby/library/net-ftp/shared/putbinaryfile.rb
+++ b/spec/ruby/library/net-ftp/shared/putbinaryfile.rb
@@ -1,167 +1,169 @@
-describe :net_ftp_putbinaryfile, shared: true do
-  before :each do
-    @server = NetFTPSpecs::DummyFTP.new
-    @server.serve_once
+ruby_version_is ""..."4.1" do
+  describe :net_ftp_putbinaryfile, shared: true do
+    before :each do
+      @server = NetFTPSpecs::DummyFTP.new
+      @server.serve_once
 
-    @local_fixture_file  = __dir__ + "/../fixtures/putbinaryfile"
-    @remote_tmp_file = tmp("binaryfile", false)
+      @local_fixture_file  = __dir__ + "/../fixtures/putbinaryfile"
+      @remote_tmp_file = tmp("binaryfile", false)
 
-    @ftp = Net::FTP.new
-    @ftp.connect(@server.hostname, @server.server_port)
-    @ftp.binary = @binary_mode
-  end
+      @ftp = Net::FTP.new
+      @ftp.connect(@server.hostname, @server.server_port)
+      @ftp.binary = @binary_mode
+    end
 
-  after :each do
-    @ftp.quit rescue nil
-    @ftp.close
-    @server.stop
+    after :each do
+      @ftp.quit rescue nil
+      @ftp.close
+      @server.stop
 
-    rm_r @remote_tmp_file
-  end
+      rm_r @remote_tmp_file
+    end
 
-  it "sends the STOR command to the server" do
-    @ftp.send(@method, @local_fixture_file, "binary")
-    @ftp.last_response.should == "200 OK, Data received. (STOR binary)\n"
-  end
+    it "sends the STOR command to the server" do
+      @ftp.send(@method, @local_fixture_file, "binary")
+      @ftp.last_response.should == "200 OK, Data received. (STOR binary)\n"
+    end
 
-  it "sends the contents of the passed local_file, without modifications" do
-    @ftp.send(@method, @local_fixture_file, "binary")
+    it "sends the contents of the passed local_file, without modifications" do
+      @ftp.send(@method, @local_fixture_file, "binary")
 
-    remote_lines = File.readlines(@remote_tmp_file)
-    local_lines  = File.readlines(@local_fixture_file)
+      remote_lines = File.readlines(@remote_tmp_file)
+      local_lines  = File.readlines(@local_fixture_file)
 
-    remote_lines.should == local_lines
-  end
+      remote_lines.should == local_lines
+    end
 
-  it "returns nil" do
-    @ftp.send(@method, @local_fixture_file, "binary").should be_nil
-  end
+    it "returns nil" do
+      @ftp.send(@method, @local_fixture_file, "binary").should be_nil
+    end
 
-  describe "when passed a block" do
-    it "yields the transmitted content as binary blocks of the passed size" do
-      res = []
-      @ftp.send(@method, @local_fixture_file, "binary", 10) { |x| res << x }
-      res.should == [
-        "This is an", " example f",
-        "ile\nwhich ", "is going t",
-        "o be trans", "mitted\nusi",
-        "ng #putbin", "aryfile.\n"
-      ]
+    describe "when passed a block" do
+      it "yields the transmitted content as binary blocks of the passed size" do
+        res = []
+        @ftp.send(@method, @local_fixture_file, "binary", 10) { |x| res << x }
+        res.should == [
+          "This is an", " example f",
+          "ile\nwhich ", "is going t",
+          "o be trans", "mitted\nusi",
+          "ng #putbin", "aryfile.\n"
+        ]
+      end
     end
-  end
 
-  describe "when resuming an existing file" do
-    before :each do
-      File.open(@remote_tmp_file, "w") do |f|
-        f << "This is an example file\n"
+    describe "when resuming an existing file" do
+      before :each do
+        File.open(@remote_tmp_file, "w") do |f|
+          f << "This is an example file\n"
+        end
+
+        @ftp.resume = true
       end
 
-      @ftp.resume = true
-    end
+      it "sends the remaining content of the passed local_file to the passed remote_file" do
+        @ftp.send(@method, @local_fixture_file, "binary")
+        File.read(@remote_tmp_file).should == File.read(@local_fixture_file)
+      end
 
-    it "sends the remaining content of the passed local_file to the passed remote_file" do
-      @ftp.send(@method, @local_fixture_file, "binary")
-      File.read(@remote_tmp_file).should == File.read(@local_fixture_file)
+      describe "and the APPE command fails" do
+        it "raises a Net::FTPProtoError when the response code is 550" do
+          @server.should_receive(:appe).and_respond("Requested action not taken.")
+          -> { @ftp.send(@method, @local_fixture_file, "binary") }.should raise_error(Net::FTPProtoError)
+        end
+
+        it "raises a Net::FTPPermError when the response code is 500" do
+          @server.should_receive(:appe).and_respond("500 Syntax error, command unrecognized.")
+          -> { @ftp.send(@method, @local_fixture_file, "binary") }.should raise_error(Net::FTPPermError)
+        end
+
+        it "raises a Net::FTPPermError when the response code is 501" do
+          @server.should_receive(:appe).and_respond("501 Syntax error, command unrecognized.")
+          -> { @ftp.send(@method, @local_fixture_file, "binary") }.should raise_error(Net::FTPPermError)
+        end
+
+        it "raises a Net::FTPPermError when the response code is 502" do
+          @server.should_receive(:appe).and_respond("502 Command not implemented.")
+          -> { @ftp.send(@method, @local_fixture_file, "binary") }.should raise_error(Net::FTPPermError)
+        end
+
+        it "raises a Net::FTPTempError when the response code is 421" do
+          @server.should_receive(:appe).and_respond("421 Service not available, closing control connection.")
+          -> { @ftp.send(@method, @local_fixture_file, "binary") }.should raise_error(Net::FTPTempError)
+        end
+
+        it "raises a Net::FTPPermError when the response code is 530" do
+          @server.should_receive(:appe).and_respond("530 Not logged in.")
+          -> { @ftp.send(@method, @local_fixture_file, "binary") }.should raise_error(Net::FTPPermError)
+        end
+      end
     end
 
-    describe "and the APPE command fails" do
-      it "raises a Net::FTPProtoError when the response code is 550" do
-        @server.should_receive(:appe).and_respond("Requested action not taken.")
-        -> { @ftp.send(@method, @local_fixture_file, "binary") }.should raise_error(Net::FTPProtoError)
+    describe "when the STOR command fails" do
+      it "raises a Net::FTPPermError when the response code is 532" do
+        @server.should_receive(:stor).and_respond("532 Need account for storing files.")
+        -> { @ftp.send(@method, @local_fixture_file, "binary") }.should raise_error(Net::FTPPermError)
       end
 
-      it "raises a Net::FTPPermError when the response code is 500" do
-        @server.should_receive(:appe).and_respond("500 Syntax error, command unrecognized.")
+      it "raises a Net::FTPTempError when the response code is 450" do
+        @server.should_receive(:stor).and_respond("450 Requested file action not taken.")
+        -> { @ftp.send(@method, @local_fixture_file, "binary") }.should raise_error(Net::FTPTempError)
+      end
+
+      it "raises a Net::FTPTempError when the response code is 452" do
+        @server.should_receive(:stor).and_respond("452 Requested action not taken.")
+        -> { @ftp.send(@method, @local_fixture_file, "binary") }.should raise_error(Net::FTPTempError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 553" do
+        @server.should_receive(:stor).and_respond("553 Requested action not taken.")
         -> { @ftp.send(@method, @local_fixture_file, "binary") }.should raise_error(Net::FTPPermError)
       end
 
-      it "raises a Net::FTPPermError when the response code is 501" do
-        @server.should_receive(:appe).and_respond("501 Syntax error, command unrecognized.")
+      it "raises a Net::FTPPermError when the response code is 500" do
+        @server.should_receive(:stor).and_respond("500 Syntax error, command unrecognized.")
         -> { @ftp.send(@method, @local_fixture_file, "binary") }.should raise_error(Net::FTPPermError)
       end
 
-      it "raises a Net::FTPPermError when the response code is 502" do
-        @server.should_receive(:appe).and_respond("502 Command not implemented.")
+      it "raises a Net::FTPPermError when the response code is 501" do
+        @server.should_receive(:stor).and_respond("501 Syntax error in parameters or arguments.")
         -> { @ftp.send(@method, @local_fixture_file, "binary") }.should raise_error(Net::FTPPermError)
       end
 
       it "raises a Net::FTPTempError when the response code is 421" do
-        @server.should_receive(:appe).and_respond("421 Service not available, closing control connection.")
+        @server.should_receive(:stor).and_respond("421 Service not available, closing control connection.")
         -> { @ftp.send(@method, @local_fixture_file, "binary") }.should raise_error(Net::FTPTempError)
       end
 
       it "raises a Net::FTPPermError when the response code is 530" do
-        @server.should_receive(:appe).and_respond("530 Not logged in.")
+        @server.should_receive(:stor).and_respond("530 Not logged in.")
         -> { @ftp.send(@method, @local_fixture_file, "binary") }.should raise_error(Net::FTPPermError)
       end
     end
-  end
 
-  describe "when the STOR command fails" do
-    it "raises a Net::FTPPermError when the response code is 532" do
-      @server.should_receive(:stor).and_respond("532 Need account for storing files.")
-      -> { @ftp.send(@method, @local_fixture_file, "binary") }.should raise_error(Net::FTPPermError)
-    end
-
-    it "raises a Net::FTPTempError when the response code is 450" do
-      @server.should_receive(:stor).and_respond("450 Requested file action not taken.")
-      -> { @ftp.send(@method, @local_fixture_file, "binary") }.should raise_error(Net::FTPTempError)
-    end
-
-    it "raises a Net::FTPTempError when the response code is 452" do
-      @server.should_receive(:stor).and_respond("452 Requested action not taken.")
-      -> { @ftp.send(@method, @local_fixture_file, "binary") }.should raise_error(Net::FTPTempError)
-    end
-
-    it "raises a Net::FTPPermError when the response code is 553" do
-      @server.should_receive(:stor).and_respond("553 Requested action not taken.")
-      -> { @ftp.send(@method, @local_fixture_file, "binary") }.should raise_error(Net::FTPPermError)
-    end
-
-    it "raises a Net::FTPPermError when the response code is 500" do
-      @server.should_receive(:stor).and_respond("500 Syntax error, command unrecognized.")
-      -> { @ftp.send(@method, @local_fixture_file, "binary") }.should raise_error(Net::FTPPermError)
-    end
-
-    it "raises a Net::FTPPermError when the response code is 501" do
-      @server.should_receive(:stor).and_respond("501 Syntax error in parameters or arguments.")
-      -> { @ftp.send(@method, @local_fixture_file, "binary") }.should raise_error(Net::FTPPermError)
-    end
-
-    it "raises a Net::FTPTempError when the response code is 421" do
-      @server.should_receive(:stor).and_respond("421 Service not available, closing control connection.")
-      -> { @ftp.send(@method, @local_fixture_file, "binary") }.should raise_error(Net::FTPTempError)
-    end
-
-    it "raises a Net::FTPPermError when the response code is 530" do
-      @server.should_receive(:stor).and_respond("530 Not logged in.")
-      -> { @ftp.send(@method, @local_fixture_file, "binary") }.should raise_error(Net::FTPPermError)
-    end
-  end
-
-  describe "when opening the data port fails" do
-    it "raises a Net::FTPPermError when the response code is 500" do
-      @server.should_receive(:eprt).and_respond("500 Syntax error, command unrecognized.")
-      @server.should_receive(:port).and_respond("500 Syntax error, command unrecognized.")
-      -> { @ftp.send(@method, @local_fixture_file, "binary") }.should raise_error(Net::FTPPermError)
-    end
+    describe "when opening the data port fails" do
+      it "raises a Net::FTPPermError when the response code is 500" do
+        @server.should_receive(:eprt).and_respond("500 Syntax error, command unrecognized.")
+        @server.should_receive(:port).and_respond("500 Syntax error, command unrecognized.")
+        -> { @ftp.send(@method, @local_fixture_file, "binary") }.should raise_error(Net::FTPPermError)
+      end
 
-    it "raises a Net::FTPPermError when the response code is 501" do
-      @server.should_receive(:eprt).and_respond("501 Syntax error in parameters or arguments.")
-      @server.should_receive(:port).and_respond("501 Syntax error in parameters or arguments.")
-      -> { @ftp.send(@method, @local_fixture_file, "binary") }.should raise_error(Net::FTPPermError)
-    end
+      it "raises a Net::FTPPermError when the response code is 501" do
+        @server.should_receive(:eprt).and_respond("501 Syntax error in parameters or arguments.")
+        @server.should_receive(:port).and_respond("501 Syntax error in parameters or arguments.")
+        -> { @ftp.send(@method, @local_fixture_file, "binary") }.should raise_error(Net::FTPPermError)
+      end
 
-    it "raises a Net::FTPTempError when the response code is 421" do
-      @server.should_receive(:eprt).and_respond("421 Service not available, closing control connection.")
-      @server.should_receive(:port).and_respond("421 Service not available, closing control connection.")
-      -> { @ftp.send(@method, @local_fixture_file, "binary") }.should raise_error(Net::FTPTempError)
-    end
+      it "raises a Net::FTPTempError when the response code is 421" do
+        @server.should_receive(:eprt).and_respond("421 Service not available, closing control connection.")
+        @server.should_receive(:port).and_respond("421 Service not available, closing control connection.")
+        -> { @ftp.send(@method, @local_fixture_file, "binary") }.should raise_error(Net::FTPTempError)
+      end
 
-    it "raises a Net::FTPPermError when the response code is 530" do
-      @server.should_receive(:eprt).and_respond("530 Not logged in.")
-      @server.should_receive(:port).and_respond("530 Not logged in.")
-      -> { @ftp.send(@method, @local_fixture_file, "binary") }.should raise_error(Net::FTPPermError)
+      it "raises a Net::FTPPermError when the response code is 530" do
+        @server.should_receive(:eprt).and_respond("530 Not logged in.")
+        @server.should_receive(:port).and_respond("530 Not logged in.")
+        -> { @ftp.send(@method, @local_fixture_file, "binary") }.should raise_error(Net::FTPPermError)
+      end
     end
   end
 end
diff --git a/spec/ruby/library/net-ftp/shared/puttextfile.rb b/spec/ruby/library/net-ftp/shared/puttextfile.rb
index e2c0453352..0009d873de 100644
--- a/spec/ruby/library/net-ftp/shared/puttextfile.rb
+++ b/spec/ruby/library/net-ftp/shared/puttextfile.rb
@@ -1,128 +1,130 @@
-describe :net_ftp_puttextfile, shared: true do
-  before :each do
-    @server = NetFTPSpecs::DummyFTP.new
-    @server.serve_once
-
-    @local_fixture_file  = __dir__ + "/../fixtures/puttextfile"
-    @remote_tmp_file = tmp("textfile", false)
-
-    @ftp = Net::FTP.new
-    @ftp.connect(@server.hostname, @server.server_port)
-    @ftp.binary = @binary_mode
-  end
-
-  after :each do
-    @ftp.quit rescue nil
-    @ftp.close
-    @server.stop
-
-    rm_r @remote_tmp_file
-  end
-
-  it "sends the STOR command to the server" do
-    @ftp.send(@method, @local_fixture_file, "text")
-    @ftp.last_response.should == "200 OK, Data received. (STOR text)\n"
-  end
-
-  it "sends the contents of the passed local_file, using \\r\\n as the newline separator" do
-    @ftp.send(@method, @local_fixture_file, "text")
-
-    remote_lines = File.binread(@remote_tmp_file)
-    local_lines  = File.binread(@local_fixture_file)
-
-    remote_lines.should_not == local_lines
-    remote_lines.should == local_lines.gsub("\n", "\r\n")
-  end
-
-  guard -> { Net::FTP::VERSION < '0.3.6' } do
-    it "returns nil" do
-      @ftp.send(@method, @local_fixture_file, "text").should be_nil
+ruby_version_is ""..."4.1" do
+  describe :net_ftp_puttextfile, shared: true do
+    before :each do
+      @server = NetFTPSpecs::DummyFTP.new
+      @server.serve_once
+
+      @local_fixture_file  = __dir__ + "/../fixtures/puttextfile"
+      @remote_tmp_file = tmp("textfile", false)
+
+      @ftp = Net::FTP.new
+      @ftp.connect(@server.hostname, @server.server_port)
+      @ftp.binary = @binary_mode
     end
-  end
 
-  guard -> { Net::FTP::VERSION >= '0.3.6' } do
-    it "returns the response" do
-      @ftp.send(@method, @local_fixture_file, "text").should == @ftp.last_response
-    end
-  end
+    after :each do
+      @ftp.quit rescue nil
+      @ftp.close
+      @server.stop
 
-  describe "when passed a block" do
-    it "yields each transmitted line" do
-      res = []
-      @ftp.send(@method, @local_fixture_file, "text") { |x| res << x }
-      res.should == [
-        "This is an example file\r\n",
-        "which is going to be transmitted\r\n",
-        "using #puttextfile.\r\n"
-      ]
+      rm_r @remote_tmp_file
     end
-  end
 
-  describe "when the STOR command fails" do
-    it "raises a Net::FTPPermError when the response code is 532" do
-      @server.should_receive(:stor).and_respond("532 Need account for storing files.")
-      -> { @ftp.send(@method, @local_fixture_file, "text") }.should raise_error(Net::FTPPermError)
+    it "sends the STOR command to the server" do
+      @ftp.send(@method, @local_fixture_file, "text")
+      @ftp.last_response.should == "200 OK, Data received. (STOR text)\n"
     end
 
-    it "raises a Net::FTPTempError when the response code is 450" do
-      @server.should_receive(:stor).and_respond("450 Requested file action not taken.")
-      -> { @ftp.send(@method, @local_fixture_file, "text") }.should raise_error(Net::FTPTempError)
-    end
+    it "sends the contents of the passed local_file, using \\r\\n as the newline separator" do
+      @ftp.send(@method, @local_fixture_file, "text")
 
-    it "raises a Net::FTPTempError when the response code is 452" do
-      @server.should_receive(:stor).and_respond("452 Requested action not taken.")
-      -> { @ftp.send(@method, @local_fixture_file, "text") }.should raise_error(Net::FTPTempError)
-    end
+      remote_lines = File.binread(@remote_tmp_file)
+      local_lines  = File.binread(@local_fixture_file)
 
-    it "raises a Net::FTPPermError when the response code is 553" do
-      @server.should_receive(:stor).and_respond("553 Requested action not taken.")
-      -> { @ftp.send(@method, @local_fixture_file, "text") }.should raise_error(Net::FTPPermError)
+      remote_lines.should_not == local_lines
+      remote_lines.should == local_lines.gsub("\n", "\r\n")
     end
 
-    it "raises a Net::FTPPermError when the response code is 500" do
-      @server.should_receive(:stor).and_respond("500 Syntax error, command unrecognized.")
-      -> { @ftp.send(@method, @local_fixture_file, "text") }.should raise_error(Net::FTPPermError)
+    guard -> { Net::FTP::VERSION < '0.3.6' } do
+      it "returns nil" do
+        @ftp.send(@method, @local_fixture_file, "text").should be_nil
+      end
     end
 
-    it "raises a Net::FTPPermError when the response code is 501" do
-      @server.should_receive(:stor).and_respond("501 Syntax error in parameters or arguments.")
-      -> { @ftp.send(@method, @local_fixture_file, "text") }.should raise_error(Net::FTPPermError)
-    end
-
-    it "raises a Net::FTPTempError when the response code is 421" do
-      @server.should_receive(:stor).and_respond("421 Service not available, closing control connection.")
-      -> { @ftp.send(@method, @local_fixture_file, "text") }.should raise_error(Net::FTPTempError)
-    end
-
-    it "raises a Net::FTPPermError when the response code is 530" do
-      @server.should_receive(:stor).and_respond("530 Not logged in.")
-      -> { @ftp.send(@method, @local_fixture_file, "text") }.should raise_error(Net::FTPPermError)
-    end
-  end
-
-  describe "when opening the data port fails" do
-    it "raises a Net::FTPPermError when the response code is 500" do
-      @server.should_receive(:eprt).and_respond("500 Syntax error, command unrecognized.")
-      @server.should_receive(:port).and_respond("500 Syntax error, command unrecognized.")
-      -> { @ftp.send(@method, @local_fixture_file, "text") }.should raise_error(Net::FTPPermError)
+    guard -> { Net::FTP::VERSION >= '0.3.6' } do
+      it "returns the response" do
+        @ftp.send(@method, @local_fixture_file, "text").should == @ftp.last_response
+      end
     end
 
-    it "raises a Net::FTPPermError when the response code is 501" do
-      @server.should_receive(:eprt).and_respond("501 Syntax error in parameters or arguments.")
-      @server.should_receive(:port).and_respond("501 Syntax error in parameters or arguments.")
-      -> { @ftp.send(@method, @local_fixture_file, "text") }.should raise_error(Net::FTPPermError)
+    describe "when passed a block" do
+      it "yields each transmitted line" do
+        res = []
+        @ftp.send(@method, @local_fixture_file, "text") { |x| res << x }
+        res.should == [
+          "This is an example file\r\n",
+          "which is going to be transmitted\r\n",
+          "using #puttextfile.\r\n"
+        ]
+      end
     end
 
-    it "raises a Net::FTPTempError when the response code is 421" do
-      @server.should_receive(:eprt).and_respond("421 Service not available, closing control connection.")
-      @server.should_receive(:port).and_respond("421 Service not available, closing control connection.")
-      -> { @ftp.send(@method, @local_fixture_file, "text") }.should raise_error(Net::FTPTempError)
+    describe "when the STOR command fails" do
+      it "raises a Net::FTPPermError when the response code is 532" do
+        @server.should_receive(:stor).and_respond("532 Need account for storing files.")
+        -> { @ftp.send(@method, @local_fixture_file, "text") }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPTempError when the response code is 450" do
+        @server.should_receive(:stor).and_respond("450 Requested file action not taken.")
+        -> { @ftp.send(@method, @local_fixture_file, "text") }.should raise_error(Net::FTPTempError)
+      end
+
+      it "raises a Net::FTPTempError when the response code is 452" do
+        @server.should_receive(:stor).and_respond("452 Requested action not taken.")
+        -> { @ftp.send(@method, @local_fixture_file, "text") }.should raise_error(Net::FTPTempError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 553" do
+        @server.should_receive(:stor).and_respond("553 Requested action not taken.")
+        -> { @ftp.send(@method, @local_fixture_file, "text") }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 500" do
+        @server.should_receive(:stor).and_respond("500 Syntax error, command unrecognized.")
+        -> { @ftp.send(@method, @local_fixture_file, "text") }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 501" do
+        @server.should_receive(:stor).and_respond("501 Syntax error in parameters or arguments.")
+        -> { @ftp.send(@method, @local_fixture_file, "text") }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPTempError when the response code is 421" do
+        @server.should_receive(:stor).and_respond("421 Service not available, closing control connection.")
+        -> { @ftp.send(@method, @local_fixture_file, "text") }.should raise_error(Net::FTPTempError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 530" do
+        @server.should_receive(:stor).and_respond("530 Not logged in.")
+        -> { @ftp.send(@method, @local_fixture_file, "text") }.should raise_error(Net::FTPPermError)
+      end
     end
 
-    it "raises a Net::FTPPermError when the response code is 530" do
-      @server.should_receive(:eprt).and_respond("530 Not logged in.")
-      @server.should_receive(:port).and_respond("530 Not logged in.")
-      -> { @ftp.send(@method, @local_fixture_file, "text") }.should raise_error(Net::FTPPermError)
+    describe "when opening the data port fails" do
+      it "raises a Net::FTPPermError when the response code is 500" do
+        @server.should_receive(:eprt).and_respond("500 Syntax error, command unrecognized.")
+        @server.should_receive(:port).and_respond("500 Syntax error, command unrecognized.")
+        -> { @ftp.send(@method, @local_fixture_file, "text") }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 501" do
+        @server.should_receive(:eprt).and_respond("501 Syntax error in parameters or arguments.")
+        @server.should_receive(:port).and_respond("501 Syntax error in parameters or arguments.")
+        -> { @ftp.send(@method, @local_fixture_file, "text") }.should raise_error(Net::FTPPermError)
+      end
+
+      it "raises a Net::FTPTempError when the response code is 421" do
+        @server.should_receive(:eprt).and_respond("421 Service not available, closing control connection.")
+        @server.should_receive(:port).and_respond("421 Service not available, closing control connection.")
+        -> { @ftp.send(@method, @local_fixture_file, "text") }.should raise_error(Net::FTPTempError)
+      end
+
+      it "raises a Net::FTPPermError when the response code is 530" do
+        @server.should_receive(:eprt).and_respond("530 Not logged in.")
+        @server.should_receive(:port).and_respond("530 Not logged in.")
+        -> { @ftp.send(@method, @local_fixture_file, "text") }.should raise_error(Net::FTPPermError)
+      end
     end
   end
 end
diff --git a/spec/ruby/library/net-ftp/shared/pwd.rb b/spec/ruby/library/net-ftp/shared/pwd.rb
index 951d020f2d..db3e587464 100644
--- a/spec/ruby/library/net-ftp/shared/pwd.rb
+++ b/spec/ruby/library/net-ftp/shared/pwd.rb
@@ -1,3 +1,5 @@
-describe :net_ftp_pwd, shared: true do
+ruby_version_is ""..."4.1" do
+  describe :net_ftp_pwd, shared: true do
 
+  end
 end
diff --git a/spec/ruby/library/net-ftp/site_spec.rb b/spec/ruby/library/net-ftp/site_spec.rb
index c3e589a920..14d17caa90 100644
--- a/spec/ruby/library/net-ftp/site_spec.rb
+++ b/spec/ruby/library/net-ftp/site_spec.rb
@@ -1,53 +1,56 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
 
-describe "Net::FTP#site" do
-  before :each do
-    @server = NetFTPSpecs::DummyFTP.new
-    @server.serve_once
-
-    @ftp = Net::FTP.new
-    @ftp.connect(@server.hostname, @server.server_port)
-  end
-
-  after :each do
-    @ftp.quit rescue nil
-    @ftp.close
-    @server.stop
-  end
-
-  it "sends the SITE command with the passed argument to the server" do
-    @ftp.site("param")
-    @ftp.last_response.should == "200 Command okay. (SITE param)\n"
-  end
-
-  it "returns nil" do
-    @ftp.site("param").should be_nil
-  end
-
-  it "does not raise an error when the response code is 202" do
-    @server.should_receive(:site).and_respond("202 Command not implemented, superfluous at this site.")
-    -> { @ftp.site("param") }.should_not raise_error
-  end
-
-  it "raises a Net::FTPPermError when the response code is 500" do
-    @server.should_receive(:site).and_respond("500 Syntax error, command unrecognized.")
-    -> { @ftp.site("param") }.should raise_error(Net::FTPPermError)
-  end
-
-  it "raises a Net::FTPPermError when the response code is 501" do
-    @server.should_receive(:site).and_respond("501 Syntax error in parameters or arguments.")
-    -> { @ftp.site("param") }.should raise_error(Net::FTPPermError)
-  end
-
-  it "raises a Net::FTPTempError when the response code is 421" do
-    @server.should_receive(:site).and_respond("421 Service not available, closing control connection.")
-    -> { @ftp.site("param") }.should raise_error(Net::FTPTempError)
-  end
-
-  it "raises a Net::FTPPermError when the response code is 530" do
-    @server.should_receive(:site).and_respond("530 Requested action not taken.")
-    -> { @ftp.site("param") }.should raise_error(Net::FTPPermError)
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
+
+  describe "Net::FTP#site" do
+    before :each do
+      @server = NetFTPSpecs::DummyFTP.new
+      @server.serve_once
+
+      @ftp = Net::FTP.new
+      @ftp.connect(@server.hostname, @server.server_port)
+    end
+
+    after :each do
+      @ftp.quit rescue nil
+      @ftp.close
+      @server.stop
+    end
+
+    it "sends the SITE command with the passed argument to the server" do
+      @ftp.site("param")
+      @ftp.last_response.should == "200 Command okay. (SITE param)\n"
+    end
+
+    it "returns nil" do
+      @ftp.site("param").should be_nil
+    end
+
+    it "does not raise an error when the response code is 202" do
+      @server.should_receive(:site).and_respond("202 Command not implemented, superfluous at this site.")
+      -> { @ftp.site("param") }.should_not raise_error
+    end
+
+    it "raises a Net::FTPPermError when the response code is 500" do
+      @server.should_receive(:site).and_respond("500 Syntax error, command unrecognized.")
+      -> { @ftp.site("param") }.should raise_error(Net::FTPPermError)
+    end
+
+    it "raises a Net::FTPPermError when the response code is 501" do
+      @server.should_receive(:site).and_respond("501 Syntax error in parameters or arguments.")
+      -> { @ftp.site("param") }.should raise_error(Net::FTPPermError)
+    end
+
+    it "raises a Net::FTPTempError when the response code is 421" do
+      @server.should_receive(:site).and_respond("421 Service not available, closing control connection.")
+      -> { @ftp.site("param") }.should raise_error(Net::FTPTempError)
+    end
+
+    it "raises a Net::FTPPermError when the response code is 530" do
+      @server.should_receive(:site).and_respond("530 Requested action not taken.")
+      -> { @ftp.site("param") }.should raise_error(Net::FTPPermError)
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/size_spec.rb b/spec/ruby/library/net-ftp/size_spec.rb
index 0cf2e24477..73536799eb 100644
--- a/spec/ruby/library/net-ftp/size_spec.rb
+++ b/spec/ruby/library/net-ftp/size_spec.rb
@@ -1,48 +1,51 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
 
-describe "Net::FTP#size" do
-  before :each do
-    @server = NetFTPSpecs::DummyFTP.new
-    @server.serve_once
-
-    @ftp = Net::FTP.new
-    @ftp.connect(@server.hostname, @server.server_port)
-  end
-
-  after :each do
-    @ftp.quit rescue nil
-    @ftp.close
-    @server.stop
-  end
-
-  it "sends the SIZE command to the server" do
-    @ftp.size("test.file")
-    @ftp.last_response.should == "213 1024\n"
-  end
-
-  it "returns the size of the passed file as Integer" do
-    @ftp.size("test.file").should eql(1024)
-  end
-
-  it "raises a Net::FTPPermError when the response code is 500" do
-    @server.should_receive(:size).and_respond("500 Syntax error, command unrecognized.")
-    -> { @ftp.size("test.file") }.should raise_error(Net::FTPPermError)
-  end
-
-  it "raises a Net::FTPPermError when the response code is 501" do
-    @server.should_receive(:size).and_respond("501 Syntax error in parameters or arguments.")
-    -> { @ftp.size("test.file") }.should raise_error(Net::FTPPermError)
-  end
-
-  it "raises a Net::FTPTempError when the response code is 421" do
-    @server.should_receive(:size).and_respond("421 Service not available, closing control connection.")
-    -> { @ftp.size("test.file") }.should raise_error(Net::FTPTempError)
-  end
-
-  it "raises a Net::FTPPermError when the response code is 550" do
-    @server.should_receive(:size).and_respond("550 Requested action not taken.")
-    -> { @ftp.size("test.file") }.should raise_error(Net::FTPPermError)
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
+
+  describe "Net::FTP#size" do
+    before :each do
+      @server = NetFTPSpecs::DummyFTP.new
+      @server.serve_once
+
+      @ftp = Net::FTP.new
+      @ftp.connect(@server.hostname, @server.server_port)
+    end
+
+    after :each do
+      @ftp.quit rescue nil
+      @ftp.close
+      @server.stop
+    end
+
+    it "sends the SIZE command to the server" do
+      @ftp.size("test.file")
+      @ftp.last_response.should == "213 1024\n"
+    end
+
+    it "returns the size of the passed file as Integer" do
+      @ftp.size("test.file").should eql(1024)
+    end
+
+    it "raises a Net::FTPPermError when the response code is 500" do
+      @server.should_receive(:size).and_respond("500 Syntax error, command unrecognized.")
+      -> { @ftp.size("test.file") }.should raise_error(Net::FTPPermError)
+    end
+
+    it "raises a Net::FTPPermError when the response code is 501" do
+      @server.should_receive(:size).and_respond("501 Syntax error in parameters or arguments.")
+      -> { @ftp.size("test.file") }.should raise_error(Net::FTPPermError)
+    end
+
+    it "raises a Net::FTPTempError when the response code is 421" do
+      @server.should_receive(:size).and_respond("421 Service not available, closing control connection.")
+      -> { @ftp.size("test.file") }.should raise_error(Net::FTPTempError)
+    end
+
+    it "raises a Net::FTPPermError when the response code is 550" do
+      @server.should_receive(:size).and_respond("550 Requested action not taken.")
+      -> { @ftp.size("test.file") }.should raise_error(Net::FTPPermError)
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/spec_helper.rb b/spec/ruby/library/net-ftp/spec_helper.rb
index c87d16218b..7689b4fb0c 100644
--- a/spec/ruby/library/net-ftp/spec_helper.rb
+++ b/spec/ruby/library/net-ftp/spec_helper.rb
@@ -1,5 +1,7 @@
-require "net/ftp"
+ruby_version_is ""..."4.1" do
+  require "net/ftp"
 
-if defined?(Net::FTP.default_passive)
-  Net::FTP.default_passive = false
+  if defined?(Net::FTP.default_passive)
+    Net::FTP.default_passive = false
+  end
 end
diff --git a/spec/ruby/library/net-ftp/status_spec.rb b/spec/ruby/library/net-ftp/status_spec.rb
index 9d9f86c381..d9a3b59ffb 100644
--- a/spec/ruby/library/net-ftp/status_spec.rb
+++ b/spec/ruby/library/net-ftp/status_spec.rb
@@ -1,67 +1,70 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
 
-describe "Net::FTP#status" do
-  before :each do
-    @server = NetFTPSpecs::DummyFTP.new
-    @server.serve_once
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
 
-    @ftp = Net::FTP.new
-    @ftp.connect(@server.hostname, @server.server_port)
-  end
+  describe "Net::FTP#status" do
+    before :each do
+      @server = NetFTPSpecs::DummyFTP.new
+      @server.serve_once
 
-  after :each do
-    @ftp.quit rescue nil
-    @ftp.close
-    @server.stop
-  end
+      @ftp = Net::FTP.new
+      @ftp.connect(@server.hostname, @server.server_port)
+    end
 
-  it "sends the STAT command to the server" do
-    @ftp.status
-    @ftp.last_response.should == "211 System status, or system help reply. (STAT)\n"
-  end
+    after :each do
+      @ftp.quit rescue nil
+      @ftp.close
+      @server.stop
+    end
 
-  it "sends the STAT command with an optional parameter to the server" do
-    @ftp.status("/pub").should == "211 System status, or system help reply. (STAT /pub)\n"
-  end
+    it "sends the STAT command to the server" do
+      @ftp.status
+      @ftp.last_response.should == "211 System status, or system help reply. (STAT)\n"
+    end
 
-  it "returns the received information" do
-    @ftp.status.should == "211 System status, or system help reply. (STAT)\n"
-  end
+    it "sends the STAT command with an optional parameter to the server" do
+      @ftp.status("/pub").should == "211 System status, or system help reply. (STAT /pub)\n"
+    end
 
-  it "does not raise an error when the response code is 212" do
-    @server.should_receive(:stat).and_respond("212 Directory status.")
-    -> { @ftp.status }.should_not raise_error
-  end
+    it "returns the received information" do
+      @ftp.status.should == "211 System status, or system help reply. (STAT)\n"
+    end
 
-  it "does not raise an error when the response code is 213" do
-    @server.should_receive(:stat).and_respond("213 File status.")
-    -> { @ftp.status }.should_not raise_error
-  end
+    it "does not raise an error when the response code is 212" do
+      @server.should_receive(:stat).and_respond("212 Directory status.")
+      -> { @ftp.status }.should_not raise_error
+    end
 
-  it "raises a Net::FTPPermError when the response code is 500" do
-    @server.should_receive(:stat).and_respond("500 Syntax error, command unrecognized.")
-    -> { @ftp.status }.should raise_error(Net::FTPPermError)
-  end
+    it "does not raise an error when the response code is 213" do
+      @server.should_receive(:stat).and_respond("213 File status.")
+      -> { @ftp.status }.should_not raise_error
+    end
 
-  it "raises a Net::FTPPermError when the response code is 501" do
-    @server.should_receive(:stat).and_respond("501 Syntax error in parameters or arguments.")
-    -> { @ftp.status }.should raise_error(Net::FTPPermError)
-  end
+    it "raises a Net::FTPPermError when the response code is 500" do
+      @server.should_receive(:stat).and_respond("500 Syntax error, command unrecognized.")
+      -> { @ftp.status }.should raise_error(Net::FTPPermError)
+    end
 
-  it "raises a Net::FTPPermError when the response code is 502" do
-    @server.should_receive(:stat).and_respond("502 Command not implemented.")
-    -> { @ftp.status }.should raise_error(Net::FTPPermError)
-  end
+    it "raises a Net::FTPPermError when the response code is 501" do
+      @server.should_receive(:stat).and_respond("501 Syntax error in parameters or arguments.")
+      -> { @ftp.status }.should raise_error(Net::FTPPermError)
+    end
 
-  it "raises a Net::FTPTempError when the response code is 421" do
-    @server.should_receive(:stat).and_respond("421 Service not available, closing control connection.")
-    -> { @ftp.status }.should raise_error(Net::FTPTempError)
-  end
+    it "raises a Net::FTPPermError when the response code is 502" do
+      @server.should_receive(:stat).and_respond("502 Command not implemented.")
+      -> { @ftp.status }.should raise_error(Net::FTPPermError)
+    end
+
+    it "raises a Net::FTPTempError when the response code is 421" do
+      @server.should_receive(:stat).and_respond("421 Service not available, closing control connection.")
+      -> { @ftp.status }.should raise_error(Net::FTPTempError)
+    end
 
-  it "raises a Net::FTPPermError when the response code is 530" do
-    @server.should_receive(:stat).and_respond("530 Requested action not taken.")
-    -> { @ftp.status }.should raise_error(Net::FTPPermError)
+    it "raises a Net::FTPPermError when the response code is 530" do
+      @server.should_receive(:stat).and_respond("530 Requested action not taken.")
+      -> { @ftp.status }.should raise_error(Net::FTPPermError)
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/storbinary_spec.rb b/spec/ruby/library/net-ftp/storbinary_spec.rb
index aa4c51f2e8..a2f81fc669 100644
--- a/spec/ruby/library/net-ftp/storbinary_spec.rb
+++ b/spec/ruby/library/net-ftp/storbinary_spec.rb
@@ -1,49 +1,52 @@
 require_relative '../../spec_helper'
 
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
+ruby_version_is ""..."4.1" do
 
-describe "Net::FTP#storbinary" do
-  before :each do
-    @server = NetFTPSpecs::DummyFTP.new
-    @server.serve_once
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
 
-    @local_fixture_file  = __dir__ + "/fixtures/putbinaryfile"
-    @tmp_file = tmp("binaryfile", false)
+  describe "Net::FTP#storbinary" do
+    before :each do
+      @server = NetFTPSpecs::DummyFTP.new
+      @server.serve_once
 
-    @ftp = Net::FTP.new
-    @ftp.connect(@server.hostname, @server.server_port)
-  end
+      @local_fixture_file  = __dir__ + "/fixtures/putbinaryfile"
+      @tmp_file = tmp("binaryfile", false)
 
-  after :each do
-    @ftp.quit rescue nil
-    @ftp.close
-    @server.stop
+      @ftp = Net::FTP.new
+      @ftp.connect(@server.hostname, @server.server_port)
+    end
 
-    rm_r @tmp_file
-  end
+    after :each do
+      @ftp.quit rescue nil
+      @ftp.close
+      @server.stop
 
-  it "sends the passed command and the passed File object's content to the server" do
-    File.open(@local_fixture_file) do |f|
-      f.binmode
+      rm_r @tmp_file
+    end
+
+    it "sends the passed command and the passed File object's content to the server" do
+      File.open(@local_fixture_file) do |f|
+        f.binmode
 
-      @ftp.storbinary("STOR binary", f, 4096) {}
-      @ftp.last_response.should == "200 OK, Data received. (STOR binary)\n"
+        @ftp.storbinary("STOR binary", f, 4096) {}
+        @ftp.last_response.should == "200 OK, Data received. (STOR binary)\n"
+      end
     end
-  end
 
-  it "yields the transmitted content as binary blocks of the passed size" do
-    File.open(@local_fixture_file) do |f|
-      f.binmode
-
-      res = []
-      @ftp.storbinary("STOR binary", f, 10) { |x| res << x }
-      res.should == [
-        "This is an", " example f",
-        "ile\nwhich ", "is going t",
-        "o be trans", "mitted\nusi",
-        "ng #putbin", "aryfile.\n"
-      ]
+    it "yields the transmitted content as binary blocks of the passed size" do
+      File.open(@local_fixture_file) do |f|
+        f.binmode
+
+        res = []
+        @ftp.storbinary("STOR binary", f, 10) { |x| res << x }
+        res.should == [
+          "This is an", " example f",
+          "ile\nwhich ", "is going t",
+          "o be trans", "mitted\nusi",
+          "ng #putbin", "aryfile.\n"
+        ]
+      end
     end
   end
 end
diff --git a/spec/ruby/library/net-ftp/storlines_spec.rb b/spec/ruby/library/net-ftp/storlines_spec.rb
index dc6830da7b..09340bafe9 100644
--- a/spec/ruby/library/net-ftp/storlines_spec.rb
+++ b/spec/ruby/library/net-ftp/storlines_spec.rb
@@ -1,44 +1,47 @@
 require_relative '../../spec_helper'
 
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
+ruby_version_is ""..."4.1" do
 
-describe "Net::FTP#storlines" do
-  before :each do
-    @server = NetFTPSpecs::DummyFTP.new
-    @server.serve_once
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
 
-    @local_fixture_file  = __dir__ + "/fixtures/puttextfile"
-    @tmp_file = tmp("textfile", false)
+  describe "Net::FTP#storlines" do
+    before :each do
+      @server = NetFTPSpecs::DummyFTP.new
+      @server.serve_once
 
-    @ftp = Net::FTP.new
-    @ftp.connect(@server.hostname, @server.server_port)
-  end
+      @local_fixture_file  = __dir__ + "/fixtures/puttextfile"
+      @tmp_file = tmp("textfile", false)
 
-  after :each do
-    @ftp.quit rescue nil
-    @ftp.close
-    @server.stop
+      @ftp = Net::FTP.new
+      @ftp.connect(@server.hostname, @server.server_port)
+    end
 
-    rm_r @tmp_file
-  end
+    after :each do
+      @ftp.quit rescue nil
+      @ftp.close
+      @server.stop
 
-  it "sends the passed command and the passed File object's content to the server" do
-    File.open(@local_fixture_file) do |f|
-      @ftp.storlines("STOR text", f) {}
-      @ftp.last_response.should == "200 OK, Data received. (STOR text)\n"
+      rm_r @tmp_file
+    end
+
+    it "sends the passed command and the passed File object's content to the server" do
+      File.open(@local_fixture_file) do |f|
+        @ftp.storlines("STOR text", f) {}
+        @ftp.last_response.should == "200 OK, Data received. (STOR text)\n"
+      end
     end
-  end
 
-  it "yields each line of the transmitted content" do
-    File.open(@local_fixture_file) do |f|
-      res = []
-      @ftp.storlines("STOR text", f) { |x| res << x }
-      res.should == [
-        "This is an example file\r\n",
-        "which is going to be transmitted\r\n",
-        "using #puttextfile.\r\n"
-      ]
+    it "yields each line of the transmitted content" do
+      File.open(@local_fixture_file) do |f|
+        res = []
+        @ftp.storlines("STOR text", f) { |x| res << x }
+        res.should == [
+          "This is an example file\r\n",
+          "which is going to be transmitted\r\n",
+          "using #puttextfile.\r\n"
+        ]
+      end
     end
   end
 end
diff --git a/spec/ruby/library/net-ftp/system_spec.rb b/spec/ruby/library/net-ftp/system_spec.rb
index 2b7f0d2560..d1d4394d79 100644
--- a/spec/ruby/library/net-ftp/system_spec.rb
+++ b/spec/ruby/library/net-ftp/system_spec.rb
@@ -1,48 +1,51 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
 
-describe "Net::FTP#system" do
-  before :each do
-    @server = NetFTPSpecs::DummyFTP.new
-    @server.serve_once
-
-    @ftp = Net::FTP.new
-    @ftp.connect(@server.hostname, @server.server_port)
-  end
-
-  after :each do
-    @ftp.quit rescue nil
-    @ftp.close
-    @server.stop
-  end
-
-  it "sends the SYST command to the server" do
-    @ftp.system
-    @ftp.last_response.should =~ /\A215 FTP Dummy Server \(SYST\)\Z/
-  end
-
-  it "returns the received information" do
-    @ftp.system.should =~ /\AFTP Dummy Server \(SYST\)\Z/
-  end
-
-  it "raises a Net::FTPPermError when the response code is 500" do
-    @server.should_receive(:syst).and_respond("500 Syntax error, command unrecognized.")
-    -> { @ftp.system }.should raise_error(Net::FTPPermError)
-  end
-
-  it "raises a Net::FTPPermError when the response code is 501" do
-    @server.should_receive(:syst).and_respond("501 Syntax error in parameters or arguments.")
-    -> { @ftp.system }.should raise_error(Net::FTPPermError)
-  end
-
-  it "raises a Net::FTPPermError when the response code is 502" do
-    @server.should_receive(:syst).and_respond("502 Command not implemented.")
-    -> { @ftp.system }.should raise_error(Net::FTPPermError)
-  end
-
-  it "raises a Net::FTPTempError when the response code is 421" do
-    @server.should_receive(:syst).and_respond("421 Service not available, closing control connection.")
-    -> { @ftp.system }.should raise_error(Net::FTPTempError)
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
+
+  describe "Net::FTP#system" do
+    before :each do
+      @server = NetFTPSpecs::DummyFTP.new
+      @server.serve_once
+
+      @ftp = Net::FTP.new
+      @ftp.connect(@server.hostname, @server.server_port)
+    end
+
+    after :each do
+      @ftp.quit rescue nil
+      @ftp.close
+      @server.stop
+    end
+
+    it "sends the SYST command to the server" do
+      @ftp.system
+      @ftp.last_response.should =~ /\A215 FTP Dummy Server \(SYST\)\Z/
+    end
+
+    it "returns the received information" do
+      @ftp.system.should =~ /\AFTP Dummy Server \(SYST\)\Z/
+    end
+
+    it "raises a Net::FTPPermError when the response code is 500" do
+      @server.should_receive(:syst).and_respond("500 Syntax error, command unrecognized.")
+      -> { @ftp.system }.should raise_error(Net::FTPPermError)
+    end
+
+    it "raises a Net::FTPPermError when the response code is 501" do
+      @server.should_receive(:syst).and_respond("501 Syntax error in parameters or arguments.")
+      -> { @ftp.system }.should raise_error(Net::FTPPermError)
+    end
+
+    it "raises a Net::FTPPermError when the response code is 502" do
+      @server.should_receive(:syst).and_respond("502 Command not implemented.")
+      -> { @ftp.system }.should raise_error(Net::FTPPermError)
+    end
+
+    it "raises a Net::FTPTempError when the response code is 421" do
+      @server.should_receive(:syst).and_respond("421 Service not available, closing control connection.")
+      -> { @ftp.system }.should raise_error(Net::FTPTempError)
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/voidcmd_spec.rb b/spec/ruby/library/net-ftp/voidcmd_spec.rb
index f2536fe697..bd12089c81 100644
--- a/spec/ruby/library/net-ftp/voidcmd_spec.rb
+++ b/spec/ruby/library/net-ftp/voidcmd_spec.rb
@@ -1,54 +1,57 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
 
-describe "Net::FTP#voidcmd" do
-  before :each do
-    @server = NetFTPSpecs::DummyFTP.new
-    @server.serve_once
-
-    @ftp = Net::FTP.new
-    @ftp.connect(@server.hostname, @server.server_port)
-  end
-
-  after :each do
-    @ftp.quit rescue nil
-    @ftp.close
-    @server.stop
-  end
-
-  it "sends the passed command to the server" do
-    @server.should_receive(:help).and_respond("2xx Does not raise.")
-    -> { @ftp.voidcmd("HELP") }.should_not raise_error
-  end
-
-  it "returns nil" do
-    @server.should_receive(:help).and_respond("2xx Does not raise.")
-    @ftp.voidcmd("HELP").should be_nil
-  end
-
-  it "raises a Net::FTPReplyError when the response code is 1xx" do
-    @server.should_receive(:help).and_respond("1xx Does raise a Net::FTPReplyError.")
-    -> { @ftp.voidcmd("HELP")  }.should raise_error(Net::FTPReplyError)
-  end
-
-  it "raises a Net::FTPReplyError when the response code is 3xx" do
-    @server.should_receive(:help).and_respond("3xx Does raise a Net::FTPReplyError.")
-    -> { @ftp.voidcmd("HELP") }.should raise_error(Net::FTPReplyError)
-  end
-
-  it "raises a Net::FTPTempError when the response code is 4xx" do
-    @server.should_receive(:help).and_respond("4xx Does raise a Net::FTPTempError.")
-    -> { @ftp.voidcmd("HELP") }.should raise_error(Net::FTPTempError)
-  end
-
-  it "raises a Net::FTPPermError when the response code is 5xx" do
-    @server.should_receive(:help).and_respond("5xx Does raise a Net::FTPPermError.")
-    -> { @ftp.voidcmd("HELP") }.should raise_error(Net::FTPPermError)
-  end
-
-  it "raises a Net::FTPProtoError when the response code is not valid" do
-    @server.should_receive(:help).and_respond("999 Does raise a Net::FTPProtoError.")
-    -> { @ftp.voidcmd("HELP") }.should raise_error(Net::FTPProtoError)
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
+
+  describe "Net::FTP#voidcmd" do
+    before :each do
+      @server = NetFTPSpecs::DummyFTP.new
+      @server.serve_once
+
+      @ftp = Net::FTP.new
+      @ftp.connect(@server.hostname, @server.server_port)
+    end
+
+    after :each do
+      @ftp.quit rescue nil
+      @ftp.close
+      @server.stop
+    end
+
+    it "sends the passed command to the server" do
+      @server.should_receive(:help).and_respond("2xx Does not raise.")
+      -> { @ftp.voidcmd("HELP") }.should_not raise_error
+    end
+
+    it "returns nil" do
+      @server.should_receive(:help).and_respond("2xx Does not raise.")
+      @ftp.voidcmd("HELP").should be_nil
+    end
+
+    it "raises a Net::FTPReplyError when the response code is 1xx" do
+      @server.should_receive(:help).and_respond("1xx Does raise a Net::FTPReplyError.")
+      -> { @ftp.voidcmd("HELP")  }.should raise_error(Net::FTPReplyError)
+    end
+
+    it "raises a Net::FTPReplyError when the response code is 3xx" do
+      @server.should_receive(:help).and_respond("3xx Does raise a Net::FTPReplyError.")
+      -> { @ftp.voidcmd("HELP") }.should raise_error(Net::FTPReplyError)
+    end
+
+    it "raises a Net::FTPTempError when the response code is 4xx" do
+      @server.should_receive(:help).and_respond("4xx Does raise a Net::FTPTempError.")
+      -> { @ftp.voidcmd("HELP") }.should raise_error(Net::FTPTempError)
+    end
+
+    it "raises a Net::FTPPermError when the response code is 5xx" do
+      @server.should_receive(:help).and_respond("5xx Does raise a Net::FTPPermError.")
+      -> { @ftp.voidcmd("HELP") }.should raise_error(Net::FTPPermError)
+    end
+
+    it "raises a Net::FTPProtoError when the response code is not valid" do
+      @server.should_receive(:help).and_respond("999 Does raise a Net::FTPProtoError.")
+      -> { @ftp.voidcmd("HELP") }.should raise_error(Net::FTPProtoError)
+    end
   end
 end
diff --git a/spec/ruby/library/net-ftp/welcome_spec.rb b/spec/ruby/library/net-ftp/welcome_spec.rb
index 4279127ce3..0d67e109c9 100644
--- a/spec/ruby/library/net-ftp/welcome_spec.rb
+++ b/spec/ruby/library/net-ftp/welcome_spec.rb
@@ -1,25 +1,28 @@
 require_relative '../../spec_helper'
-require_relative 'spec_helper'
-require_relative 'fixtures/server'
 
-describe "Net::FTP#welcome" do
-  before :each do
-    @server = NetFTPSpecs::DummyFTP.new
-    @server.serve_once
+ruby_version_is ""..."4.1" do
+  require_relative 'spec_helper'
+  require_relative 'fixtures/server'
 
-    @ftp = Net::FTP.new
-    @ftp.connect(@server.hostname, @server.server_port)
-  end
+  describe "Net::FTP#welcome" do
+    before :each do
+      @server = NetFTPSpecs::DummyFTP.new
+      @server.serve_once
 
-  after :each do
-    @ftp.quit rescue nil
-    @ftp.close
-    @server.stop
-  end
+      @ftp = Net::FTP.new
+      @ftp.connect(@server.hostname, @server.server_port)
+    end
+
+    after :each do
+      @ftp.quit rescue nil
+      @ftp.close
+      @server.stop
+    end
 
-  it "returns the server's welcome message" do
-    @ftp.welcome.should be_nil
-    @ftp.login
-    @ftp.welcome.should == "230 User logged in, proceed. (USER anonymous)\n"
+    it "returns the server's welcome message" do
+      @ftp.welcome.should be_nil
+      @ftp.login
+      @ftp.welcome.should == "230 User logged in, proceed. (USER anonymous)\n"
+    end
   end
 end