* test/ruby/test_file_exhaustive.rb: Create sample files lazily.

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@50226 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

1 files changed, 363 insertions, 330 deletions

diff --git a/test/ruby/test_file_exhaustive.rb b/test/ruby/test_file_exhaustive.rb
index ae76507cef..6027f46243 100644
--- a/test/ruby/test_file_exhaustive.rb
+++ b/test/ruby/test_file_exhaustive.rb
@@ -15,51 +15,102 @@ class TestFileExhaustive < Test::Unit::TestCase
 
   def setup
     @dir = Dir.mktmpdir("rubytest-file")
-    @rootdir = "#{DRIVE}/"
     File.chown(-1, Process.gid, @dir)
-    @file = make_tmp_filename("file")
-    @zerofile = make_tmp_filename("zerofile")
+  end
+
+  def teardown
+    GC.start
+    FileUtils.remove_entry_secure @dir
+  end
+
+  def make_tmp_filename(prefix)
+    "#{@dir}/#{prefix}.test"
+  end
+
+  def rootdir
+    return @rootdir if defined? @rootdir
+    @rootdir = "#{DRIVE}/"
+    @rootdir
+  end
+
+  def nofile
+    return @nofile if defined? @nofile
     @nofile = make_tmp_filename("nofile")
-    @symlinkfile = make_tmp_filename("symlinkfile")
-    @hardlinkfile = make_tmp_filename("hardlinkfile")
-    make_file("foo", @file)
+    @nofile
+  end
+
+  def make_file(content, file)
+    open(file, "w") {|fh| fh << content }
+  end
+
+  def zerofile
+    return @zerofile if defined? @zerofile
+    @zerofile = make_tmp_filename("zerofile")
     make_file("", @zerofile)
-    @chardev = File::NULL == "/dev/null" ? "/dev/null" : nil
-    @time = Time.now
+    @zerofile
+  end
+
+  def regular_file
+    return @file if defined? @file
+    @file = make_tmp_filename("file")
+    make_file("foo", @file)
+    @file
+  end
+
+  def symlinkfile
+    return @symlinkfile if @symlinkfile
+    @symlinkfile = make_tmp_filename("symlinkfile")
     begin
-      File.symlink(@file, @symlinkfile)
+      File.symlink(regular_file, @symlinkfile)
     rescue NotImplementedError
       @symlinkfile = nil
     end
+    @symlinkfile
+  end
+
+  def hardlinkfile
+    return @hardlinkfile if defined? @hardlinkfile
+    @hardlinkfile = make_tmp_filename("hardlinkfile")
     begin
-      File.link(@file, @hardlinkfile)
+      File.link(regular_file, @hardlinkfile)
     rescue NotImplementedError, Errno::EINVAL	# EINVAL for Windows Vista
       @hardlinkfile = nil
     end
+    @hardlinkfile
   end
 
-  def teardown
-    GC.start
-    FileUtils.remove_entry_secure @dir
-  end
-
-  def make_file(content, file = @file)
-    open(file, "w") {|fh| fh << content }
+  def fifo
+    return @fifo if defined? @fifo
+    if /mswin|mingw|bccwin/ !~ RUBY_PLATFORM
+      fn = make_tmp_filename("fifo")
+      system("mkfifo", fn)
+      assert $?.success?, "mkfifo fails"
+      @fifo = fn
+    else
+      @fifo = nil
+    end
+    @fifo
   end
 
-  if /mswin|mingw|bccwin/ !~ RUBY_PLATFORM
-    def make_fifo(file)
-      system("mkfifo", file)
-      assert $?.success?, "mkfifo fails"
+  def socket
+    return @socket if defined? @socket
+    if defined? UNIXServer
+      socket = make_tmp_filename("s")
+      UNIXServer.open(socket).close
+      @socket = socket
+    else
+      @socket = nil
     end
   end
 
-  def make_tmp_filename(prefix)
-    "#{@dir}/#{prefix}.test"
+  def chardev
+    return @chardev if defined? @chardev
+    @chardev = File::NULL == "/dev/null" ? "/dev/null" : nil
+    @chardev
   end
 
   def test_path
-    file = @file
+    file = regular_file
 
     assert_equal(file, File.open(file) {|f| f.path})
     assert_equal(file, File.path(file))
@@ -84,9 +135,12 @@ class TestFileExhaustive < Test::Unit::TestCase
   end
 
   def test_stat
-    sleep(@time - Time.now + 1.1)
-    make_file("foo", @file + "2")
-    fs1, fs2 = File.stat(@file), File.stat(@file + "2")
+    hardlinkfile
+    fn1 = regular_file
+    sleep(1.1)
+    fn2 = fn1 + "2"
+    make_file("foo", fn2)
+    fs1, fs2 = File.stat(fn1), File.stat(fn2)
     assert_nothing_raised do
       assert_equal(0, fs1 <=> fs1)
       assert_equal(-1, fs1 <=> fs2)
@@ -103,7 +157,7 @@ class TestFileExhaustive < Test::Unit::TestCase
       unless /emx|mswin|mingw/ =~ RUBY_PLATFORM
         # on Windows, nlink is always 1. but this behavior will be changed
         # in the future.
-        assert_equal(@hardlinkfile ? 2 : 1, fs1.nlink)
+        assert_equal(hardlinkfile ? 2 : 1, fs1.nlink)
       end
       assert_integer(fs1.uid)
       assert_integer(fs1.gid)
@@ -115,10 +169,10 @@ class TestFileExhaustive < Test::Unit::TestCase
       assert_kind_of(Time, fs1.ctime)
       assert_kind_of(String, fs1.inspect)
     end
-    assert_raise(Errno::ENOENT) { File.stat(@nofile) }
-    assert_kind_of(File::Stat, File.open(@file) {|f| f.stat})
-    assert_raise(Errno::ENOENT) { File.lstat(@nofile) }
-    assert_kind_of(File::Stat, File.open(@file) {|f| f.lstat})
+    assert_raise(Errno::ENOENT) { File.stat(nofile) }
+    assert_kind_of(File::Stat, File.open(fn1) {|f| f.stat})
+    assert_raise(Errno::ENOENT) { File.lstat(nofile) }
+    assert_kind_of(File::Stat, File.open(fn1) {|f| f.lstat})
   end
 
   def test_stat_drive_root
@@ -146,254 +200,245 @@ class TestFileExhaustive < Test::Unit::TestCase
   def test_directory_p
     assert_file.directory?(@dir)
     assert_file.not_directory?(@dir+"/...")
-    assert_file.not_directory?(@file)
-    assert_file.not_directory?(@nofile)
+    assert_file.not_directory?(regular_file)
+    assert_file.not_directory?(nofile)
   end
 
   def test_pipe_p
     assert_file.not_pipe?(@dir)
-    assert_file.not_pipe?(@file)
-    assert_file.not_pipe?(@nofile)
-    if self.respond_to? :make_fifo
-      fifo = make_tmp_filename("fifo")
-      make_fifo fifo
-      assert_file.pipe?(fifo)
-    end
+    assert_file.not_pipe?(regular_file)
+    assert_file.not_pipe?(nofile)
+    assert_file.pipe?(fifo) if fifo
   end
 
   def test_symlink_p
     assert_file.not_symlink?(@dir)
-    assert_file.not_symlink?(@file)
-    assert_file.symlink?(@symlinkfile) if @symlinkfile
-    assert_file.not_symlink?(@hardlinkfile) if @hardlinkfile
-    assert_file.not_symlink?(@nofile)
+    assert_file.not_symlink?(regular_file)
+    assert_file.symlink?(symlinkfile) if symlinkfile
+    assert_file.not_symlink?(hardlinkfile) if hardlinkfile
+    assert_file.not_symlink?(nofile)
   end
 
   def test_socket_p
     assert_file.not_socket?(@dir)
-    assert_file.not_socket?(@file)
-    assert_file.not_socket?(@nofile)
-    if defined? UNIXServer
-      socket = make_tmp_filename("s")
-      UNIXServer.open(socket) {|sock|
-        assert_file.socket?(socket)
-      }
-    end
+    assert_file.not_socket?(regular_file)
+    assert_file.not_socket?(nofile)
+    assert_file.socket?(socket) if socket
   end
 
   def test_blockdev_p ## xxx
     assert_file.not_blockdev?(@dir)
-    assert_file.not_blockdev?(@file)
-    assert_file.not_blockdev?(@nofile)
+    assert_file.not_blockdev?(regular_file)
+    assert_file.not_blockdev?(nofile)
   end
 
   def test_chardev_p
     assert_file.not_chardev?(@dir)
-    assert_file.not_chardev?(@file)
-    assert_file.not_chardev?(@nofile)
-    assert_file.chardev?(@chardev) if @chardev
+    assert_file.not_chardev?(regular_file)
+    assert_file.not_chardev?(nofile)
+    assert_file.chardev?(chardev) if chardev
   end
 
   def test_exist_p
     assert_file.exist?(@dir)
-    assert_file.exist?(@file)
-    assert_file.not_exist?(@nofile)
+    assert_file.exist?(regular_file)
+    assert_file.not_exist?(nofile)
   end
 
   def test_readable_p
     return if /cygwin|mswin|bccwin|mingw|emx/ =~ RUBY_PLATFORM
     return if Process.euid == 0
-    File.chmod(0200, @file)
-    assert_file.not_readable?(@file)
-    File.chmod(0600, @file)
-    assert_file.readable?(@file)
-    assert_file.not_readable?(@nofile)
+    File.chmod(0200, regular_file)
+    assert_file.not_readable?(regular_file)
+    File.chmod(0600, regular_file)
+    assert_file.readable?(regular_file)
+    assert_file.not_readable?(nofile)
   end
 
   def test_readable_real_p
     return if /cygwin|mswin|bccwin|mingw|emx/ =~ RUBY_PLATFORM
     return if Process.euid == 0
-    File.chmod(0200, @file)
-    assert_file.not_readable_real?(@file)
-    File.chmod(0600, @file)
-    assert_file.readable_real?(@file)
-    assert_file.not_readable_real?(@nofile)
+    File.chmod(0200, regular_file)
+    assert_file.not_readable_real?(regular_file)
+    File.chmod(0600, regular_file)
+    assert_file.readable_real?(regular_file)
+    assert_file.not_readable_real?(nofile)
   end
 
   def test_world_readable_p
     return if /cygwin|mswin|bccwin|mingw|emx/ =~ RUBY_PLATFORM
-    File.chmod(0006, @file)
-    assert_file.world_readable?(@file)
-    File.chmod(0060, @file)
-    assert_file.not_world_readable?(@file)
-    File.chmod(0600, @file)
-    assert_file.not_world_readable?(@file)
-    assert_file.not_world_readable?(@nofile)
+    File.chmod(0006, regular_file)
+    assert_file.world_readable?(regular_file)
+    File.chmod(0060, regular_file)
+    assert_file.not_world_readable?(regular_file)
+    File.chmod(0600, regular_file)
+    assert_file.not_world_readable?(regular_file)
+    assert_file.not_world_readable?(nofile)
   end
 
   def test_writable_p
     return if /cygwin|mswin|bccwin|mingw|emx/ =~ RUBY_PLATFORM
     return if Process.euid == 0
-    File.chmod(0400, @file)
-    assert_file.not_writable?(@file)
-    File.chmod(0600, @file)
-    assert_file.writable?(@file)
-    assert_file.not_writable?(@nofile)
+    File.chmod(0400, regular_file)
+    assert_file.not_writable?(regular_file)
+    File.chmod(0600, regular_file)
+    assert_file.writable?(regular_file)
+    assert_file.not_writable?(nofile)
   end
 
   def test_writable_real_p
     return if /cygwin|mswin|bccwin|mingw|emx/ =~ RUBY_PLATFORM
     return if Process.euid == 0
-    File.chmod(0400, @file)
-    assert_file.not_writable_real?(@file)
-    File.chmod(0600, @file)
-    assert_file.writable_real?(@file)
-    assert_file.not_writable_real?(@nofile)
+    File.chmod(0400, regular_file)
+    assert_file.not_writable_real?(regular_file)
+    File.chmod(0600, regular_file)
+    assert_file.writable_real?(regular_file)
+    assert_file.not_writable_real?(nofile)
   end
 
   def test_world_writable_p
     return if /cygwin|mswin|bccwin|mingw|emx/ =~ RUBY_PLATFORM
-    File.chmod(0006, @file)
-    assert_file.world_writable?(@file)
-    File.chmod(0060, @file)
-    assert_file.not_world_writable?(@file)
-    File.chmod(0600, @file)
-    assert_file.not_world_writable?(@file)
-    assert_file.not_world_writable?(@nofile)
+    File.chmod(0006, regular_file)
+    assert_file.world_writable?(regular_file)
+    File.chmod(0060, regular_file)
+    assert_file.not_world_writable?(regular_file)
+    File.chmod(0600, regular_file)
+    assert_file.not_world_writable?(regular_file)
+    assert_file.not_world_writable?(nofile)
   end
 
   def test_executable_p
     return if /cygwin|mswin|bccwin|mingw|emx/ =~ RUBY_PLATFORM
-    File.chmod(0100, @file)
-    assert_file.executable?(@file)
-    File.chmod(0600, @file)
-    assert_file.not_executable?(@file)
-    assert_file.not_executable?(@nofile)
+    File.chmod(0100, regular_file)
+    assert_file.executable?(regular_file)
+    File.chmod(0600, regular_file)
+    assert_file.not_executable?(regular_file)
+    assert_file.not_executable?(nofile)
   end
 
   def test_executable_real_p
     return if /cygwin|mswin|bccwin|mingw|emx/ =~ RUBY_PLATFORM
-    File.chmod(0100, @file)
-    assert_file.executable_real?(@file)
-    File.chmod(0600, @file)
-    assert_file.not_executable_real?(@file)
-    assert_file.not_executable_real?(@nofile)
+    File.chmod(0100, regular_file)
+    assert_file.executable_real?(regular_file)
+    File.chmod(0600, regular_file)
+    assert_file.not_executable_real?(regular_file)
+    assert_file.not_executable_real?(nofile)
   end
 
   def test_file_p
     assert_file.not_file?(@dir)
-    assert_file.file?(@file)
-    assert_file.not_file?(@nofile)
+    assert_file.file?(regular_file)
+    assert_file.not_file?(nofile)
   end
 
   def test_zero_p
     assert_nothing_raised { File.zero?(@dir) }
-    assert_file.not_zero?(@file)
-    assert_file.zero?(@zerofile)
-    assert_file.not_zero?(@nofile)
+    assert_file.not_zero?(regular_file)
+    assert_file.zero?(zerofile)
+    assert_file.not_zero?(nofile)
   end
 
   def test_size_p
     assert_nothing_raised { File.size?(@dir) }
-    assert_equal(3, File.size?(@file))
-    assert_file.not_size?(@zerofile)
-    assert_file.not_size?(@nofile)
+    assert_equal(3, File.size?(regular_file))
+    assert_file.not_size?(zerofile)
+    assert_file.not_size?(nofile)
   end
 
   def test_owned_p ## xxx
     return if /cygwin|mswin|bccwin|mingw|emx/ =~ RUBY_PLATFORM
-    assert_file.owned?(@file)
-    assert_file.grpowned?(@file)
+    assert_file.owned?(regular_file)
+    assert_file.grpowned?(regular_file)
   end
 
   def test_suid_sgid_sticky ## xxx
-    assert_file.not_setuid?(@file)
-    assert_file.not_setgid?(@file)
-    assert_file.not_sticky?(@file)
+    assert_file.not_setuid?(regular_file)
+    assert_file.not_setgid?(regular_file)
+    assert_file.not_sticky?(regular_file)
   end
 
   def test_path_identical_p
-    assert_file.identical?(@file, @file)
-    assert_file.not_identical?(@file, @zerofile)
-    assert_file.not_identical?(@file, @nofile)
-    assert_file.not_identical?(@nofile, @file)
+    assert_file.identical?(regular_file, regular_file)
+    assert_file.not_identical?(regular_file, zerofile)
+    assert_file.not_identical?(regular_file, nofile)
+    assert_file.not_identical?(nofile, regular_file)
   end
 
   def test_io_identical_p
-    open(@file) {|f|
+    open(regular_file) {|f|
       assert_file.identical?(f, f)
-      assert_file.identical?(@file, f)
-      assert_file.identical?(f, @file)
+      assert_file.identical?(regular_file, f)
+      assert_file.identical?(f, regular_file)
     }
   end
 
   def test_closed_io_identical_p
-    io = open(@file) {|f| f}
+    io = open(regular_file) {|f| f}
     assert_raise(IOError) {
-      File.identical?(@file, io)
+      File.identical?(regular_file, io)
     }
-    File.unlink(@file)
-    assert_file.not_exist?(@file)
+    File.unlink(regular_file)
+    assert_file.not_exist?(regular_file)
   end
 
   def test_s_size
     assert_integer(File.size(@dir))
-    assert_equal(3, File.size(@file))
-    assert_equal(0, File.size(@zerofile))
-    assert_raise(Errno::ENOENT) { File.size(@nofile) }
+    assert_equal(3, File.size(regular_file))
+    assert_equal(0, File.size(zerofile))
+    assert_raise(Errno::ENOENT) { File.size(nofile) }
   end
 
   def test_ftype
     assert_equal("directory", File.ftype(@dir))
-    assert_equal("file", File.ftype(@file))
-    assert_equal("link", File.ftype(@symlinkfile)) if @symlinkfile
-    assert_equal("file", File.ftype(@hardlinkfile)) if @hardlinkfile
-    assert_raise(Errno::ENOENT) { File.ftype(@nofile) }
+    assert_equal("file", File.ftype(regular_file))
+    assert_equal("link", File.ftype(symlinkfile)) if symlinkfile
+    assert_equal("file", File.ftype(hardlinkfile)) if hardlinkfile
+    assert_raise(Errno::ENOENT) { File.ftype(nofile) }
   end
 
   def test_atime
-    t1 = File.atime(@file)
-    t2 = File.open(@file) {|f| f.atime}
+    t1 = File.atime(regular_file)
+    t2 = File.open(regular_file) {|f| f.atime}
     assert_kind_of(Time, t1)
     assert_kind_of(Time, t2)
     assert_equal(t1, t2)
-    assert_raise(Errno::ENOENT) { File.atime(@nofile) }
+    assert_raise(Errno::ENOENT) { File.atime(nofile) }
   end
 
   def test_mtime
-    t1 = File.mtime(@file)
-    t2 = File.open(@file) {|f| f.mtime}
+    t1 = File.mtime(regular_file)
+    t2 = File.open(regular_file) {|f| f.mtime}
     assert_kind_of(Time, t1)
     assert_kind_of(Time, t2)
     assert_equal(t1, t2)
-    assert_raise(Errno::ENOENT) { File.mtime(@nofile) }
+    assert_raise(Errno::ENOENT) { File.mtime(nofile) }
   end
 
   def test_ctime
-    t1 = File.ctime(@file)
-    t2 = File.open(@file) {|f| f.ctime}
+    t1 = File.ctime(regular_file)
+    t2 = File.open(regular_file) {|f| f.ctime}
     assert_kind_of(Time, t1)
     assert_kind_of(Time, t2)
     assert_equal(t1, t2)
-    assert_raise(Errno::ENOENT) { File.ctime(@nofile) }
+    assert_raise(Errno::ENOENT) { File.ctime(nofile) }
   end
 
   def test_chmod
     return if /cygwin|mswin|bccwin|mingw|emx/ =~ RUBY_PLATFORM
-    assert_equal(1, File.chmod(0444, @file))
-    assert_equal(0444, File.stat(@file).mode % 01000)
-    assert_equal(0, File.open(@file) {|f| f.chmod(0222)})
-    assert_equal(0222, File.stat(@file).mode % 01000)
-    File.chmod(0600, @file)
-    assert_raise(Errno::ENOENT) { File.chmod(0600, @nofile) }
+    assert_equal(1, File.chmod(0444, regular_file))
+    assert_equal(0444, File.stat(regular_file).mode % 01000)
+    assert_equal(0, File.open(regular_file) {|f| f.chmod(0222)})
+    assert_equal(0222, File.stat(regular_file).mode % 01000)
+    File.chmod(0600, regular_file)
+    assert_raise(Errno::ENOENT) { File.chmod(0600, nofile) }
   end
 
   def test_lchmod
     return if /cygwin|mswin|bccwin|mingw|emx/ =~ RUBY_PLATFORM
-    assert_equal(1, File.lchmod(0444, @file))
-    assert_equal(0444, File.stat(@file).mode % 01000)
-    File.lchmod(0600, @file)
-    assert_raise(Errno::ENOENT) { File.lchmod(0600, @nofile) }
+    assert_equal(1, File.lchmod(0444, regular_file))
+    assert_equal(0444, File.stat(regular_file).mode % 01000)
+    File.lchmod(0600, regular_file)
+    assert_raise(Errno::ENOENT) { File.lchmod(0600, nofile) }
   rescue NotImplementedError
   end
 
@@ -404,39 +449,39 @@ class TestFileExhaustive < Test::Unit::TestCase
   end
 
   def test_symlink
-    return unless @symlinkfile
-    assert_equal("link", File.ftype(@symlinkfile))
-    assert_raise(Errno::EEXIST) { File.symlink(@file, @file) }
+    return unless symlinkfile
+    assert_equal("link", File.ftype(symlinkfile))
+    assert_raise(Errno::EEXIST) { File.symlink(regular_file, regular_file) }
   end
 
   def test_utime
     t = Time.local(2000)
-    File.utime(t + 1, t + 2, @zerofile)
-    assert_equal(t + 1, File.atime(@zerofile))
-    assert_equal(t + 2, File.mtime(@zerofile))
+    File.utime(t + 1, t + 2, zerofile)
+    assert_equal(t + 1, File.atime(zerofile))
+    assert_equal(t + 2, File.mtime(zerofile))
   end
 
   def test_hardlink
-    return unless @hardlinkfile
-    assert_equal("file", File.ftype(@hardlinkfile))
-    assert_raise(Errno::EEXIST) { File.link(@file, @file) }
+    return unless hardlinkfile
+    assert_equal("file", File.ftype(hardlinkfile))
+    assert_raise(Errno::EEXIST) { File.link(regular_file, regular_file) }
   end
 
   def test_readlink
-    return unless @symlinkfile
-    assert_equal(@file, File.readlink(@symlinkfile))
-    assert_raise(Errno::EINVAL) { File.readlink(@file) }
-    assert_raise(Errno::ENOENT) { File.readlink(@nofile) }
+    return unless symlinkfile
+    assert_equal(regular_file, File.readlink(symlinkfile))
+    assert_raise(Errno::EINVAL) { File.readlink(regular_file) }
+    assert_raise(Errno::ENOENT) { File.readlink(nofile) }
     if fs = Encoding.find("filesystem")
-      assert_equal(fs, File.readlink(@symlinkfile).encoding)
+      assert_equal(fs, File.readlink(symlinkfile).encoding)
     end
   rescue NotImplementedError
   end
 
   def test_readlink_long_path
-    return unless @symlinkfile
+    return unless symlinkfile
     bug9157 = '[ruby-core:58592] [Bug #9157]'
-    assert_separately(["-", @symlinkfile, bug9157], <<-"end;")
+    assert_separately(["-", symlinkfile, bug9157], <<-"end;")
       symlinkfile, bug9157 = *ARGV
       100.step(1000, 100) do |n|
         File.unlink(symlinkfile)
@@ -452,50 +497,50 @@ class TestFileExhaustive < Test::Unit::TestCase
   end
 
   def test_unlink
-    assert_equal(1, File.unlink(@file))
-    make_file("foo", @file)
-    assert_raise(Errno::ENOENT) { File.unlink(@nofile) }
+    assert_equal(1, File.unlink(regular_file))
+    make_file("foo", regular_file)
+    assert_raise(Errno::ENOENT) { File.unlink(nofile) }
   end
 
   def test_rename
-    assert_equal(0, File.rename(@file, @nofile))
-    assert_file.not_exist?(@file)
-    assert_file.exist?(@nofile)
-    assert_equal(0, File.rename(@nofile, @file))
-    assert_raise(Errno::ENOENT) { File.rename(@nofile, @file) }
+    assert_equal(0, File.rename(regular_file, nofile))
+    assert_file.not_exist?(regular_file)
+    assert_file.exist?(nofile)
+    assert_equal(0, File.rename(nofile, regular_file))
+    assert_raise(Errno::ENOENT) { File.rename(nofile, regular_file) }
   end
 
   def test_umask
     return if /cygwin|mswin|bccwin|mingw|emx/ =~ RUBY_PLATFORM
     prev = File.umask(0777)
     assert_equal(0777, File.umask)
-    open(@nofile, "w") { }
-    assert_equal(0, File.stat(@nofile).mode % 01000)
-    File.unlink(@nofile)
+    open(nofile, "w") { }
+    assert_equal(0, File.stat(nofile).mode % 01000)
+    File.unlink(nofile)
     assert_equal(0777, File.umask(prev))
     assert_raise(ArgumentError) { File.umask(0, 1, 2) }
   end
 
   def test_expand_path
-    assert_equal(@file, File.expand_path(File.basename(@file), File.dirname(@file)))
+    assert_equal(regular_file, File.expand_path(File.basename(regular_file), File.dirname(regular_file)))
     case RUBY_PLATFORM
     when /cygwin|mingw|mswin|bccwin/
-      assert_equal(@file, File.expand_path(@file + " "))
-      assert_equal(@file, File.expand_path(@file + "."))
-      assert_equal(@file, File.expand_path(@file + "::$DATA"))
+      assert_equal(regular_file, File.expand_path(regular_file + " "))
+      assert_equal(regular_file, File.expand_path(regular_file + "."))
+      assert_equal(regular_file, File.expand_path(regular_file + "::$DATA"))
       assert_match(/\Ac:\//i, File.expand_path('c:'), '[ruby-core:31591]')
       assert_match(/\Ac:\//i, File.expand_path('c:foo', 'd:/bar'))
       assert_match(/\Ae:\//i, File.expand_path('e:foo', 'd:/bar'))
       assert_match(%r'\Ac:/bar/foo\z'i, File.expand_path('c:foo', 'c:/bar'))
     when /darwin/
       ["\u{feff}", *"\u{2000}"..."\u{2100}"].each do |c|
-        file = @file + c
+        file = regular_file + c
         begin
           open(file) {}
         rescue
           assert_equal(file, File.expand_path(file), c.dump)
         else
-          assert_equal(@file, File.expand_path(file), c.dump)
+          assert_equal(regular_file, File.expand_path(file), c.dump)
         end
       end
     end
@@ -629,9 +674,9 @@ class TestFileExhaustive < Test::Unit::TestCase
 
 
   def test_expand_path_remove_trailing_alternative_data
-    assert_equal File.join(@rootdir, "aaa"), File.expand_path("#{@rootdir}/aaa::$DATA")
-    assert_equal File.join(@rootdir, "aa:a"), File.expand_path("#{@rootdir}/aa:a:$DATA")
-    assert_equal File.join(@rootdir, "aaa:$DATA"), File.expand_path("#{@rootdir}/aaa:$DATA")
+    assert_equal File.join(rootdir, "aaa"), File.expand_path("#{rootdir}/aaa::$DATA")
+    assert_equal File.join(rootdir, "aa:a"), File.expand_path("#{rootdir}/aa:a:$DATA")
+    assert_equal File.join(rootdir, "aaa:$DATA"), File.expand_path("#{rootdir}/aaa:$DATA")
   end if DRIVE
 
   def test_expand_path_resolve_empty_string_current_directory
@@ -675,20 +720,20 @@ class TestFileExhaustive < Test::Unit::TestCase
     assert_equal(@dir, File.expand_path("", "#{@dir}"))
     assert_equal(File.join(@dir, "a"), File.expand_path("a", "#{@dir}"))
     assert_equal(File.join(@dir, "a"), File.expand_path("../a", "#{@dir}/xxx"))
-    assert_equal(@rootdir, File.expand_path(".", "#{@rootdir}"))
+    assert_equal(rootdir, File.expand_path(".", "#{rootdir}"))
   end
 
   def test_expand_path_ignores_supplied_dir_if_path_contains_a_drive_letter
-    assert_equal(@rootdir, File.expand_path(@rootdir, "D:/"))
+    assert_equal(rootdir, File.expand_path(rootdir, "D:/"))
   end if DRIVE
 
   def test_expand_path_removes_trailing_slashes_from_absolute_path
-    assert_equal(File.join(@rootdir, "foo"), File.expand_path("#{@rootdir}foo/"))
-    assert_equal(File.join(@rootdir, "foo.rb"), File.expand_path("#{@rootdir}foo.rb/"))
+    assert_equal(File.join(rootdir, "foo"), File.expand_path("#{rootdir}foo/"))
+    assert_equal(File.join(rootdir, "foo.rb"), File.expand_path("#{rootdir}foo.rb/"))
   end
 
   def test_expand_path_removes_trailing_spaces_from_absolute_path
-    assert_equal(File.join(@rootdir, "a"), File.expand_path("#{@rootdir}a "))
+    assert_equal(File.join(rootdir, "a"), File.expand_path("#{rootdir}a "))
   end if DRIVE
 
   def test_expand_path_converts_a_pathname_which_starts_with_a_slash_using_dir_s_drive
@@ -841,7 +886,7 @@ class TestFileExhaustive < Test::Unit::TestCase
   end if DRIVE
 
   def test_basename
-    assert_equal(File.basename(@file).sub(/\.test$/, ""), File.basename(@file, ".test"))
+    assert_equal(File.basename(regular_file).sub(/\.test$/, ""), File.basename(regular_file, ".test"))
     assert_equal("", s = File.basename(""))
     assert(!s.frozen?, '[ruby-core:24199]')
     assert_equal("foo", s = File.basename("foo"))
@@ -850,17 +895,17 @@ class TestFileExhaustive < Test::Unit::TestCase
     assert_equal("foo", File.basename("foo.ext", ".ext"))
     assert_equal("foo", File.basename("foo.ext", ".*"))
     if /cygwin|mingw|mswin|bccwin/ =~ RUBY_PLATFORM
-      basename = File.basename(@file)
-      assert_equal(basename, File.basename(@file + " "))
-      assert_equal(basename, File.basename(@file + "."))
-      assert_equal(basename, File.basename(@file + "::$DATA"))
+      basename = File.basename(regular_file)
+      assert_equal(basename, File.basename(regular_file + " "))
+      assert_equal(basename, File.basename(regular_file + "."))
+      assert_equal(basename, File.basename(regular_file + "::$DATA"))
       basename.chomp!(".test")
-      assert_equal(basename, File.basename(@file + " ", ".test"))
-      assert_equal(basename, File.basename(@file + ".", ".test"))
-      assert_equal(basename, File.basename(@file + "::$DATA", ".test"))
-      assert_equal(basename, File.basename(@file + " ", ".*"))
-      assert_equal(basename, File.basename(@file + ".", ".*"))
-      assert_equal(basename, File.basename(@file + "::$DATA", ".*"))
+      assert_equal(basename, File.basename(regular_file + " ", ".test"))
+      assert_equal(basename, File.basename(regular_file + ".", ".test"))
+      assert_equal(basename, File.basename(regular_file + "::$DATA", ".test"))
+      assert_equal(basename, File.basename(regular_file + " ", ".*"))
+      assert_equal(basename, File.basename(regular_file + ".", ".*"))
+      assert_equal(basename, File.basename(regular_file + "::$DATA", ".*"))
     end
     if File::ALT_SEPARATOR == '\\'
       a = "foo/\225\\\\"
@@ -881,7 +926,7 @@ class TestFileExhaustive < Test::Unit::TestCase
   end
 
   def test_dirname
-    assert(@file.start_with?(File.dirname(@file)))
+    assert(regular_file.start_with?(File.dirname(regular_file)))
     assert_equal(".", File.dirname(""))
     assert_incompatible_encoding {|d| File.dirname(d)}
     if File::ALT_SEPARATOR == '\\'
@@ -893,7 +938,7 @@ class TestFileExhaustive < Test::Unit::TestCase
   end
 
   def test_extname
-    assert_equal(".test", File.extname(@file))
+    assert_equal(".test", File.extname(regular_file))
     prefixes = ["", "/", ".", "/.", "bar/.", "/bar/."]
     infixes = ["", " ", "."]
     infixes2 = infixes + [".ext "]
@@ -920,9 +965,9 @@ class TestFileExhaustive < Test::Unit::TestCase
   end
 
   def test_split
-    d, b = File.split(@file)
-    assert_equal(File.dirname(@file), d)
-    assert_equal(File.basename(@file), b)
+    d, b = File.split(regular_file)
+    assert_equal(File.dirname(regular_file), d)
+    assert_equal(File.basename(regular_file), b)
   end
 
   def test_join
@@ -965,31 +1010,31 @@ class TestFileExhaustive < Test::Unit::TestCase
   end
 
   def test_truncate
-    assert_equal(0, File.truncate(@file, 1))
-    assert_file.exist?(@file)
-    assert_equal(1, File.size(@file))
-    assert_equal(0, File.truncate(@file, 0))
-    assert_file.exist?(@file)
-    assert_file.zero?(@file)
-    make_file("foo", @file)
-    assert_raise(Errno::ENOENT) { File.truncate(@nofile, 0) }
-
-    f = File.new(@file, "w")
+    assert_equal(0, File.truncate(regular_file, 1))
+    assert_file.exist?(regular_file)
+    assert_equal(1, File.size(regular_file))
+    assert_equal(0, File.truncate(regular_file, 0))
+    assert_file.exist?(regular_file)
+    assert_file.zero?(regular_file)
+    make_file("foo", regular_file)
+    assert_raise(Errno::ENOENT) { File.truncate(nofile, 0) }
+
+    f = File.new(regular_file, "w")
     assert_equal(0, f.truncate(2))
-    assert_file.exist?(@file)
-    assert_equal(2, File.size(@file))
+    assert_file.exist?(regular_file)
+    assert_equal(2, File.size(regular_file))
     assert_equal(0, f.truncate(0))
-    assert_file.exist?(@file)
-    assert_file.zero?(@file)
+    assert_file.exist?(regular_file)
+    assert_file.zero?(regular_file)
     f.close
-    make_file("foo", @file)
+    make_file("foo", regular_file)
 
-    assert_raise(IOError) { File.open(@file) {|ff| ff.truncate(0)} }
+    assert_raise(IOError) { File.open(regular_file) {|ff| ff.truncate(0)} }
   rescue NotImplementedError
   end
 
   def test_flock ## xxx
-    f = File.new(@file, "r+")
+    f = File.new(regular_file, "r+")
     f.flock(File::LOCK_EX)
     f.flock(File::LOCK_SH)
     f.flock(File::LOCK_UN)
@@ -998,17 +1043,11 @@ class TestFileExhaustive < Test::Unit::TestCase
   end
 
   def test_test
-    sleep(@time - Time.now + 1.1)
-    make_file("foo", @file + "2")
-    if self.respond_to? :make_fifo
-      fifo = make_tmp_filename("fifo")
-      make_fifo fifo
-    end
-    if defined? UNIXServer
-      socket = make_tmp_filename("s")
-      UNIXServer.open(socket).close
-    end
-    [@dir, @file, @zerofile, @symlinkfile, @hardlinkfile, @chardev, fifo, socket].compact.each do |f|
+    fn1 = regular_file
+    sleep(1.1)
+    fn2 = fn1 + "2"
+    make_file("foo", fn2)
+    [@dir, fn1, zerofile, symlinkfile, hardlinkfile, chardev, fifo, socket].compact.each do |f|
       assert_equal(File.atime(f), test(?A, f))
       assert_equal(File.ctime(f), test(?C, f))
       assert_equal(File.mtime(f), test(?M, f))
@@ -1035,28 +1074,31 @@ class TestFileExhaustive < Test::Unit::TestCase
       assert_equal(File.executable_real?(f), test(?X, f))
       assert_equal(File.zero?(f), test(?z, f))
     end
-    assert_equal(false, test(?-, @dir, @file))
-    assert_equal(true, test(?-, @file, @file))
-    assert_equal(true, test(?=, @file, @file))
-    assert_equal(false, test(?>, @file, @file))
-    assert_equal(false, test(?<, @file, @file))
+    assert_equal(false, test(?-, @dir, fn1))
+    assert_equal(true, test(?-, fn1, fn1))
+    assert_equal(true, test(?=, fn1, fn1))
+    assert_equal(false, test(?>, fn1, fn1))
+    assert_equal(false, test(?<, fn1, fn1))
     unless /cygwin/ =~ RUBY_PLATFORM
-      assert_equal(false, test(?=, @file, @file + "2"))
-      assert_equal(false, test(?>, @file, @file + "2"))
-      assert_equal(true, test(?>, @file + "2", @file))
-      assert_equal(true, test(?<, @file, @file + "2"))
-      assert_equal(false, test(?<, @file + "2", @file))
+      assert_equal(false, test(?=, fn1, fn2))
+      assert_equal(false, test(?>, fn1, fn2))
+      assert_equal(true, test(?>, fn2, fn1))
+      assert_equal(true, test(?<, fn1, fn2))
+      assert_equal(false, test(?<, fn2, fn1))
     end
     assert_raise(ArgumentError) { test }
-    assert_raise(Errno::ENOENT) { test(?A, @nofile) }
+    assert_raise(Errno::ENOENT) { test(?A, nofile) }
     assert_raise(ArgumentError) { test(?a) }
     assert_raise(ArgumentError) { test("\0".ord) }
   end
 
   def test_stat_init
-    sleep(@time - Time.now + 1.1)
-    make_file("foo", @file + "2")
-    fs1, fs2 = File::Stat.new(@file), File::Stat.new(@file + "2")
+    hardlinkfile
+    sleep(1.1)
+    fn1 = regular_file
+    fn2 = regular_file + "2"
+    make_file("foo", fn2)
+    fs1, fs2 = File::Stat.new(fn1), File::Stat.new(fn2)
     assert_nothing_raised do
       assert_equal(0, fs1 <=> fs1)
       assert_equal(-1, fs1 <=> fs2)
@@ -1073,7 +1115,7 @@ class TestFileExhaustive < Test::Unit::TestCase
       unless /emx|mswin|mingw/ =~ RUBY_PLATFORM
         # on Windows, nlink is always 1. but this behavior will be changed
         # in the future.
-        assert_equal(@hardlinkfile ? 2 : 1, fs1.nlink)
+        assert_equal(hardlinkfile ? 2 : 1, fs1.nlink)
       end
       assert_integer(fs1.uid)
       assert_integer(fs1.gid)
@@ -1085,34 +1127,30 @@ class TestFileExhaustive < Test::Unit::TestCase
       assert_kind_of(Time, fs1.ctime)
       assert_kind_of(String, fs1.inspect)
     end
-    assert_raise(Errno::ENOENT) { File::Stat.new(@nofile) }
-    assert_kind_of(File::Stat, File::Stat.new(@file).dup)
+    assert_raise(Errno::ENOENT) { File::Stat.new(nofile) }
+    assert_kind_of(File::Stat, File::Stat.new(fn1).dup)
     assert_raise(TypeError) do
-      File::Stat.new(@file).instance_eval { initialize_copy(0) }
+      File::Stat.new(fn1).instance_eval { initialize_copy(0) }
     end
   end
 
   def test_stat_ftype
     assert_equal("directory", File::Stat.new(@dir).ftype)
-    assert_equal("file", File::Stat.new(@file).ftype)
+    assert_equal("file", File::Stat.new(regular_file).ftype)
     # File::Stat uses stat
-    assert_equal("file", File::Stat.new(@symlinkfile).ftype) if @symlinkfile
-    assert_equal("file", File::Stat.new(@hardlinkfile).ftype) if @hardlinkfile
+    assert_equal("file", File::Stat.new(symlinkfile).ftype) if symlinkfile
+    assert_equal("file", File::Stat.new(hardlinkfile).ftype) if hardlinkfile
   end
 
   def test_stat_directory_p
     assert(File::Stat.new(@dir).directory?)
-    assert(!(File::Stat.new(@file).directory?))
+    assert(!(File::Stat.new(regular_file).directory?))
   end
 
   def test_stat_pipe_p
     assert(!(File::Stat.new(@dir).pipe?))
-    assert(!(File::Stat.new(@file).pipe?))
-    if self.respond_to? :make_fifo
-      fifo = make_tmp_filename("fifo")
-      make_fifo fifo
-      assert((File::Stat.new(fifo).pipe?))
-    end
+    assert(!(File::Stat.new(regular_file).pipe?))
+    assert((File::Stat.new(fifo).pipe?)) if fifo
     IO.pipe {|r, w|
       assert(r.stat.pipe?)
       assert(w.stat.pipe?)
@@ -1121,139 +1159,134 @@ class TestFileExhaustive < Test::Unit::TestCase
 
   def test_stat_symlink_p
     assert(!(File::Stat.new(@dir).symlink?))
-    assert(!(File::Stat.new(@file).symlink?))
+    assert(!(File::Stat.new(regular_file).symlink?))
     # File::Stat uses stat
-    assert(!(File::Stat.new(@symlinkfile).symlink?)) if @symlinkfile
-    assert(!(File::Stat.new(@hardlinkfile).symlink?)) if @hardlinkfile
+    assert(!(File::Stat.new(symlinkfile).symlink?)) if symlinkfile
+    assert(!(File::Stat.new(hardlinkfile).symlink?)) if hardlinkfile
   end
 
   def test_stat_socket_p
     assert(!(File::Stat.new(@dir).socket?))
-    assert(!(File::Stat.new(@file).socket?))
-    if defined? UNIXServer
-      socket = make_tmp_filename("s")
-      UNIXServer.open(socket) {|sock|
-        assert(File::Stat.new(socket).socket?)
-      }
-    end
+    assert(!(File::Stat.new(regular_file).socket?))
+    assert(File::Stat.new(socket).socket?)
   end
 
   def test_stat_blockdev_p ## xxx
     assert(!(File::Stat.new(@dir).blockdev?))
-    assert(!(File::Stat.new(@file).blockdev?))
+    assert(!(File::Stat.new(regular_file).blockdev?))
   end
 
   def test_stat_chardev_p ## xxx
     assert(!(File::Stat.new(@dir).chardev?))
-    assert(!(File::Stat.new(@file).chardev?))
-    assert(File::Stat.new(@chardev).chardev?) if @chardev
+    assert(!(File::Stat.new(regular_file).chardev?))
+    assert(File::Stat.new(chardev).chardev?) if chardev
   end
 
   def test_stat_readable_p
     return if /cygwin|mswin|bccwin|mingw|emx/ =~ RUBY_PLATFORM
     return if Process.euid == 0
-    File.chmod(0200, @file)
-    assert(!(File::Stat.new(@file).readable?))
-    File.chmod(0600, @file)
-    assert(File::Stat.new(@file).readable?)
+    File.chmod(0200, regular_file)
+    assert(!(File::Stat.new(regular_file).readable?))
+    File.chmod(0600, regular_file)
+    assert(File::Stat.new(regular_file).readable?)
   end
 
   def test_stat_readable_real_p
     return if /cygwin|mswin|bccwin|mingw|emx/ =~ RUBY_PLATFORM
     return if Process.euid == 0
-    File.chmod(0200, @file)
-    assert(!(File::Stat.new(@file).readable_real?))
-    File.chmod(0600, @file)
-    assert(File::Stat.new(@file).readable_real?)
+    File.chmod(0200, regular_file)
+    assert(!(File::Stat.new(regular_file).readable_real?))
+    File.chmod(0600, regular_file)
+    assert(File::Stat.new(regular_file).readable_real?)
   end
 
   def test_stat_world_readable_p
     return if /cygwin|mswin|bccwin|mingw|emx/ =~ RUBY_PLATFORM
-    File.chmod(0006, @file)
-    assert(File::Stat.new(@file).world_readable?)
-    File.chmod(0060, @file)
-    assert(!(File::Stat.new(@file).world_readable?))
-    File.chmod(0600, @file)
-    assert(!(File::Stat.new(@file).world_readable?))
+    File.chmod(0006, regular_file)
+    assert(File::Stat.new(regular_file).world_readable?)
+    File.chmod(0060, regular_file)
+    assert(!(File::Stat.new(regular_file).world_readable?))
+    File.chmod(0600, regular_file)
+    assert(!(File::Stat.new(regular_file).world_readable?))
   end
 
   def test_stat_writable_p
     return if /cygwin|mswin|bccwin|mingw|emx/ =~ RUBY_PLATFORM
     return if Process.euid == 0
-    File.chmod(0400, @file)
-    assert(!(File::Stat.new(@file).writable?))
-    File.chmod(0600, @file)
-    assert(File::Stat.new(@file).writable?)
+    File.chmod(0400, regular_file)
+    assert(!(File::Stat.new(regular_file).writable?))
+    File.chmod(0600, regular_file)
+    assert(File::Stat.new(regular_file).writable?)
   end
 
   def test_stat_writable_real_p
     return if /cygwin|mswin|bccwin|mingw|emx/ =~ RUBY_PLATFORM
     return if Process.euid == 0
-    File.chmod(0400, @file)
-    assert(!(File::Stat.new(@file).writable_real?))
-    File.chmod(0600, @file)
-    assert(File::Stat.new(@file).writable_real?)
+    File.chmod(0400, regular_file)
+    assert(!(File::Stat.new(regular_file).writable_real?))
+    File.chmod(0600, regular_file)
+    assert(File::Stat.new(regular_file).writable_real?)
   end
 
   def test_stat_world_writable_p
     return if /cygwin|mswin|bccwin|mingw|emx/ =~ RUBY_PLATFORM
-    File.chmod(0006, @file)
-    assert(File::Stat.new(@file).world_writable?)
-    File.chmod(0060, @file)
-    assert(!(File::Stat.new(@file).world_writable?))
-    File.chmod(0600, @file)
-    assert(!(File::Stat.new(@file).world_writable?))
+    File.chmod(0006, regular_file)
+    assert(File::Stat.new(regular_file).world_writable?)
+    File.chmod(0060, regular_file)
+    assert(!(File::Stat.new(regular_file).world_writable?))
+    File.chmod(0600, regular_file)
+    assert(!(File::Stat.new(regular_file).world_writable?))
   end
 
   def test_stat_executable_p
     return if /cygwin|mswin|bccwin|mingw|emx/ =~ RUBY_PLATFORM
-    File.chmod(0100, @file)
-    assert(File::Stat.new(@file).executable?)
-    File.chmod(0600, @file)
-    assert(!(File::Stat.new(@file).executable?))
+    File.chmod(0100, regular_file)
+    assert(File::Stat.new(regular_file).executable?)
+    File.chmod(0600, regular_file)
+    assert(!(File::Stat.new(regular_file).executable?))
   end
 
   def test_stat_executable_real_p
     return if /cygwin|mswin|bccwin|mingw|emx/ =~ RUBY_PLATFORM
-    File.chmod(0100, @file)
-    assert(File::Stat.new(@file).executable_real?)
-    File.chmod(0600, @file)
-    assert(!(File::Stat.new(@file).executable_real?))
+    File.chmod(0100, regular_file)
+    assert(File::Stat.new(regular_file).executable_real?)
+    File.chmod(0600, regular_file)
+    assert(!(File::Stat.new(regular_file).executable_real?))
   end
 
   def test_stat_file_p
     assert(!(File::Stat.new(@dir).file?))
-    assert(File::Stat.new(@file).file?)
+    assert(File::Stat.new(regular_file).file?)
   end
 
   def test_stat_zero_p
     assert_nothing_raised { File::Stat.new(@dir).zero? }
-    assert(!(File::Stat.new(@file).zero?))
-    assert(File::Stat.new(@zerofile).zero?)
+    assert(!(File::Stat.new(regular_file).zero?))
+    assert(File::Stat.new(zerofile).zero?)
   end
 
   def test_stat_size_p
     assert_nothing_raised { File::Stat.new(@dir).size? }
-    assert_equal(3, File::Stat.new(@file).size?)
-    assert(!(File::Stat.new(@zerofile).size?))
+    assert_equal(3, File::Stat.new(regular_file).size?)
+    assert(!(File::Stat.new(zerofile).size?))
   end
 
   def test_stat_owned_p ## xxx
     return if /cygwin|mswin|bccwin|mingw|emx/ =~ RUBY_PLATFORM
-    assert(File::Stat.new(@file).owned?)
-    assert(File::Stat.new(@file).grpowned?)
+    assert(File::Stat.new(regular_file).owned?)
+    assert(File::Stat.new(regular_file).grpowned?)
   end
 
   def test_stat_suid_sgid_sticky ## xxx
-    assert(!(File::Stat.new(@file).setuid?))
-    assert(!(File::Stat.new(@file).setgid?))
-    assert(!(File::Stat.new(@file).sticky?))
+    assert(!(File::Stat.new(regular_file).setuid?))
+    assert(!(File::Stat.new(regular_file).setgid?))
+    assert(!(File::Stat.new(regular_file).sticky?))
   end
 
   def test_stat_size
     assert_integer(File::Stat.new(@dir).size)
-    assert_equal(3, File::Stat.new(@file).size)
-    assert_equal(0, File::Stat.new(@zerofile).size)
+    assert_equal(3, File::Stat.new(regular_file).size)
+    assert_equal(0, File::Stat.new(zerofile).size)
   end
 
   def test_stat_special_file
@@ -1268,8 +1301,8 @@ class TestFileExhaustive < Test::Unit::TestCase
   end
 
   def test_size
-    assert_equal(3, File.open(@file) {|f| f.size })
-    File.open(@file, "a") do |f|
+    assert_equal(3, File.open(regular_file) {|f| f.size })
+    File.open(regular_file, "a") do |f|
       f.write("bar")
       assert_equal(6, f.size)
     end