ruby-ole-patched-for-home_run 1.2.10.1.1

data/test/test_mbat.rb

@@ -0,0 +1,41 @@
+#! /usr/bin/ruby
+
+$: << File.dirname(__FILE__) + '/../lib'
+
+require 'test/unit'
+require 'ole/storage/base'
+require 'ole/storage/file_system'
+require 'tempfile'
+
+class TestWriteMbat < Test::Unit::TestCase
+	def test_write_mbat
+		Tempfile.open 'myolefile' do |temp|
+			temp.binmode
+
+			# this used to raise an error at flush time, due to failure to write the mbat
+			Ole::Storage.open temp do |ole|
+				# create a 10mb file
+				ole.file.open 'myfile', 'w' do |f|
+					s = 0.chr * 1_000_000
+					10.times { f.write s }
+				end
+			end
+
+			assert((10_000_000..10_100_000) === temp.size, 'check file size')
+
+			Ole::Storage.open temp do |ole|
+				assert_equal 10_000_000, ole.file.size('myfile')
+				compare = ole.bbat.truncate[(0...ole.bbat.length).find { |i| ole.bbat[i] > 50_000 }..-1]
+				c = Ole::Storage::AllocationTable
+				# 10_000_000 * 4 / 512 / 512 rounded up is 153. but then there is room needed to store the
+				# bat in the bat, and the mbat too. hence 154. 
+				expect = [c::EOC] * 2 + [c::BAT] * 154 + [c::META_BAT]
+				assert_equal expect, compare, 'allocation table structure'
+				# the sbat should be empty. in fact the file shouldn't exist at all, so the root's first
+				# block should be EOC
+				assert ole.sbat.empty?
+				assert_equal c::EOC, ole.root.first_block
+			end
+		end
+	end
+end

data/test/test_meta_data.rb

@@ -0,0 +1,45 @@
+#! /usr/bin/ruby
+
+$: << File.dirname(__FILE__) + '/../lib'
+
+require 'test/unit'
+require 'ole/storage/base'
+require 'ole/storage/meta_data'
+require 'ole/storage/file_system'
+
+class TestMetaData < Test::Unit::TestCase
+	def test_meta_data
+		Ole::Storage.open File.dirname(__FILE__) + '/test.doc', 'rb' do |ole|
+			assert_equal 'Charles Lowe', ole.meta_data[:doc_author]
+			assert_equal 'Charles Lowe', ole.meta_data['doc_author']
+			assert_equal 'Charles Lowe', ole.meta_data.to_h[:doc_author]
+			assert_equal 'Title', ole.meta_data.doc_title
+			assert_equal 'MSWordDoc', ole.meta_data.file_format
+			assert_equal 'application/msword', ole.meta_data.mime_type
+			assert_raises NotImplementedError do
+				ole.meta_data[:doc_author] = 'New Author'
+			end
+		end
+	end
+	
+	# this tests the other ways of getting the mime_type, than using "\001CompObj",
+	# ie, relying on root clsid, and on the heuristics
+	def test_mime_type
+		ole = Ole::Storage.new StringIO.new
+		ole.root.clsid = Ole::Storage::MetaData::CLSID_EXCEL97.to_s
+		assert_equal nil, ole.meta_data.file_format
+		assert_equal 'application/vnd.ms-excel', ole.meta_data.mime_type
+		
+		ole.root.clsid = 0.chr * Ole::Types::Clsid::SIZE
+		assert_equal nil, ole.meta_data.file_format
+		assert_equal 'application/x-ole-storage', ole.meta_data.mime_type
+		
+		ole.file.open('Book', 'w') { |f| }
+		assert_equal 'application/vnd.ms-excel', ole.meta_data.mime_type
+		ole.file.open('WordDocument', 'w') { |f| }
+		assert_equal 'application/msword', ole.meta_data.mime_type
+		ole.file.open('__properties_version1.0', 'w') { |f| }
+		assert_equal 'application/vnd.ms-outlook', ole.meta_data.mime_type
+	end
+end
+

data/test/test_property_set.rb

@@ -0,0 +1,40 @@
+#! /usr/bin/ruby
+
+$: << File.dirname(__FILE__) + '/../lib'
+
+require 'test/unit'
+require 'ole/types/property_set'
+
+class TestPropertySet < Test::Unit::TestCase
+	include Ole::Types
+
+	def setup
+		@io = open File.dirname(__FILE__) + '/test_SummaryInformation', 'rb'
+	end
+
+	def teardown
+		@io.close
+	end
+
+	def test_property_set
+		propset = PropertySet.new @io
+		assert_equal :mac, propset.os
+		assert_equal 1, propset.sections.length
+		section = propset.sections.first
+		assert_equal 14, section.length
+		assert_equal 'f29f85e0-4ff9-1068-ab91-08002b27b3d9', section.guid.format
+		assert_equal PropertySet::FMTID_SummaryInformation, section.guid
+		assert_equal 'Charles Lowe', section.to_a.assoc(4).last
+		assert_equal 'Charles Lowe', propset.doc_author
+		assert_equal 'Charles Lowe', propset.to_h[:doc_author]
+
+		# knows the difference between existent and non-existent properties
+		assert_raise(NoMethodError) { propset.non_existent_key }
+		assert_raise(NotImplementedError) { propset.doc_author = 'New Author'}
+		assert_raise(NoMethodError) { propset.non_existent_key = 'Value'}
+		
+		# a valid property that has no value in this property set
+		assert_equal nil, propset.security
+	end
+end
+

data/test/test_ranges_io.rb

@@ -0,0 +1,103 @@
+#! /usr/bin/ruby
+
+$: << File.dirname(__FILE__) + '/../lib'
+
+require 'test/unit'
+require 'ole/ranges_io'
+require 'stringio'
+
+class TestRangesIO < Test::Unit::TestCase
+	TEST_DIR = File.dirname __FILE__
+
+	def setup
+		# read from ourself, also using overlaps.
+		ranges = [100..200, 0..10, 100..150]
+		@io = RangesIO.new open("#{TEST_DIR}/test_ranges_io.rb"), :ranges => ranges, :close_parent => true
+	end
+
+	def teardown
+		@io.close
+	end
+
+	def test_open
+		# block form
+		f = open("#{TEST_DIR}/test_ranges_io.rb")
+		assert_equal false, f.closed?
+		RangesIO.open f, :ranges => []
+		assert_equal false, f.closed?
+		RangesIO.open(f, :ranges => [], :close_parent => true) {}
+		assert_equal true, f.closed?
+	end
+
+	def test_basics
+		assert_equal 160, @io.size
+		assert_match %r{size=160}, @io.inspect
+	end
+
+	def test_truncate
+		assert_raises(NotImplementedError) { @io.size += 10 }
+	end
+
+	def test_seek
+		@io.pos = 10
+		@io.seek(-100, IO::SEEK_END)
+		@io.seek(-10, IO::SEEK_CUR)
+		@io.pos += 20
+		assert_equal 70, @io.pos
+		# seeking past the end doesn't throw an exception for normal
+		# files, even in read mode, but RangesIO does
+		assert_raises(Errno::EINVAL) { @io.seek 500 }
+		assert_raises(Errno::EINVAL) { @io.seek(-500, IO::SEEK_END) }
+		assert_raises(Errno::EINVAL) { @io.seek 1, 10 }
+	end
+
+	def test_read
+		# this will map to the start of the file:
+		@io.pos = 100
+		assert_equal '#! /usr/bi', @io.read(10)
+		# test selection of initial range, offset within that range
+		pos = 80
+		@io.seek pos
+		# test advancing of pos properly, by...
+		chunked = (0...10).map { @io.read 10 }.join
+		# given the file is 160 long:
+		assert_equal 80, chunked.length
+		@io.seek pos
+		# comparing with a flat read
+		assert_equal chunked, @io.read(80)
+	end
+
+	# should test gets, lineno, and other IO methods we want to have
+	def test_gets
+		assert_equal "io'\n", @io.gets
+	end
+
+	def test_write
+		str = File.read "#{TEST_DIR}/test_ranges_io.rb"
+		@io = RangesIO.new StringIO.new(str), :ranges => @io.ranges
+		assert_equal "io'\nrequir", str[100, 10]
+		@io.write 'testing testing'
+		assert_equal 'testing te', str[100, 10]
+		@io.seek 0
+		assert_equal 'testing te', @io.read(10)
+		# lets write over a range barrier
+		assert_equal '#! /usr/bi', str[0, 10]
+		assert_equal "LE__\n\n\tdef", str[195, 10]
+		@io.write 'x' * 100
+		assert_equal 'x' * 10, str[0, 10]
+		assert_equal "xxxxx\n\tdef", str[195, 10]
+		# write enough to overflow the file
+		assert_raises(IOError) { @io.write 'x' * 60 }
+	end
+	
+	def test_non_resizeable
+		# will try to truncate, which will fail
+		assert_raises NotImplementedError do
+			@io = RangesIO.new(StringIO.new, 'w', :ranges => [])
+		end
+		# will be fine
+		@io = RangesIONonResizeable.new(StringIO.new, 'w', :ranges => [])
+		assert_equal '#<IO::Mode wronly|creat>', @io.instance_variable_get(:@mode).inspect
+	end
+end
+

data/test/test_storage.rb

@@ -0,0 +1,220 @@
+#! /usr/bin/ruby
+
+$: << File.dirname(__FILE__) + '/../lib'
+#require 'rubygems'
+
+require 'test/unit'
+require 'ole/storage'
+require 'digest/sha1'
+require 'stringio'
+require 'tempfile'
+
+#
+# = TODO
+#
+# These tests could be a lot more complete.
+#
+
+# should test resizeable and migrateable IO.
+
+class TestStorageRead < Test::Unit::TestCase
+	TEST_DIR = File.dirname __FILE__
+
+	def setup
+		@ole = Ole::Storage.open "#{TEST_DIR}/test_word_6.doc", 'rb'
+	end
+
+	def teardown
+		@ole.close
+	end
+
+	def test_header
+		# should have further header tests, testing the validation etc.
+		assert_equal 17,  @ole.header.to_a.length
+		assert_equal 117, @ole.header.dirent_start
+		assert_equal 1,   @ole.header.num_bat
+		assert_equal 1,   @ole.header.num_sbat
+		assert_equal 0,   @ole.header.num_mbat
+	end
+	
+	def test_new_without_explicit_mode
+		open "#{TEST_DIR}/test_word_6.doc", 'rb' do |f|
+			assert_equal false, Ole::Storage.new(f).writeable
+		end
+	end
+
+	def capture_warnings
+		@warn = []
+		outer_warn = @warn
+		old_log = Ole::Log
+		old_verbose = $VERBOSE
+		begin
+			$VERBOSE = nil
+			Ole.const_set :Log, Object.new
+			# restore for the yield
+			$VERBOSE = old_verbose
+			(class << Ole::Log; self; end).send :define_method, :warn do |message|
+				outer_warn << message
+			end
+			yield
+		ensure
+			$VERBOSE = nil
+			Ole.const_set :Log, old_log
+			$VERBOSE = old_verbose
+		end
+	end
+
+	def test_invalid
+		assert_raises Ole::Storage::FormatError do
+			Ole::Storage.open StringIO.new(0.chr * 1024)
+		end
+		assert_raises Ole::Storage::FormatError do
+			Ole::Storage.open StringIO.new(Ole::Storage::Header::MAGIC + 0.chr * 1024)
+		end
+		capture_warnings do
+			head = Ole::Storage::Header.new
+			head.threshold = 1024
+			assert_raises NoMethodError do
+				Ole::Storage.open StringIO.new(head.to_s + 0.chr * 1024)
+			end
+		end
+		assert_equal ['may not be a valid OLE2 structured storage file'], @warn
+	end
+	
+	def test_inspect
+		assert_match(/#<Ole::Storage io=#<File:.*?test_word_6.doc> root=#<Dirent:"Root Entry">>/, @ole.inspect)
+	end
+
+	def test_fat
+		# the fat block has all the numbers from 5..118 bar 117
+		bbat_table = [112] + ((5..118).to_a - [112, 117])
+		assert_equal bbat_table, @ole.bbat.reject { |i| i >= (1 << 32) - 3 }, 'bbat'
+		sbat_table = (1..43).to_a - [2, 3]
+		assert_equal sbat_table, @ole.sbat.reject { |i| i >= (1 << 32) - 3 }, 'sbat'
+	end
+
+	def test_directories
+		assert_equal 5, @ole.dirents.length, 'have all directories'
+		# a more complicated one would be good for this
+		assert_equal 4, @ole.root.children.length, 'properly nested directories'
+	end
+
+	def test_utf16_conversion
+		assert_equal 'Root Entry', @ole.root.name
+		assert_equal 'WordDocument', @ole.root.children[2].name
+	end
+
+	def test_read
+		# the regular String#hash was different on the mac, so asserting
+		# against full strings. switch this to sha1 instead of this fugly blob
+		sha1sums = %w[
+			d3d1cde9eb43ed4b77d197af879f5ca8b8837577
+			65b75cbdd1f94ade632baeeb0848dec2a342c844
+			cfc230ec7515892cfdb85e4a173e0ce364094970
+			ffd859d94647a11b693f06f092d1a2bccc59d50d
+		]
+
+		# test the ole storage type
+		type = 'Microsoft Word 6.0-Dokument'
+		assert_equal type, (@ole.root/"\001CompObj").read[32..-1][/([^\x00]+)/m, 1]
+		# i was actually not loading data correctly before, so carefully check everything here
+		assert_equal sha1sums, @ole.root.children.map { |child| Digest::SHA1.hexdigest child.read }
+	end
+
+	def test_dirent
+		dirent = @ole.root.children.first
+		assert_equal "\001Ole", dirent.name
+		assert_equal 20, dirent.size
+		assert_equal '#<Dirent:"Root Entry">', @ole.root.inspect
+		
+		# exercise Dirent#[]. note that if you use a number, you get the Struct
+		# fields.
+		assert_equal dirent, @ole.root["\001Ole"]
+		assert_equal dirent.name_utf16, dirent[0]
+		assert_equal nil, @ole.root.time
+		
+		assert_equal @ole.root.children, @ole.root.to_enum(:each_child).to_a
+
+		dirent.open('r') { |f| assert_equal 2, f.first_block }
+		dirent.open('w') { |f| }
+		dirent.open('a') { |f| }
+	end
+
+	def test_delete
+		dirent = @ole.root.children.first
+		assert_raises(ArgumentError) { @ole.root.delete nil }
+		assert_equal [dirent], @ole.root.children & [dirent]
+		assert_equal 20, dirent.size
+		@ole.root.delete dirent
+		assert_equal [], @ole.root.children & [dirent]
+		assert_equal 0, dirent.size
+	end
+end
+
+class TestStorageWrite < Test::Unit::TestCase
+	TEST_DIR = File.dirname __FILE__
+
+	def sha1 str
+		Digest::SHA1.hexdigest str
+	end
+
+	# try and test all the various things the #flush function does
+	def test_flush
+	end
+	
+	# FIXME
+	# don't really want to lock down the actual internal api's yet. this will just
+	# ensure for the time being that #flush continues to work properly. need a host
+	# of checks involving writes that resize their file bigger/smaller, that resize
+	# the bats to more blocks, that resizes the sb_blocks, that has migration etc.
+	def test_write_hash
+		io = StringIO.open open("#{TEST_DIR}/test_word_6.doc", 'rb', &:read)
+		assert_equal '9974e354def8471225f548f82b8d81c701221af7', sha1(io.string)
+		Ole::Storage.open(io, :update_timestamps => false) { }
+		# hash changed. used to be efa8cfaf833b30b1d1d9381771ddaafdfc95305c
+		# thats because i now truncate the io, and am probably removing some trailing
+		# allocated available blocks.
+		assert_equal 'a39e3c4041b8a893c753d50793af8d21ca8f0a86', sha1(io.string)
+		# add a repack test here
+		Ole::Storage.open io, :update_timestamps => false, &:repack
+		assert_equal 'c8bb9ccacf0aaad33677e1b2a661ee6e66a48b5a', sha1(io.string)
+	end
+
+	def test_plain_repack
+		io = StringIO.open open("#{TEST_DIR}/test_word_6.doc", 'rb', &:read)
+		assert_equal '9974e354def8471225f548f82b8d81c701221af7', sha1(io.string)
+		Ole::Storage.open io, :update_timestamps => false, &:repack
+		# note equivalence to the above flush, repack, flush
+		assert_equal 'c8bb9ccacf0aaad33677e1b2a661ee6e66a48b5a', sha1(io.string)
+		# lets do it again using memory backing
+		Ole::Storage.open(io, :update_timestamps => false) { |ole| ole.repack :mem }
+		# note equivalence to the above flush, repack, flush
+		assert_equal 'c8bb9ccacf0aaad33677e1b2a661ee6e66a48b5a', sha1(io.string)
+		assert_raises ArgumentError do
+			Ole::Storage.open(io, :update_timestamps => false) { |ole| ole.repack :typo }
+		end
+	end
+
+	def test_create_from_scratch_hash
+		io = StringIO.new('')
+		Ole::Storage.open(io) { }
+		assert_equal '6bb9d6c1cdf1656375e30991948d70c5fff63d57', sha1(io.string)
+		# more repack test, note invariance
+		Ole::Storage.open io, :update_timestamps => false, &:repack
+		assert_equal '6bb9d6c1cdf1656375e30991948d70c5fff63d57', sha1(io.string)
+	end
+
+	def test_create_dirent
+		Ole::Storage.open StringIO.new do |ole|
+			dirent = Ole::Storage::Dirent.new ole, :name => 'test name', :type => :dir
+			assert_equal 'test name', dirent.name
+			assert_equal :dir, dirent.type
+			# for a dirent created from scratch, type_id is currently not set until serialization:
+			assert_equal 0, dirent.type_id
+			dirent.to_s
+			assert_equal 1, dirent.type_id
+			assert_raises(ArgumentError) { Ole::Storage::Dirent.new ole, :type => :bogus }
+		end
+	end
+end
+