fakefs 0.4.0 → 0.4.1

data/lib/fakefs/safe.rb

@@ -9,3 +9,5 @@ require 'fakefs/fileutils'
 require 'fakefs/file'
 require 'fakefs/file_test'
 require 'fakefs/dir'
+require 'fakefs/pathname' if RUBY_VERSION >= "1.9.3"
+

data/lib/fakefs/version.rb

@@ -1,6 +1,6 @@
 module FakeFS
   module Version
-    VERSION = "0.4.0"
+    VERSION = "0.4.1"
 
     def self.to_s
       VERSION

data/test/fakefs_test.rb

@@ -55,12 +55,12 @@ class FakeFSTest < Test::Unit::TestCase
     assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir']
   end
 
-  def test_can_create_directories_with_mkpath
+  def test_can_create_directories_with_mkdirs
     FileUtils.makedirs("/path/to/dir")
     assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir']
   end
 
-  def test_can_create_directories_with_mkpath_and_options
+  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']
   end
@@ -71,6 +71,12 @@ class FakeFSTest < Test::Unit::TestCase
     end
   end
 
+  def test_unlink_doesnt_error_on_file_not_found_when_forced
+    assert_nothing_raised do
+      FileUtils.rm("/foo", :force => true)
+    end
+  end
+
   def test_can_delete_directories
     FileUtils.mkdir_p("/path/to/dir")
     FileUtils.rmdir("/path/to/dir")
@@ -95,6 +101,13 @@ class FakeFSTest < Test::Unit::TestCase
     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")
+
+    assert File.directory?(period_path)
+  end
+
   def test_knows_symlink_directories_are_directories
     FileUtils.mkdir_p(path = "/path/to/dir")
     FileUtils.ln_s path, sympath = '/sympath'
@@ -412,6 +425,15 @@ class FakeFSTest < Test::Unit::TestCase
     assert_equal "Yatta!", File.read(path)
   end
 
+  def test_file_read_accepts_hashes
+    path = 'file.txt'
+    File.open(path, 'w') do |f|
+      f.write 'Yatta!'
+    end
+
+    assert_nothing_raised { File.read(path, :mode => 'r:UTF-8:-') }
+  end
+
   def test_can_write_to_files
     path = 'file.txt'
     File.open(path, 'w') do |f|
@@ -495,27 +517,46 @@ class FakeFSTest < Test::Unit::TestCase
     assert File.ctime('foo').is_a?(Time)
   end
 
-  def test_ctime_and_mtime_are_equal_for_new_files
+  def test_raises_error_on_atime_if_file_does_not_exist
+    assert_raise Errno::ENOENT do
+      File.atime('file.txt')
+    end
+  end
+
+  def test_can_return_atime_on_existing_file
     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")
     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|
       assert_equal ctime, f.ctime
       assert_equal mtime, f.mtime
+      assert_equal atime, f.atime
     end
   end
 
-  def test_ctime_and_mtime_are_equal_for_new_directories
+  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")
     assert ctime.is_a?(Time)
     assert mtime.is_a?(Time)
+    assert atime.is_a?(Time)
     assert_equal ctime, mtime
+    assert_equal ctime, atime
   end
 
   def test_file_ctime_is_equal_to_file_stat_ctime
@@ -538,6 +579,16 @@ class FakeFSTest < Test::Unit::TestCase
     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")
+  end
+
+  def test_directory_atime_is_equal_to_directory_stat_atime
+    FileUtils.mkdir_p("foo")
+    assert_equal File.stat("foo").atime, File.atime("foo")
+  end
+
   def test_utime_raises_error_if_path_does_not_exist
     assert_raise Errno::ENOENT do
       File.utime(Time.now, Time.now, '/path/to/file.txt')
@@ -552,6 +603,7 @@ class FakeFSTest < Test::Unit::TestCase
     end
     File.utime(time, time, path)
     assert_equal time, File.mtime('file.txt')
+    assert_equal time, File.atime('file.txt')
   end
 
   def test_utime_returns_number_of_paths
@@ -564,6 +616,21 @@ class FakeFSTest < Test::Unit::TestCase
     assert_equal 2, File.utime(Time.now, Time.now, path1, path2)
   end
 
+  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"
+    end
+
+    File.utime(old_atime, File.mtime(path), path)
+
+    assert_equal File.atime(path), old_atime
+    File.read(path)
+    assert File.atime(path) != old_atime
+  end
+
   def test_can_read_with_File_readlines
     path = 'file.txt'
     File.open(path, 'w') do |f|
@@ -603,6 +670,21 @@ class FakeFSTest < Test::Unit::TestCase
     assert_equal "Yatta!", File.new(path).read
   end
 
+  if RUBY_VERSION >= "1.9"
+    def test_file_object_has_default_external_encoding
+      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
+    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!' }
+    end
+  end
+
   def test_file_read_errors_appropriately
     assert_raise Errno::ENOENT do
       File.read('anything')
@@ -646,30 +728,83 @@ class FakeFSTest < Test::Unit::TestCase
     good = 'file.txt'
     bad = 'nofile.txt'
     File.open(good,'w') { |f| f.write "foo" }
+    username = Etc.getpwuid(Process.uid).name
+    groupname = Etc.getgrgid(Process.gid).name
 
-    out = FileUtils.chown('noone', 'nogroup', 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('noone', 'nogroup', bad, :verbose => true)
+      FileUtils.chown(username, groupname, bad, :verbose => true)
     end
 
-    assert_equal [good], FileUtils.chown('noone', 'nogroup', good)
+    assert_equal [good], FileUtils.chown(username, groupname, good)
+    assert_equal File.stat(good).uid, Process.uid
+    assert_equal File.stat(good).gid, Process.gid
     assert_raises(Errno::ENOENT) do
-      FileUtils.chown('noone', 'nogroup', bad)
+      FileUtils.chown(username, groupname, bad)
     end
 
-    assert_equal [good], FileUtils.chown('noone', 'nogroup', [good])
+    assert_equal [good], FileUtils.chown(username, groupname, [good])
+    assert_equal File.stat(good).uid, Process.uid
+    assert_equal File.stat(good).gid, Process.gid
     assert_raises(Errno::ENOENT) do
-      FileUtils.chown('noone', 'nogroup', [good, bad])
+      FileUtils.chown(username, groupname, [good, bad])
     end
   end
 
   def test_can_chown_R_files
+    username = Etc.getpwuid(Process.uid).name
+    groupname = Etc.getgrgid(Process.gid).name
     FileUtils.mkdir_p '/path/'
     File.open('/path/foo', 'w') { |f| f.write 'foo' }
     File.open('/path/foobar', 'w') { |f| f.write 'foo' }
-    resp = FileUtils.chown_R('no', 'no', '/path')
-    assert_equal ['/path'], resp
+    assert_equal ['/path'], FileUtils.chown_R(username, groupname, '/path')
+    %w(/path /path/foo /path/foobar).each do |f|
+      assert_equal File.stat(f).uid, Process.uid
+      assert_equal File.stat(f).gid, Process.gid
+    end
+  end
+
+  def test_can_chmod_files
+    good = "file.txt"
+    bad = "nofile.txt"
+    FileUtils.touch(good)
+
+    assert_equal [good], FileUtils.chmod(0600, good, :verbose => true)
+    assert_equal File.stat(good).mode, 0100600
+    assert_raises(Errno::ENOENT) do
+      FileUtils.chmod(0600, bad)
+    end
+
+    assert_equal [good], FileUtils.chmod(0666, good)
+    assert_equal File.stat(good).mode, 0100666
+    assert_raises(Errno::ENOENT) do
+      FileUtils.chmod(0666, bad)
+    end
+
+    assert_equal [good], FileUtils.chmod(0644, [good])
+    assert_equal File.stat(good).mode, 0100644
+    assert_raises(Errno::ENOENT) do
+      FileUtils.chmod(0644, bad)
+    end
+  end
+
+  def test_can_chmod_R_files
+    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
+
+    FileUtils.mkdir_p "/path2"
+    FileUtils.touch "/path2/hej"
+    assert_equal ["/path2"], FileUtils.chmod_R(0600, "/path2")
   end
 
   def test_dir_globs_paths
@@ -698,6 +833,9 @@ class FakeFSTest < Test::Unit::TestCase
     assert_equal ['/path/bar', '/path/bar/baz', '/path/bar2', '/path/bar2/baz', '/path/foo', '/path/foobar'], Dir['/path/**/*']
     assert_equal ['/path/bar/baz'], Dir['/path/bar/**/*']
 
+    assert_equal ['/path/bar/baz', '/path/bar2/baz'], Dir['/path/bar/**/*', '/path/bar2/**/*']
+    assert_equal ['/path/bar/baz', '/path/bar2/baz', '/path/bar/baz'], Dir['/path/ba*/**/*', '/path/bar/**/*']
+
     FileUtils.cp_r '/path', '/otherpath'
 
     assert_equal %w( /otherpath/foo /otherpath/foobar /path/foo /path/foobar ), Dir['/*/foo*']
@@ -705,6 +843,10 @@ class FakeFSTest < Test::Unit::TestCase
     assert_equal ['/path/bar', '/path/foo'], Dir['/path/{foo,bar}']
 
     assert_equal ['/path/bar', '/path/bar2'], Dir['/path/bar{2,}']
+
+    Dir.chdir '/path' do
+      assert_equal ['foo'], Dir['foo']
+    end
   end
 
   def test_dir_glob_handles_root
@@ -741,6 +883,12 @@ class FakeFSTest < Test::Unit::TestCase
     assert_equal 2, yielded.size
   end
 
+  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"
@@ -783,19 +931,16 @@ class FakeFSTest < Test::Unit::TestCase
     assert_equal 1, fp.pos
   end
 
-  # Every method in File is in FakeFS::File
-  RealFile.instance_methods.each do |method_name|
-    define_method "test_should_have_method_#{method_name}_from_real_file_class" do
-      assert File.instance_methods.include?(method_name)
+  def test_every_method_in_file_is_in_fake_fs_file
+    RealFile.instance_methods.each do |method_name|
+      assert File.instance_methods.include?(method_name), "#{method_name} method is not available in File :("
     end
   end
 
-  # No methods which are in StringIO that aren't in File are included into
-  # FakeFS::File (because of inheritence)
-  uniq_string_io_methods = StringIO.instance_methods - RealFile.instance_methods
-  uniq_string_io_methods.each do |method_name|
-    define_method "test_file_should_not_respond_to_#{method_name}" do
-      assert !File.instance_methods.include?(method_name)
+  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}"
     end
   end
 
@@ -808,14 +953,14 @@ class FakeFSTest < Test::Unit::TestCase
     # I know memes!
     FileUtils.mkdir_p '/path'
     assert_equal '/', FileSystem.fs.name
-    assert_equal({}, FileSystem.fs['path'])
+    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(['foo', 'foobar'], FileSystem.fs['path'].keys.sort)
+    assert_equal(['/path/foo', '/path/foobar'], Dir.glob('/path/*').sort)
 
     c = nil
     Dir.chdir '/path' do
@@ -832,16 +977,16 @@ class FakeFSTest < Test::Unit::TestCase
       File.open('foo', 'w') { |f| f.write 'foo'}
       File.open('/foobar', 'w') { |f| f.write 'foo'}
     end
-    assert_equal ['foo'], FileSystem.fs['path'].keys.sort
-    assert_equal ['foobar', 'path'], FileSystem.fs.keys.sort
+    assert_equal ['/path/foo'], Dir.glob('/path/*').sort
+    assert_equal ['/foobar', '/path'], Dir.glob('/*').sort
 
     Dir.chdir '/path' do
       FileUtils.rm('foo')
       FileUtils.rm('/foobar')
     end
 
-    assert_equal [], FileSystem.fs['path'].keys.sort
-    assert_equal ['path'], FileSystem.fs.keys.sort
+    assert_equal [], Dir.glob('/path/*').sort
+    assert_equal ['/path'], Dir.glob('/*').sort
   end
 
   def test_chdir_should_be_nestable
@@ -853,8 +998,8 @@ class FakeFSTest < Test::Unit::TestCase
       end
     end
 
-    assert_equal ['foo','me'], FileSystem.fs['path'].keys.sort
-    assert_equal ['foobar'], FileSystem.fs['path']['me'].keys.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_flop_over_and_die_if_the_dir_doesnt_exist
@@ -889,23 +1034,23 @@ class FakeFSTest < Test::Unit::TestCase
       assert_equal ['/path'], FileSystem.dir_levels
     end
 
-    assert_equal(['foo', 'foobar'], FileSystem.fs['path'].keys.sort)
+    assert_equal(['/path/foo', '/path/foobar'], Dir.glob('/path/*').sort)
   end
 
   def test_chdir_with_no_block_is_awesome
     FileUtils.mkdir_p '/path'
     Dir.chdir('/path')
     FileUtils.mkdir_p 'subdir'
-    assert_equal ['subdir'], FileSystem.current_dir.keys
+    assert_equal ['subdir'], Dir.glob('*')
     Dir.chdir('subdir')
     File.open('foo', 'w') { |f| f.write 'foo'}
-    assert_equal ['foo'], FileSystem.current_dir.keys
+    assert_equal ['foo'], Dir.glob('*')
 
     assert_raises(Errno::ENOENT) do
       Dir.chdir('subsubdir')
     end
 
-    assert_equal ['foo'], FileSystem.current_dir.keys
+    assert_equal ['foo'], Dir.glob('*')
   end
 
   def test_current_dir_reflected_by_pwd
@@ -985,6 +1130,25 @@ class FakeFSTest < Test::Unit::TestCase
     assert_equal 'bar', File.read('baz/foo')
   end
 
+  def test_cp_array_of_files_into_directory
+    File.open('foo', 'w') { |f| f.write 'footext' }
+    File.open('bar', 'w') { |f| f.write 'bartext' }
+    FileUtils.mkdir_p 'destdir'
+    FileUtils.cp(%w(foo bar), 'destdir')
+
+    assert_equal 'footext', File.read('destdir/foo')
+    assert_equal 'bartext', File.read('destdir/bar')
+  end
+
+  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
+      FileUtils.cp(%w(foo), 'baz')
+    end
+    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' }
@@ -1042,6 +1206,26 @@ class FakeFSTest < Test::Unit::TestCase
     end
   end
 
+  def test_cp_r_array_of_files
+    FileUtils.mkdir_p 'subdir'
+    File.open('foo', 'w') { |f| f.write 'footext' }
+    File.open('bar', 'w') { |f| f.write 'bartext' }
+    FileUtils.cp_r(%w(foo bar), 'subdir')
+
+    assert_equal 'footext', File.open('subdir/foo') { |f| f.read }
+    assert_equal 'bartext', File.open('subdir/bar') { |f| f.read }
+  end
+
+  def test_cp_r_array_of_directories
+    %w(foo bar subdir).each { |d| FileUtils.mkdir_p d }
+    File.open('foo/baz', 'w') { |f| f.write 'baztext' }
+    File.open('bar/quux', 'w') { |f| f.write 'quuxtext' }
+
+    FileUtils.cp_r(%w(foo bar), 'subdir')
+    assert_equal 'baztext', File.open('subdir/foo/baz') { |f| f.read }
+    assert_equal 'quuxtext', File.open('subdir/bar/quux') { |f| f.read }
+  end
+
   def test_cp_r_only_copies_into_directories
     FileUtils.mkdir_p 'subdir'
     Dir.chdir('subdir') { File.open('foo', 'w') { |f| f.write 'footext' } }
@@ -1081,34 +1265,49 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_clone_clones_directories
-    FakeFS.deactivate!
-    RealFileUtils.mkdir_p(here('subdir'))
-    FakeFS.activate!
+    act_on_real_fs { RealFileUtils.mkdir_p(here('subdir')) }
 
     FileSystem.clone(here('subdir'))
 
     assert File.exists?(here('subdir')), 'subdir was cloned'
     assert File.directory?(here('subdir')), 'subdir is a directory'
   ensure
-    FakeFS.deactivate!
-    RealFileUtils.rm_rf(here('subdir'))
-    FakeFS.activate!
+    act_on_real_fs { RealFileUtils.rm_rf(here('subdir')) }
   end
 
   def test_clone_clones_dot_files_even_hard_to_find_ones
-    FakeFS.deactivate!
-    RealFileUtils.mkdir_p(here('subdir/.bar/baz/.quux/foo'))
-    FakeFS.activate!
+    act_on_real_fs { RealFileUtils.mkdir_p(here('subdir/.bar/baz/.quux/foo')) }
 
     assert !File.exists?(here('subdir'))
 
     FileSystem.clone(here('subdir'))
-    assert_equal ['.bar'], FileSystem.find(here('subdir')).keys
-    assert_equal ['foo'], FileSystem.find(here('subdir/.bar/baz/.quux')).keys
+    assert_equal ['.', '..', '.bar'], Dir.entries(here('subdir'))
+    assert_equal ['.', '..', 'foo'], Dir.entries(here('subdir/.bar/baz/.quux'))
   ensure
-    FakeFS.deactivate!
-    RealFileUtils.rm_rf(here('subdir'))
-    FakeFS.activate!
+    act_on_real_fs { RealFileUtils.rm_rf(here('subdir')) }
+  end
+
+  def test_dir_glob_on_clone_with_absolute_path
+    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/*"
+  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')) }
+
+    assert !File.exists?(here('subdir'))
+
+    FileSystem.clone(here('subdir'), here('subdir2'))
+    assert !File.exists?(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')) }
   end
 
   def test_putting_a_dot_at_end_copies_the_contents
@@ -1413,6 +1612,29 @@ class FakeFSTest < Test::Unit::TestCase
     assert File.exists?('/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")
+  end
+
+  def test_can_create_subdirectories_with_dir_mkdir
+    Dir.mkdir 'foo'
+    Dir.mkdir 'foo/bar'
+    assert Dir.exists?('foo/bar')
+  end
+
+  def test_can_create_absolute_subdirectories_with_dir_mkdir
+    Dir.mkdir '/foo'
+    Dir.mkdir '/foo/bar'
+    assert Dir.exists?('/foo/bar')
+  end
+
+  def test_can_create_directories_starting_with_dot
+    Dir.mkdir './path'
+    assert File.exists? './path'
+  end
+
   def test_directory_mkdir_relative
     FileUtils.mkdir_p('/new/root')
     FileSystem.chdir('/new/root')
@@ -1623,7 +1845,7 @@ class FakeFSTest < Test::Unit::TestCase
     File.link("/foo", "/bar")
 
     File.unlink("/bar")
-    File.read("/foo") == "some_content"
+    assert_equal "some_content", File.read("/foo")
   end
 
   def test_link_reports_correct_stat_info_after_unlinking
@@ -1774,6 +1996,80 @@ class FakeFSTest < Test::Unit::TestCase
     assert_equal filename, "expect.txt"
   end
 
+  #########################
+  def test_file_default_mode
+    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)
+  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
+  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
+  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
+  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
+  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
+  end
+
+  def test_file_umask
+    assert_equal File.umask, RealFile.umask
+  end
+
+  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")
+
+    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
+
+    assert same1.mtime == same2.mtime
+    assert different1.mtime != different2.mtime
+
+    assert same1.stat == same2.stat
+    assert (same1.stat <=> same2.stat) == 0
+
+    assert different1.stat != different2.stat
+    assert (different1.stat <=> different2.stat) == -1
+  end
 
   def here(fname)
     RealFile.expand_path(File.join(RealFile.dirname(__FILE__), fname))
@@ -1810,4 +2106,14 @@ class FakeFSTest < Test::Unit::TestCase
       end
     end
   end
+
+  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
+      end
+    end
+  end
 end