fakefs 0.5.4 → 0.6.0

data/test/fake/file_test.rb

@@ -1,5 +1,6 @@
-require "test_helper"
+require 'test_helper'
 
+# Fake File test class
 class FakeFileTest < Test::Unit::TestCase
   include FakeFS
 
@@ -10,12 +11,12 @@ class FakeFileTest < Test::Unit::TestCase
   end
 
   def test_fake_file_has_empty_content_by_default
-    assert_equal "", @file.content
+    assert_equal '', @file.content
   end
 
   def test_fake_file_can_read_and_write_to_content
-    @file.content = "foobar"
-    assert_equal "foobar", @file.content
+    @file.content = 'foobar'
+    assert_equal 'foobar', @file.content
   end
 
   def test_fake_file_has_1_link_by_default
@@ -64,9 +65,9 @@ class FakeFileTest < Test::Unit::TestCase
 
     @file.link other_file
 
-    @file.content = "foobar"
+    @file.content = 'foobar'
 
-    assert_equal "foobar", other_file.content
+    assert_equal 'foobar', other_file.content
   end
 
   def test_clone_creates_new_inode
@@ -77,15 +78,15 @@ class FakeFileTest < Test::Unit::TestCase
   def test_cloning_does_not_use_same_content_object
     clone = @file.clone
 
-    clone.content = "foo"
-    @file.content = "bar"
+    clone.content = 'foo'
+    @file.content = 'bar'
 
-    assert_equal "foo", clone.content
-    assert_equal "bar", @file.content
+    assert_equal 'foo', clone.content
+    assert_equal 'bar', @file.content
   end
 
   def test_raises_an_error_with_the_correct_path
-    path = "/some/non/existing/file"
+    path = '/some/non/existing/file'
     begin
       FakeFS::File.new path
       msg = nil

data/test/fake/symlink_test.rb

@@ -1,25 +1,33 @@
-require "test_helper"
+require 'test_helper'
 
+# Fake symlink test class
 class FakeSymlinkTest < Test::Unit::TestCase
   include FakeFS
 
   def test_symlink_has_method_missing_as_private
-    methods = FakeSymlink.private_instance_methods.map { |m| m.to_s }
-    assert methods.include?("method_missing")
+    methods = FakeSymlink.private_instance_methods.map(&:to_s)
+    assert methods.include?('method_missing')
   end
 
   def test_symlink_respond_to_accepts_multiple_params
     fake_symlink = FakeSymlink.new('foo')
-    assert fake_symlink.respond_to?(:to_s, false), '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), 'has private method \#initialize'
-    assert fake_symlink.respond_to?(:initialize, true), 'has private method \#initialize'
+    assert fake_symlink.respond_to?(:to_s, false),
+           '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),
+           'has private method \#initialize'
+    assert fake_symlink.respond_to?(:initialize, true),
+           'has private method \#initialize'
   end
 
   def test_symlink_respond_to_uses_same_param_defaults
     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)
-    assert_equal fake_symlink.respond_to?(:initialize), fake_symlink.entry.respond_to?(:initialize)
+    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)
+    assert_equal fake_symlink.respond_to?(:initialize),
+                 fake_symlink.entry.respond_to?(:initialize)
   end
 end

data/test/fakefs_test.rb

@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
-require "test_helper"
+require 'test_helper'
 
+# FakeFS tests
 class FakeFSTest < Test::Unit::TestCase
   include FakeFS
 
@@ -25,109 +26,109 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_can_create_directories_with_file_utils_mkdir_p
-    FileUtils.mkdir_p("/path/to/dir")
+    FileUtils.mkdir_p('/path/to/dir')
     assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir']
   end
 
   def test_can_cd_to_directory_with_block
-    FileUtils.mkdir_p("/path/to/dir")
+    FileUtils.mkdir_p('/path/to/dir')
     new_path = nil
-    FileUtils.cd("/path/to") do
+    FileUtils.cd('/path/to') do
       new_path = Dir.getwd
     end
 
-    assert_equal new_path, "/path/to"
+    assert_equal new_path, '/path/to'
   end
 
   def test_can_create_a_list_of_directories_with_file_utils_mkdir_p
-    FileUtils.mkdir_p(["/path/to/dir1", "/path/to/dir2"])
+    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']
   end
 
   def test_can_create_directories_with_options
-    FileUtils.mkdir_p("/path/to/dir", :mode => 0755)
+    FileUtils.mkdir_p('/path/to/dir', mode: 0755)
     assert_kind_of FakeDir, 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")
+    FileUtils.mkdir_p('/path/to/dir')
+    FileUtils.mkdir('/path/to/dir/subdir')
     assert_kind_of FakeDir, 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(["/path/to/dir/subdir1", "/path/to/dir/subdir2"])
+    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']
   end
 
   def test_raises_error_when_creating_a_new_dir_with_mkdir_in_non_existent_path
     assert_raises Errno::ENOENT do
-      FileUtils.mkdir("/this/path/does/not/exists/newdir")
+      FileUtils.mkdir('/this/path/does/not/exists/newdir')
     end
   end
 
   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." }
+    File.open('file', 'w') { |f| f << 'This is a file, not a directory.' }
 
     assert_raise Errno::EEXIST do
-      FileUtils.mkdir_p("file/subdir")
+      FileUtils.mkdir_p('file/subdir')
     end
 
-    FileUtils.mkdir("dir")
-    File.open("dir/subfile", "w") {|f| f << "This is a file inside a directory." }
+    FileUtils.mkdir('dir')
+    File.open('dir/subfile', 'w') { |f| f << 'This is a file inside a directory.' }
 
     assert_raise Errno::EEXIST do
-      FileUtils.mkdir_p("dir/subfile/subdir")
+      FileUtils.mkdir_p('dir/subfile/subdir')
     end
   end
 
   def test_can_create_directories_with_mkpath
-    FileUtils.mkpath("/path/to/dir")
+    FileUtils.mkpath('/path/to/dir')
     assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir']
   end
 
   def test_can_create_directories_with_mkpath_and_options
-    FileUtils.mkpath("/path/to/dir", :mode => 0755)
+    FileUtils.mkpath('/path/to/dir', mode: 0755)
     assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir']
   end
 
   def test_can_create_directories_with_mkdirs
-    FileUtils.makedirs("/path/to/dir")
+    FileUtils.makedirs('/path/to/dir')
     assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir']
   end
 
   def test_can_create_directories_with_mkdirs_and_options
-    FileUtils.makedirs("/path/to/dir", :mode => 0755)
+    FileUtils.makedirs('/path/to/dir', mode: 0755)
     assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir']
   end
 
   def test_unlink_errors_on_file_not_found
     assert_raise Errno::ENOENT do
-      FileUtils.rm("/foo")
+      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)
+      FileUtils.rm('/foo', force: true)
     end
   end
 
   def test_can_delete_directories
-    FileUtils.mkdir_p("/path/to/dir")
-    FileUtils.rmdir("/path/to/dir")
-    assert File.exists?("/path/to/")
-    assert File.exists?("/path/to/dir") == false
+    FileUtils.mkdir_p('/path/to/dir')
+    FileUtils.rmdir('/path/to/dir')
+    assert File.exist?('/path/to/')
+    assert File.exist?('/path/to/dir') == false
   end
 
   def test_can_delete_multiple_files
-    FileUtils.touch(["foo", "bar"])
-    FileUtils.rm(["foo", "bar"])
-    assert File.exists?("foo") == false
-    assert File.exists?("bar") == false
+    FileUtils.touch(%w(foo bar))
+    FileUtils.rm(%w(foo bar))
+    assert File.exist?('foo') == false
+    assert File.exist?('bar') == false
   end
 
   def test_aliases_exist
@@ -148,24 +149,24 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_knows_directories_exist
-    FileUtils.mkdir_p(path = "/path/to/dir")
-    assert File.exists?(path)
+    FileUtils.mkdir_p(path = '/path/to/dir')
+    assert File.exist?(path)
   end
 
   def test_knows_directories_are_directories
-    FileUtils.mkdir_p(path = "/path/to/dir")
+    FileUtils.mkdir_p(path = '/path/to/dir')
     assert File.directory?(path)
   end
 
   def test_knows_directories_are_directories_with_periods
-    FileUtils.mkdir_p(period_path = "/path/to/periodfiles/one.one")
-    FileUtils.mkdir("/path/to/periodfiles/one-one")
+    FileUtils.mkdir_p(period_path = '/path/to/periodfiles/one.one')
+    FileUtils.mkdir('/path/to/periodfiles/one-one')
 
     assert File.directory?(period_path)
   end
 
   def test_knows_symlink_directories_are_directories
-    FileUtils.mkdir_p(path = "/path/to/dir")
+    FileUtils.mkdir_p(path = '/path/to/dir')
     FileUtils.ln_s path, sympath = '/sympath'
     assert File.directory?(sympath)
   end
@@ -176,29 +177,29 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_doesnt_overwrite_existing_directories
-    FileUtils.mkdir_p(path = "/path/to/dir")
-    assert File.exists?(path)
-    FileUtils.mkdir_p("/path/to")
-    assert File.exists?(path)
+    FileUtils.mkdir_p(path = '/path/to/dir')
+    assert File.exist?(path)
+    FileUtils.mkdir_p('/path/to')
+    assert File.exist?(path)
     assert_raises Errno::EEXIST do
-      FileUtils.mkdir("/path/to")
+      FileUtils.mkdir('/path/to')
     end
-    assert File.exists?(path)
+    assert File.exist?(path)
   end
 
   def test_file_utils_mkdir_takes_options
-    FileUtils.mkdir("/foo", :some => :option)
-    assert File.exists?("/foo")
+    FileUtils.mkdir('/foo', some: :option)
+    assert File.exist?('/foo')
   end
 
   def test_symlink_with_missing_refferent_does_not_exist
     File.symlink('/foo', '/bar')
-    assert !File.exists?('/bar')
+    assert !File.exist?('/bar')
   end
 
   def test_can_create_symlinks
-    FileUtils.mkdir_p(target = "/path/to/target")
-    FileUtils.ln_s(target, "/path/to/link")
+    FileUtils.mkdir_p(target = '/path/to/target')
+    FileUtils.ln_s(target, '/path/to/link')
     assert_kind_of FakeSymlink, FileSystem.fs['path']['to']['link']
 
     assert_raises(Errno::EEXIST) do
@@ -207,244 +208,246 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_can_force_creation_of_symlinks
-    FileUtils.mkdir_p(target = "/path/to/first/target")
-    FileUtils.ln_s(target, "/path/to/link")
+    FileUtils.mkdir_p(target = '/path/to/first/target')
+    FileUtils.ln_s(target, '/path/to/link')
     assert_kind_of FakeSymlink, FileSystem.fs['path']['to']['link']
-    FileUtils.ln_s(target, '/path/to/link', :force => true)
+    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")
+    FileUtils.mkdir_p(target = '/path/to/first/target')
+    FileUtils.ln_s(target, '/path/to/link')
     assert_kind_of FakeSymlink, FileSystem.fs['path']['to']['link']
     FileUtils.ln_sf(target, '/path/to/link')
   end
 
   def test_can_follow_symlinks
-    FileUtils.mkdir_p(target = "/path/to/target")
-    FileUtils.ln_s(target, link = "/path/to/symlink")
+    FileUtils.mkdir_p(target = '/path/to/target')
+    FileUtils.ln_s(target, link = '/path/to/symlink')
     assert_equal target, File.readlink(link)
   end
 
   def test_symlinks_in_different_directories
-    FileUtils.mkdir_p("/path/to/bar")
-    FileUtils.mkdir_p(target = "/path/to/foo/target")
+    FileUtils.mkdir_p('/path/to/bar')
+    FileUtils.mkdir_p(target = '/path/to/foo/target')
 
-    FileUtils.ln_s(target, link = "/path/to/bar/symlink")
+    FileUtils.ln_s(target, link = '/path/to/bar/symlink')
     assert_equal target, File.readlink(link)
   end
 
   def test_symlink_with_relative_path_exists
-    FileUtils.touch("/file")
-    FileUtils.mkdir_p("/a/b")
-    FileUtils.ln_s("../../file", link = "/a/b/symlink")
+    FileUtils.touch('/file')
+    FileUtils.mkdir_p('/a/b')
+    FileUtils.ln_s('../../file', '/a/b/symlink')
     assert File.exist?('/a/b/symlink')
   end
 
   def test_symlink_with_relative_path_and_nonexistant_file_does_not_exist
-    FileUtils.touch("/file")
-    FileUtils.mkdir_p("/a/b")
-    FileUtils.ln_s("../../file_foo", link = "/a/b/symlink")
+    FileUtils.touch('/file')
+    FileUtils.mkdir_p('/a/b')
+    FileUtils.ln_s('../../file_foo', '/a/b/symlink')
     assert !File.exist?('/a/b/symlink')
   end
 
   def test_symlink_with_relative_path_has_correct_target
-    FileUtils.touch("/file")
-    FileUtils.mkdir_p("/a/b")
-    FileUtils.ln_s("../../file", link = "/a/b/symlink")
-    assert_equal "../../file", File.readlink(link)
+    FileUtils.touch('/file')
+    FileUtils.mkdir_p('/a/b')
+    FileUtils.ln_s('../../file', link = '/a/b/symlink')
+    assert_equal '../../file', File.readlink(link)
   end
 
   def test_symlinks_to_symlinks
-    FileUtils.mkdir_p(target = "/path/to/foo/target")
-    FileUtils.mkdir_p("/path/to/bar")
-    FileUtils.mkdir_p("/path/to/bar2")
+    FileUtils.mkdir_p(target = '/path/to/foo/target')
+    FileUtils.mkdir_p('/path/to/bar')
+    FileUtils.mkdir_p('/path/to/bar2')
 
-    FileUtils.ln_s(target, link1 = "/path/to/bar/symlink")
-    FileUtils.ln_s(link1, link2 = "/path/to/bar2/symlink")
+    FileUtils.ln_s(target, link1 = '/path/to/bar/symlink')
+    FileUtils.ln_s(link1, link2 = '/path/to/bar2/symlink')
     assert_equal link1, File.readlink(link2)
   end
 
   def test_symlink_to_symlinks_should_raise_error_if_dir_doesnt_exist
-    FileUtils.mkdir_p(target = "/path/to/foo/target")
+    FileUtils.mkdir_p(target = '/path/to/foo/target')
 
-    assert !Dir.exists?("/path/to/bar")
+    assert !Dir.exist?('/path/to/bar')
 
     assert_raise Errno::ENOENT do
-      FileUtils.ln_s(target, "/path/to/bar/symlink")
+      FileUtils.ln_s(target, '/path/to/bar/symlink')
     end
   end
 
   def test_knows_symlinks_are_symlinks
-    FileUtils.mkdir_p(target = "/path/to/target")
-    FileUtils.ln_s(target, link = "/path/to/symlink")
+    FileUtils.mkdir_p(target = '/path/to/target')
+    FileUtils.ln_s(target, link = '/path/to/symlink')
     assert File.symlink?(link)
   end
 
   def test_can_create_files_in_current_dir
     path = 'file.txt'
     File.open(path, 'w') do |f|
-      f.write "Yatta!"
+      f.write 'Yatta!'
     end
 
-    assert File.exists?(path)
+    assert File.exist?(path)
     assert File.readable?(path)
     assert File.writable?(path)
   end
 
+  def test_nothing_is_sticky
+    assert !File.sticky?('/')
+  end
+
   def test_can_create_files_in_existing_dir
-    FileUtils.mkdir_p "/path/to"
-    path = "/path/to/file.txt"
+    FileUtils.mkdir_p '/path/to'
+    path = '/path/to/file.txt'
 
     File.open(path, 'w') do |f|
-      f.write "Yatta!"
+      f.write 'Yatta!'
     end
 
-    assert File.exists?(path)
+    assert File.exist?(path)
     assert File.readable?(path)
     assert File.writable?(path)
   end
 
   def test_raises_ENOENT_trying_to_create_files_in_nonexistent_dir
-    path = "/path/to/file.txt"
+    path = '/path/to/file.txt'
 
-    assert_raises(Errno::ENOENT) {
+    assert_raises(Errno::ENOENT) do
       File.open(path, 'w') do |f|
-        f.write "Yatta!"
+        f.write 'Yatta!'
       end
-    }
+    end
   end
 
   def test_raises_ENOENT_trying_to_create_files_in_relative_nonexistent_dir
-    FileUtils.mkdir_p "/some/path"
+    FileUtils.mkdir_p '/some/path'
 
-    Dir.chdir("/some/path") {
-      assert_raises(Errno::ENOENT) {
-        File.open("../foo") {|f| f.write "moo" }
-      }
-    }
+    Dir.chdir('/some/path') do
+      assert_raises(Errno::ENOENT) do
+        File.open('../foo') { |f| f.write 'moo' }
+      end
+    end
   end
 
   def test_raises_ENOENT_trying_to_create_files_in_obscured_nonexistent_dir
-    FileUtils.mkdir_p "/some/path"
+    FileUtils.mkdir_p '/some/path'
 
-    assert_raises(Errno::ENOENT) {
-      File.open("/some/path/../foo") {|f| f.write "moo" }
-    }
+    assert_raises(Errno::ENOENT) do
+      File.open('/some/path/../foo') { |f| f.write 'moo' }
+    end
   end
 
   def test_raises_ENOENT_trying_to_create_tilde_referenced_nonexistent_dir
-    path = "~/fakefs_test_#{$$}_0000"
+    path = "~/fakefs_test_#{$PID}_0000"
 
-    while File.exist? path
-      path = path.succ
-    end
+    path = path.succ while File.exist? path
 
-    assert_raises(Errno::ENOENT) {
-      File.open("#{path}/foo") {|f| f.write "moo" }
-    }
+    assert_raises(Errno::ENOENT) do
+      File.open("#{path}/foo") { |f| f.write 'moo' }
+    end
   end
 
   def test_raises_EISDIR_if_trying_to_open_existing_directory_name
-    path = "/path/to"
+    path = '/path/to'
 
     FileUtils.mkdir_p path
 
-    assert_raises(Errno::EISDIR) {
+    assert_raises(Errno::EISDIR) do
       File.open(path, 'w') do |f|
-        f.write "Yatta!"
+        f.write 'Yatta!'
       end
-    }
+    end
   end
 
   def test_can_create_files_with_bitmasks
-    FileUtils.mkdir_p("/path/to")
+    FileUtils.mkdir_p('/path/to')
 
     path = '/path/to/file.txt'
     File.open(path, File::RDWR | File::CREAT) do |f|
-      f.write "Yatta!"
+      f.write 'Yatta!'
     end
 
-    assert File.exists?(path)
+    assert File.exist?(path)
     assert File.readable?(path)
     assert File.writable?(path)
   end
 
   def test_file_opens_in_read_only_mode
-    File.open("foo", "w") { |f| f << "foo" }
+    File.open('foo', 'w') { |f| f << 'foo' }
 
-    f = File.open("foo")
+    f = File.open('foo')
 
     assert_raises(IOError) do
-      f << "bar"
+      f << 'bar'
     end
   end
 
   def test_file_opens_in_read_only_mode_with_bitmasks
-    File.open("foo", "w") { |f| f << "foo" }
+    File.open('foo', 'w') { |f| f << 'foo' }
 
-    f = File.open("foo", File::RDONLY)
+    f = File.open('foo', File::RDONLY)
 
     assert_raises(IOError) do
-      f << "bar"
+      f << 'bar'
     end
   end
 
   def test_file_opens_in_invalid_mode
-    FileUtils.touch("foo")
+    FileUtils.touch('foo')
 
     assert_raises(ArgumentError) do
-      File.open("foo", "an_illegal_mode")
+      File.open('foo', 'an_illegal_mode')
     end
   end
 
   def test_raises_error_when_cannot_find_file_in_read_mode
     assert_raises(Errno::ENOENT) do
-      File.open("does_not_exist", "r")
+      File.open('does_not_exist', 'r')
     end
   end
 
   def test_raises_error_when_cannot_find_file_in_read_write_mode
     assert_raises(Errno::ENOENT) do
-      File.open("does_not_exist", "r+")
+      File.open('does_not_exist', 'r+')
     end
   end
 
   def test_creates_files_in_write_only_mode
-    File.open("foo", "w")
-    assert File.exists?("foo")
+    File.open('foo', 'w')
+    assert File.exist?('foo')
   end
 
   def test_creates_files_in_write_only_mode_with_bitmasks
-    File.open("foo", File::WRONLY | File::CREAT)
-    assert File.exists?("foo")
+    File.open('foo', File::WRONLY | File::CREAT)
+    assert File.exist?('foo')
   end
 
   def test_raises_in_write_only_mode_without_create_bitmask
     assert_raises(Errno::ENOENT) do
-      File.open("foo", File::WRONLY)
+      File.open('foo', File::WRONLY)
     end
   end
 
   def test_creates_files_in_read_write_truncate_mode
-    File.open("foo", "w+")
-    assert File.exists?("foo")
+    File.open('foo', 'w+')
+    assert File.exist?('foo')
   end
 
   def test_creates_files_in_append_write_only
-    File.open("foo", "a")
-    assert File.exists?("foo")
+    File.open('foo', 'a')
+    assert File.exist?('foo')
   end
 
   def test_creates_files_in_append_read_write
-    File.open("foo", "a+")
-    assert File.exists?("foo")
+    File.open('foo', 'a+')
+    assert File.exist?('foo')
   end
 
   def test_file_in_write_only_raises_error_when_reading
-    FileUtils.touch("foo")
+    FileUtils.touch('foo')
 
-    f = File.open("foo", "w")
+    f = File.open('foo', 'w')
 
     assert_raises(IOError) do
       f.read
@@ -452,25 +455,21 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_file_in_write_mode_truncates_existing_file
-    File.open("foo", "w") { |f| f << "contents" }
-
-    f = File.open("foo", "w")
-
-    assert_equal "", File.read("foo")
+    File.open('foo', 'w') { |f| f << 'contents' }
+    File.open('foo', 'w')
+    assert_equal '', File.read('foo')
   end
 
   def test_file_in_read_write_truncation_mode_truncates_file
-    File.open("foo", "w") { |f| f << "foo" }
-
-    f = File.open("foo", "w+")
-
-    assert_equal "", File.read("foo")
+    File.open('foo', 'w') { |f| f << 'foo' }
+    File.open('foo', 'w+')
+    assert_equal '', File.read('foo')
   end
 
   def test_file_in_append_write_only_raises_error_when_reading
-    FileUtils.touch("foo")
+    FileUtils.touch('foo')
 
-    f = File.open("foo", "a")
+    f = File.open('foo', 'a')
 
     assert_raises(IOError) do
       f.read
@@ -480,10 +479,10 @@ class FakeFSTest < Test::Unit::TestCase
   def test_can_read_files_once_written
     path = 'file.txt'
     File.open(path, 'w') do |f|
-      f.write "Yatta!"
+      f.write 'Yatta!'
     end
 
-    assert_equal "Yatta!", File.read(path)
+    assert_equal 'Yatta!', File.read(path)
   end
 
   def test_file_read_accepts_hashes
@@ -492,7 +491,7 @@ class FakeFSTest < Test::Unit::TestCase
       f.write 'Yatta!'
     end
 
-    assert_nothing_raised { File.read(path, :mode => 'r:UTF-8:-') }
+    assert_nothing_raised { File.read(path, mode: 'r:UTF-8:-') }
   end
 
   def test_file_read_respects_args
@@ -516,17 +515,17 @@ class FakeFSTest < Test::Unit::TestCase
 
   def test_raises_error_when_opening_with_binary_mode_only
     assert_raise ArgumentError do
-      File.open("/foo", "b")
+      File.open('/foo', 'b')
     end
   end
 
   def test_can_open_file_in_binary_mode
-    File.open("foo", "wb") { |x| x << "a" }
-    assert_equal "a", File.read("foo")
+    File.open('foo', 'wb') { |x| x << 'a' }
+    assert_equal 'a', File.read('foo')
   end
 
   def test_can_chunk_io_when_reading
-    FileUtils.mkdir_p "/path/to"
+    FileUtils.mkdir_p '/path/to'
     path = '/path/to/file.txt'
     File.open(path, 'w') do |f|
       f << 'Yada Yada'
@@ -550,7 +549,7 @@ class FakeFSTest < Test::Unit::TestCase
   def test_can_get_correct_size_for_files_with_multibyte_characters
     path = 'file.txt'
     File.open(path, 'wb') do |f|
-      f << "Y\xC3\xA1da" # Yáda
+      f << "Y\xC3\xA1da"
     end
     assert_equal 5, File.size(path)
   end
@@ -561,7 +560,7 @@ class FakeFSTest < Test::Unit::TestCase
       f << 'Yada Yada'
     end
     assert_equal 9, File.size?(path)
-    assert_nil File.size?("other.txt")
+    assert_nil File.size?('other.txt')
   end
 
   def test_can_check_size_of_empty_file
@@ -569,7 +568,7 @@ class FakeFSTest < Test::Unit::TestCase
     File.open(path, 'w') do |f|
       f << ''
     end
-    assert_nil File.size?("file.txt")
+    assert_nil File.size?('file.txt')
   end
 
   def test_zero_on_empty_file
@@ -599,21 +598,21 @@ class FakeFSTest < Test::Unit::TestCase
     end
   end
 
-  if RUBY_VERSION >= "1.9"
+  if RUBY_VERSION >= '1.9'
     def test_can_set_mtime_on_new_file_touch_with_param
-      time = Time.new(2002, 10, 31, 2, 2, 2, "+02:00")
-      FileUtils.touch("foo.txt", :mtime => time)
+      time = Time.new(2002, 10, 31, 2, 2, 2, '+02:00')
+      FileUtils.touch('foo.txt', mtime: time)
 
-      assert_equal File.mtime("foo.txt"), time
+      assert_equal File.mtime('foo.txt'), time
     end
 
     def test_can_set_mtime_on_existing_file_touch_with_param
-      FileUtils.touch("foo.txt")
+      FileUtils.touch('foo.txt')
 
-      time = Time.new(2002, 10, 31, 2, 2, 2, "+02:00")
-      FileUtils.touch("foo.txt", :mtime => time)
+      time = Time.new(2002, 10, 31, 2, 2, 2, '+02:00')
+      FileUtils.touch('foo.txt', mtime: time)
 
-      assert_equal File.mtime("foo.txt"), time
+      assert_equal File.mtime('foo.txt'), time
     end
   end
 
@@ -632,7 +631,7 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_can_return_ctime_on_existing_file
-    File.open("foo", "w") { |f| f << "some content" }
+    File.open('foo', 'w') { |f| f << 'some content' }
     assert File.ctime('foo').is_a?(Time)
   end
 
@@ -643,23 +642,23 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_can_return_atime_on_existing_file
-    File.open("foo", "w") { |f| f << "some content" }
+    File.open('foo', 'w') { |f| f << 'some content' }
     assert File.atime('foo').is_a?(Time)
   end
 
   def test_ctime_mtime_and_atime_are_equal_for_new_files
     FileUtils.touch('foo')
 
-    ctime = File.ctime("foo")
-    mtime = File.mtime("foo")
-    atime = File.atime("foo")
+    ctime = File.ctime('foo')
+    mtime = File.mtime('foo')
+    atime = File.atime('foo')
     assert ctime.is_a?(Time)
     assert mtime.is_a?(Time)
     assert atime.is_a?(Time)
     assert_equal ctime, mtime
     assert_equal ctime, atime
 
-    File.open("foo", "r") do |f|
+    File.open('foo', 'r') do |f|
       assert_equal ctime, f.ctime
       assert_equal mtime, f.mtime
       assert_equal atime, f.atime
@@ -667,10 +666,10 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_ctime_mtime_and_atime_are_equal_for_new_directories
-    FileUtils.mkdir_p("foo")
-    ctime = File.ctime("foo")
-    mtime = File.mtime("foo")
-    atime = File.atime("foo")
+    FileUtils.mkdir_p('foo')
+    ctime = File.ctime('foo')
+    mtime = File.mtime('foo')
+    atime = File.atime('foo')
     assert ctime.is_a?(Time)
     assert mtime.is_a?(Time)
     assert atime.is_a?(Time)
@@ -679,33 +678,33 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_file_ctime_is_equal_to_file_stat_ctime
-    File.open("foo", "w") { |f| f << "some content" }
-    assert_equal File.stat("foo").ctime, File.ctime("foo")
+    File.open('foo', 'w') { |f| f << 'some content' }
+    assert_equal File.stat('foo').ctime, File.ctime('foo')
   end
 
   def test_directory_ctime_is_equal_to_directory_stat_ctime
-    FileUtils.mkdir_p("foo")
-    assert_equal File.stat("foo").ctime, File.ctime("foo")
+    FileUtils.mkdir_p('foo')
+    assert_equal File.stat('foo').ctime, File.ctime('foo')
   end
 
   def test_file_mtime_is_equal_to_file_stat_mtime
-    File.open("foo", "w") { |f| f << "some content" }
-    assert_equal File.stat("foo").mtime, File.mtime("foo")
+    File.open('foo', 'w') { |f| f << 'some content' }
+    assert_equal File.stat('foo').mtime, File.mtime('foo')
   end
 
   def test_directory_mtime_is_equal_to_directory_stat_mtime
-    FileUtils.mkdir_p("foo")
-    assert_equal File.stat("foo").mtime, File.mtime("foo")
+    FileUtils.mkdir_p('foo')
+    assert_equal File.stat('foo').mtime, File.mtime('foo')
   end
 
   def test_file_atime_is_equal_to_file_stat_atime
-    File.open("foo", "w") { |f| f << "some content" }
-    assert_equal File.stat("foo").atime, File.atime("foo")
+    File.open('foo', 'w') { |f| f << 'some content' }
+    assert_equal File.stat('foo').atime, File.atime('foo')
   end
 
   def test_directory_atime_is_equal_to_directory_stat_atime
-    FileUtils.mkdir_p("foo")
-    assert_equal File.stat("foo").atime, File.atime("foo")
+    FileUtils.mkdir_p('foo')
+    assert_equal File.stat('foo').atime, File.atime('foo')
   end
 
   def test_utime_raises_error_if_path_does_not_exist
@@ -738,9 +737,9 @@ class FakeFSTest < Test::Unit::TestCase
   def test_file_a_time_updated_when_file_is_read
     old_atime = Time.now - 300
 
-    path = "file.txt"
-    File.open(path, "w") do |f|
-      f << "Hello"
+    path = 'file.txt'
+    File.open(path, 'w') do |f|
+      f << 'Hello'
     end
 
     File.utime(old_atime, File.mtime(path), path)
@@ -753,8 +752,8 @@ class FakeFSTest < Test::Unit::TestCase
   def test_can_read_with_File_readlines
     path = 'file.txt'
     File.open(path, 'w') do |f|
-      f.puts "Yatta!", "Gatta!"
-      f.puts ["woot","toot"]
+      f.puts 'Yatta!', 'Gatta!'
+      f.puts %w(woot toot)
     end
 
     assert_equal ["Yatta!\n", "Gatta!\n", "woot\n", "toot\n"], File.readlines(path)
@@ -794,55 +793,54 @@ class FakeFSTest < Test::Unit::TestCase
     file.write 'Yada'
     file.close
     assert_raise IOError do
-      file << "foo"
+      file << 'foo'
     end
   end
 
   def test_can_read_from_file_objects
     path = 'file.txt'
     File.open(path, 'w') do |f|
-      f.write "Yatta!"
+      f.write 'Yatta!'
     end
 
-    assert_equal "Yatta!", File.new(path).read
+    assert_equal 'Yatta!', File.new(path).read
   end
 
-  if RUBY_VERSION >= "1.9"
+  if RUBY_VERSION >= '1.9'
     def test_file_object_has_default_external_encoding
-      Encoding.default_external = "UTF-8"
+      Encoding.default_external = 'UTF-8'
       path = 'file.txt'
-      File.open(path, 'w'){|f| f.write 'Yatta!' }
-      assert_equal "UTF-8", File.new(path).read.encoding.name
+      File.open(path, 'w') { |f| f.write 'Yatta!' }
+      assert_equal 'UTF-8', File.new(path).read.encoding.name
     end
   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!' }
+      File.open('file.txt', mode: 'w') { |f| f.write 'Yatta!' }
     end
   end
 
   def test_file_object_initialization_with_brackets_in_filename
-    filename = "bracket[1](2).txt"
-    expected_contents = "Yokudekimashita"
+    filename = 'bracket[1](2).txt'
+    expected_contents = 'Yokudekimashita'
     assert_nothing_raised do
-      File.open(filename, {:mode => "w"}){ |f| f.write "#{expected_contents}" }
+      File.open(filename, mode: 'w') { |f| f.write "#{expected_contents}" }
     end
-    the_file = Dir["/*"]
+    the_file = Dir['/*']
     assert_equal the_file.length, 1
     assert_equal the_file[0], "/#{filename}"
-    contents = File.open("/#{filename}").read()
+    contents = File.open("/#{filename}").read
     assert_equal contents, expected_contents
   end
 
   def test_file_object_initialization_with_brackets_in_filename
-    # 日本語
     filename = "\u65e5\u672c\u8a9e.txt"
-    expected_contents = "Yokudekimashita"
+    expected_contents = 'Yokudekimashita'
     assert_nothing_raised do
-      File.open(filename, {:mode => "w"}){ |f| f.write "#{expected_contents}" }
+      File.open(filename,  mode: 'w') { |f| f.write "#{expected_contents}" }
     end
-    contents = File.open("/#{filename}").read()
+    contents = File.open("/#{filename}").read
     assert_equal contents, expected_contents
   end
 
@@ -853,38 +851,38 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_file_read_errors_on_directory
-    FileUtils.mkdir_p("a_directory")
+    FileUtils.mkdir_p('a_directory')
 
     assert_raise Errno::EISDIR do
-      File.read("a_directory")
+      File.read('a_directory')
     end
   end
 
   def test_knows_files_are_files
     path = 'file.txt'
     File.open(path, 'w') do |f|
-      f.write "Yatta!"
+      f.write 'Yatta!'
     end
 
     assert File.file?(path)
   end
 
   def test_File_io_returns_self
-    f = File.open("foo", "w")
+    f = File.open('foo', 'w')
     assert_equal f, f.to_io
   end
 
   def test_File_to_i_is_alias_for_filno
-    f = File.open("foo", "w")
+    f = File.open('foo', 'w')
     assert_equal f.method(:to_i), f.method(:fileno)
   end
 
   def test_knows_symlink_files_are_files
     path = 'file.txt'
     File.open(path, 'w') do |f|
-      f.write "Yatta!"
+      f.write 'Yatta!'
     end
-    FileUtils.ln_s path, sympath='/sympath'
+    FileUtils.ln_s path, sympath = '/sympath'
 
     assert File.file?(sympath)
   end
@@ -900,16 +898,16 @@ class FakeFSTest < Test::Unit::TestCase
   def test_can_chown_files
     good = 'file.txt'
     bad = 'nofile.txt'
-    File.open(good,'w') { |f| f.write "foo" }
+    File.open(good, 'w') { |f| f.write 'foo' }
     username = Etc.getpwuid(Process.uid).name
     groupname = Etc.getgrgid(Process.gid).name
 
-    out = FileUtils.chown(1337, 1338, good, :verbose => true)
+    out = FileUtils.chown(1337, 1338, good, verbose: true)
     assert_equal [good], out
     assert_equal File.stat(good).uid, 1337
     assert_equal File.stat(good).gid, 1338
     assert_raises(Errno::ENOENT) do
-      FileUtils.chown(username, groupname, bad, :verbose => true)
+      FileUtils.chown(username, groupname, bad, verbose: true)
     end
 
     assert_equal [good], FileUtils.chown(username, groupname, good)
@@ -952,11 +950,11 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_can_chmod_files
-    good = "file.txt"
-    bad = "nofile.txt"
+    good = 'file.txt'
+    bad = 'nofile.txt'
     FileUtils.touch(good)
 
-    assert_equal [good], FileUtils.chmod(0600, good, :verbose => true)
+    assert_equal [good], FileUtils.chmod(0600, good, verbose: true)
     assert_equal File.stat(good).mode, 0100600
     assert_equal File.executable?(good), false
     assert_raises(Errno::ENOENT) do
@@ -985,19 +983,19 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_can_chmod_R_files
-    FileUtils.mkdir_p "/path/sub"
-    FileUtils.touch "/path/file1"
-    FileUtils.touch "/path/sub/file2"
+    FileUtils.mkdir_p '/path/sub'
+    FileUtils.touch '/path/file1'
+    FileUtils.touch '/path/sub/file2'
 
-    assert_equal ["/path"], FileUtils.chmod_R(0600, "/path")
-    assert_equal File.stat("/path").mode, 0100600
-    assert_equal File.stat("/path/file1").mode, 0100600
-    assert_equal File.stat("/path/sub").mode, 0100600
-    assert_equal File.stat("/path/sub/file2").mode, 0100600
+    assert_equal ['/path'], FileUtils.chmod_R(0600, '/path')
+    assert_equal File.stat('/path').mode, 0100600
+    assert_equal File.stat('/path/file1').mode, 0100600
+    assert_equal File.stat('/path/sub').mode, 0100600
+    assert_equal File.stat('/path/sub/file2').mode, 0100600
 
-    FileUtils.mkdir_p "/path2"
-    FileUtils.touch "/path2/hej"
-    assert_equal ["/path2"], FileUtils.chmod_R(0600, "/path2")
+    FileUtils.mkdir_p '/path2'
+    FileUtils.touch '/path2/hej'
+    assert_equal ['/path2'], FileUtils.chmod_R(0600, '/path2')
   end
 
   def test_dir_globs_paths
@@ -1010,7 +1008,7 @@ class FakeFSTest < Test::Unit::TestCase
 
     FileUtils.cp_r '/path/bar', '/path/bar2'
 
-    assert_equal  ['/path'], Dir['/path']
+    assert_equal ['/path'], Dir['/path']
     assert_equal %w( /path/bar /path/bar2 /path/foo /path/foobar ), Dir['/path/*']
 
     assert_equal ['/path/bar/baz'], Dir['/path/bar/*']
@@ -1043,30 +1041,30 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_file_utils_cp_allows_verbose_option
-    File.open('foo', 'w') {|f| f << 'TEST' }
-    assert_equal "cp foo bar\n", capture_stderr { FileUtils.cp 'foo', 'bar', :verbose => true }
+    File.open('foo', 'w') { |f| f << 'TEST' }
+    assert_equal "cp foo bar\n", capture_stderr { FileUtils.cp 'foo', 'bar', verbose: true }
   end
 
   def test_file_utils_cp_allows_noop_option
-    File.open('foo', 'w') {|f| f << 'TEST' }
-    FileUtils.cp 'foo', 'bar', :noop => true
+    File.open('foo', 'w') { |f| f << 'TEST' }
+    FileUtils.cp 'foo', 'bar', noop: true
     assert !File.exist?('bar'), 'does not actually copy'
   end
 
   def test_file_utils_cp_raises_on_invalid_option
     assert_raises ArgumentError do
-      FileUtils.cp 'foo', 'bar', :whatisthis => "I don't know"
+      FileUtils.cp 'foo', 'bar', whatisthis: "I don't know"
     end
   end
 
   def test_file_utils_cp_r_allows_verbose_option
-    FileUtils.touch "/foo"
-    assert_equal "cp -r /foo /bar\n", capture_stderr { FileUtils.cp_r '/foo', '/bar', :verbose => true }
+    FileUtils.touch '/foo'
+    assert_equal "cp -r /foo /bar\n", capture_stderr { FileUtils.cp_r '/foo', '/bar', verbose: true }
   end
 
   def test_file_utils_cp_r_allows_noop_option
-    FileUtils.touch "/foo"
-    FileUtils.cp_r '/foo', '/bar', :noop => true
+    FileUtils.touch '/foo'
+    FileUtils.cp_r '/foo', '/bar', noop: true
     assert !File.exist?('/bar'), 'does not actually copy'
   end
 
@@ -1078,12 +1076,12 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_dir_glob_takes_optional_flags
-    FileUtils.touch "/foo"
-    assert_equal Dir.glob("/*", 0), ["/foo"]
+    FileUtils.touch '/foo'
+    assert_equal Dir.glob('/*', 0), ['/foo']
   end
 
   def test_dir_glob_handles_recursive_globs
-    FileUtils.mkdir_p "/one/two/three"
+    FileUtils.mkdir_p '/one/two/three'
     File.open('/one/two/three/four.rb', 'w')
     File.open('/one/five.rb', 'w')
     assert_equal ['/one/five.rb', '/one/two/three/four.rb'], Dir['/one/**/*.rb']
@@ -1092,7 +1090,7 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_dir_recursive_glob_ending_in_wildcards_returns_both_files_and_dirs
-    FileUtils.mkdir_p "/one/two/three"
+    FileUtils.mkdir_p '/one/two/three'
     File.open('/one/two/three/four.rb', 'w')
     File.open('/one/five.rb', 'w')
     assert_equal ['/one/five.rb', '/one/two', '/one/two/three', '/one/two/three/four.rb'], Dir['/one/**/*']
@@ -1100,9 +1098,9 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_dir_glob_ending_in_group_and_wildcard
-    FileUtils.mkdir_p "/tmp/python-3.4.1"
-    FileUtils.mkdir_p "/tmp/python-2.7.8"
-    assert_equal ['/tmp/python-2.7.8', '/tmp/python-3.4.1'], Dir.glob("/tmp/python-[0-9]*")
+    FileUtils.mkdir_p '/tmp/python-3.4.1'
+    FileUtils.mkdir_p '/tmp/python-2.7.8'
+    assert_equal ['/tmp/python-2.7.8', '/tmp/python-3.4.1'], Dir.glob('/tmp/python-[0-9]*')
   end
 
   def test_dir_glob_with_block
@@ -1116,24 +1114,24 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_copy_with_subdirectory
-    FileUtils.mkdir_p "/one/two/three/"
-    FileUtils.mkdir_p "/onebis/two/three/"
-    FileUtils.touch "/one/two/three/foo"
-    Dir.glob("/one/two/three/*") do |hook|
-      FileUtils.cp(hook, "/onebis/two/three/")
+    FileUtils.mkdir_p '/one/two/three/'
+    FileUtils.mkdir_p '/onebis/two/three/'
+    FileUtils.touch '/one/two/three/foo'
+    Dir.glob('/one/two/three/*') do |hook|
+      FileUtils.cp(hook, '/onebis/two/three/')
     end
     assert_equal ['/onebis/two/three/foo'], Dir['/onebis/two/three/*']
   end
 
-  if RUBY_VERSION >= "1.9"
+  if RUBY_VERSION >= '1.9'
     def test_dir_home
       assert_equal RealDir.home, Dir.home
     end
   end
 
   def test_should_report_pos_as_0_when_opening
-    File.open("foo", "w") do |f|
-      f << "foobar"
+    File.open('foo', 'w') do |f|
+      f << 'foobar'
       f.rewind
 
       assert_equal 0, f.pos
@@ -1141,8 +1139,8 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_should_report_pos_as_1_when_seeking_one_char
-    File.open("foo", "w") do |f|
-      f << "foobar"
+    File.open('foo', 'w') do |f|
+      f << 'foobar'
 
       f.rewind
       f.seek(1)
@@ -1152,22 +1150,22 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_should_set_pos
-    File.open("foo", "w") do |f|
-      f << "foo"
+    File.open('foo', 'w') do |f|
+      f << 'foo'
     end
 
-    fp = File.open("foo", "r")
+    fp = File.open('foo', 'r')
     fp.pos = 1
 
     assert_equal 1, fp.pos
   end
 
   def test_should_set_pos_with_tell_method
-    File.open("foo", "w") do |f|
-      f << "foo"
+    File.open('foo', 'w') do |f|
+      f << 'foo'
     end
 
-    fp = File.open("foo", "r")
+    fp = File.open('foo', 'r')
     fp.tell = 1
 
     assert_equal 1, fp.pos
@@ -1196,12 +1194,12 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_does_not_remove_methods_from_stringio
-    stringio = StringIO.new("foo")
+    stringio = StringIO.new('foo')
     assert stringio.respond_to?(:size)
   end
 
   def test_is_not_a_stringio
-    File.open("foo", "w") do |f|
+    File.open('foo', 'w') do |f|
       assert !f.is_a?(StringIO), 'File is not a StringIO'
     end
   end
@@ -1212,8 +1210,8 @@ class FakeFSTest < Test::Unit::TestCase
     assert_equal '/', 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'}
+      File.open('foo', 'w') { |f| f.write 'foo' }
+      File.open('foobar', 'w') { |f| f.write 'foo' }
     end
 
     assert_equal '/', FileSystem.fs.name
@@ -1231,8 +1229,8 @@ class FakeFSTest < Test::Unit::TestCase
     FileUtils.mkdir_p '/path'
 
     Dir.chdir '/path' do
-      File.open('foo', 'w') { |f| f.write 'foo'}
-      File.open('/foobar', 'w') { |f| f.write 'foo'}
+      File.open('foo', 'w') { |f| f.write 'foo' }
+      File.open('/foobar', 'w') { |f| f.write 'foo' }
     end
     assert_equal ['/path/foo'], Dir.glob('/path/*').sort
     assert_equal ['/foobar', '/path'], Dir.glob('/*').sort
@@ -1249,26 +1247,26 @@ class FakeFSTest < Test::Unit::TestCase
   def test_chdir_should_be_nestable
     FileUtils.mkdir_p '/path/me'
     Dir.chdir '/path' do
-      File.open('foo', 'w') { |f| f.write 'foo'}
+      File.open('foo', 'w') { |f| f.write 'foo' }
       Dir.chdir 'me' do
-        File.open('foobar', 'w') { |f| f.write 'foo'}
+        File.open('foobar', 'w') { |f| f.write 'foo' }
       end
     end
 
-    assert_equal ['/path/foo','/path/me'], Dir.glob('/path/*').sort
+    assert_equal ['/path/foo', '/path/me'], Dir.glob('/path/*').sort
     assert_equal ['/path/me/foobar'], Dir.glob('/path/me/*').sort
   end
 
   def test_chdir_should_be_nestable_with_absolute_paths
     FileUtils.mkdir_p '/path/me'
     Dir.chdir '/path' do
-      File.open('foo', 'w') { |f| f.write 'foo'}
+      File.open('foo', 'w') { |f| f.write 'foo' }
       Dir.chdir '/path/me' do
-        File.open('foobar', 'w') { |f| f.write 'foo'}
+        File.open('foobar', 'w') { |f| f.write 'foo' }
       end
     end
 
-    assert_equal ['/path/foo','/path/me'], Dir.glob('/path/*').sort
+    assert_equal ['/path/foo', '/path/me'], Dir.glob('/path/*').sort
     assert_equal ['/path/me/foobar'], Dir.glob('/path/me/*').sort
   end
 
@@ -1284,21 +1282,23 @@ class FakeFSTest < Test::Unit::TestCase
     FileUtils.mkdir_p '/path'
 
     Dir.chdir '/path' do
-      File.open('foo', 'w') { |f| f.write 'foo'}
-      File.open('foobar', 'w') { |f| f.write 'foo'}
+      File.open('foo', 'w') { |f| f.write 'foo' }
+      File.open('foobar', 'w') { |f| f.write 'foo' }
     end
 
     begin
       Dir.chdir('/path') do
-        raise Exception
+        fail Errno::ENOENT
       end
-    rescue Exception # hardcore
+    rescue Errno::ENOENT => e # hardcore
+      'Nothing to do'
     end
 
     Dir.chdir('/path') do
       begin
-        Dir.chdir('nope'){ }
-      rescue Errno::ENOENT
+        Dir.chdir('nope') {}
+      rescue Errno::ENOENT => e
+        'Nothing to do'
       end
 
       assert_equal ['/', '/path'], FileSystem.dir_levels
@@ -1313,7 +1313,7 @@ class FakeFSTest < Test::Unit::TestCase
     FileUtils.mkdir_p 'subdir'
     assert_equal ['subdir'], Dir.glob('*')
     Dir.chdir('subdir')
-    File.open('foo', 'w') { |f| f.write 'foo'}
+    File.open('foo', 'w') { |f| f.write 'foo' }
     assert_equal ['foo'], Dir.glob('*')
 
     assert_raises(Errno::ENOENT) do
@@ -1353,9 +1353,9 @@ class FakeFSTest < Test::Unit::TestCase
 
   def test_expand_path_with_parent_dir
     FakeFS.deactivate!
-    real = File.expand_path('../other.file',__FILE__)
+    real = File.expand_path('../other.file', __FILE__)
     FakeFS.activate!
-    fake = File.expand_path('../other.file',__FILE__)
+    fake = File.expand_path('../other.file', __FILE__)
     assert_equal real, fake
   end
 
@@ -1368,12 +1368,15 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_file_open_defaults_to_read
-    File.open('foo','w') { |f| f.write 'bar' }
+    File.open('foo', 'w') { |f| f.write 'bar' }
     assert_equal 'bar', File.open('foo') { |f| f.read }
   end
 
   def test_flush_exists_on_file
-    r = File.open('foo','w') { |f| f.write 'bar';  f.flush }
+    r = File.open('foo', 'w') do |f|
+      f.write 'bar'
+      f.flush
+    end
     assert_equal 'foo', r.path
   end
 
@@ -1382,9 +1385,9 @@ class FakeFSTest < Test::Unit::TestCase
       FileUtils.mv 'blafgag', 'foo'
     end
     exception = assert_raise(Errno::ENOENT) do
-      FileUtils.mv ['foo', 'bar'], 'destdir'
+      FileUtils.mv %w(foo bar), 'destdir'
     end
-    assert_equal "No such file or directory - foo", exception.message
+    assert_equal 'No such file or directory - foo', exception.message
   end
 
   def test_mv_actually_works
@@ -1401,36 +1404,36 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_mv_works_with_options
-    File.open('foo', 'w') {|f| f.write 'bar'}
-    FileUtils.mv 'foo', 'baz', :force => true
+    File.open('foo', 'w') { |f| f.write 'bar' }
+    FileUtils.mv 'foo', 'baz', force: true
     assert_equal('bar', File.open('baz') { |f| f.read })
   end
 
   def test_mv_to_directory
-    File.open('foo', 'w') {|f| f.write 'bar'}
+    File.open('foo', 'w') { |f| f.write 'bar' }
     FileUtils.mkdir_p 'destdir'
     FileUtils.mv 'foo', 'destdir'
-    assert_equal('bar', File.open('destdir/foo') {|f| f.read })
+    assert_equal('bar', File.open('destdir/foo') { |f| f.read })
     assert File.directory?('destdir')
   end
 
   def test_mv_array
-    File.open('foo', 'w') {|f| f.write 'bar' }
-    File.open('baz', 'w') {|f| f.write 'binky' }
+    File.open('foo', 'w') { |f| f.write 'bar' }
+    File.open('baz', 'w') { |f| f.write 'binky' }
     FileUtils.mkdir_p 'destdir'
     FileUtils.mv %w(foo baz), 'destdir'
-    assert_equal('bar', File.open('destdir/foo') {|f| f.read })
-    assert_equal('binky', File.open('destdir/baz') {|f| f.read })
+    assert_equal('bar', File.open('destdir/foo') { |f| f.read })
+    assert_equal('binky', File.open('destdir/baz') { |f| f.read })
   end
 
   def test_mv_accepts_verbose_option
     FileUtils.touch 'foo'
-    assert_equal "mv foo bar\n", capture_stderr { FileUtils.mv 'foo', 'bar', :verbose => true }
+    assert_equal "mv foo bar\n", capture_stderr { FileUtils.mv 'foo', 'bar', verbose: true }
   end
 
   def test_mv_accepts_noop_option
     FileUtils.touch 'foo'
-    FileUtils.mv 'foo', 'bar', :noop => true
+    FileUtils.mv 'foo', 'bar', noop: true
     assert File.exist?('foo'), 'does not remove src'
     assert !File.exist?('bar'), 'does not create target'
   end
@@ -1452,25 +1455,25 @@ class FakeFSTest < Test::Unit::TestCase
 
   def test_mv_ignores_failures_when_using_force
     FileUtils.mkdir_p 'dir/stuff'
-    FileUtils.touch %w[stuff other]
-    FileUtils.mv %w[stuff other], 'dir', :force => true
+    FileUtils.touch %w(stuff other)
+    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'
 
-    FileUtils.mv 'stuff', '/this/path/is/not/here', :force => true
+    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'
   end
 
   def test_cp_actually_works
-    File.open('foo', 'w') {|f| f.write 'bar' }
+    File.open('foo', 'w') { |f| f.write 'bar' }
     FileUtils.cp('foo', 'baz')
     assert_equal 'bar', File.read('baz')
   end
 
   def test_cp_file_into_dir
-    File.open('foo', 'w') {|f| f.write 'bar' }
+    File.open('foo', 'w') { |f| f.write 'bar' }
     FileUtils.mkdir_p 'baz'
 
     FileUtils.cp('foo', 'baz')
@@ -1493,12 +1496,12 @@ class FakeFSTest < Test::Unit::TestCase
     exception = assert_raise(Errno::ENOTDIR) do
       FileUtils.cp(%w(foo), 'baz')
     end
-    assert_equal "Not a directory - baz", exception.to_s
+    assert_equal 'Not a directory - baz', exception.to_s
   end
 
   def test_cp_overwrites_dest_file
-    File.open('foo', 'w') {|f| f.write 'FOO' }
-    File.open('bar', 'w') {|f| f.write 'BAR' }
+    File.open('foo', 'w') { |f| f.write 'FOO' }
+    File.open('bar', 'w') { |f| f.write 'BAR' }
 
     FileUtils.cp('foo', 'bar')
     assert_equal 'FOO', File.read('bar')
@@ -1519,7 +1522,7 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_copy_file_works
-    File.open('foo', 'w') {|f| f.write 'bar' }
+    File.open('foo', 'w') { |f| f.write 'bar' }
     FileUtils.copy_file('foo', 'baz', :ignore_param_1, :ignore_param_2)
     assert_equal 'bar', File.read('baz')
   end
@@ -1541,7 +1544,7 @@ class FakeFSTest < Test::Unit::TestCase
 
   def test_cp_r_handles_copying_directories
     FileUtils.mkdir_p 'subdir'
-    Dir.chdir('subdir'){ File.open('foo', 'w') { |f| f.write 'footext' } }
+    Dir.chdir('subdir') { File.open('foo', 'w') { |f| f.write 'footext' } }
 
     FileUtils.mkdir_p 'baz'
 
@@ -1603,18 +1606,18 @@ class FakeFSTest < Test::Unit::TestCase
 
     FileUtils.cp_r '/path/foo', '/path/bar'
 
-    assert File.exists?('/path/bar/baz')
+    assert File.exist?('/path/bar/baz')
     FileUtils.rm_rf '/path/bar/baz'
     assert_equal %w( /path/bar/bar ), Dir['/path/bar/*']
   end
 
   def test_clone_clones_normal_files
     RealFile.open(here('foo'), 'w') { |f| f.write 'bar' }
-    assert !File.exists?(here('foo'))
+    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.exists?(here('foo'))
+    RealFile.unlink(here('foo')) if RealFile.exist?(here('foo'))
   end
 
   def test_clone_clones_directories
@@ -1622,7 +1625,7 @@ class FakeFSTest < Test::Unit::TestCase
 
     FileSystem.clone(here('subdir'))
 
-    assert File.exists?(here('subdir')), 'subdir was cloned'
+    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')) }
@@ -1631,7 +1634,7 @@ class FakeFSTest < Test::Unit::TestCase
   def test_clone_clones_dot_files_even_hard_to_find_ones
     act_on_real_fs { RealFileUtils.mkdir_p(here('subdir/.bar/baz/.quux/foo')) }
 
-    assert !File.exists?(here('subdir'))
+    assert !File.exist?(here('subdir'))
 
     FileSystem.clone(here('subdir'))
     assert_equal ['.', '..', '.bar'], Dir.entries(here('subdir'))
@@ -1644,8 +1647,8 @@ class FakeFSTest < Test::Unit::TestCase
     act_on_real_fs { RealFileUtils.mkdir_p(here('subdir/.bar/baz/.quux/foo')) }
     FileUtils.mkdir_p '/path'
     Dir.chdir('/path')
-    FileSystem.clone(here('subdir'), "/foo")
-    assert Dir.glob "/foo/*"
+    FileSystem.clone(here('subdir'), '/foo')
+    assert Dir.glob '/foo/*'
   ensure
     act_on_real_fs { RealFileUtils.rm_rf(here('subdir')) }
   end
@@ -1653,10 +1656,10 @@ class FakeFSTest < Test::Unit::TestCase
   def test_clone_with_target_specified
     act_on_real_fs { RealFileUtils.mkdir_p(here('subdir/.bar/baz/.quux/foo')) }
 
-    assert !File.exists?(here('subdir'))
+    assert !File.exist?(here('subdir'))
 
     FileSystem.clone(here('subdir'), here('subdir2'))
-    assert !File.exists?(here('subdir'))
+    assert !File.exist?(here('subdir'))
     assert_equal ['.', '..', '.bar'], Dir.entries(here('subdir2'))
     assert_equal ['.', '..', 'foo'], Dir.entries(here('subdir2/.bar/baz/.quux'))
   ensure
@@ -1669,12 +1672,12 @@ class FakeFSTest < Test::Unit::TestCase
 
     act_on_real_fs do
       RealDir.mkdir(RealFile.dirname(original))
-      RealFile.open(original, 'w') {|f| f << 'stuff' }
+      RealFile.open(original, 'w') { |f| f << 'stuff' }
       RealFileUtils.ln_s original, symlink
       assert RealFile.symlink?(symlink), 'real symlink is in place'
     end
 
-    assert !File.exists?(original), 'file does not already exist'
+    assert !File.exist?(original), 'file does not already exist'
 
     FileSystem.clone(File.dirname(original))
     assert File.symlink?(symlink), 'symlinks are cloned as symlinks'
@@ -1691,12 +1694,12 @@ class FakeFSTest < Test::Unit::TestCase
 
     act_on_real_fs do
       RealFileUtils.mkdir_p(original)
-      RealFile.open(original_file, 'w') {|f| f << 'stuff' }
+      RealFile.open(original_file, 'w') { |f| f << 'stuff' }
       RealFileUtils.ln_s original, symlink
       assert RealFile.symlink?(symlink), 'real symlink is in place'
     end
 
-    assert !File.exists?(original_file), 'file does not already exist'
+    assert !File.exist?(original_file), 'file does not already exist'
 
     FileSystem.clone(File.dirname(original))
     assert File.symlink?(symlink), 'symlinks are cloned as symlinks'
@@ -1715,30 +1718,30 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_file_can_read_from_symlinks
-    File.open('first', 'w') { |f| f.write '1'}
+    File.open('first', 'w') { |f| f.write '1' }
     FileUtils.ln_s 'first', 'one'
     assert_equal '1', File.open('one') { |f| f.read }
 
     FileUtils.mkdir_p 'subdir'
-    File.open('subdir/nother','w') { |f| f.write 'works' }
+    File.open('subdir/nother', 'w') { |f| f.write 'works' }
     FileUtils.ln_s 'subdir', 'new'
     assert_equal 'works', File.open('new/nother') { |f| f.read }
   end
 
   def test_can_symlink_through_file
-    FileUtils.touch("/foo")
+    FileUtils.touch('/foo')
 
-    File.symlink("/foo", "/bar")
+    File.symlink('/foo', '/bar')
 
-    assert File.symlink?("/bar")
+    assert File.symlink?('/bar')
   end
 
   def test_files_can_be_touched
     FileUtils.touch('touched_file')
-    assert File.exists?('touched_file')
-    list = ['newfile', 'another']
+    assert File.exist?('touched_file')
+    list = %w(newfile another)
     FileUtils.touch(list)
-    list.each { |fp| assert(File.exists?(fp)) }
+    list.each { |fp| assert(File.exist?(fp)) }
   end
 
   def test_touch_does_not_work_if_the_dir_path_cannot_be_found
@@ -1754,7 +1757,7 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_extname
-    assert File.extname("test.doc") == ".doc"
+    assert File.extname('test.doc') == '.doc'
   end
 
   # Directory tests
@@ -1778,12 +1781,12 @@ class FakeFSTest < Test::Unit::TestCase
     assert dir.close.nil?
 
     assert_raises(IOError) do
-      dir.each { |dir| dir }
+      dir.each { |d| d }
     end
   end
 
   def test_directory_each
-    test = ['.', '..', 'file_1', 'file_2', 'file_3', 'file_4', 'file_5' ]
+    test = ['.', '..', 'file_1', 'file_2', 'file_3', 'file_4', 'file_5']
 
     FileUtils.mkdir_p('/this/path/should/be/here')
 
@@ -1794,8 +1797,8 @@ class FakeFSTest < Test::Unit::TestCase
     dir = Dir.new('/this/path/should/be/here')
 
     yielded = []
-    dir.each do |dir|
-      yielded << dir
+    dir.each do |d|
+      yielded << d
     end
 
     assert yielded.size == test.size
@@ -1809,7 +1812,7 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_directory_pos
-    test = ['.', '..', 'file_1', 'file_2', 'file_3', 'file_4', 'file_5' ]
+    test = ['.', '..', 'file_1', 'file_2', 'file_3', 'file_4', 'file_5']
     FileUtils.mkdir_p('/this/path/should/be/here')
     test.each do |f|
       FileUtils.touch("/this/path/should/be/here/#{f}")
@@ -1831,7 +1834,7 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_directory_pos_assign
-    test = ['.', '..', 'file_1', 'file_2', 'file_3', 'file_4', 'file_5' ]
+    test = ['.', '..', 'file_1', 'file_2', 'file_3', 'file_4', 'file_5']
 
     FileUtils.mkdir_p('/this/path/should/be/here')
     test.each do |f|
@@ -1846,7 +1849,7 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_directory_read
-    test = ['.', '..', 'file_1', 'file_2', 'file_3', 'file_4', 'file_5' ]
+    test = ['.', '..', 'file_1', 'file_2', 'file_3', 'file_4', 'file_5']
 
     FileUtils.mkdir_p('/this/path/should/be/here')
     test.each do |f|
@@ -1866,7 +1869,7 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_directory_read_past_length
-    test = ['.', '..', 'file_1', 'file_2', 'file_3', 'file_4', 'file_5' ]
+    test = ['.', '..', 'file_1', 'file_2', 'file_3', 'file_4', 'file_5']
 
     FileUtils.mkdir_p('/this/path/should/be/here')
     test.each do |f|
@@ -1894,7 +1897,7 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_directory_rewind
-    test = ['.', '..', 'file_1', 'file_2', 'file_3', 'file_4', 'file_5' ]
+    test = ['.', '..', 'file_1', 'file_2', 'file_3', 'file_4', 'file_5']
 
     FileUtils.mkdir_p('/this/path/should/be/here')
     test.each do |f|
@@ -1903,15 +1906,15 @@ class FakeFSTest < Test::Unit::TestCase
 
     dir = Dir.new('/this/path/should/be/here')
 
-    d = dir.read
-    d = dir.read
+    dir.read
+    dir.read
     assert dir.pos == 2
     dir.rewind
     assert dir.pos == 0
   end
 
   def test_directory_seek
-    test = ['.', '..', 'file_1', 'file_2', 'file_3', 'file_4', 'file_5' ]
+    test = ['.', '..', 'file_1', 'file_2', 'file_3', 'file_4', 'file_5']
 
     FileUtils.mkdir_p('/this/path/should/be/here')
     test.each do |f|
@@ -1928,11 +1931,11 @@ class FakeFSTest < Test::Unit::TestCase
   def test_directory_class_delete
     FileUtils.mkdir_p('/this/path/should/be/here')
     Dir.delete('/this/path/should/be/here')
-    assert File.exists?('/this/path/should/be/here') == false
+    assert File.exist?('/this/path/should/be/here') == false
   end
 
   def test_directory_class_delete_does_not_act_on_non_empty_directory
-    test = ['.', '..', 'file_1', 'file_2', 'file_3', 'file_4', 'file_5' ]
+    test = ['.', '..', 'file_1', 'file_2', 'file_3', 'file_4', 'file_5']
 
     FileUtils.mkdir_p('/this/path/should/be/here')
     test.each do |f|
@@ -1951,7 +1954,7 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_directory_entries
-    test = ['.', '..', 'file_1', 'file_2', 'file_3', 'file_4', 'file_5' ]
+    test = ['.', '..', 'file_1', 'file_2', 'file_3', 'file_4', 'file_5']
 
     FileUtils.mkdir_p('/this/path/should/be/here')
 
@@ -1965,7 +1968,7 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_directory_entries_works_with_trailing_slash
-    test = ['.', '..', 'file_1', 'file_2', 'file_3', 'file_4', 'file_5' ]
+    test = ['.', '..', 'file_1', 'file_2', 'file_3', 'file_4', 'file_5']
 
     FileUtils.mkdir_p('/this/path/should/be/here')
 
@@ -1985,7 +1988,7 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_directory_foreach
-    test = ['.', '..', 'file_1', 'file_2', 'file_3', 'file_4', 'file_5' ]
+    test = ['.', '..', 'file_1', 'file_2', 'file_3', 'file_4', 'file_5']
 
     FileUtils.mkdir_p('/this/path/should/be/here')
 
@@ -2003,7 +2006,7 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_directory_foreach_relative_paths
-    test = ['.', '..', 'file_1', 'file_2', 'file_3', 'file_4', 'file_5' ]
+    test = ['.', '..', 'file_1', 'file_2', 'file_3', 'file_4', 'file_5']
 
     FileUtils.mkdir_p('/this/path/should/be/here')
 
@@ -2024,37 +2027,37 @@ class FakeFSTest < Test::Unit::TestCase
 
   def test_directory_mkdir
     Dir.mkdir('/path')
-    assert File.exists?('/path')
+    assert File.exist?('/path')
   end
 
   def test_directory_mkdir_nested
-    Dir.mkdir("/tmp")
-    Dir.mkdir("/tmp/stream20120103-11847-xc8pb.lock")
-    assert File.exists?("/tmp/stream20120103-11847-xc8pb.lock")
+    Dir.mkdir('/tmp')
+    Dir.mkdir('/tmp/stream20120103-11847-xc8pb.lock')
+    assert File.exist?('/tmp/stream20120103-11847-xc8pb.lock')
   end
 
   def test_can_create_subdirectories_with_dir_mkdir
     Dir.mkdir 'foo'
     Dir.mkdir 'foo/bar'
-    assert Dir.exists?('foo/bar')
+    assert Dir.exist?('foo/bar')
   end
 
   def test_can_create_absolute_subdirectories_with_dir_mkdir
     Dir.mkdir '/foo'
     Dir.mkdir '/foo/bar'
-    assert Dir.exists?('/foo/bar')
+    assert Dir.exist?('/foo/bar')
   end
 
   def test_can_create_directories_starting_with_dot
     Dir.mkdir './path'
-    assert File.exists? './path'
+    assert File.exist? './path'
   end
 
   def test_directory_mkdir_relative
     FileUtils.mkdir_p('/new/root')
     FileSystem.chdir('/new/root')
     Dir.mkdir('path')
-    assert File.exists?('/new/root/path')
+    assert File.exist?('/new/root/path')
   end
 
   def test_directory_mkdir_not_recursive
@@ -2064,15 +2067,15 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_mkdir_raises_error_if_already_created
-    Dir.mkdir "foo"
+    Dir.mkdir 'foo'
 
     assert_raises(Errno::EEXIST) do
-      Dir.mkdir "foo"
+      Dir.mkdir 'foo'
     end
   end
 
   def test_directory_open
-    test = ['.', '..', 'file_1', 'file_2', 'file_3', 'file_4', 'file_5' ]
+    test = ['.', '..', 'file_1', 'file_2', 'file_3', 'file_4', 'file_5']
 
     FileUtils.mkdir_p('/this/path/should/be/here')
 
@@ -2085,7 +2088,7 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_directory_open_block
-    test = ['.', '..', 'file_1', 'file_2', 'file_3', 'file_4', 'file_5' ]
+    test = ['.', '..', 'file_1', 'file_2', 'file_3', 'file_4', 'file_5']
 
     FileUtils.mkdir_p('/this/path/should/be/here')
 
@@ -2103,142 +2106,141 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_directory_exists
-    assert Dir.exists?('/this/path/should/be/here') == false
+    assert Dir.exist?('/this/path/should/be/here') == false
     assert Dir.exist?('/this/path/should/be/here') == false
     FileUtils.mkdir_p('/this/path/should/be/here')
-    assert Dir.exists?('/this/path/should/be/here') == true
+    assert Dir.exist?('/this/path/should/be/here') == true
     assert Dir.exist?('/this/path/should/be/here') == true
   end
 
   def test_tmpdir
-    assert Dir.tmpdir == "/tmp"
+    assert Dir.tmpdir == '/tmp'
   end
 
   def test_rename_renames_a_file
-    FileUtils.touch("/foo")
-    File.rename("/foo", "/bar")
-    assert File.file?("/bar")
+    FileUtils.touch('/foo')
+    File.rename('/foo', '/bar')
+    assert File.file?('/bar')
   end
 
   def test_rename_returns
-    FileUtils.touch("/foo")
-    assert_equal 0, File.rename("/foo", "/bar")
+    FileUtils.touch('/foo')
+    assert_equal 0, File.rename('/foo', '/bar')
   end
 
   def test_rename_renames_two_files
-    FileUtils.touch("/foo")
-    FileUtils.touch("/bar")
-    File.rename("/foo", "/bar")
-    assert File.file?("/bar")
+    FileUtils.touch('/foo')
+    FileUtils.touch('/bar')
+    File.rename('/foo', '/bar')
+    assert File.file?('/bar')
   end
 
   def test_rename_renames_a_directories
-    Dir.mkdir("/foo")
-    File.rename("/foo", "/bar")
-    assert File.directory?("/bar")
+    Dir.mkdir('/foo')
+    File.rename('/foo', '/bar')
+    assert File.directory?('/bar')
   end
 
   def test_rename_renames_two_directories
-    Dir.mkdir("/foo")
-    Dir.mkdir("/bar")
-    File.rename("/foo", "/bar")
-    assert File.directory?("/bar")
+    Dir.mkdir('/foo')
+    Dir.mkdir('/bar')
+    File.rename('/foo', '/bar')
+    assert File.directory?('/bar')
   end
 
   def test_rename_file_to_directory_raises_error
-    FileUtils.touch("/foo")
-    Dir.mkdir("/bar")
+    FileUtils.touch('/foo')
+    Dir.mkdir('/bar')
     assert_raises(Errno::EISDIR) do
-      File.rename("/foo", "/bar")
+      File.rename('/foo', '/bar')
     end
   end
 
   def test_rename_directory_to_file_raises_error
-    Dir.mkdir("/foo")
-    FileUtils.touch("/bar")
+    Dir.mkdir('/foo')
+    FileUtils.touch('/bar')
     assert_raises(Errno::ENOTDIR) do
-      File.rename("/foo", "/bar")
+      File.rename('/foo', '/bar')
     end
   end
 
-
   def test_rename_with_missing_source_raises_error
     assert_raises(Errno::ENOENT) do
-      File.rename("/no_such_file", "/bar")
+      File.rename('/no_such_file', '/bar')
     end
   end
 
   def test_rename_with_missing_dest_directory_raises_error
-    FileUtils.touch("/foo")
+    FileUtils.touch('/foo')
     assert_raises(Errno::ENOENT) do
-      File.rename("/foo", "/bar/foo")
+      File.rename('/foo', '/bar/foo')
     end
   end
 
   def test_hard_link_creates_file
-    FileUtils.touch("/foo")
+    FileUtils.touch('/foo')
 
-    File.link("/foo", "/bar")
-    assert File.exists?("/bar")
+    File.link('/foo', '/bar')
+    assert File.exist?('/bar')
   end
 
   def test_hard_link_with_missing_file_raises_error
     assert_raises(Errno::ENOENT) do
-      File.link("/foo", "/bar")
+      File.link('/foo', '/bar')
     end
   end
 
   def test_hard_link_with_existing_destination_file
-    FileUtils.touch("/foo")
-    FileUtils.touch("/bar")
+    FileUtils.touch('/foo')
+    FileUtils.touch('/bar')
 
     assert_raises(Errno::EEXIST) do
-      File.link("/foo", "/bar")
+      File.link('/foo', '/bar')
     end
   end
 
   def test_hard_link_returns_0_when_successful
-    FileUtils.touch("/foo")
+    FileUtils.touch('/foo')
 
-    assert_equal 0, File.link("/foo", "/bar")
+    assert_equal 0, File.link('/foo', '/bar')
   end
 
   def test_hard_link_returns_duplicate_file
-    File.open("/foo", "w") { |x| x << "some content" }
+    File.open('/foo', 'w') { |x| x << 'some content' }
 
-    File.link("/foo", "/bar")
-    assert_equal "some content", File.read("/bar")
+    File.link('/foo', '/bar')
+    assert_equal 'some content', File.read('/bar')
   end
 
   def test_hard_link_with_directory_raises_error
-    Dir.mkdir "/foo"
+    Dir.mkdir '/foo'
 
     assert_raises(Errno::EPERM) do
-      File.link("/foo", "/bar")
+      File.link('/foo', '/bar')
     end
   end
 
   def test_file_stat_returns_file_stat_object
-    FileUtils.touch("/foo")
-    assert_equal File::Stat, File.stat("/foo").class
+    FileUtils.touch('/foo')
+    assert_equal File::Stat, File.stat('/foo').class
   end
 
   def test_can_delete_file_with_delete
-    FileUtils.touch("/foo")
+    FileUtils.touch('/foo')
 
-    File.delete("/foo")
+    File.delete('/foo')
 
-    assert !File.exists?("/foo")
+    assert !File.exist?('/foo')
   end
 
   def test_can_delete_multiple_files_with_delete
-    FileUtils.touch("/foo")
-    FileUtils.touch("/bar")
+    FileUtils.touch('/foo')
+    FileUtils.touch('/bar')
 
-    File.delete("/foo", "/bar")
+    File.delete('/foo', '/bar')
 
-    assert !File.exists?("/foo")
-    assert !File.exists?("/bar")
+    assert !File.exist?('/foo')
+    assert !File.exist?('/bar')
   end
 
   def test_delete_returns_zero_when_no_filename_given
@@ -2246,104 +2248,104 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_delete_returns_number_one_when_given_one_arg
-    FileUtils.touch("/foo")
+    FileUtils.touch('/foo')
 
-    assert_equal 1, File.delete("/foo")
+    assert_equal 1, File.delete('/foo')
   end
 
   def test_delete_returns_number_two_when_given_two_args
-    FileUtils.touch("/foo")
-    FileUtils.touch("/bar")
+    FileUtils.touch('/foo')
+    FileUtils.touch('/bar')
 
-    assert_equal 2, File.delete("/foo", "/bar")
+    assert_equal 2, File.delete('/foo', '/bar')
   end
 
   def test_delete_raises_error_when_first_file_does_not_exist
     assert_raises Errno::ENOENT do
-      File.delete("/foo")
+      File.delete('/foo')
     end
   end
 
   def test_unlink_removes_only_one_file_content
-    File.open("/foo", "w") { |f| f << "some_content" }
-    File.link("/foo", "/bar")
+    File.open('/foo', 'w') { |f| f << 'some_content' }
+    File.link('/foo', '/bar')
 
-    File.unlink("/bar")
-    assert_equal "some_content", File.read("/foo")
+    File.unlink('/bar')
+    assert_equal 'some_content', File.read('/foo')
   end
 
   def test_link_reports_correct_stat_info_after_unlinking
-    File.open("/foo", "w") { |f| f << "some_content" }
-    File.link("/foo", "/bar")
+    File.open('/foo', 'w') { |f| f << 'some_content' }
+    File.link('/foo', '/bar')
 
-    File.unlink("/bar")
-    assert_equal 1, File.stat("/foo").nlink
+    File.unlink('/bar')
+    assert_equal 1, File.stat('/foo').nlink
   end
 
   def test_delete_works_with_symlink
-    FileUtils.touch("/foo")
-    File.symlink("/foo", "/bar")
+    FileUtils.touch('/foo')
+    File.symlink('/foo', '/bar')
 
-    File.unlink("/bar")
+    File.unlink('/bar')
 
-    assert File.exists?("/foo")
-    assert !File.exists?("/bar")
+    assert File.exist?('/foo')
+    assert !File.exist?('/bar')
   end
 
   def test_delete_works_with_symlink_source
-    FileUtils.touch("/foo")
-    File.symlink("/foo", "/bar")
+    FileUtils.touch('/foo')
+    File.symlink('/foo', '/bar')
 
-    File.unlink("/foo")
+    File.unlink('/foo')
 
-    assert !File.exists?("/foo")
+    assert !File.exist?('/foo')
   end
 
   def test_file_seek_returns_0
-    File.open("/foo", "w") do |f|
+    File.open('/foo', 'w') do |f|
       f << "one\ntwo\nthree"
     end
 
-    file = File.open("/foo", "r")
+    file = File.open('/foo', 'r')
 
     assert_equal 0, file.seek(1)
   end
 
   def test_file_seek_seeks_to_location
-    File.open("/foo", "w") do |f|
-      f << "123"
+    File.open('/foo', 'w') do |f|
+      f << '123'
     end
 
-    file = File.open("/foo", "r")
+    file = File.open('/foo', 'r')
     file.seek(1)
-    assert_equal "23", file.read
+    assert_equal '23', file.read
   end
 
   def test_file_seek_seeks_to_correct_location
-    File.open("/foo", "w") do |f|
-      f << "123"
+    File.open('/foo', 'w') do |f|
+      f << '123'
     end
 
-    file = File.open("/foo", "r")
+    file = File.open('/foo', 'r')
     file.seek(2)
-    assert_equal "3", file.read
+    assert_equal '3', file.read
   end
 
   def test_file_seek_can_take_negative_offset
-    File.open("/foo", "w") do |f|
-      f << "123456789"
+    File.open('/foo', 'w') do |f|
+      f << '123456789'
     end
 
-    file = File.open("/foo", "r")
+    file = File.open('/foo', 'r')
 
     file.seek(-1, IO::SEEK_END)
-    assert_equal "9", file.read
+    assert_equal '9', file.read
 
     file.seek(-2, IO::SEEK_END)
-    assert_equal "89", file.read
+    assert_equal '89', file.read
 
     file.seek(-3, IO::SEEK_END)
-    assert_equal "789", file.read
+    assert_equal '789', file.read
   end
 
   def test_should_have_constants_inherited_from_descending_from_io
@@ -2353,11 +2355,11 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_filetest_exists_return_correct_values
-    FileUtils.mkdir_p("/path/to/dir")
-    assert FileTest.exist?("/path/to/")
+    FileUtils.mkdir_p('/path/to/dir')
+    assert FileTest.exist?('/path/to/')
 
-    FileUtils.rmdir("/path/to/dir")
-    assert !FileTest.exist?("/path/to/dir")
+    FileUtils.rmdir('/path/to/dir')
+    assert !FileTest.exist?('/path/to/dir')
   end
 
   def test_filetest_directory_returns_correct_values
@@ -2369,10 +2371,10 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_filetest_file_returns_correct_values
-    FileUtils.mkdir_p("/path/to")
+    FileUtils.mkdir_p('/path/to')
 
     path = '/path/to/file.txt'
-    File.open(path, 'w') { |f| f.write "Yatta!" }
+    File.open(path, 'w') { |f| f.write 'Yatta!' }
     assert FileTest.file?(path)
 
     FileUtils.rm path
@@ -2393,10 +2395,10 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_pathname_exists_returns_correct_value
-    FileUtils.touch "foo"
-    assert Pathname.new("foo").exist?
+    FileUtils.touch 'foo'
+    assert Pathname.new('foo').exist?
 
-    assert !Pathname.new("bar").exist?
+    assert !Pathname.new('bar').exist?
   end
 
   def test_pathname_method_is_faked
@@ -2429,73 +2431,73 @@ class FakeFSTest < Test::Unit::TestCase
 
   def test_split
     assert File.respond_to? :split
-    filename = "/this/is/what/we/expect.txt"
-    path,filename = File.split(filename)
-    assert_equal path, "/this/is/what/we"
-    assert_equal filename, "expect.txt"
+    filename = '/this/is/what/we/expect.txt'
+    path, filename = File.split(filename)
+    assert_equal path, '/this/is/what/we'
+    assert_equal filename, 'expect.txt'
   end
 
   #########################
   def test_file_default_mode
-    FileUtils.touch "foo"
-    assert_equal File.stat("foo").mode, (0100000 + 0666 - File.umask)
+    FileUtils.touch 'foo'
+    assert_equal File.stat('foo').mode, (0100000 + 0666 - File.umask)
   end
 
   def test_dir_default_mode
-    Dir.mkdir "bar"
-    assert_equal File.stat("bar").mode, (0100000 + 0777 - File.umask)
+    Dir.mkdir 'bar'
+    assert_equal File.stat('bar').mode, (0100000 + 0777 - File.umask)
   end
 
   def test_file_default_uid_and_gid
-    FileUtils.touch "foo"
-    assert_equal File.stat("foo").uid, Process.uid
-    assert_equal File.stat("foo").gid, Process.gid
+    FileUtils.touch 'foo'
+    assert_equal File.stat('foo').uid, Process.uid
+    assert_equal File.stat('foo').gid, Process.gid
   end
 
   def test_file_chmod_of_file
-    FileUtils.touch "foo"
-    File.chmod 0600, "foo"
-    assert_equal File.stat("foo").mode, 0100600
-    File.new("foo").chmod 0644
-    assert_equal File.stat("foo").mode, 0100644
+    FileUtils.touch 'foo'
+    File.chmod 0600, 'foo'
+    assert_equal File.stat('foo').mode, 0100600
+    File.new('foo').chmod 0644
+    assert_equal File.stat('foo').mode, 0100644
   end
 
   def test_file_chmod_of_dir
-    Dir.mkdir "bar"
-    File.chmod 0777, "bar"
-    assert_equal File.stat("bar").mode, 0100777
-    File.new("bar").chmod 01700
-    assert_equal File.stat("bar").mode, 0101700
+    Dir.mkdir 'bar'
+    File.chmod 0777, 'bar'
+    assert_equal File.stat('bar').mode, 0100777
+    File.new('bar').chmod 01700
+    assert_equal File.stat('bar').mode, 0101700
   end
 
   def test_file_chown_of_file
-    FileUtils.touch "foo"
-    File.chown 1337, 1338, "foo"
-    assert_equal File.stat("foo").uid, 1337
-    assert_equal File.stat("foo").gid, 1338
+    FileUtils.touch 'foo'
+    File.chown 1337, 1338, 'foo'
+    assert_equal File.stat('foo').uid, 1337
+    assert_equal File.stat('foo').gid, 1338
   end
 
   def test_file_chown_of_dir
-    Dir.mkdir "bar"
-    File.chown 1337, 1338, "bar"
-    assert_equal File.stat("bar").uid, 1337
-    assert_equal File.stat("bar").gid, 1338
+    Dir.mkdir 'bar'
+    File.chown 1337, 1338, 'bar'
+    assert_equal File.stat('bar').uid, 1337
+    assert_equal File.stat('bar').gid, 1338
   end
 
   def test_file_chown_of_file_nil_user_group
-    FileUtils.touch "foo"
-    File.chown 1337, 1338, "foo"
-    File.chown nil, nil, "foo"
-    assert_equal File.stat("foo").uid, 1337
-    assert_equal File.stat("foo").gid, 1338
+    FileUtils.touch 'foo'
+    File.chown 1337, 1338, 'foo'
+    File.chown nil, nil, 'foo'
+    assert_equal File.stat('foo').uid, 1337
+    assert_equal File.stat('foo').gid, 1338
   end
 
   def test_file_chown_of_file_negative_user_group
-    FileUtils.touch "foo"
-    File.chown 1337, 1338, "foo"
-    File.chown -1, -1, "foo"
-    assert_equal File.stat("foo").uid, 1337
-    assert_equal File.stat("foo").gid, 1338
+    FileUtils.touch 'foo'
+    File.chown 1337, 1338, 'foo'
+    File.chown(-1, -1, 'foo')
+    assert_equal File.stat('foo').uid, 1337
+    assert_equal File.stat('foo').gid, 1338
   end
 
   def test_file_instance_chown_nil_user_group
@@ -2515,7 +2517,7 @@ class FakeFSTest < Test::Unit::TestCase
     assert_equal File.stat('foo').uid, 1337
     assert_equal File.stat('foo').gid, 1338
     file = File.new('foo')
-    file.chown -1, -1
+    file.chown(-1, -1)
     file.close
     assert_equal File.stat('foo').uid, 1337
     assert_equal File.stat('foo').gid, 1338
@@ -2532,35 +2534,35 @@ class FakeFSTest < Test::Unit::TestCase
   def test_file_stat_comparable
     a_time = Time.new
 
-    same1 = File.new("s1", "w")
-    same2 = File.new("s2", "w")
-    different1 = File.new("d1", "w")
-    different2 = File.new("d2", "w")
+    same1 = File.new('s1', 'w')
+    same2 = File.new('s2', 'w')
+    different1 = File.new('d1', 'w')
+    different2 = File.new('d2', 'w')
 
-    FileSystem.find("s1").mtime = a_time
-    FileSystem.find("s2").mtime = a_time
+    FileSystem.find('s1').mtime = a_time
+    FileSystem.find('s2').mtime = a_time
 
-    FileSystem.find("d1").mtime = a_time
-    FileSystem.find("d2").mtime = a_time + 1
+    FileSystem.find('d1').mtime = a_time
+    FileSystem.find('d2').mtime = a_time + 1
 
     assert same1.mtime == same2.mtime
     assert different1.mtime != different2.mtime
 
     assert same1.stat == same2.stat
-    assert (same1.stat <=> same2.stat) == 0
+    assert((same1.stat <=> same2.stat) == 0)
 
     assert different1.stat != different2.stat
-    assert (different1.stat <=> different2.stat) == -1
+    assert((different1.stat <=> different2.stat) == -1)
   end
 
   def test_file_binread_works
-    File.open("testfile", 'w') do |f|
+    File.open('testfile', 'w') do |f|
       f << "This is line one\nThis is line two\nThis is line three\nAnd so on...\n"
     end
 
-    assert_equal File.binread("testfile"), "This is line one\nThis is line two\nThis is line three\nAnd so on...\n"
-    assert_equal File.binread("testfile", 20), "This is line one\nThi"
-    assert_equal File.binread("testfile", 20, 10), "ne one\nThis is line "
+    assert_equal File.binread('testfile'), "This is line one\nThis is line two\nThis is line three\nAnd so on...\n"
+    assert_equal File.binread('testfile', 20), "This is line one\nThi"
+    assert_equal File.binread('testfile', 20, 10), "ne one\nThis is line "
   end
 
   def here(fname)
@@ -2584,11 +2586,11 @@ class FakeFSTest < Test::Unit::TestCase
     assert_equal FileUtils.compare_file(file1, file2), true
     assert_equal FileUtils.compare_file(file1, file3), false
     assert_raises Errno::ENOENT do
-      FileUtils.compare_file(file1, "file4.txt")
+      FileUtils.compare_file(file1, 'file4.txt')
     end
   end
 
-  if RUBY_VERSION >= "1.9.1"
+  if RUBY_VERSION >= '1.9.1'
     def test_absolute_path_with_absolute_path
       assert_equal '/foo/bar', File.absolute_path('/foo/bar')
     end
@@ -2602,21 +2604,20 @@ class FakeFSTest < Test::Unit::TestCase
     end
 
     def test_absolute_path_with_relative_path_with_dir_name
-      assert_equal "/dir/foo/bar", File.absolute_path('foo/bar', '/dir')
+      assert_equal '/dir/foo/bar', File.absolute_path('foo/bar', '/dir')
     end
   end
 
-
-  if RUBY_VERSION >= "1.9.2"
+  if RUBY_VERSION >= '1.9.2'
     def test_file_size
-      File.open("foo", 'w') do |f|
+      File.open('foo', 'w') do |f|
         f << 'Yada Yada'
         assert_equal 9, f.size
       end
     end
 
     def test_fdatasync
-      File.open("foo", 'w') do |f|
+      File.open('foo', 'w') do |f|
         f << 'Yada Yada'
         assert_nothing_raised do
           f.fdatasync
@@ -2625,7 +2626,7 @@ class FakeFSTest < Test::Unit::TestCase
     end
 
     def test_autoclose
-      File.open("foo", 'w') do |f|
+      File.open('foo', 'w') do |f|
         assert_equal true, f.autoclose?
         f.autoclose = false
         assert_equal false, f.autoclose?
@@ -2633,15 +2634,15 @@ class FakeFSTest < Test::Unit::TestCase
     end
 
     def test_to_path
-      File.new("foo", 'w') do |f|
-        assert_equal "foo", f.to_path
+      File.new('foo', 'w') do |f|
+        assert_equal 'foo', f.to_path
       end
     end
   end
 
-  if RUBY_VERSION >= "1.9.3"
+  if RUBY_VERSION >= '1.9.3'
     def test_advise
-      File.open("foo", 'w') do |f|
+      File.open('foo', 'w') do |f|
         assert_nothing_raised do
           f.advise(:normal, 0, 0)
         end
@@ -2654,7 +2655,7 @@ class FakeFSTest < Test::Unit::TestCase
         f.write 'Yatta!'
       end
 
-      assert_equal 'ASCII-8BIT', File.read(path, :mode => 'rb').encoding.to_s
+      assert_equal 'ASCII-8BIT', File.read(path, mode: 'rb').encoding.to_s
     end
 
     def test_file_read_respects_args_and_hashes
@@ -2663,23 +2664,23 @@ class FakeFSTest < Test::Unit::TestCase
         f.write 'Yatta!'
       end
 
-      result = File.read(path, 2, 1, :mode => 'rb')
+      result = File.read(path, 2, 1, mode: 'rb')
       assert_equal 'at', result
       assert_equal 'ASCII-8BIT', result.encoding.to_s
     end
 
     def test_file_write_can_write_a_file
-      File.write("testfile", "0123456789")
-      assert_equal File.read("testfile"), "0123456789"
+      File.write('testfile', '0123456789')
+      assert_equal File.read('testfile'), '0123456789'
     end
 
     def test_file_write_returns_the_length_written
-      assert_equal File.write("testfile", "0123456789"), 10
+      assert_equal File.write('testfile', '0123456789'), 10
     end
 
     def test_file_write_truncates_file_if_offset_not_given
-      File.open("foo", 'w') do |f|
-        f << "foo"
+      File.open('foo', 'w') do |f|
+        f << 'foo'
       end
 
       File.write('foo', 'bar')
@@ -2687,8 +2688,8 @@ class FakeFSTest < Test::Unit::TestCase
     end
 
     def test_file_write_writes_at_offset_and_does_not_truncate
-      File.open("foo", 'w') do |f|
-        f << "foo"
+      File.open('foo', 'w') do |f|
+        f << 'foo'
       end
 
       File.write('foo', 'bar', 3)
@@ -2697,17 +2698,17 @@ class FakeFSTest < Test::Unit::TestCase
 
     def test_can_read_binary_data_in_binary_mode
       File.open('foo', 'wb') { |f| f << "\u0000\u0000\u0000\u0003\u0000\u0003\u0000\xA3\u0000\u0000\u0000y\u0000\u0000\u0000\u0000\u0000" }
-      assert_equal "\x00\x00\x00\x03\x00\x03\x00\xA3\x00\x00\x00y\x00\x00\x00\x00\x00".force_encoding('ASCII-8BIT'), File.open("foo", "rb").read
+      assert_equal "\x00\x00\x00\x03\x00\x03\x00\xA3\x00\x00\x00y\x00\x00\x00\x00\x00".force_encoding('ASCII-8BIT'), File.open('foo', 'rb').read
     end
 
     def test_can_read_binary_data_in_non_binary_mode
       File.open('foo_non_bin', 'wb') { |f| f << "\u0000\u0000\u0000\u0003\u0000\u0003\u0000\xA3\u0000\u0000\u0000y\u0000\u0000\u0000\u0000\u0000" }
-      assert_equal "\x00\x00\x00\x03\x00\x03\x00\xA3\x00\x00\x00y\x00\x00\x00\x00\x00".force_encoding('UTF-8'), File.open("foo_non_bin", "r").read
+      assert_equal "\x00\x00\x00\x03\x00\x03\x00\xA3\x00\x00\x00y\x00\x00\x00\x00\x00".force_encoding('UTF-8'), File.open('foo_non_bin', 'r').read
     end
 
     def test_can_read_binary_data_using_binread
       File.open('foo', 'wb') { |f| f << "\u0000\u0000\u0000\u0003\u0000\u0003\u0000\xA3\u0000\u0000\u0000y\u0000\u0000\u0000\u0000\u0000" }
-      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")
+      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
 end