ruby-ole 1.2.1 → 1.2.2

data/lib/ole/support.rb

@@ -2,12 +2,26 @@
 # 
 # A file with general support functions used by most files in the project.
 # 
+# These are the only methods added to other classes.
+# 
 
 require 'logger'
+require 'stringio'
+require 'enumerator'
+
+class String # :nodoc:
+	# plural of String#index. returns all offsets of +string+. rename to indices?
+	#
+	# note that it doesn't check for overlapping values.
+	def indexes string
+		# in some ways i'm surprised that $~ works properly in this case...
+		to_enum(:scan, /#{Regexp.quote string}/m).map { $~.begin 0 }
+	end
+end
 
 class File # :nodoc:
-	# for consistency with StringIO and others. makes more sense than forcing
-	# them to provide a #stat
+	# for interface consistency with StringIO etc (rather than adding #stat
+	# to them). used by RangesIO.
 	def size
 		stat.size
 	end
@@ -32,8 +46,18 @@ module Enumerable # :nodoc:
 	end
 end
 
+# move to support?
+class IO # :nodoc:
+	def self.copy src, dst
+		until src.eof?
+			buf = src.read(4096)
+			dst.write buf
+		end
+	end
+end
+
 class Logger # :nodoc:
-	# A helper method for creating <tt>Logger</tt>s which produce call stack
+	# A helper method for creating a +Logger+ which produce call stack
 	# in their output
 	def self.new_with_callstack logdev=STDERR
 		log = Logger.new logdev
@@ -49,3 +73,88 @@ class Logger # :nodoc:
 	end
 end
 
+# Include this module into a class that defines #each_child. It should
+# maybe use #each instead, but its easier to be more specific, and use
+# an alias.
+#
+# I don't want to force the class to cache children (eg where children
+# are loaded on request in pst), because that forces the whole tree to
+# be loaded. So, the methods should only call #each_child once, and 
+# breadth first iteration holds its own copy of the children around.
+#
+# Main methods are #recursive, and #to_tree
+module RecursivelyEnumerable
+	def each_recursive_depth_first(&block)
+		each_child do |child|
+			yield child
+			if child.respond_to? :each_recursive_depth_first
+				child.each_recursive_depth_first(&block)
+			end
+		end
+	end
+
+	def each_recursive_breadth_first(&block)
+		children = []
+		each_child do |child|
+			children << child if child.respond_to? :each_recursive_breadth_first
+			yield child
+		end
+		children.each { |child| child.each_recursive_breadth_first(&block) }
+	end
+
+	def each_recursive mode=:depth_first, &block
+		# we always actually yield ourself (the tree root) before recursing
+		yield self
+		send "each_recursive_#{mode}", &block
+	end
+
+	# the idea of this function, is to allow use of regular Enumerable methods
+	# in a recursive fashion. eg:
+	#
+	#   # just looks at top level children
+	#   root.find { |child| child.some_condition? }
+	#   # recurse into all children getting non-folders, breadth first
+	#   root.recursive(:breadth_first).select { |child| !child.folder? }
+	#   # just get everything
+	#   items = root.recursive.to_a
+	#
+	def recursive mode=:depth_first
+		to_enum(:each_recursive, mode)
+	end
+
+	# streams a "tree" form of the recursively enumerable structure to +io+, or
+	# return a string form instead if +io+ is not specified.
+	#
+	# mostly a debugging aid. can specify a different +method+ to call if desired,
+	# though it should return a single line string.
+	def to_tree io=nil, method=:inspect
+		unless io
+			to_tree io = StringIO.new
+			return io.string
+		end
+		io << "- #{send method}\n"
+		to_tree_helper io, method, '  '
+	end
+
+	def to_tree_helper io, method, prefix
+		# i need to know when i get to the last child. use delay to know
+		child = nil
+		each_child do |next_child|
+			if child
+				io << "#{prefix}|- #{child.send method}\n"
+				if child.respond_to? :to_tree_helper
+					child.to_tree_helper io, method, prefix + '|  '
+				end
+			end
+			child = next_child
+		end
+		return unless child
+		# child is the last child
+		io << "#{prefix}\\- #{child.send method}\n"
+		if child.respond_to? :to_tree_helper
+			child.to_tree_helper io, method, prefix + '   '
+		end
+	end
+	protected :to_tree_helper
+end
+

data/lib/ole/types.rb

@@ -6,8 +6,91 @@ require 'ole/base'
 module Ole # :nodoc:
 	# FIXME
 	module Types
+		#
+		# The OLE variant types, extracted from
+		# http://www.marin.clara.net/COM/variant_type_definitions.htm.
+		#
+		# A subset is also in WIN32OLE::VARIANT, but its not cross platform (obviously).
+		#
+		# Use like:
+		#
+		#   p Ole::Types::Variant::NAMES[0x001f] => 'VT_LPWSTR'
+		#   p Ole::Types::VT_DATE # => 7
+		#
+		# The serialization / deserialization functions should be fixed to make it easier
+		# to work with. like
+		#
+		#   Ole::Types.from_str(VT_DATE, data) # and
+		#   Ole::Types.to_str(VT_DATE, data)
+		#
+		# Or similar, rather than having to do VT_* <=> ad hoc class name etc as it is
+		# currently.
+		#
+		module Variant
+			NAMES = {
+				0x0000 => 'VT_EMPTY',
+				0x0001 => 'VT_NULL',
+				0x0002 => 'VT_I2',
+				0x0003 => 'VT_I4',
+				0x0004 => 'VT_R4',
+				0x0005 => 'VT_R8',
+				0x0006 => 'VT_CY',
+				0x0007 => 'VT_DATE',
+				0x0008 => 'VT_BSTR',
+				0x0009 => 'VT_DISPATCH',
+				0x000a => 'VT_ERROR',
+				0x000b => 'VT_BOOL',
+				0x000c => 'VT_VARIANT',
+				0x000d => 'VT_UNKNOWN',
+				0x000e => 'VT_DECIMAL',
+				0x0010 => 'VT_I1',
+				0x0011 => 'VT_UI1',
+				0x0012 => 'VT_UI2',
+				0x0013 => 'VT_UI4',
+				0x0014 => 'VT_I8',
+				0x0015 => 'VT_UI8',
+				0x0016 => 'VT_INT',
+				0x0017 => 'VT_UINT',
+				0x0018 => 'VT_VOID',
+				0x0019 => 'VT_HRESULT',
+				0x001a => 'VT_PTR',
+				0x001b => 'VT_SAFEARRAY',
+				0x001c => 'VT_CARRAY',
+				0x001d => 'VT_USERDEFINED',
+				0x001e => 'VT_LPSTR',
+				0x001f => 'VT_LPWSTR',
+				0x0040 => 'VT_FILETIME',
+				0x0041 => 'VT_BLOB',
+				0x0042 => 'VT_STREAM',
+				0x0043 => 'VT_STORAGE',
+				0x0044 => 'VT_STREAMED_OBJECT',
+				0x0045 => 'VT_STORED_OBJECT',
+				0x0046 => 'VT_BLOB_OBJECT',
+				0x0047 => 'VT_CF',
+				0x0048 => 'VT_CLSID',
+				0x0fff => 'VT_ILLEGALMASKED',
+				0x0fff => 'VT_TYPEMASK',
+				0x1000 => 'VT_VECTOR',
+				0x2000 => 'VT_ARRAY',
+				0x4000 => 'VT_BYREF',
+				0x8000 => 'VT_RESERVED',
+				0xffff => 'VT_ILLEGAL'
+			}
+
+			module Constants
+				NAMES.each { |num, name| const_set name, num }
+			end
+		end
+
+		include Variant::Constants
+
+		# the rest of this file is all a bit of adhoc marshal/unmarshal stuff
+
+		# for VT_LPWSTR
 		FROM_UTF16 = Iconv.new 'utf-8', 'utf-16le'
 		TO_UTF16   = Iconv.new 'utf-16le', 'utf-8'
+
+		# for VT_FILETIME
 		EPOCH = DateTime.parse '1601-01-01'
 		# Create a +DateTime+ object from a struct +FILETIME+
 		# (http://msdn2.microsoft.com/en-us/library/ms724284.aspx).
@@ -18,7 +101,7 @@ module Ole # :nodoc:
 			low, high = str.unpack 'L2'
 			# we ignore these, without even warning about it
 			return nil if low == 0 and high == 0
-			time = EPOCH + (high * (1 << 32) + low) * 1e-7 / 86400 rescue return
+			time = EPOCH + (high * (1 << 32) + low) / 1e7 / 86400 rescue return
 			# extra sanity check...
 			unless (1800...2100) === time.year
 				Log.warn "ignoring unlikely time value #{time.to_s}"
@@ -27,6 +110,18 @@ module Ole # :nodoc:
 			time
 		end
 
+		# +time+ should be able to be either a Time, Date, or DateTime.
+		def self.save_time time
+			# i think i'll convert whatever i get to be a datetime, because of
+			# the covered range.
+			return 0.chr * 8 unless time
+			time = time.send(:to_datetime) if Time === time
+			bignum = ((time - Ole::Types::EPOCH) * 86400 * 1e7.to_i)
+			high, low = bignum.divmod 1 << 32
+			[low, high].pack 'L2'
+		end
+
+		# for VT_CLSID
 		# Convert a binary guid into a plain string (will move to proper class later).
 		def self.load_guid str
 			"{%08x-%04x-%04x-%02x%02x-#{'%02x' * 6}}" % str.unpack('L S S CC C6')

data/test/test_filesystem.rb

@@ -0,0 +1,877 @@
+#! /usr/bin/ruby
+
+#
+# = NOTE
+#
+# This file was originally called "zipfilesystemtest.rb", and was part of
+# the test case for the "rubyzip" project.
+#
+# As I borrowed the smart idea of using a filesystem style interface, it
+# only seemed right that I appropriate the test case in addition :). It is
+# a testament to the cleanliness of the original api & tests as to how
+# easy it was to repurpose it for this project.
+#
+# I have made some modifications to the file due to some differences in the
+# capabilities of zip vs ole, but the majority of the copyright and credit
+# still goes to Thomas. His original copyright message:
+#
+#   Copyright (C) 2002, 2003 Thomas Sondergaard
+#   rubyzip is free software; you can redistribute it and/or
+#   modify it under the terms of the ruby license.
+#
+
+TEST_DIR = File.dirname __FILE__
+$:.unshift "#{TEST_DIR}/../lib"
+
+require 'ole/file_system'
+require 'test/unit'
+
+module ExtraAssertions
+
+	def assert_forwarded(anObject, method, retVal, *expectedArgs)
+		callArgs = nil
+		setCallArgsProc = proc { |args| callArgs = args }
+		anObject.instance_eval <<-"end_eval"
+			alias #{method}_org #{method}
+			def #{method}(*args)
+				ObjectSpace._id2ref(#{setCallArgsProc.object_id}).call(args)
+				ObjectSpace._id2ref(#{retVal.object_id})
+				end
+		end_eval
+
+		assert_equal(retVal, yield) # Invoke test
+		assert_equal(expectedArgs, callArgs)
+	ensure
+		anObject.instance_eval "alias #{method} #{method}_org"
+	end
+
+end
+
+class OleFsNonmutatingTest < Test::Unit::TestCase
+	def setup
+		@ole = Ole::Storage.open TEST_DIR + '/oleWithDirs.ole'
+	end
+
+	def teardown
+		@ole.close if @ole
+	end
+
+=begin
+	def test_umask
+		assert_equal(File.umask, @ole.file.umask)
+		@ole.file.umask(0006)
+	end
+=end
+
+	def test_exists?
+		assert(! @ole.file.exists?("notAFile"))
+		assert(@ole.file.exists?("file1"))
+		assert(@ole.file.exists?("dir1"))
+		assert(@ole.file.exists?("dir1/"))
+		assert(@ole.file.exists?("dir1/file12"))
+		assert(@ole.file.exist?("dir1/file12")) # notice, tests exist? alias of exists? !
+
+		@ole.dir.chdir "dir1/"
+		assert(!@ole.file.exists?("file1"))
+		assert(@ole.file.exists?("file12"))
+	end
+
+	def test_open_read
+		blockCalled = false
+		@ole.file.open("file1", "r") {
+			|f|
+			blockCalled = true
+			assert_equal("this is the entry 'file1' in my test archive!", 
+										f.readline.chomp)
+		}
+		assert(blockCalled)
+
+		blockCalled = false
+		@ole.dir.chdir "dir2"
+		@ole.file.open("file21", "r") {
+			|f|
+			blockCalled = true
+			assert_equal("this is the entry 'dir2/file21' in my test archive!", 
+										f.readline.chomp)
+		}
+		assert(blockCalled)
+		@ole.dir.chdir "/"
+		
+		assert_raise(Errno::ENOENT) {
+			@ole.file.open("noSuchEntry")
+		}
+
+		begin
+			is = @ole.file.open("file1")
+			assert_equal("this is the entry 'file1' in my test archive!", 
+										is.readline.chomp)
+		ensure
+			is.close if is
+		end
+	end
+
+	def test_new
+		begin
+			is = @ole.file.new("file1")
+			assert_equal("this is the entry 'file1' in my test archive!", 
+										is.readline.chomp)
+		ensure
+			is.close if is
+		end
+		begin
+			is = @ole.file.new("file1") {
+				fail "should not call block"
+			}
+		ensure
+			is.close if is
+		end
+	end
+
+	# currently commented out because I've taken the approach of
+	# using implicit NameError rather than explicit NotImplementedError.
+=begin
+	def test_symlink
+		assert_raise(NotImplementedError) {
+			@ole.file.symlink("file1", "aSymlink")
+		}
+	end
+=end
+
+	def test_size
+		assert_raise(Errno::ENOENT) { @ole.file.size("notAFile") }
+		assert_equal(72, @ole.file.size("file1"))
+		assert_equal(0, @ole.file.size("dir2/dir21"))
+
+		assert_equal(72, @ole.file.stat("file1").size)
+		assert_equal(0, @ole.file.stat("dir2/dir21").size)
+	end
+
+=begin
+	def test_size?
+		assert_equal(nil, @ole.file.size?("notAFile"))
+		assert_equal(72, @ole.file.size?("file1"))
+		assert_equal(nil, @ole.file.size?("dir2/dir21"))
+
+		assert_equal(72, @ole.file.stat("file1").size?)
+		assert_equal(nil, @ole.file.stat("dir2/dir21").size?)
+	end
+=end
+
+	def test_file?
+		assert(@ole.file.file?("file1"))
+		assert(@ole.file.file?("dir2/file21"))
+		assert(! @ole.file.file?("dir1"))
+		assert(! @ole.file.file?("dir1/dir11"))
+
+		assert(@ole.file.stat("file1").file?)
+		assert(@ole.file.stat("dir2/file21").file?)
+		assert(! @ole.file.stat("dir1").file?)
+		assert(! @ole.file.stat("dir1/dir11").file?)
+	end
+
+=begin
+	include ExtraAssertions
+
+	def test_dirname
+		assert_forwarded(File, :dirname, "retVal", "a/b/c/d") { 
+			@ole.file.dirname("a/b/c/d")
+		}
+	end
+
+	def test_basename
+		assert_forwarded(File, :basename, "retVal", "a/b/c/d") { 
+			@ole.file.basename("a/b/c/d")
+		}
+	end
+
+	def test_split
+		assert_forwarded(File, :split, "retVal", "a/b/c/d") { 
+			@ole.file.split("a/b/c/d")
+		}
+	end
+
+	def test_join
+		assert_equal("a/b/c", @ole.file.join("a/b", "c"))
+		assert_equal("a/b/c/d", @ole.file.join("a/b", "c/d"))
+		assert_equal("/c/d", @ole.file.join("", "c/d"))
+		assert_equal("a/b/c/d", @ole.file.join("a", "b", "c", "d"))
+	end
+
+	def test_utime
+		t_now = Time.now
+		t_bak = @ole.file.mtime("file1")
+		@ole.file.utime(t_now, "file1")
+		assert_equal(t_now, @ole.file.mtime("file1"))
+		@ole.file.utime(t_bak, "file1")
+		assert_equal(t_bak, @ole.file.mtime("file1"))
+	end
+
+
+	def assert_always_false(operation)
+		assert(! @ole.file.send(operation, "noSuchFile"))
+		assert(! @ole.file.send(operation, "file1"))
+		assert(! @ole.file.send(operation, "dir1"))
+		assert(! @ole.file.stat("file1").send(operation))
+		assert(! @ole.file.stat("dir1").send(operation))
+	end
+
+	def assert_true_if_entry_exists(operation)
+		assert(! @ole.file.send(operation, "noSuchFile"))
+		assert(@ole.file.send(operation, "file1"))
+		assert(@ole.file.send(operation, "dir1"))
+		assert(@ole.file.stat("file1").send(operation))
+		assert(@ole.file.stat("dir1").send(operation))
+	end
+
+	def test_pipe?
+		assert_always_false(:pipe?)
+	end
+
+	def test_blockdev?
+		assert_always_false(:blockdev?)
+	end
+
+	def test_symlink?
+		assert_always_false(:symlink?)
+	end
+
+	def test_socket?
+		assert_always_false(:socket?)
+	end
+
+	def test_chardev?
+		assert_always_false(:chardev?)
+	end
+
+	def test_truncate
+		assert_raise(StandardError, "truncate not supported") {
+			@ole.file.truncate("file1", 100)
+		}
+	end
+
+	def assert_e_n_o_e_n_t(operation, args = ["NoSuchFile"])
+		assert_raise(Errno::ENOENT) {
+			@ole.file.send(operation, *args)
+		}
+	end
+
+	def test_ftype
+		assert_e_n_o_e_n_t(:ftype)
+		assert_equal("file", @ole.file.ftype("file1"))
+		assert_equal("directory", @ole.file.ftype("dir1/dir11"))
+		assert_equal("directory", @ole.file.ftype("dir1/dir11/"))
+	end
+=end
+
+	def test_directory?
+		assert(! @ole.file.directory?("notAFile"))
+		assert(! @ole.file.directory?("file1"))
+		assert(! @ole.file.directory?("dir1/file11"))
+		assert(@ole.file.directory?("dir1"))
+		assert(@ole.file.directory?("dir1/"))
+		assert(@ole.file.directory?("dir2/dir21"))
+
+		assert(! @ole.file.stat("file1").directory?)
+		assert(! @ole.file.stat("dir1/file11").directory?)
+		assert(@ole.file.stat("dir1").directory?)
+		assert(@ole.file.stat("dir1/").directory?)
+		assert(@ole.file.stat("dir2/dir21").directory?)
+	end
+
+=begin
+	def test_chown
+		assert_equal(2, @ole.file.chown(1,2, "dir1", "file1"))
+		assert_equal(1, @ole.file.stat("dir1").uid)
+		assert_equal(2, @ole.file.stat("dir1").gid)
+		assert_equal(2, @ole.file.chown(nil, nil, "dir1", "file1"))
+	end
+
+	def test_zero?
+		assert(! @ole.file.zero?("notAFile"))
+		assert(! @ole.file.zero?("file1"))
+		assert(@ole.file.zero?("dir1"))
+		blockCalled = false
+		ZipFile.open("data/generated/5entry.zip") {
+			|zf|
+			blockCalled = true
+			assert(zf.file.zero?("data/generated/empty.txt"))
+		}
+		assert(blockCalled)
+
+		assert(! @ole.file.stat("file1").zero?)
+		assert(@ole.file.stat("dir1").zero?)
+		blockCalled = false
+		ZipFile.open("data/generated/5entry.zip") {
+			|zf|
+			blockCalled = true
+			assert(zf.file.stat("data/generated/empty.txt").zero?)
+		}
+		assert(blockCalled)
+	end
+=end
+
+	def test_expand_path
+		assert_equal("/", @ole.file.expand_path("."))
+		@ole.dir.chdir "dir1"
+		assert_equal("/dir1", @ole.file.expand_path("."))
+		assert_equal("/dir1/file12", @ole.file.expand_path("file12"))
+		assert_equal("/", @ole.file.expand_path(".."))
+		assert_equal("/dir2/dir21", @ole.file.expand_path("../dir2/dir21"))
+	end
+
+=begin
+	def test_mtime
+		assert_equal(Time.at(1027694306),
+									@ole.file.mtime("dir2/file21"))
+		assert_equal(Time.at(1027690863),
+									@ole.file.mtime("dir2/dir21"))
+		assert_raise(Errno::ENOENT) {
+			@ole.file.mtime("noSuchEntry")
+		}
+
+		assert_equal(Time.at(1027694306),
+									@ole.file.stat("dir2/file21").mtime)
+		assert_equal(Time.at(1027690863),
+									@ole.file.stat("dir2/dir21").mtime)
+	end
+
+	def test_ctime
+		assert_nil(@ole.file.ctime("file1"))
+		assert_nil(@ole.file.stat("file1").ctime)
+	end
+
+	def test_atime
+		assert_nil(@ole.file.atime("file1"))
+		assert_nil(@ole.file.stat("file1").atime)
+	end
+
+	def test_readable?
+		assert(! @ole.file.readable?("noSuchFile"))
+		assert(@ole.file.readable?("file1"))
+		assert(@ole.file.readable?("dir1"))
+		assert(@ole.file.stat("file1").readable?)
+		assert(@ole.file.stat("dir1").readable?)
+	end
+
+	def test_readable_real?
+		assert(! @ole.file.readable_real?("noSuchFile"))
+		assert(@ole.file.readable_real?("file1"))
+		assert(@ole.file.readable_real?("dir1"))
+		assert(@ole.file.stat("file1").readable_real?)
+		assert(@ole.file.stat("dir1").readable_real?)
+	end
+
+	def test_writable?
+		assert(! @ole.file.writable?("noSuchFile"))
+		assert(@ole.file.writable?("file1"))
+		assert(@ole.file.writable?("dir1"))
+		assert(@ole.file.stat("file1").writable?)
+		assert(@ole.file.stat("dir1").writable?)
+	end
+
+	def test_writable_real?
+		assert(! @ole.file.writable_real?("noSuchFile"))
+		assert(@ole.file.writable_real?("file1"))
+		assert(@ole.file.writable_real?("dir1"))
+		assert(@ole.file.stat("file1").writable_real?)
+		assert(@ole.file.stat("dir1").writable_real?)
+	end
+
+	def test_executable?
+		assert(! @ole.file.executable?("noSuchFile"))
+		assert(! @ole.file.executable?("file1"))
+		assert(@ole.file.executable?("dir1"))
+		assert(! @ole.file.stat("file1").executable?)
+		assert(@ole.file.stat("dir1").executable?)
+	end
+
+	def test_executable_real?
+		assert(! @ole.file.executable_real?("noSuchFile"))
+		assert(! @ole.file.executable_real?("file1"))
+		assert(@ole.file.executable_real?("dir1"))
+		assert(! @ole.file.stat("file1").executable_real?)
+		assert(@ole.file.stat("dir1").executable_real?)
+	end
+
+	def test_owned?
+		assert_true_if_entry_exists(:owned?)
+	end
+
+	def test_grpowned?
+		assert_true_if_entry_exists(:grpowned?)
+	end
+
+	def test_setgid?
+		assert_always_false(:setgid?)
+	end
+
+	def test_setuid?
+		assert_always_false(:setgid?)
+	end
+
+	def test_sticky?
+		assert_always_false(:sticky?)
+	end
+
+	def test_stat
+		s = @ole.file.stat("file1")
+		assert(s.kind_of?(File::Stat)) # It pretends
+		assert_raise(Errno::ENOENT, "No such file or directory - noSuchFile") {
+			@ole.file.stat("noSuchFile")
+		}
+	end
+
+	def test_lstat
+		assert(@ole.file.lstat("file1").file?)
+	end
+
+
+	def test_chmod
+		assert_raise(Errno::ENOENT, "No such file or directory - noSuchFile") {
+			@ole.file.chmod(0644, "file1", "NoSuchFile")
+		}
+		assert_equal(2, @ole.file.chmod(0644, "file1", "dir1"))
+	end
+
+	def test_pipe
+		assert_raise(NotImplementedError) {
+			@ole.file.pipe
+		}
+	end
+
+	def test_foreach
+		ZipFile.open("data/generated/zipWithDir.zip") {
+			|zf|
+			ref = []
+			File.foreach("data/file1.txt") { |e| ref << e }
+			
+			index = 0
+			zf.file.foreach("data/file1.txt") { 
+				|l|
+				assert_equal(ref[index], l)
+				index = index.next
+			}
+			assert_equal(ref.size, index)
+		}
+		
+		ZipFile.open("data/generated/zipWithDir.zip") {
+			|zf|
+			ref = []
+			File.foreach("data/file1.txt", " ") { |e| ref << e }
+			
+			index = 0
+			zf.file.foreach("data/file1.txt", " ") { 
+				|l|
+				assert_equal(ref[index], l)
+				index = index.next
+			}
+			assert_equal(ref.size, index)
+		}
+	end
+
+	def test_popen
+		cmd = /mswin/i =~ RUBY_PLATFORM ? 'dir' : 'ls'
+
+		assert_equal(File.popen(cmd)          { |f| f.read }, 
+									@ole.file.popen(cmd) { |f| f.read })
+	end
+
+# Can be added later
+#  def test_select
+#    fail "implement test"
+#  end
+
+	def test_readlines
+		ZipFile.open("data/generated/zipWithDir.zip") {
+			|zf|
+			assert_equal(File.readlines("data/file1.txt"), 
+										zf.file.readlines("data/file1.txt"))
+		}
+	end
+
+	def test_read
+		ZipFile.open("data/generated/zipWithDir.zip") {
+			|zf|
+			assert_equal(File.read("data/file1.txt"), 
+										zf.file.read("data/file1.txt"))
+		}
+	end
+=end
+end
+
+class OleFsFileStatTest < Test::Unit::TestCase
+
+	def setup
+		@ole = Ole::Storage.open TEST_DIR + '/oleWithDirs.ole'
+	end
+
+	def teardown
+		@ole.close if @ole
+	end
+
+	def test_blocks
+		assert_equal(2, @ole.file.stat("file1").blocks)
+	end
+
+	def test_ino
+		assert_equal(0, @ole.file.stat("file1").ino)
+	end
+
+	def test_uid
+		assert_equal(0, @ole.file.stat("file1").uid)
+	end
+
+	def test_gid
+		assert_equal(0, @ole.file.stat("file1").gid)
+	end
+
+	def test_ftype
+		assert_equal("file", @ole.file.stat("file1").ftype)
+		assert_equal("directory", @ole.file.stat("dir1").ftype)
+	end
+
+=begin
+	def test_mode
+		assert_equal(0600, @ole.file.stat("file1").mode & 0777)
+		assert_equal(0600, @ole.file.stat("file1").mode & 0777)
+		assert_equal(0755, @ole.file.stat("dir1").mode & 0777)
+		assert_equal(0755, @ole.file.stat("dir1").mode & 0777)
+	end
+=end
+
+	def test_dev
+		assert_equal(0, @ole.file.stat("file1").dev)
+	end
+
+	def test_rdev
+		assert_equal(0, @ole.file.stat("file1").rdev)
+	end
+
+	def test_rdev_major
+		assert_equal(0, @ole.file.stat("file1").rdev_major)
+	end
+
+	def test_rdev_minor
+		assert_equal(0, @ole.file.stat("file1").rdev_minor)
+	end
+
+	def test_nlink
+		assert_equal(1, @ole.file.stat("file1").nlink)
+	end
+
+	def test_blksize
+		assert_equal(64, @ole.file.stat("file1").blksize)
+	end
+
+end
+
+class OleFsFileMutatingTest < Test::Unit::TestCase
+	def setup
+		# we use an in memory copy of the file instead of the original
+		# file based.
+		@io = StringIO.new File.read(TEST_DIR + '/oleWithDirs.ole')
+	end
+
+	def teardown
+		@io.close if @io
+	end
+ 
+	def test_delete
+		do_test_delete_or_unlink(:delete)
+	end
+
+	def test_unlink
+		do_test_delete_or_unlink(:unlink)
+	end
+	
+	def test_open_write
+		Ole::Storage.open(@io) {
+			|zf|
+
+			zf.file.open("test_open_write_entry", "w") {
+				|f|
+				blockCalled = true
+				f.write "This is what I'm writing"
+			}
+			assert_equal("This is what I'm writing",
+										zf.file.read("test_open_write_entry"))
+
+			# Test with existing entry
+			zf.file.open("file1", "w") {
+				|f|
+				blockCalled = true
+				f.write "This is what I'm writing too"
+			}
+			assert_equal("This is what I'm writing too",
+										zf.file.read("file1"))
+		}
+	end
+
+	def test_rename
+		Ole::Storage.open(@io) {
+			|zf|
+			assert_raise(Errno::ENOENT, "") { 
+				zf.file.rename("NoSuchFile", "bimse")
+			}
+			zf.file.rename("file1", "newNameForFile1")
+			# lets also try moving a file to a different directory,
+			# and renaming a directory
+			zf.file.rename('/dir1/file11', '/dir1/dir11/file111')
+			zf.file.rename('dir1', 'dir9')
+		}
+
+		Ole::Storage.open(@io) {
+			|zf|
+			assert(! zf.file.exists?("file1"))
+			assert(zf.file.exists?("newNameForFile1"))
+			assert(zf.file.exists?("dir9/dir11/file111"))
+		}
+	end
+
+	def do_test_delete_or_unlink(symbol)
+		Ole::Storage.open(@io) {
+			|zf|
+			assert(zf.file.exists?("dir2/dir21/dir221/file2221"))
+			zf.file.send(symbol, "dir2/dir21/dir221/file2221")
+			assert(! zf.file.exists?("dir2/dir21/dir221/file2221"))
+
+			assert(zf.file.exists?("dir1/file11"))
+			assert(zf.file.exists?("dir1/file12"))
+			zf.file.send(symbol, "dir1/file11", "dir1/file12")
+			assert(! zf.file.exists?("dir1/file11"))
+			assert(! zf.file.exists?("dir1/file12"))
+
+			assert_raise(Errno::ENOENT) { zf.file.send(symbol, "noSuchFile") }
+			assert_raise(Errno::EISDIR) { zf.file.send(symbol, "dir1/dir11") }
+			assert_raise(Errno::EISDIR) { zf.file.send(symbol, "dir1/dir11/") }
+		}
+
+		Ole::Storage.open(@io) {
+			|zf|
+			assert(! zf.file.exists?("dir2/dir21/dir221/file2221"))
+			assert(! zf.file.exists?("dir1/file11"))
+			assert(! zf.file.exists?("dir1/file12"))
+
+			assert(zf.file.exists?("dir1/dir11"))
+			assert(zf.file.exists?("dir1/dir11/"))
+		}
+	end
+
+end
+
+class ZipFsDirectoryTest < Test::Unit::TestCase
+	TEST_ZIP = "zipWithDirs_copy.zip"
+
+	def setup
+		# we use an in memory copy of the file instead of the original
+		# file based.
+		@io = StringIO.new File.read(TEST_DIR + '/oleWithDirs.ole')
+	end
+
+	def teardown
+		@io.close if @io
+	end
+	
+	def test_delete
+		Ole::Storage.open(@io) {
+			|zf|
+			assert_raise(Errno::ENOENT, "No such file or directory - NoSuchFile.txt") {
+				zf.dir.delete("NoSuchFile.txt")
+			}
+			# see explanation below, touch a && ruby -e 'Dir.delete "a"' gives ENOTDIR not EINVAL
+			assert_raise(Errno::ENOTDIR, "Invalid argument - file1") {
+				zf.dir.delete("file1")
+			}
+			assert(zf.file.exists?("dir1"))
+			#zf.dir.delete("dir1")
+			#assert(! zf.file.exists?("dir1"))
+			# ^ this was allowed in zipfilesystem, but my code follows Dir.delete, and requires that
+			# the directory be empty first. need to delete recursively if you want other behaviour.
+			assert_raises(Errno::ENOTEMPTY) { zf.dir.delete('dir1') }
+		}
+	end
+
+	def test_mkdir
+		Ole::Storage.open(@io) {
+			|zf|
+			assert_raise(Errno::EEXIST, "File exists - dir1") { 
+				zf.dir.mkdir("file1") 
+			}
+			assert_raise(Errno::EEXIST, "File exists - dir1") { 
+				zf.dir.mkdir("dir1") 
+			}
+			assert(!zf.file.exists?("newDir"))
+			zf.dir.mkdir("newDir")
+			assert(zf.file.directory?("newDir"))
+			assert(!zf.file.exists?("newDir2"))
+			# FIXME - mode not supported yet
+			#zf.dir.mkdir("newDir2", 3485)
+			#assert(zf.file.directory?("newDir2"))
+			zf.dir.rmdir 'newDir'
+			assert(!zf.file.exists?("newDir"))
+		}
+	end
+	
+	def test_pwd_chdir_entries
+		Ole::Storage.open(@io) {
+			|zf|
+			assert_equal("/", zf.dir.pwd)
+
+			assert_raise(Errno::ENOENT, "No such file or directory - no such dir") {
+				zf.dir.chdir "no such dir"
+			}
+			
+			# changed this to ENOTDIR, which is what touch a; ruby -e "Dir.chdir('a')" gives you.
+			assert_raise(Errno::ENOTDIR, "Invalid argument - file1") {
+				zf.dir.chdir "file1"
+			}
+
+			assert_equal(['.', '..', "dir1", "dir2", "file1"].sort, zf.dir.entries(".").sort)
+			zf.dir.chdir "dir1"
+			assert_equal("/dir1", zf.dir.pwd)
+			zf.dir.chdir('dir11') { assert_equal '/dir1/dir11', zf.dir.pwd }
+			assert_equal '/dir1', zf.dir.pwd
+			assert_equal(['.', '..', "dir11", "file11", "file12"], zf.dir.entries(".").sort)
+			
+			zf.dir.chdir "../dir2/dir21"
+			assert_equal("/dir2/dir21", zf.dir.pwd)
+			assert_equal(['.', '..', "dir221"].sort, zf.dir.entries(".").sort)
+		}
+	end
+
+	# results here are a bit different from zip/zipfilesystem, as i've chosen to fake '.'
+	# and '..'
+	def test_foreach
+		Ole::Storage.open(@io) {
+			|zf|
+
+			blockCalled = false
+			assert_raise(Errno::ENOENT, "No such file or directory - noSuchDir") {
+				zf.dir.foreach("noSuchDir") { |e| blockCalled = true }
+			}
+			assert(! blockCalled)
+
+			assert_raise(Errno::ENOTDIR, "Not a directory - file1") {
+				zf.dir.foreach("file1") { |e| blockCalled = true }
+			}
+			assert(! blockCalled)
+
+			entries = []
+			zf.dir.foreach(".") { |e| entries << e }
+			assert_equal(['.', '..', "dir1", "dir2", "file1"].sort, entries.sort)
+
+			entries = []
+			zf.dir.foreach("dir1") { |e| entries << e }
+			assert_equal(['.', '..', "dir11", "file11", "file12"], entries.sort)
+		}
+	end
+
+=begin
+	# i've gone for NoMethodError instead.
+	def test_chroot
+		Ole::Storage.open(@io) {
+			|zf|
+			assert_raise(NotImplementedError) {
+				zf.dir.chroot
+			}
+		}
+	end
+=end
+
+	# Globbing not supported yet
+	#def test_glob
+	#  # test alias []-operator too
+	#  fail "implement test"
+	#end
+
+	def test_open_new
+		Ole::Storage.open(@io) {
+			|zf|
+
+			assert_raise(Errno::ENOTDIR, "Not a directory - file1") {
+				zf.dir.new("file1")
+			}
+
+			assert_raise(Errno::ENOENT, "No such file or directory - noSuchFile") {
+				zf.dir.new("noSuchFile")
+			}
+
+			d = zf.dir.new(".")
+			assert_equal(['.', '..', "file1", "dir1", "dir2"].sort, d.entries.sort)
+			d.close
+
+			zf.dir.open("dir1") {
+				|d|
+				assert_equal(['.', '..', "dir11", "file11", "file12"].sort, d.entries.sort)
+			}
+		}
+	end
+
+end
+
+=begin
+class ZipFsDirIteratorTest < Test::Unit::TestCase
+	
+	FILENAME_ARRAY = [ "f1", "f2", "f3", "f4", "f5", "f6"  ]
+
+	def setup
+		@dirIt = ZipFileSystem::ZipFsDirIterator.new(FILENAME_ARRAY)
+	end
+
+	def test_close
+		@dirIt.close
+		assert_raise(IOError, "closed directory") {
+			@dirIt.each { |e| p e }
+		}
+		assert_raise(IOError, "closed directory") {
+			@dirIt.read
+		}
+		assert_raise(IOError, "closed directory") {
+			@dirIt.rewind
+		}
+		assert_raise(IOError, "closed directory") {
+			@dirIt.seek(0)
+		}
+		assert_raise(IOError, "closed directory") {
+			@dirIt.tell
+		}
+		
+	end
+
+	def test_each 
+		# Tested through Enumerable.entries
+		assert_equal(FILENAME_ARRAY, @dirIt.entries)
+	end
+
+	def test_read
+		FILENAME_ARRAY.size.times {
+			|i|
+			assert_equal(FILENAME_ARRAY[i], @dirIt.read)
+		}
+	end
+
+	def test_rewind
+		@dirIt.read
+		@dirIt.read
+		assert_equal(FILENAME_ARRAY[2], @dirIt.read)
+		@dirIt.rewind
+		assert_equal(FILENAME_ARRAY[0], @dirIt.read)
+	end
+	
+	def test_tell_seek
+		@dirIt.read
+		@dirIt.read
+		pos = @dirIt.tell
+		valAtPos = @dirIt.read
+		@dirIt.read
+		@dirIt.seek(pos)
+		assert_equal(valAtPos, @dirIt.read)
+	end
+
+end
+
+
+# Copyright (C) 2002, 2003 Thomas Sondergaard
+# rubyzip is free software; you can redistribute it and/or
+# modify it under the terms of the ruby license.
+=end