keeguon-ruby-ole 1.2.11.7

data/lib/ole/types/property_set.rb

@@ -0,0 +1,202 @@
+# encoding: ASCII-8BIT
+
+module Ole
+	module Types
+		#
+		# The PropertySet class currently supports readonly access to the properties
+		# serialized in "property set" streams, such as the file "\005SummaryInformation",
+		# in OLE files.
+		#
+		# Think it has its roots in MFC property set serialization.
+		#
+		# See http://poi.apache.org/hpsf/internals.html for details
+		#
+		class PropertySet
+			HEADER_SIZE = 28
+			HEADER_PACK = "vvVa#{Clsid::SIZE}V"
+			OS_MAP = {
+				0 => :win16,
+				1 => :mac,
+				2 => :win32,
+				0x20001 => :ooffice, # open office on linux...
+			}
+
+			# define a smattering of the property set guids. 
+			DATA = {
+				Clsid.parse('{f29f85e0-4ff9-1068-ab91-08002b27b3d9}') => ['FMTID_SummaryInformation', {
+					2  => 'doc_title',
+					3  => 'doc_subject',
+					4  => 'doc_author',
+					5  => 'doc_keywords',
+					6  => 'doc_comments',
+					7  => 'doc_template',
+					8  => 'doc_last_author',
+					9  => 'doc_rev_number',
+					10 => 'doc_edit_time',
+					11 => 'doc_last_printed',
+					12 => 'doc_created_time',
+					13 => 'doc_last_saved_time',
+					14 => 'doc_page_count',
+					15 => 'doc_word_count',
+					16 => 'doc_char_count',
+					18 => 'doc_app_name',
+					19 => 'security'
+				}],
+				Clsid.parse('{d5cdd502-2e9c-101b-9397-08002b2cf9ae}') => ['FMTID_DocSummaryInfo', {
+					2  => 'doc_category',
+					3  => 'doc_presentation_target',
+					4  => 'doc_byte_count',
+					5  => 'doc_line_count',
+					6  => 'doc_para_count',
+					7  => 'doc_slide_count',
+					8  => 'doc_note_count',
+					9  => 'doc_hidden_count',
+					10 => 'mmclips',
+					11 => 'scale_crop',
+					12 => 'heading_pairs',
+					13 => 'doc_part_titles',
+					14 => 'doc_manager',
+					15 => 'doc_company',
+					16 => 'links_up_to_date'
+				}],
+				Clsid.parse('{d5cdd505-2e9c-101b-9397-08002b2cf9ae}') => ['FMTID_UserDefinedProperties', {}]
+			}
+
+			# create an inverted map of names to guid/key pairs
+			PROPERTY_MAP = DATA.inject({}) do |h1, (guid, data)|
+				data[1].inject(h1) { |h2, (id, name)| h2.update name => [guid, id] }
+			end
+
+			module Constants
+				DATA.each { |guid, (name, _)| const_set name, guid }
+			end
+
+			include Constants
+			include Enumerable
+
+			class Section
+				include Variant::Constants
+				include Enumerable
+
+				SIZE = Clsid::SIZE + 4
+				PACK = "a#{Clsid::SIZE}v"
+
+				attr_accessor :guid, :offset
+				attr_reader :length
+
+				def initialize str, property_set
+					@property_set = property_set
+					@guid, @offset = str.unpack PACK
+					self.guid = Clsid.load guid
+					load_header
+				end
+
+				def io
+					@property_set.io
+				end
+
+				def load_header
+					io.seek offset
+					@byte_size, @length = io.read(8).unpack 'V2'
+				end
+				
+				def [] key
+					each_raw do |id, property_offset|
+						return read_property(property_offset).last if key == id
+					end
+					nil
+				end
+				
+				def []= key, value
+					raise NotImplementedError, 'section writes not yet implemented'
+				end
+				
+				def each
+					each_raw do |id, property_offset|
+						yield id, read_property(property_offset).last
+					end
+				end
+
+			private
+
+				def each_raw
+					io.seek offset + 8
+					io.read(length * 8).each_chunk(8) { |str| yield(*str.unpack('V2')) }
+				end
+				
+				def read_property property_offset
+					io.seek offset + property_offset
+					type, value = io.read(8).unpack('V2')
+					# is the method of serialization here custom?
+					case type
+					when VT_LPSTR, VT_LPWSTR
+						value = Variant.load type, io.read(value)
+					# ....
+					end
+					[type, value]
+				end
+			end
+						
+			attr_reader :io, :signature, :unknown, :os, :guid, :sections
+			
+			def initialize io
+				@io = io
+				load_header io.read(HEADER_SIZE)
+				load_section_list io.read(@num_sections * Section::SIZE)
+				# expect no gap between last section and start of data.
+				#Log.warn "gap between section list and property data" unless io.pos == @sections.map(&:offset).min
+			end
+
+			def load_header str
+				@signature, @unknown, @os_id, @guid, @num_sections = str.unpack HEADER_PACK
+				# should i check that unknown == 0? it usually is. so is the guid actually
+				@guid = Clsid.load @guid
+				@os = OS_MAP[@os_id] || Log.warn("unknown operating system id #{@os_id}")
+			end
+
+			def load_section_list str
+				@sections = str.to_enum(:each_chunk, Section::SIZE).map { |s| Section.new s, self }
+			end
+			
+			def [] key
+				pair = PROPERTY_MAP[key.to_s] or return nil
+				section = @sections.find { |s| s.guid == pair.first } or return nil
+				section[pair.last]
+			end
+			
+			def []= key, value
+				pair = PROPERTY_MAP[key.to_s] or return nil
+				section = @sections.find { |s| s.guid == pair.first } or return nil
+				section[pair.last] = value
+			end
+			
+			def method_missing name, *args, &block
+				if name.to_s =~ /(.*)=$/
+					return super unless args.length == 1
+					return super unless PROPERTY_MAP[$1]
+					self[$1] = args.first
+				else
+					return super unless args.length == 0
+					return super unless PROPERTY_MAP[name.to_s]
+					self[name]
+				end
+			end
+			
+			def each
+				@sections.each do |section|
+					next unless pair = DATA[section.guid]
+					map = pair.last
+					section.each do |id, value|
+						name = map[id] or next
+						yield name, value
+					end
+				end
+			end
+			
+			def to_h
+				inject({}) { |hash, (name, value)| hash.update name.to_sym => value }
+			end
+		end
+	end
+end
+

data/ruby-ole.gemspec

@@ -0,0 +1,32 @@
+$:.unshift File.dirname(__FILE__) + '/lib'
+require 'ole/storage/version'
+
+PKG_NAME = 'keeguon-ruby-ole'
+PKG_VERSION = Ole::Storage::VERSION
+
+Gem::Specification.new do |s|
+	s.name = PKG_NAME
+	s.version = PKG_VERSION
+	s.summary = %q{Ruby OLE library.}
+	s.description = %q{A library for easy read/write access to OLE compound documents for Ruby.}
+	s.authors = ['Charles Lowe', 'Félix Bellanger']
+	s.email = %q{aquasync@gmail.com}
+	s.homepage = %q{http://code.google.com/p/ruby-ole}
+	s.rubyforge_project = %q{ruby-ole}
+
+	s.executables = ['oletool']
+	s.files  = ['README', 'COPYING', 'Rakefile', 'ChangeLog', 'ruby-ole.gemspec']
+	s.files += Dir.glob('lib/**/*.rb')
+	s.files += Dir.glob('test/{test_*.rb,*.doc,oleWithDirs.ole,test_SummaryInformation}')
+	s.files += Dir.glob('bin/*')
+	s.test_files = Dir.glob('test/test_*.rb')
+
+	s.has_rdoc = true
+	s.extra_rdoc_files = ['README', 'ChangeLog']
+	s.rdoc_options += [
+		'--main', 'README',
+		'--title', "#{PKG_NAME} documentation",
+		'--tab-width', '2'
+	]
+end
+

data/test/test_filesystem.rb

@@ -0,0 +1,932 @@
+#! /usr/bin/ruby
+# encoding: ASCII-8BIT
+
+#
+# = 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/storage'
+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', 'rb'
+	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
+
+	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
+
+	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', 'rb'
+	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
+
+	# an additional test i added for coverage. i've tried to make the inspect
+	# string on the ole stat match that of the regular one.
+	def test_inspect
+		# normalize, as instance_variables order is undefined
+		normalize = proc { |s| s[/ (.*)>$/, 1].split(', ').sort.join(', ') }
+		assert_match %r{blocks=2.*ftype=file.*size=72}, normalize[@ole.file.stat('file1').inspect]
+	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 open(TEST_DIR + '/oleWithDirs.ole', 'rb', &:read)
+	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|
+
+			blockCalled = nil
+			zf.file.open("test_open_write_entry", "w") {
+				|f|
+				blockCalled = true
+				f.write "This is what I'm writing"
+			}
+			assert(blockCalled)
+			assert_equal("This is what I'm writing",
+										zf.file.read("test_open_write_entry"))
+
+			blockCalled = nil
+			# Test with existing entry
+			zf.file.open("file1", "w") {
+				|f|
+				blockCalled = true
+				f.write "This is what I'm writing too"
+			}
+			assert(blockCalled)
+			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 OleFsDirectoryTest < Test::Unit::TestCase
+	def setup
+		# we use an in memory copy of the file instead of the original
+		# file based.
+		@io = StringIO.new open(TEST_DIR + '/oleWithDirs.ole', 'rb', &:read)
+	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") {
+				|d2|
+				assert_equal(['.', '..', "dir11", "file11", "file12"].sort, d2.entries.sort)
+			}
+		}
+	end
+
+end
+
+class OleFsDirIteratorTest < Test::Unit::TestCase
+	
+	FILENAME_ARRAY = [ "f1", "f2", "f3", "f4", "f5", "f6"  ]
+
+	def setup
+		@dirIt = Ole::Storage::DirClass::Dir.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
+
+class OleUnicodeTest < Test::Unit::TestCase
+	def setup
+		@io = StringIO.new ''
+	end
+	
+	def test_unicode
+		# in ruby-1.8, encoding is assumed to be UTF-8 (and converted with iconv).
+		# in ruby-1.9, UTF-8 should work also, but probably shouldn't be using fixed
+		# TO_UTF16 iconv for other encodings.
+		resume = "R\xc3\xa9sum\xc3\xa9"
+		resume.force_encoding Encoding::UTF_8 if resume.respond_to? :encoding
+		Ole::Storage.open @io do |ole|
+			ole.file.open(resume, 'w') { |f| f.write 'Skills: writing bad unit tests' }
+		end
+		Ole::Storage.open @io do |ole|
+			assert_equal ['.', '..', resume], ole.dir.entries('.')
+			# use internal api to verify utf16 encoding
+			assert_equal "R\x00\xE9\x00s\x00u\x00m\x00\xE9\x00", ole.root.children[0].name_utf16[0, 6 * 2]
+			# FIXME: there is a bug in ruby-1.9 (at least in p376), which makes encoded
+			# strings useless as hash keys. identical bytes, identical encodings, identical
+			# according to #==, but different hash.
+			temp = File.expand_path("/#{resume}").split('/').last
+			if resume == temp and resume.hash != temp.hash
+				warn 'skipping assertion due to broken String#hash'
+			else
+				assert_equal 'Skills', ole.file.read(resume).split(': ', 2).first
+			end
+		end
+	end
+
+	def test_write_utf8_string
+		programmer = "programa\xC3\xA7\xC3\xA3o "
+		programmer.force_encoding Encoding::UTF_8 if programmer.respond_to? :encoding
+		Ole::Storage.open @io do |ole|
+			ole.file.open '1', 'w' do |writer|
+				writer.write(programmer)
+				writer.write('ruby')
+			end
+		end
+		Ole::Storage.open @io do |ole|
+			ole.file.open '1', 'r' do |reader|
+				s = reader.read
+				s = s.force_encoding('UTF-8') if s.respond_to?(:encoding)
+				assert_equal(programmer + 'ruby', s)
+			end
+		end
+	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.
+