fakefs 0.2.1 → 0.3.1

data/lib/fakefs/file_system.rb

@@ -109,11 +109,14 @@ module FakeFS
       matches = case pattern
       when '**'
         case parts
-        when ['*'], []
+        when ['*']
           parts = [] # end recursion
           directories_under(dir).map do |d|
-            d.values.select{|f| f.is_a? FakeFile }
+            d.values.select{|f| f.is_a?(FakeFile) || f.is_a?(FakeDir) }
           end.flatten.uniq
+        when []
+          parts = [] # end recursion
+          dir.values.flatten.uniq
         else
           directories_under(dir)
         end

data/lib/fakefs/file_test.rb

@@ -0,0 +1,7 @@
+module FakeFS
+  class FileTest
+    def self.exist?(file_name)
+      File.exist?(file_name)
+    end
+  end
+end

data/lib/fakefs/fileutils.rb

@@ -2,7 +2,7 @@ module FakeFS
   module FileUtils
     extend self
 
-    def mkdir_p(path)
+    def mkdir_p(path, options = {})
       FileSystem.add(path, FakeDir.new)
     end
     alias_method :mkpath, :mkdir_p
@@ -19,8 +19,10 @@ module FakeFS
       end
     end
 
-    def rm(path)
-      FileSystem.delete(path)
+    def rm(list, options = {})
+      Array(list).each do |path|
+        FileSystem.delete(path)
+      end
     end
 
     alias_method :rm_rf, :rm
@@ -36,8 +38,6 @@ module FakeFS
       ln_s(target, path, { :force => true })
     end
 
-    
-
     def cp(src, dest)
       dst_file = FileSystem.find(dest)
       src_file = FileSystem.find(src)
@@ -86,7 +86,7 @@ module FakeFS
       end
     end
 
-    def mv(src, dest)
+    def mv(src, dest, options={})
       if target = FileSystem.find(src)
         FileSystem.add(dest, target.entry.clone)
         FileSystem.delete(src)

data/lib/fakefs/safe.rb

@@ -7,5 +7,5 @@ require 'fakefs/fake/symlink'
 require 'fakefs/file_system'
 require 'fakefs/fileutils'
 require 'fakefs/file'
+require 'fakefs/file_test'
 require 'fakefs/dir'
-

data/lib/fakefs/version.rb

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

data/spec/fakefs/spec_helpers_spec.rb

@@ -54,4 +54,4 @@ module FakeFS
       end
     end
   end
-end
+end

data/spec/spec.opts

@@ -1 +1 @@
---color
+--color

data/spec/spec_helper.rb

@@ -1,3 +1,3 @@
 $LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
 
-require 'fakefs/spec_helpers'
+require 'fakefs/spec_helpers'

data/test/fake/file/lstat_test.rb

@@ -0,0 +1,59 @@
+require "test_helper"
+
+class FileStat < Test::Unit::TestCase
+  def setup
+    FakeFS.activate!
+    FakeFS::FileSystem.clear
+  end
+
+  def teardown
+    FakeFS.deactivate!
+  end
+
+  def test_calling_lstat_should_create_a_new_file_stat_object
+    File.open("foo", "w") do |f|
+      f << "bar"
+    end
+
+    File.open("foo") do |f|
+      assert_equal File::Stat, f.lstat.class
+    end
+  end
+
+  def test_lstat_should_use_correct_file
+    File.open("bar", "w") do |f|
+      f << "1"
+    end
+
+    File.open("bar") do |f|
+      assert_equal 1, f.lstat.size
+    end
+  end
+
+  def test_lstat_should_report_on_symlink_itself
+    File.open("foo", "w") { |f| f << "some content" }
+    File.symlink "foo", "my_symlink"
+
+    assert_not_equal File.lstat("my_symlink").size, File.lstat("foo").size
+  end
+
+  def test_should_report_on_symlink_itself_with_size_instance_method
+    File.open("foo", "w") { |f| f << "some content" }
+    File.symlink "foo", "my_symlink"
+
+    file = File.open("foo")
+    symlink = File.open("my_symlink")
+
+    assert_not_equal file.lstat.size, symlink.lstat.size
+  end
+
+  def test_symlink_size_is_size_of_path_pointed_to
+    File.open("a", "w") { |x| x << "foobarbazfoobarbaz" }
+    File.symlink "a", "one_char_symlink"
+    assert_equal 1, File.lstat("one_char_symlink").size
+
+    File.open("ab", "w") { |x| x << "foobarbazfoobarbaz" }
+    File.symlink "ab", "two_char_symlink"
+    assert_equal 2, File.lstat("two_char_symlink").size
+  end
+end

data/test/fake/file/stat_test.rb

@@ -0,0 +1,39 @@
+require "test_helper"
+
+class FileStat < Test::Unit::TestCase
+  def setup
+    FakeFS.activate!
+    FakeFS::FileSystem.clear
+  end
+
+  def teardown
+    FakeFS.deactivate!
+  end
+
+  def test_calling_stat_should_create_a_new_file_stat_object
+    File.open("foo", "w") do |f|
+      f << "bar"
+    end
+
+    File.open("foo") do |f|
+      assert_equal File::Stat, f.stat.class
+    end
+  end
+
+  def test_stat_should_use_correct_file
+    File.open("bar", "w") do |f|
+      f << "1"
+    end
+
+    File.open("bar") do |f|
+      assert_equal 1, f.stat.size
+    end
+  end
+
+  def test_stat_should_report_on_symlink_pointer
+    File.open("foo", "w") { |f| f << "some content" }
+    File.symlink "foo", "my_symlink"
+
+    assert_equal File.stat("my_symlink").size, File.stat("foo").size
+  end
+end

data/test/fake/file/sysseek_test.rb

@@ -0,0 +1,44 @@
+require "test_helper"
+
+class FileSysSeek < Test::Unit::TestCase
+  def setup
+    FakeFS.activate!
+    FakeFS::FileSystem.clear
+  end
+
+  def teardown
+    FakeFS.deactivate!
+  end
+
+  def test_should_seek_to_position
+    file = File.open("foo", "w") do |f|
+      f << "0123456789"
+    end
+
+    File.open("foo", "r") do |f|
+      f.sysseek(3)
+      assert_equal 3, f.pos
+
+      f.sysseek(0)
+      assert_equal 0, f.pos
+    end
+  end
+
+  def test_seek_returns_offset_into_file
+    File.open("foo", "w") do |f|
+      # 66 chars long
+      str = "0123456789" +
+            "0123456789" +
+            "0123456789" +
+            "0123456789" +
+            "0123456789" +
+            "0123456789" +
+            "012345"
+
+      f << str
+    end
+
+    f = File.open("foo")
+    assert_equal 53, f.sysseek(-13, IO::SEEK_END)
+  end
+end

data/test/fake/file/syswrite_test.rb

@@ -0,0 +1,62 @@
+require "test_helper"
+
+class FileSysWriteTest < Test::Unit::TestCase
+  def setup
+    FakeFS.activate!
+    FakeFS::FileSystem.clear
+  end
+
+  def teardown
+    FakeFS.deactivate!
+  end
+
+  def test_returns_one_byte_when_written
+    f = File.open "foo", "w"
+    result = f.syswrite "a"
+    assert_equal 1, result
+  end
+
+  def test_returns_two_bytes_when_two_written
+    f = File.open "foo", "w"
+    result = f.syswrite "ab"
+    assert_equal 2, result
+  end
+
+  def test_syswrite_writes_file
+    f = File.open "foo", "w"
+    f.syswrite "abcdef"
+    f.close
+
+    assert_equal "abcdef", File.read("foo")
+  end
+
+  def test_writes_to_the_actual_position_when_called_after_buffered_io_read
+    File.open("foo", "w") do |file|
+      file.syswrite("012345678901234567890123456789")
+    end
+
+    file = File.open("foo", "r+")
+    file.read(5)
+    file.syswrite("abcde")
+
+    File.open("foo") do |file|
+      assert_equal "01234abcde", file.sysread(10)
+    end
+  end
+
+  def test_writes_all_of_the_strings_bytes_but_does_not_buffer_them
+    File.open("foo", "w") do |file|
+      file.syswrite("012345678901234567890123456789")
+    end
+
+    file = File.open("foo", "r+")
+    written = file.syswrite("abcde")
+
+    File.open("foo") do |file|
+      assert_equal "abcde56789", file.sysread(10)
+      file.seek(0)
+      file.fsync
+      assert_equal "abcde56789", file.sysread(10)
+    end
+  end
+end

data/test/fake/file_test.rb

@@ -1,13 +1,11 @@
-$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', '..', 'lib')
-require 'fakefs/safe'
-require 'test/unit'
+require "test_helper"
 
 class FakeFileTest < Test::Unit::TestCase
   include FakeFS
 
   def setup
     FileSystem.clear
-    
+
     @file = FakeFile.new
   end
 
@@ -43,9 +41,9 @@ class FakeFileTest < Test::Unit::TestCase
 
   def test_links_are_mutual
     other_file = FakeFile.new
-  
+
     @file.link(other_file)
-  
+
     assert_equal [@file, other_file], other_file.links
   end
 

data/test/fake/symlink_test.rb

@@ -1,6 +1,4 @@
-$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', '..', 'lib')
-require 'fakefs/safe'
-require 'test/unit'
+require "test_helper"
 
 class FakeSymlinkTest < Test::Unit::TestCase
   include FakeFS

data/test/fakefs_test.rb

@@ -1,14 +1,17 @@
-$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
-require 'fakefs'
-require 'test/unit'
+require "test_helper"
 
 class FakeFSTest < Test::Unit::TestCase
   include FakeFS
 
   def setup
+    FakeFS.activate!
     FileSystem.clear
   end
 
+  def teardown
+    FakeFS.deactivate!
+  end
+
   def test_can_be_initialized_empty
     fs = FileSystem
     assert_equal 0, fs.files.size
@@ -24,12 +27,22 @@ class FakeFSTest < Test::Unit::TestCase
     FileUtils.mkdir_p("/path/to/dir")
     assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir']
   end
-  
+
+  def test_can_create_directories_with_options
+    FileUtils.mkdir_p("/path/to/dir", :mode => 0755)
+    assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir']
+  end
+
   def test_can_create_directories_with_mkpath
     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)
+    assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir']
+  end
+
   def test_can_delete_directories
     FileUtils.mkdir_p("/path/to/dir")
     FileUtils.rmdir("/path/to/dir")
@@ -37,6 +50,13 @@ class FakeFSTest < Test::Unit::TestCase
     assert File.exists?("/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
+  end
+
   def test_knows_directories_exist
     FileUtils.mkdir_p(path = "/path/to/dir")
     assert File.exists?(path)
@@ -74,14 +94,14 @@ class FakeFSTest < Test::Unit::TestCase
       FileUtils.ln_s(target, '/path/to/link')
     end
   end
-  
+
   def test_can_force_creation_of_symlinks
     FileUtils.mkdir_p(target = "/path/to/first/target")
     FileUtils.ln_s(target, "/path/to/link")
     assert_kind_of FakeSymlink, FileSystem.fs['path']['to']['link']
     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")
@@ -288,7 +308,7 @@ class FakeFSTest < Test::Unit::TestCase
     assert_nil File.size?("/path/to/other.txt")
   end
 
-  def test_can_check_size?_of_empty_file
+  def test_can_check_size_of_empty_file
     path = '/path/to/file.txt'
     File.open(path, 'w') do |f|
       f << ''
@@ -310,6 +330,60 @@ class FakeFSTest < Test::Unit::TestCase
     assert File.mtime('/path/to/file.txt').is_a?(Time)
   end
 
+  def test_raises_error_on_ctime_if_file_does_not_exist
+    assert_raise Errno::ENOENT do
+      File.ctime('/path/to/file.txt')
+    end
+  end
+
+  def test_can_return_ctime_on_existing_file
+    File.open("foo", "w") { |f| f << "some content" }
+    assert File.ctime('foo').is_a?(Time)
+  end
+
+  def test_ctime_and_mtime_are_equal_for_new_files
+    File.open("foo", "w") { |f| f << "some content" }
+    ctime = File.ctime("foo")
+    mtime = File.mtime("foo")
+    assert ctime.is_a?(Time)
+    assert mtime.is_a?(Time)
+    assert_equal ctime, mtime
+
+    File.open("foo", "r") do |f|
+      assert_equal ctime, f.ctime
+      assert_equal mtime, f.mtime
+    end
+  end
+
+  def test_ctime_and_mtime_are_equal_for_new_directories
+    FileUtils.mkdir_p("foo")
+    ctime = File.ctime("foo")
+    mtime = File.mtime("foo")
+    assert ctime.is_a?(Time)
+    assert mtime.is_a?(Time)
+    assert_equal ctime, mtime
+  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")
+  end
+
+  def test_directory_ctime_is_equal_to_directory_stat_ctime
+    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")
+  end
+
+  def test_directory_mtime_is_equal_to_directory_stat_mtime
+    FileUtils.mkdir_p("foo")
+    assert_equal File.stat("foo").mtime, File.mtime("foo")
+  end
+
   def test_can_read_with_File_readlines
     path = '/path/to/file.txt'
     File.open(path, 'w') do |f|
@@ -330,6 +404,16 @@ class FakeFSTest < Test::Unit::TestCase
     end
   end
 
+  def test_File_close_disallows_further_writes
+    path = '/path/to/file.txt'
+    file = File.open(path, 'w')
+    file.write 'Yada'
+    file.close
+    assert_raise IOError do
+      file << "foo"
+    end
+  end
+
   def test_can_read_from_file_objects
     path = '/path/to/file.txt'
     File.open(path, 'w') do |f|
@@ -354,6 +438,16 @@ class FakeFSTest < Test::Unit::TestCase
     assert File.file?(path)
   end
 
+  def test_File_io_returns_self
+    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")
+    assert_equal f.method(:to_i), f.method(:fileno)
+  end
+
   def test_knows_symlink_files_are_files
     path = '/path/to/file.txt'
     File.open(path, 'w') do |f|
@@ -418,6 +512,13 @@ class FakeFSTest < Test::Unit::TestCase
     assert_equal ['/path/foo', '/path/foobar'], Dir['/p*h/foo*']
     assert_equal ['/path/foo', '/path/foobar'], Dir['/p??h/foo*']
 
+    assert_equal ['/path/bar', '/path/bar/baz', '/path/bar2', '/path/bar2/baz', '/path/foo', '/path/foobar'], Dir['/path/**/*']
+    assert_equal ['/path', '/path/bar', '/path/bar/baz', '/path/bar2', '/path/bar2/baz', '/path/foo', '/path/foobar'], Dir['/**/*']
+
+    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/**/*']
+
     FileUtils.cp_r '/path', '/otherpath'
 
     assert_equal %w( /otherpath/foo /otherpath/foobar /path/foo /path/foobar ), Dir['/*/foo*']
@@ -438,11 +539,74 @@ class FakeFSTest < Test::Unit::TestCase
     assert_equal ['/one/two/three'], Dir['/one/**/three']
   end
 
-  def test_dir_recursive_glob_ending_in_wildcards_only_returns_files
+  def test_dir_recursive_glob_ending_in_wildcards_returns_both_files_and_dirs
     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/**/*']
-    assert_equal ['/one/five.rb', '/one/two/three/four.rb'], Dir['/one/**']
+    assert_equal ['/one/five.rb', '/one/two', '/one/two/three', '/one/two/three/four.rb'], Dir['/one/**/*']
+    assert_equal ['/one/five.rb', '/one/two'], Dir['/one/**']
+  end
+
+  def test_should_report_pos_as_0_when_opening
+    File.open("/foo", "w") do |f|
+      f << "foobar"
+      f.rewind
+
+      assert_equal 0, f.pos
+    end
+  end
+
+  def test_should_report_pos_as_1_when_seeking_one_char
+    File.open("/foo", "w") do |f|
+      f << "foobar"
+
+      f.rewind
+      f.seek(1)
+
+      assert_equal 1, f.pos
+    end
+  end
+
+  def test_should_set_pos
+    File.open("/foo", "w") do |f|
+      f << "foo"
+    end
+
+    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"
+    end
+
+    fp = File.open("/foo", "r")
+    fp.tell = 1
+
+    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)
+    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)
+    end
+  end
+
+  def test_does_not_remove_methods_from_stringio
+    stringio = StringIO.new("foo")
+    assert stringio.respond_to?(:size)
   end
 
   def test_chdir_changes_directories_like_a_boss
@@ -585,6 +749,12 @@ class FakeFSTest < Test::Unit::TestCase
     assert_equal 'bar', File.open('baz') { |f| f.read }
   end
 
+  def test_mv_works_with_options
+    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_cp_actually_works
     File.open('foo', 'w') {|f| f.write 'bar' }
     FileUtils.cp('foo', 'baz')
@@ -695,25 +865,34 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_clone_clones_directories
+    FakeFS.deactivate!
     RealFileUtils.mkdir_p(here('subdir'))
+    FakeFS.activate!
 
     FileSystem.clone(here('subdir'))
 
     assert File.exists?(here('subdir')), 'subdir was cloned'
     assert File.directory?(here('subdir')), 'subdir is a directory'
   ensure
-    RealFileUtils.rm_rf(here('subdir')) if RealFile.exists?(here('subdir'))
+    FakeFS.deactivate!
+    RealFileUtils.rm_rf(here('subdir'))
+    FakeFS.activate!
   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!
+
     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
   ensure
-    RealFileUtils.rm_rf(here('subdir')) if RealFile.exists?(here('subdir'))
+    FakeFS.deactivate!
+    RealFileUtils.rm_rf(here('subdir'))
+    FakeFS.activate!
   end
 
   def test_putting_a_dot_at_end_copies_the_contents
@@ -1019,6 +1198,14 @@ class FakeFSTest < Test::Unit::TestCase
     end
   end
 
+  def test_mkdir_raises_error_if_already_created
+    Dir.mkdir "foo"
+
+    assert_raises(Errno::EEXIST) do
+      Dir.mkdir "foo"
+    end
+  end
+
   def test_directory_open
     test = ['.', '..', 'file_1', 'file_2', 'file_3', 'file_4', 'file_5' ]
 
@@ -1053,38 +1240,38 @@ class FakeFSTest < Test::Unit::TestCase
   def test_tmpdir
     assert Dir.tmpdir == "/tmp"
   end
-  
+
   def test_hard_link_creates_file
     FileUtils.touch("/foo")
-    
+
     File.link("/foo", "/bar")
     assert File.exists?("/bar")
   end
-  
+
   def test_hard_link_with_missing_file_raises_error
     assert_raises(Errno::ENOENT) do
       File.link("/foo", "/bar")
     end
   end
-  
+
   def test_hard_link_with_existing_destination_file
     FileUtils.touch("/foo")
     FileUtils.touch("/bar")
-    
+
     assert_raises(Errno::EEXIST) do
       File.link("/foo", "/bar")
     end
   end
-  
+
   def test_hard_link_returns_0_when_successful
     FileUtils.touch("/foo")
-    
+
     assert_equal 0, File.link("/foo", "/bar")
   end
-  
+
   def test_hard_link_returns_duplicate_file
     File.open("/foo", "w") { |x| x << "some content" }
-    
+
     File.link("/foo", "/bar")
     assert_equal "some content", File.read("/bar")
   end
@@ -1245,7 +1432,57 @@ class FakeFSTest < Test::Unit::TestCase
     assert_equal IO::SEEK_SET, File::SEEK_SET
   end
 
+  def test_filetest_exists_return_correct_values
+    FileUtils.mkdir_p("/path/to/dir")
+    assert FileTest.exist?("/path/to/")
+
+    FileUtils.rmdir("/path/to/dir")
+    assert !FileTest.exist?("/path/to/dir")
+  end
+
+  def test_pathname_exists_returns_correct_value
+    FileUtils.touch "foo"
+    assert Pathname.new("foo").exist?
+
+    assert !Pathname.new("bar").exist?
+  end
+
+  def test_activating_returns_true
+    FakeFS.deactivate!
+    assert_equal true, FakeFS.activate!
+  end
+
+  def test_deactivating_returns_true
+    assert_equal true, FakeFS.deactivate!
+  end
+
   def here(fname)
-    RealFile.expand_path(RealFile.dirname(__FILE__)+'/'+fname)
+    RealFile.expand_path(File.join(RealFile.dirname(__FILE__), fname))
+  end
+
+  if RUBY_VERSION >= "1.9.2"
+    def test_file_size
+      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|
+        f << 'Yada Yada'
+        assert_nothing_raised do
+          f.fdatasync
+        end
+      end
+    end
+
+    def test_autoclose
+      File.open("foo", 'w') do |f|
+        assert_equal true, f.autoclose?
+        f.autoclose = false
+        assert_equal false, f.autoclose?
+      end
+    end
   end
 end