fakefs 0.6.5 → 0.6.7

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    M2Q1M2IzMDYzOTczY2E4NjFkZGRhYWRhMTI2ZTQxNzZkYjNlZGE0Ng==
-  data.tar.gz: !binary |-
-    YzFhYTRmZmU1NTY3MWJlZTljZjkyZTBjMmQ4NjBiZWZhNDBiNDg1YQ==
+SHA1:
+  metadata.gz: fc6809d0301720e85b2242f8e37100be5e77395b
+  data.tar.gz: 63eaa2bfd50a523613ec164fdbcfbbd14195aeae
 SHA512:
-  metadata.gz: !binary |-
-    YjgzZWNjYjA2NjliMzE3ZmFiOTY4NTE0N2UyODI0ZWI2YjE4MjU2NDE1NGNh
-    YzIzYTc0YmFlMThjYmY5Yjk4OWQwZWM0ZTU2YTI4ZGJiNDEzNzA3M2NkYjEy
-    YzljYmJiY2EzOGNiNTBhZTdkOWY5M2FmZjEzZWFmNDQ4ODg1ZGI=
-  data.tar.gz: !binary |-
-    ODRiYzE1NjBhZjRjMGVhNTE1YWE1ZmM0YmRjMjZkNzAwNDcwYTkzNjRmNjJh
-    MDNkODk2MzVlNTVhZWVmODFjNjhkMTEzNGZjNGYyOGNiODFhMzg3YThhOTg4
-    N2E3Y2JlM2I3NzI2ZWQ1YTY1ZjNkMzhhYzc2ZTgzYzU0ZjY1MTQ=
+  metadata.gz: cd81047918fe4c89615fc92c5e5b57c5c7953c367c61c2e9b823c7b4bc8079fc82fa08048dca9cb17cffefd17b19a7b1a0f69740d1345658d047b2ceb34d16a4
+  data.tar.gz: 0a7cddc534cf1a1430392d95b8c17301ddb3f5cb233da7481da62401ef97e8995cd11522a030f04899aa932630bb976e68506fe36decac49c3d5c55db93d56e2

data/.travis.yml

@@ -1,7 +1,10 @@
+language: ruby
+sudo: false
 rvm:
   - 1.9.3
   - 2.0.0
   - 2.1.1
+  - 2.2.0
   - jruby
   - rbx-19mode
 matrix:
@@ -9,5 +12,4 @@ matrix:
     - rvm: jruby
     - rvm: rbx-19mode
 before_install:
-  - gem update --system 2.1.11
   - gem --version

data/CONTRIBUTORS

@@ -6,6 +6,7 @@ Lukas Oberhuber <lukaso@gmail.com>
 Brian Donovan <donovan@squareup.com>
 Myles Eftos <myles@madpilot.com.au>
 Jeff Hodges <jeff@somethingsimilar.com>
+Jakub Jirutka <jakub@jirutka.cz>
 Pierre RAMBAUD <pierre.rambaud86@gmail.com>
 Morten Møller Riis <mortenmoellerriis@gmail.com>
 Matt Freels <matt@freels.name>
@@ -32,9 +33,9 @@ Maarten Hoogendoorn <maarten@moretea.nl>
 Jon Yurek <jyurek@thoughtbot.com>
 Jared Luxenberg <jared@jaredlux.com>
 DSIW <dsiw@dsiw-it.de>
-Lars Gierth <lars.gierth@gmail.com>
-Greg Campbell <gtcampbell@gmail.com>
 doc75 <github@virlet.org>
+Greg Campbell <gtcampbell@gmail.com>
+Lars Gierth <lars.gierth@gmail.com>
 marano <thiagomarano@gmail.com>
 Ben Mabey <ben@benmabey.com>
 Jorge Orlando Munoz <jmunoz@altavistaed.com>
@@ -43,11 +44,10 @@ Sam Goldstein <sam@aboutus.org>
 Adam Alboyadjian <adam@vistahigherlearning.com>
 Rick Salevsky <rsalevsky@suse.com>
 Scott Petersen <petersen@centtech.com>
-Emil Soman <emil.soman@gmail.com>
-Ryan McGeary <ryan@mcgeary.org>
 Matt Todd <chiology@gmail.com>
 Noah Paessel <knowuh@gmail.com>
-Jakub Jirutka <jakub@jirutka.cz>
+Emil Soman <emil.soman@gmail.com>
+Ryan McGeary <ryan@mcgeary.org>
 dmathieu <42@dmathieu.com>
 Oleg Sukhodolsky <os97673@gmail.com>
 Winston Lee <lee.winston@gmail.com>
@@ -56,37 +56,37 @@ Grayson Wright <wright.grayson@gmail.com>
 Zequez <zequez@gmail.com>
 jameswilding <james@jameswilding.net>
 Ed Ruder <ed@squareup.com>
-Benjamin Oakes <hello@benjaminoakes.com>
 Tymon Tobolski <i@teamon.eu>
+Benjamin Oakes <hello@benjaminoakes.com>
 Scott Barron <scott@elitists.net>
 Andrius Chamentauskas <andrius.chamentauskas@gmail.com>
 Eric Daspet <eric.daspet@survol.fr>
+W. Andrew Loe III <andrew@andrewloe.com>
 Matt Hoyle <matt@deployable.co>
 Xavier Shay <xavier@squareup.com>
-W. Andrew Loe III <andrew@andrewloe.com>
 Travis Herrick <travis@carbonfive.com>
 Keita Urashima <ursm@ursm.jp>
 rambutan <usul@usul-HP-EliteBook-8460p.(none)>
-andrea longhi <andrea@spaghetticode.it>
-= <gokulnath@mobme.in>
 Matthew Morgan <lytithwyn@gmail.com>
+= <gokulnath@mobme.in>
+andrea longhi <andrea@spaghetticode.it>
 msassak <msassak@gmail.com>
 David Reese <david@whatcould.com>
-Andrius Chamentauskas <sinsiliux@gmail.com>
 timo3377 <tim.linquist@gmail.com>
+Andrius Chamentauskas <sinsiliux@gmail.com>
+Paolo Gianrossi <paolino.gianrossi@gmail.com>
 Matt Rogers <mattrogers@sbcglobal.net>
 Michael Scherer <misc@zarb.org>
-Paolo Gianrossi <paolino.gianrossi@gmail.com>
 Mislav Marohnić <mislav.marohnic@gmail.com>
-Rob Sanheim <rsanheim@gmail.com>
 Andrew Ryan <nerdrew@gmail.com>
+Rob Sanheim <rsanheim@gmail.com>
+Chris Wanstrath <chris@github.com>
+Chris Knadler <takeshi91k@gmail.com>
 Toon Willems <willemstoon@gmail.com>
 Ryan Scott Lewis <ryanscottlewis@lewis-software.com>
-Chris Knadler <takeshi91k@gmail.com>
-Chris Wanstrath <chris@github.com>
-Yuta Shimizu <pachirel@gmail.com>
 Sven Riedel <sr@gimp.org>
 Dane O'Connor <dane.oconnor@gmail.com>
+Yuta Shimizu <pachirel@gmail.com>
+Benjamin Fleischer <github@benjaminfleischer.com>
 Jordi Massaguer Pla <jmassaguerpla@suse.de>
 Maria Shaldibina <mariash@pivotallabs.com>
-Benjamin Fleischer <github@benjaminfleischer.com>

data/README.markdown

@@ -170,4 +170,4 @@ Releasing
 
 1. Update version in lib/fakefs/version.rb
 2. Commit it
-3. run `rake publish`
+3. run `bundle exec rake publish`

data/Rakefile

@@ -30,7 +30,7 @@ end
 task default: [:test, :spec, :rubocop]
 
 desc 'Push a new version to rubygems.org'
-task :publish => [:test, :spec, :update_contributors, :tag, :release, :push]
+task :publish => [:test, :spec, :rubocop, :update_contributors, :tag, :release, :push]
 
 desc 'Update contributors'
 task :update_contributors do
@@ -39,7 +39,7 @@ task :update_contributors do
   sh "#{git_rank_contributors} > CONTRIBUTORS"
   if `git status | grep CONTRIBUTORS`.strip.length > 0
     sh "git add CONTRIBUTORS"
-    sh "git commit -m 'Updates contributors for release'"
+    sh "git commit -m 'Update contributors for release'"
   end
 end
 

data/fakefs.gemspec

@@ -22,4 +22,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 10.3"
   spec.add_development_dependency "rspec", "~> 3.1"
   spec.add_development_dependency 'rubocop', '~>0.25'
+  spec.add_development_dependency 'minitest', '~> 5.5'
+  spec.add_development_dependency 'minitest-rg', '~> 5.1'
 end

data/lib/fakefs/base.rb

@@ -16,14 +16,12 @@ end
 
 # FakeFS module
 module FakeFS
-  @activated = false
   class << self
     def activated?
-      @activated
+      @activated ? true : false
     end
 
     def activate!
-      @activated = true
       Object.class_eval do
         remove_const(:Dir)
         remove_const(:File)
@@ -38,12 +36,13 @@ module FakeFS
         const_set(:Pathname,  FakeFS::Pathname) if RUBY_VERSION >= '1.9.3'
         ::FakeFS::Kernel.hijack!
       end
+
+      @activated = true
+
       true
     end
 
     def deactivate!
-      @activated = false
-
       Object.class_eval do
         remove_const(:Dir)
         remove_const(:File)
@@ -58,6 +57,9 @@ module FakeFS
         const_set(:Pathname,  RealPathname) if RUBY_VERSION >= '1.9.3'
         ::FakeFS::Kernel.unhijack!
       end
+
+      @activated = false
+
       true
     end
 

data/lib/fakefs/fake/file.rb

@@ -2,7 +2,7 @@ module FakeFS
   # Fake file class
   class FakeFile
     attr_accessor :name, :parent, :content, :mtime, :atime, :mode, :uid, :gid
-    attr_reader :ctime
+    attr_reader :ctime, :birthtime
 
     # Inode class
     class Inode
@@ -34,15 +34,16 @@ module FakeFS
     end
 
     def initialize(name = nil, parent = nil)
-      @name   = name
-      @parent = parent
-      @inode  = Inode.new(self)
-      @ctime  = Time.now
-      @mtime  = @ctime
-      @atime  = @ctime
-      @mode   = 0100000 + (0666 - File.umask)
-      @uid    = Process.uid
-      @gid    = Process.gid
+      @name      = name
+      @parent    = parent
+      @inode     = Inode.new(self)
+      @ctime     = Time.now
+      @mtime     = @ctime
+      @atime     = @ctime
+      @birthtime = @ctime
+      @mode      = 0100000 + (0666 - File.umask)
+      @uid       = Process.uid
+      @gid       = Process.gid
     end
 
     attr_accessor :inode

data/lib/fakefs/file.rb

@@ -283,6 +283,7 @@ module FakeFS
     # FakeFS Stat class
     class Stat
       attr_reader :ctime, :mtime, :atime, :mode, :uid, :gid
+      attr_reader :birthtime if RUBY_VERSION >= '2.2.0'
 
       def initialize(file, lstat = false)
         fail(Errno::ENOENT, file) unless File.exist?(file)
@@ -296,6 +297,12 @@ module FakeFS
         @mode      = @fake_file.mode
         @uid       = @fake_file.uid
         @gid       = @fake_file.gid
+        @birthtime =
+          if @fake_file.respond_to?(:birthtime)
+            @fake_file.birthtime
+          else
+            @fake_file.ctime
+          end
       end
 
       def symlink?
@@ -553,6 +560,20 @@ module FakeFS
       end
     end
 
+    if RUBY_VERSION >= '2.2.0'
+      def self.birthtime(path)
+        if exists?(path)
+          FileSystem.find(path).birthtime
+        else
+          fail Errno::ENOENT
+        end
+      end
+
+      def birthtime
+        self.class.birthtime(@path)
+      end
+    end
+
     def read(length = nil, buf = '')
       read_buf = super(length, buf)
       # change to binary only for ruby 1.9.3

data/lib/fakefs/file_system.rb

@@ -60,12 +60,13 @@ module FakeFS
 
       files.each do |f|
         target_path = target ? f.gsub(path, target) : f
+
         if RealFile.symlink?(f)
           FileUtils.ln_s(RealFile.readlink(f), f)
         elsif RealFile.file?(f)
           FileUtils.mkdir_p(File.dirname(f))
           File.open(target_path, File::WRITE_ONLY) do |g|
-            g.print RealFile.open(f) { |h| h.read }
+            g.print RealFile.read(f)
           end
         elsif RealFile.directory?(f)
           FileUtils.mkdir_p(target_path)

data/lib/fakefs/version.rb

@@ -1,7 +1,7 @@
 module FakeFS
   # Version module
   module Version
-    VERSION = '0.6.5'
+    VERSION = '0.6.7'
 
     def self.to_s
       VERSION

data/test/dir/tempfile_test.rb

@@ -2,16 +2,15 @@ require 'test_helper'
 require 'tempfile'
 
 # Tempfile test class
-class TempfileTest < Test::Unit::TestCase
+class TempfileTest < Minitest::Test
   include FakeFS
 
   if RUBY_VERSION >= '2.1'
     def test_should_not_raise_error
       FakeFS do
-        assert_nothing_raised do
-          FileUtils.mkdir_p('/tmp')
-          Tempfile.open('test')
-        end
+        # nothing raised
+        FileUtils.mkdir_p('/tmp')
+        Tempfile.open('test')
       end
     end
   else

data/test/fake/file/join_test.rb

@@ -1,7 +1,7 @@
 require 'test_helper'
 
 # File join test class
-class FileJoin < Test::Unit::TestCase
+class FileJoin < Minitest::Test
   def setup
     FakeFS.activate!
   end

data/test/fake/file/lstat_test.rb

@@ -1,7 +1,7 @@
 require 'test_helper'
 
 # File stat test class
-class FileStat < Test::Unit::TestCase
+class FileStat < Minitest::Test
   def setup
     FakeFS.activate!
     FakeFS::FileSystem.clear
@@ -35,7 +35,7 @@ class FileStat < Test::Unit::TestCase
     File.open('foo', 'w') { |f| f << 'some content' }
     File.symlink 'foo', 'my_symlink'
 
-    assert_not_equal File.lstat('my_symlink').size, File.lstat('foo').size
+    refute_equal File.lstat('my_symlink').size, File.lstat('foo').size
   end
 
   def test_should_report_on_symlink_itself_with_size_instance_method
@@ -45,7 +45,7 @@ class FileStat < Test::Unit::TestCase
     file = File.open('foo')
     symlink = File.open('my_symlink')
 
-    assert_not_equal file.lstat.size, symlink.lstat.size
+    refute_equal file.lstat.size, symlink.lstat.size
   end
 
   def test_symlink_size_is_size_of_path_pointed_to

data/test/fake/file/stat_test.rb

@@ -1,7 +1,7 @@
 require 'test_helper'
 
 # File stat test class
-class FileStat < Test::Unit::TestCase
+class FileStat < Minitest::Test
   def setup
     FakeFS.activate!
     FakeFS::FileSystem.clear

data/test/fake/file/sysseek_test.rb

@@ -1,7 +1,7 @@
 require 'test_helper'
 
 # File SysSeek test class
-class FileSysSeek < Test::Unit::TestCase
+class FileSysSeek < Minitest::Test
   def setup
     FakeFS.activate!
     FakeFS::FileSystem.clear

data/test/fake/file/syswrite_test.rb

@@ -1,7 +1,7 @@
 require 'test_helper'
 
 # File SysWrite test class
-class FileSysWriteTest < Test::Unit::TestCase
+class FileSysWriteTest < Minitest::Test
   def setup
     FakeFS.activate!
     FakeFS::FileSystem.clear

data/test/fake/file_test.rb

@@ -1,7 +1,7 @@
 require 'test_helper'
 
 # Fake File test class
-class FakeFileTest < Test::Unit::TestCase
+class FakeFileTest < Minitest::Test
   include FakeFS
 
   def setup
@@ -72,7 +72,7 @@ class FakeFileTest < Test::Unit::TestCase
 
   def test_clone_creates_new_inode
     clone = @file.clone
-    assert !clone.inode.equal?(@file.inode)
+    refute clone.inode.equal?(@file.inode)
   end
 
   def test_cloning_does_not_use_same_content_object

data/test/fake/symlink_test.rb

@@ -1,7 +1,7 @@
 require 'test_helper'
 
 # Fake symlink test class
-class FakeSymlinkTest < Test::Unit::TestCase
+class FakeSymlinkTest < Minitest::Test
   include FakeFS
 
   def test_symlink_has_method_missing_as_private
@@ -15,7 +15,7 @@ class FakeSymlinkTest < Test::Unit::TestCase
            'has public method \#to_s'
     assert fake_symlink.respond_to?(:to_s, true),
            'has public or private method \#to_s'
-    assert !fake_symlink.respond_to?(:initialize, false),
+    refute fake_symlink.respond_to?(:initialize, false),
            'has private method \#initialize'
     assert fake_symlink.respond_to?(:initialize, true),
            'has private method \#initialize'
@@ -25,8 +25,8 @@ class FakeSymlinkTest < Test::Unit::TestCase
     fake_symlink = FakeSymlink.new('foo')
     assert_equal fake_symlink.respond_to?(:to_s),
                  fake_symlink.entry.respond_to?(:to_s)
-    assert_not_equal fake_symlink.respond_to?(:to_s),
-                     fake_symlink.entry.respond_to?(:initialize)
+    refute_equal fake_symlink.respond_to?(:to_s),
+                 fake_symlink.entry.respond_to?(:initialize)
     assert_equal fake_symlink.respond_to?(:initialize),
                  fake_symlink.entry.respond_to?(:initialize)
   end

data/test/fakefs_test.rb

@@ -2,32 +2,41 @@
 require 'test_helper'
 
 # FakeFS tests
-class FakeFSTest < Test::Unit::TestCase
-  include FakeFS
-
+class FakeFSTest < Minitest::Test
   def setup
+    act_on_real_fs do
+      File.umask(0006)
+      FileUtils.rm_rf(real_file_sandbox)
+      FileUtils.mkdir_p(real_file_sandbox)
+      FileUtils.chmod(0777, real_file_sandbox)
+    end
+
     FakeFS.activate!
-    FileSystem.clear
+    FakeFS::FileSystem.clear
   end
 
   def teardown
     FakeFS.deactivate!
+
+    act_on_real_fs do
+      FileUtils.rm_rf(real_file_sandbox)
+    end
   end
 
   def test_can_be_initialized_empty
-    fs = FileSystem
+    fs = FakeFS::FileSystem
     assert_equal 0, fs.files.size
   end
 
   def xtest_can_be_initialized_with_an_existing_directory
-    fs = FileSystem
+    fs = FakeFS::FileSystem
     fs.clone(File.expand_path(File.dirname(__FILE__))).inspect
     assert_equal 1, fs.files.size
   end
 
   def test_can_create_directories_with_file_utils_mkdir_p
     FileUtils.mkdir_p('/path/to/dir')
-    assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir']
+    assert_kind_of FakeFS::FakeDir, FakeFS::FileSystem.fs['path']['to']['dir']
   end
 
   def test_can_cd_to_directory_with_block
@@ -42,26 +51,26 @@ class FakeFSTest < Test::Unit::TestCase
 
   def test_can_create_a_list_of_directories_with_file_utils_mkdir_p
     FileUtils.mkdir_p(%w(/path/to/dir1 /path/to/dir2))
-    assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir1']
-    assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir2']
+    assert_kind_of FakeFS::FakeDir, FakeFS::FileSystem.fs['path']['to']['dir1']
+    assert_kind_of FakeFS::FakeDir, FakeFS::FileSystem.fs['path']['to']['dir2']
   end
 
   def test_can_create_directories_with_options
     FileUtils.mkdir_p('/path/to/dir', mode: 0755)
-    assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir']
+    assert_kind_of FakeFS::FakeDir, FakeFS::FileSystem.fs['path']['to']['dir']
   end
 
   def test_can_create_directories_with_file_utils_mkdir
     FileUtils.mkdir_p('/path/to/dir')
     FileUtils.mkdir('/path/to/dir/subdir')
-    assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir']['subdir']
+    assert_kind_of FakeFS::FakeDir, FakeFS::FileSystem.fs['path']['to']['dir']['subdir']
   end
 
   def test_can_create_a_list_of_directories_with_file_utils_mkdir
     FileUtils.mkdir_p('/path/to/dir')
     FileUtils.mkdir(%w(/path/to/dir/subdir1 /path/to/dir/subdir2))
-    assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir']['subdir1']
-    assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir']['subdir2']
+    assert_kind_of FakeFS::FakeDir, FakeFS::FileSystem.fs['path']['to']['dir']['subdir1']
+    assert_kind_of FakeFS::FakeDir, FakeFS::FileSystem.fs['path']['to']['dir']['subdir2']
   end
 
   def test_raises_error_when_creating_a_new_dir_with_mkdir_in_non_existent_path
@@ -73,54 +82,50 @@ class FakeFSTest < Test::Unit::TestCase
   def test_raises_error_when_creating_a_new_dir_over_existing_file
     File.open('file', 'w') { |f| f << 'This is a file, not a directory.' }
 
-    assert_raise Errno::EEXIST do
+    assert_raises Errno::EEXIST do
       FileUtils.mkdir_p('file/subdir')
     end
 
     FileUtils.mkdir('dir')
     File.open('dir/subfile', 'w') { |f| f << 'This is a file inside a directory.' }
 
-    assert_raise Errno::EEXIST do
+    assert_raises Errno::EEXIST do
       FileUtils.mkdir_p('dir/subfile/subdir')
     end
   end
 
   def test_can_create_directories_with_mkpath
     FileUtils.mkpath('/path/to/dir')
-    assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir']
+    assert_kind_of FakeFS::FakeDir, FakeFS::FileSystem.fs['path']['to']['dir']
   end
 
   def test_can_create_directories_with_mkpath_and_options
     FileUtils.mkpath('/path/to/dir', mode: 0755)
-    assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir']
+    assert_kind_of FakeFS::FakeDir, FakeFS::FileSystem.fs['path']['to']['dir']
   end
 
   def test_can_create_directories_with_mkdirs
     FileUtils.makedirs('/path/to/dir')
-    assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir']
+    assert_kind_of FakeFS::FakeDir, FakeFS::FileSystem.fs['path']['to']['dir']
   end
 
   def test_can_create_directories_with_mkdirs_and_options
     FileUtils.makedirs('/path/to/dir', mode: 0755)
-    assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir']
+    assert_kind_of FakeFS::FakeDir, FakeFS::FileSystem.fs['path']['to']['dir']
   end
 
   def test_unlink_errors_on_file_not_found
-    assert_raise Errno::ENOENT do
+    assert_raises Errno::ENOENT do
       FileUtils.rm('/foo')
     end
   end
 
   def test_unlink_doesnt_error_on_file_not_found_when_forced
-    assert_nothing_raised do
-      FileUtils.rm('/foo', force: true)
-    end
+    FileUtils.rm('/foo', force: true)
   end
 
   def test_unlink_doesnt_error_on_file_not_found_with_rm_rf
-    assert_nothing_raised do
-      FileUtils.rm_rf('/foo')
-    end
+    FileUtils.rm_rf('/foo')
   end
 
   def test_can_delete_directories
@@ -199,13 +204,13 @@ class FakeFSTest < Test::Unit::TestCase
 
   def test_symlink_with_missing_refferent_does_not_exist
     File.symlink('/foo', '/bar')
-    assert !File.exist?('/bar')
+    refute File.exist?('/bar')
   end
 
   def test_can_create_symlinks
     FileUtils.mkdir_p(target = '/path/to/target')
     FileUtils.ln_s(target, '/path/to/link')
-    assert_kind_of FakeSymlink, FileSystem.fs['path']['to']['link']
+    assert_kind_of FakeFS::FakeSymlink, FakeFS::FileSystem.fs['path']['to']['link']
 
     assert_raises(Errno::EEXIST) do
       FileUtils.ln_s(target, '/path/to/link')
@@ -215,14 +220,14 @@ class FakeFSTest < Test::Unit::TestCase
   def test_can_force_creation_of_symlinks
     FileUtils.mkdir_p(target = '/path/to/first/target')
     FileUtils.ln_s(target, '/path/to/link')
-    assert_kind_of FakeSymlink, FileSystem.fs['path']['to']['link']
+    assert_kind_of FakeFS::FakeSymlink, FakeFS::FileSystem.fs['path']['to']['link']
     FileUtils.ln_s(target, '/path/to/link', force: true)
   end
 
   def test_create_symlink_using_ln_sf
     FileUtils.mkdir_p(target = '/path/to/first/target')
     FileUtils.ln_s(target, '/path/to/link')
-    assert_kind_of FakeSymlink, FileSystem.fs['path']['to']['link']
+    assert_kind_of FakeFS::FakeSymlink, FakeFS::FileSystem.fs['path']['to']['link']
     FileUtils.ln_sf(target, '/path/to/link')
   end
 
@@ -251,7 +256,7 @@ class FakeFSTest < Test::Unit::TestCase
     FileUtils.touch('/file')
     FileUtils.mkdir_p('/a/b')
     FileUtils.ln_s('../../file_foo', '/a/b/symlink')
-    assert !File.exist?('/a/b/symlink')
+    refute File.exist?('/a/b/symlink')
   end
 
   def test_symlink_with_relative_path_has_correct_target
@@ -274,9 +279,9 @@ class FakeFSTest < Test::Unit::TestCase
   def test_symlink_to_symlinks_should_raise_error_if_dir_doesnt_exist
     FileUtils.mkdir_p(target = '/path/to/foo/target')
 
-    assert !Dir.exist?('/path/to/bar')
+    refute Dir.exist?('/path/to/bar')
 
-    assert_raise Errno::ENOENT do
+    assert_raises Errno::ENOENT do
       FileUtils.ln_s(target, '/path/to/bar/symlink')
     end
   end
@@ -299,7 +304,7 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_nothing_is_sticky
-    assert !File.sticky?('/')
+    refute File.sticky?('/')
   end
 
   def test_can_create_files_in_existing_dir
@@ -496,7 +501,8 @@ class FakeFSTest < Test::Unit::TestCase
       f.write 'Yatta!'
     end
 
-    assert_nothing_raised { File.read(path, mode: 'r:UTF-8:-') }
+    # nothing raised
+    File.read(path, mode: 'r:UTF-8:-')
   end
 
   def test_file_read_respects_args
@@ -519,7 +525,7 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_raises_error_when_opening_with_binary_mode_only
-    assert_raise ArgumentError do
+    assert_raises ArgumentError do
       File.open('/foo', 'b')
     end
   end
@@ -598,7 +604,7 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_raises_error_on_mtime_if_file_does_not_exist
-    assert_raise Errno::ENOENT do
+    assert_raises Errno::ENOENT do
       File.mtime('/path/to/file.txt')
     end
   end
@@ -630,7 +636,7 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_raises_error_on_ctime_if_file_does_not_exist
-    assert_raise Errno::ENOENT do
+    assert_raises Errno::ENOENT do
       File.ctime('file.txt')
     end
   end
@@ -641,7 +647,7 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_raises_error_on_atime_if_file_does_not_exist
-    assert_raise Errno::ENOENT do
+    assert_raises Errno::ENOENT do
       File.atime('file.txt')
     end
   end
@@ -713,7 +719,7 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_utime_raises_error_if_path_does_not_exist
-    assert_raise Errno::ENOENT do
+    assert_raises Errno::ENOENT do
       File.utime(Time.now, Time.now, '/path/to/file.txt')
     end
   end
@@ -787,7 +793,7 @@ class FakeFSTest < Test::Unit::TestCase
     file = File.open(path, 'w')
     file.write 'Yada'
     file.close
-    assert_raise IOError do
+    assert_raises IOError do
       file.read
     end
   end
@@ -797,7 +803,7 @@ class FakeFSTest < Test::Unit::TestCase
     file = File.open(path, 'w')
     file.write 'Yada'
     file.close
-    assert_raise IOError do
+    assert_raises IOError do
       file << 'foo'
     end
   end
@@ -821,17 +827,14 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_file_object_initialization_with_mode_in_hash_parameter
-    assert_nothing_raised do
-      File.open('file.txt', mode: 'w') { |f| f.write 'Yatta!' }
-    end
+    File.open('file.txt', mode: 'w') { |f| f.write 'Yatta!' }
   end
 
   def test_file_object_initialization_with_brackets_in_filename
     filename = 'bracket[1](2).txt'
     expected_contents = 'Yokudekimashita'
-    assert_nothing_raised do
-      File.open(filename, mode: 'w') { |f| f.write "#{expected_contents}" }
-    end
+    # nothing raised
+    File.open(filename, mode: 'w') { |f| f.write "#{expected_contents}" }
     the_file = Dir['/*']
     assert_equal the_file.length, 1
     assert_equal the_file[0], "/#{filename}"
@@ -842,15 +845,14 @@ class FakeFSTest < Test::Unit::TestCase
   def test_file_object_initialization_with_brackets_in_filename
     filename = "\u65e5\u672c\u8a9e.txt"
     expected_contents = 'Yokudekimashita'
-    assert_nothing_raised do
-      File.open(filename,  mode: 'w') { |f| f.write "#{expected_contents}" }
-    end
+    # nothing raised
+    File.open(filename,  mode: 'w') { |f| f.write "#{expected_contents}" }
     contents = File.open("/#{filename}").read
     assert_equal contents, expected_contents
   end
 
   def test_file_read_errors_appropriately
-    assert_raise Errno::ENOENT do
+    assert_raises Errno::ENOENT do
       File.read('anything')
     end
   end
@@ -858,7 +860,7 @@ class FakeFSTest < Test::Unit::TestCase
   def test_file_read_errors_on_directory
     FileUtils.mkdir_p('a_directory')
 
-    assert_raise Errno::EISDIR do
+    assert_raises Errno::EISDIR do
       File.read('a_directory')
     end
   end
@@ -918,7 +920,7 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_executable_returns_false_for_non_existent_files
-    assert !File.executable?('/does/not/exist')
+    refute File.executable?('/does/not/exist')
   end
 
   def test_can_chown_files
@@ -1078,7 +1080,7 @@ class FakeFSTest < Test::Unit::TestCase
   def test_file_utils_cp_allows_noop_option
     File.open('foo', 'w') { |f| f << 'TEST' }
     FileUtils.cp 'foo', 'bar', noop: true
-    assert !File.exist?('bar'), 'does not actually copy'
+    refute File.exist?('bar'), 'does not actually copy'
   end
 
   def test_file_utils_cp_raises_on_invalid_option
@@ -1095,7 +1097,7 @@ class FakeFSTest < Test::Unit::TestCase
   def test_file_utils_cp_r_allows_noop_option
     FileUtils.touch '/foo'
     FileUtils.cp_r '/foo', '/bar', noop: true
-    assert !File.exist?('/bar'), 'does not actually copy'
+    refute File.exist?('/bar'), 'does not actually copy'
   end
 
   def test_dir_glob_handles_root
@@ -1207,7 +1209,8 @@ class FakeFSTest < Test::Unit::TestCase
     :echo?, :echo=, :noecho,
     :winsize, :winsize=,
     :getch,
-    :iflush, :ioflush, :oflush
+    :iflush, :ioflush, :oflush,
+    :pathconf
   ]
 
   def test_every_method_in_file_is_in_fake_fs_file
@@ -1219,7 +1222,7 @@ class FakeFSTest < Test::Unit::TestCase
   def test_file_should_not_respond_to_string_io_unique_methods
     uniq_string_io_methods = StringIO.instance_methods - RealFile.instance_methods
     uniq_string_io_methods.each do |method_name|
-      assert !File.instance_methods.include?(method_name), "File responds to #{method_name}"
+      refute File.instance_methods.include?(method_name), "File responds to #{method_name}"
     end
   end
 
@@ -1230,21 +1233,21 @@ class FakeFSTest < Test::Unit::TestCase
 
   def test_is_not_a_stringio
     File.open('foo', 'w') do |f|
-      assert !f.is_a?(StringIO), 'File is not a StringIO'
+      refute f.is_a?(StringIO), 'File is not a StringIO'
     end
   end
 
   def test_chdir_changes_directories_like_a_boss
     # I know memes!
     FileUtils.mkdir_p '/path'
-    assert_equal '/', FileSystem.fs.name
+    assert_equal '/', FakeFS::FileSystem.fs.name
     assert_equal [], Dir.glob('/path/*')
     Dir.chdir '/path' do
       File.open('foo', 'w') { |f| f.write 'foo' }
       File.open('foobar', 'w') { |f| f.write 'foo' }
     end
 
-    assert_equal '/', FileSystem.fs.name
+    assert_equal '/', FakeFS::FileSystem.fs.name
     assert_equal(['/path/foo', '/path/foobar'], Dir.glob('/path/*').sort)
 
     c = nil
@@ -1301,7 +1304,7 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_chdir_should_flop_over_and_die_if_the_dir_doesnt_exist
-    assert_raise(Errno::ENOENT) do
+    assert_raises(Errno::ENOENT) do
       Dir.chdir('/nope') do
         1
       end
@@ -1331,7 +1334,7 @@ class FakeFSTest < Test::Unit::TestCase
         'Nothing to do'
       end
 
-      assert_equal ['/', '/path'], FileSystem.dir_levels
+      assert_equal ['/', '/path'], FakeFS::FileSystem.dir_levels
     end
 
     assert_equal(['/path/foo', '/path/foobar'], Dir.glob('/path/*').sort)
@@ -1411,10 +1414,10 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_mv_should_raise_error_on_missing_file
-    assert_raise(Errno::ENOENT) do
+    assert_raises(Errno::ENOENT) do
       FileUtils.mv 'blafgag', 'foo'
     end
-    exception = assert_raise(Errno::ENOENT) do
+    exception = assert_raises(Errno::ENOENT) do
       FileUtils.mv %w(foo bar), 'destdir'
     end
     assert_equal 'No such file or directory - foo', exception.message
@@ -1465,7 +1468,7 @@ class FakeFSTest < Test::Unit::TestCase
     FileUtils.touch 'foo'
     FileUtils.mv 'foo', 'bar', noop: true
     assert File.exist?('foo'), 'does not remove src'
-    assert !File.exist?('bar'), 'does not create target'
+    refute File.exist?('bar'), 'does not create target'
   end
 
   def test_mv_raises_when_moving_file_onto_directory
@@ -1489,11 +1492,11 @@ class FakeFSTest < Test::Unit::TestCase
     FileUtils.mv %w(stuff other), 'dir', force: true
     assert File.exist?('stuff'), 'failed move remains where it was'
     assert File.exist?('dir/other'), 'successful one is moved'
-    assert !File.exist?('other'), 'successful one is moved'
+    refute File.exist?('other'), 'successful one is moved'
 
     FileUtils.mv 'stuff', '/this/path/is/not/here', force: true
     assert File.exist?('stuff'), 'failed move remains where it was'
-    assert !File.exist?('/this/path/is/not/here'), 'nothing is created for a failed move'
+    refute File.exist?('/this/path/is/not/here'), 'nothing is created for a failed move'
   end
 
   def test_cp_actually_works
@@ -1523,7 +1526,7 @@ class FakeFSTest < Test::Unit::TestCase
   def test_cp_fails_on_array_of_files_into_non_directory
     File.open('foo', 'w') { |f| f.write 'footext' }
 
-    exception = assert_raise(Errno::ENOTDIR) do
+    exception = assert_raises(Errno::ENOTDIR) do
       FileUtils.cp(%w(foo), 'baz')
     end
     assert_equal 'Not a directory - baz', exception.to_s
@@ -1538,7 +1541,7 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_cp_fails_on_no_source
-    assert_raise Errno::ENOENT do
+    assert_raises Errno::ENOENT do
       FileUtils.cp('foo', 'baz')
     end
   end
@@ -1546,7 +1549,7 @@ class FakeFSTest < Test::Unit::TestCase
   def test_cp_fails_on_directory_copy
     FileUtils.mkdir_p 'baz'
 
-    assert_raise Errno::EISDIR do
+    assert_raises Errno::EISDIR do
       FileUtils.cp('baz', 'bar')
     end
   end
@@ -1567,7 +1570,7 @@ class FakeFSTest < Test::Unit::TestCase
   def test_cp_r_should_raise_error_on_missing_file
     # Yes, this error sucks, but it conforms to the original Ruby
     # method.
-    assert_raise(RuntimeError) do
+    assert_raises(RuntimeError) do
       FileUtils.cp_r 'blafgag', 'foo'
     end
   end
@@ -1642,100 +1645,99 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_clone_clones_normal_files
-    RealFile.open(here('foo'), 'w') { |f| f.write 'bar' }
-    assert !File.exist?(here('foo'))
-    FileSystem.clone(here('foo'))
-    assert_equal 'bar', File.open(here('foo')) { |f| f.read }
-  ensure
-    RealFile.unlink(here('foo')) if RealFile.exist?(here('foo'))
+    act_on_real_fs do
+      File.open(real_file_sandbox('foo'), 'w') do |f|
+        f.write 'bar'
+      end
+
+      assert RealFile.file?(real_file_sandbox('foo'))
+      assert File.file?(real_file_sandbox('foo'))
+    end
+
+    assert RealFile.file?(real_file_sandbox('foo'))
+
+    refute File.exist?(real_file_sandbox('foo'))
+    FakeFS::FileSystem.clone(real_file_sandbox('foo'))
+    assert_equal 'bar', File.open(real_file_sandbox('foo')) { |f| f.read }
   end
 
   def test_clone_clones_directories
-    act_on_real_fs { RealFileUtils.mkdir_p(here('subdir')) }
+    act_on_real_fs { FileUtils.mkdir_p(real_file_sandbox('subdir')) }
 
-    FileSystem.clone(here('subdir'))
+    FakeFS::FileSystem.clone(real_file_sandbox('subdir'))
 
-    assert File.exist?(here('subdir')), 'subdir was cloned'
-    assert File.directory?(here('subdir')), 'subdir is a directory'
-  ensure
-    act_on_real_fs { RealFileUtils.rm_rf(here('subdir')) }
+    assert File.exist?(real_file_sandbox('subdir')), 'subdir was cloned'
+    assert File.directory?(real_file_sandbox('subdir')), 'subdir is a directory'
   end
 
   def test_clone_clones_dot_files_even_hard_to_find_ones
-    act_on_real_fs { RealFileUtils.mkdir_p(here('subdir/.bar/baz/.quux/foo')) }
+    act_on_real_fs { FileUtils.mkdir_p(real_file_sandbox('subdir/.bar/baz/.quux/foo')) }
 
-    assert !File.exist?(here('subdir'))
+    refute File.exist?(real_file_sandbox('subdir'))
 
-    FileSystem.clone(here('subdir'))
-    assert_equal ['.', '..', '.bar'], Dir.entries(here('subdir'))
-    assert_equal ['.', '..', 'foo'], Dir.entries(here('subdir/.bar/baz/.quux'))
-  ensure
-    act_on_real_fs { RealFileUtils.rm_rf(here('subdir')) }
+    FakeFS::FileSystem.clone(real_file_sandbox('subdir'))
+    assert_equal ['.', '..', '.bar'], Dir.entries(real_file_sandbox('subdir'))
+    assert_equal ['.', '..', 'foo'], Dir.entries(real_file_sandbox('subdir/.bar/baz/.quux'))
   end
 
   def test_dir_glob_on_clone_with_absolute_path
-    act_on_real_fs { RealFileUtils.mkdir_p(here('subdir/.bar/baz/.quux/foo')) }
+    act_on_real_fs { FileUtils.mkdir_p(real_file_sandbox('subdir/.bar/baz/.quux/foo')) }
     FileUtils.mkdir_p '/path'
     Dir.chdir('/path')
-    FileSystem.clone(here('subdir'), '/foo')
+    FakeFS::FileSystem.clone(real_file_sandbox('subdir'), '/foo')
     assert Dir.glob '/foo/*'
-  ensure
-    act_on_real_fs { RealFileUtils.rm_rf(here('subdir')) }
   end
 
   def test_clone_with_target_specified
-    act_on_real_fs { RealFileUtils.mkdir_p(here('subdir/.bar/baz/.quux/foo')) }
+    act_on_real_fs do
+      assert FileUtils == RealFileUtils, 'using the real FileUtils in act_on_real_fs'
+      FileUtils.mkdir_p(real_file_sandbox('subdir/.bar/baz/.quux/foo'))
+    end
 
-    assert !File.exist?(here('subdir'))
+    refute File.exist?(real_file_sandbox('subdir'))
 
-    FileSystem.clone(here('subdir'), here('subdir2'))
-    assert !File.exist?(here('subdir'))
-    assert_equal ['.', '..', '.bar'], Dir.entries(here('subdir2'))
-    assert_equal ['.', '..', 'foo'], Dir.entries(here('subdir2/.bar/baz/.quux'))
-  ensure
-    act_on_real_fs { RealFileUtils.rm_rf(here('subdir')) }
+    FakeFS::FileSystem.clone(real_file_sandbox('subdir'), real_file_sandbox('subdir2'))
+    refute File.exist?(real_file_sandbox('subdir'))
+    assert_equal ['.', '..', '.bar'], Dir.entries(real_file_sandbox('subdir2'))
+    assert_equal ['.', '..', 'foo'], Dir.entries(real_file_sandbox('subdir2/.bar/baz/.quux'))
   end
 
   def test_clone_with_file_symlinks
-    original = here('subdir/test-file')
-    symlink  = here('subdir/test-file.txt')
+    original = real_file_sandbox('subdir/test-file')
+    symlink  = real_file_sandbox('subdir/test-file.txt')
 
     act_on_real_fs do
-      RealDir.mkdir(RealFile.dirname(original))
-      RealFile.open(original, 'w') { |f| f << 'stuff' }
-      RealFileUtils.ln_s original, symlink
-      assert RealFile.symlink?(symlink), 'real symlink is in place'
+      FileUtils.mkdir_p(File.dirname(original))
+      File.open(original, 'w') { |f| f << 'stuff' }
+      FileUtils.ln_s original, symlink
+      assert File.symlink?(symlink), 'real symlink is in place'
     end
 
-    assert !File.exist?(original), 'file does not already exist'
+    refute File.exist?(original), 'file does not already exist'
 
-    FileSystem.clone(File.dirname(original))
+    FakeFS::FileSystem.clone(File.dirname(original))
     assert File.symlink?(symlink), 'symlinks are cloned as symlinks'
     assert_equal 'stuff', File.read(symlink)
-  ensure
-    act_on_real_fs { RealFileUtils.rm_rf File.dirname(original) }
   end
 
   def test_clone_with_dir_symlinks
-    original = here('subdir/dir')
-    symlink  = here('subdir/dir.link')
+    original = real_file_sandbox('subdir/dir')
+    symlink  = real_file_sandbox('subdir/dir.link')
     original_file = File.join(original, 'test-file')
     symlink_file  = File.join(symlink, 'test-file')
 
     act_on_real_fs do
-      RealFileUtils.mkdir_p(original)
-      RealFile.open(original_file, 'w') { |f| f << 'stuff' }
-      RealFileUtils.ln_s original, symlink
-      assert RealFile.symlink?(symlink), 'real symlink is in place'
+      FileUtils.mkdir_p(original)
+      File.open(original_file, 'w') { |f| f << 'stuff' }
+      FileUtils.ln_s original, symlink
+      assert File.symlink?(symlink), 'real symlink is in place'
     end
 
-    assert !File.exist?(original_file), 'file does not already exist'
+    refute File.exist?(original_file), 'file does not already exist'
 
-    FileSystem.clone(File.dirname(original))
+    FakeFS::FileSystem.clone(File.dirname(original))
     assert File.symlink?(symlink), 'symlinks are cloned as symlinks'
     assert_equal 'stuff', File.read(symlink_file)
-  ensure
-    act_on_real_fs { RealFileUtils.rm_rf File.dirname(original) }
   end
 
   def test_putting_a_dot_at_end_copies_the_contents
@@ -1794,9 +1796,8 @@ class FakeFSTest < Test::Unit::TestCase
   def test_new_directory
     FileUtils.mkdir_p('/this/path/should/be/here')
 
-    assert_nothing_raised do
-      Dir.new('/this/path/should/be/here')
-    end
+    # nothing raised
+    Dir.new('/this/path/should/be/here')
   end
 
   def test_new_directory_does_not_work_if_dir_path_cannot_be_found
@@ -1909,19 +1910,19 @@ class FakeFSTest < Test::Unit::TestCase
     dir = Dir.new('/this/path/should/be/here')
 
     d = dir.read
-    assert_not_nil d
+    refute_nil d
     d = dir.read
-    assert_not_nil d
+    refute_nil d
     d = dir.read
-    assert_not_nil d
+    refute_nil d
     d = dir.read
-    assert_not_nil d
+    refute_nil d
     d = dir.read
-    assert_not_nil d
+    refute_nil d
     d = dir.read
-    assert_not_nil d
+    refute_nil d
     d = dir.read
-    assert_not_nil d
+    refute_nil d
     d = dir.read
     assert_nil d
   end
@@ -2085,7 +2086,7 @@ class FakeFSTest < Test::Unit::TestCase
 
   def test_directory_mkdir_relative
     FileUtils.mkdir_p('/new/root')
-    FileSystem.chdir('/new/root')
+    FakeFS::FileSystem.chdir('/new/root')
     Dir.mkdir('path')
     assert File.exist?('/new/root/path')
   end
@@ -2260,7 +2261,7 @@ class FakeFSTest < Test::Unit::TestCase
 
     File.delete('/foo')
 
-    assert !File.exist?('/foo')
+    refute File.exist?('/foo')
   end
 
   def test_can_delete_multiple_files_with_delete
@@ -2269,8 +2270,8 @@ class FakeFSTest < Test::Unit::TestCase
 
     File.delete('/foo', '/bar')
 
-    assert !File.exist?('/foo')
-    assert !File.exist?('/bar')
+    refute File.exist?('/foo')
+    refute File.exist?('/bar')
   end
 
   def test_delete_returns_zero_when_no_filename_given
@@ -2319,7 +2320,7 @@ class FakeFSTest < Test::Unit::TestCase
     File.unlink('/bar')
 
     assert File.exist?('/foo')
-    assert !File.exist?('/bar')
+    refute File.exist?('/bar')
   end
 
   def test_delete_works_with_symlink_source
@@ -2328,7 +2329,7 @@ class FakeFSTest < Test::Unit::TestCase
 
     File.unlink('/foo')
 
-    assert !File.exist?('/foo')
+    refute File.exist?('/foo')
   end
 
   def test_file_seek_returns_0
@@ -2389,7 +2390,7 @@ class FakeFSTest < Test::Unit::TestCase
     assert FileTest.exist?('/path/to/')
 
     FileUtils.rmdir('/path/to/dir')
-    assert !FileTest.exist?('/path/to/dir')
+    refute FileTest.exist?('/path/to/dir')
   end
 
   def test_filetest_directory_returns_correct_values
@@ -2397,7 +2398,7 @@ class FakeFSTest < Test::Unit::TestCase
     assert FileTest.directory?('/path/to/somedir')
 
     FileUtils.rm_r '/path/to/somedir'
-    assert !FileTest.directory?('/path/to/somedir')
+    refute FileTest.directory?('/path/to/somedir')
   end
 
   def test_filetest_file_returns_correct_values
@@ -2408,14 +2409,14 @@ class FakeFSTest < Test::Unit::TestCase
     assert FileTest.file?(path)
 
     FileUtils.rm path
-    assert !FileTest.file?(path)
+    refute FileTest.file?(path)
 
     FileUtils.mkdir_p '/path/to/somedir'
-    assert !FileTest.file?('/path/to/somedir')
+    refute FileTest.file?('/path/to/somedir')
   end
 
   def test_filetest_readable_returns_correct_values
-    assert !FileTest.readable?('not-here.txt'), 'missing files are not readable'
+    refute FileTest.readable?('not-here.txt'), 'missing files are not readable'
 
     FileUtils.touch 'here.txt'
     assert FileTest.readable?('here.txt'), 'existing files are readable'
@@ -2425,7 +2426,7 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_filetest_writable_returns_correct_values
-    assert !FileTest.writable?('not-here.txt'), 'missing files are not writable'
+    refute FileTest.writable?('not-here.txt'), 'missing files are not writable'
 
     FileUtils.touch 'here.txt'
     assert FileTest.writable?('here.txt'), 'existing files are writable'
@@ -2445,7 +2446,7 @@ class FakeFSTest < Test::Unit::TestCase
       tmpdir = t
       assert File.directory?(t)
     end
-    assert !File.directory?(tmpdir)
+    refute File.directory?(tmpdir)
   end
 
   def test_activating_returns_true
@@ -2567,11 +2568,11 @@ class FakeFSTest < Test::Unit::TestCase
     different1 = File.new('d1', 'w')
     different2 = File.new('d2', 'w')
 
-    FileSystem.find('s1').mtime = a_time
-    FileSystem.find('s2').mtime = a_time
+    FakeFS::FileSystem.find('s1').mtime = a_time
+    FakeFS::FileSystem.find('s2').mtime = a_time
 
-    FileSystem.find('d1').mtime = a_time
-    FileSystem.find('d2').mtime = a_time + 1
+    FakeFS::FileSystem.find('d1').mtime = a_time
+    FakeFS::FileSystem.find('d2').mtime = a_time + 1
 
     assert same1.mtime == same2.mtime
     assert different1.mtime != different2.mtime
@@ -2593,10 +2594,6 @@ class FakeFSTest < Test::Unit::TestCase
     assert_equal File.binread('testfile', 20, 10), "ne one\nThis is line "
   end
 
-  def here(fname)
-    RealFile.expand_path(File.join(RealFile.dirname(__FILE__), fname))
-  end
-
   def test_file_utils_compare_file
     file1 = 'file1.txt'
     file2 = 'file2.txt'
@@ -2653,9 +2650,8 @@ class FakeFSTest < Test::Unit::TestCase
     def test_fdatasync
       File.open('foo', 'w') do |f|
         f << 'Yada Yada'
-        assert_nothing_raised do
-          f.fdatasync
-        end
+        # nothing raised
+        f.fdatasync
       end
     end
 
@@ -2677,9 +2673,8 @@ class FakeFSTest < Test::Unit::TestCase
   if RUBY_VERSION >= '1.9.3'
     def test_advise
       File.open('foo', 'w') do |f|
-        assert_nothing_raised do
-          f.advise(:normal, 0, 0)
-        end
+        # nothing raised
+        f.advise(:normal, 0, 0)
       end
     end
 
@@ -2745,4 +2740,22 @@ class FakeFSTest < Test::Unit::TestCase
       assert_equal "\x00\x00\x00\x03\x00\x03\x00\xA3\x00\x00\x00y\x00\x00\x00\x00\x00".force_encoding('ASCII-8BIT'), File.binread('foo')
     end
   end
+
+  if RUBY_VERSION >= '2.2.0'
+    def test_raises_error_on_birthtime_if_file_does_not_exist
+      assert_raises Errno::ENOENT do
+        File.birthtime('file.txt')
+      end
+    end
+
+    def test_can_return_birthtime_on_existing_file
+      File.open('foo', 'w') { |f| f << 'some content' }
+      assert File.birthtime('foo').is_a?(Time)
+    end
+
+    def test_file_birthtime_is_equal_to_file_stat_birthtime
+      File.open('foo', 'w') { |f| f << 'some content' }
+      assert_equal File.stat('foo').birthtime, File.birthtime('foo')
+    end
+  end
 end