ruby-ole 1.2.1 → 1.2.2

data/test/test_ranges_io.rb

@@ -0,0 +1,100 @@
+#! /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, :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, []
+		assert_equal false, f.closed?
+		RangesIO.open(f, [], :close_parent => true) {}
+		assert_equal true, f.closed?
+	end
+
+	def test_basics
+		assert_equal 160, @io.size
+		assert_match %r{size=160,.*range=100\.\.200}, @io.inspect
+	end
+
+	def test_truncate
+		assert_raises(NotImplementedError) { @io.size += 10 }
+	end
+
+	def test_offset_and_size
+		assert_equal [[100, 100], 0], @io.offset_and_size(0)
+		assert_equal [[150, 50], 0], @io.offset_and_size(50)
+		assert_equal [[5, 5], 1], @io.offset_and_size(105)
+		assert_raises(ArgumentError) { @io.offset_and_size 1000 }
+	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), @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
+end
+

data/test/test_storage.rb

@@ -1,7 +1,6 @@
-#! /usr/bin/ruby -w
+#! /usr/bin/ruby
 
-TEST_DIR = File.dirname __FILE__
-$: << "#{TEST_DIR}/../lib"
+$: << File.dirname(__FILE__) + '/../lib'
 
 require 'test/unit'
 require 'ole/storage'
@@ -14,44 +13,11 @@ require 'stringio'
 # These tests could be a lot more complete.
 #
 
-class TestRangesIO < Test::Unit::TestCase
-	def setup
-		# why not :) ?
-		# repeats too
-		ranges = [100..200, 0..10, 100..150]
-		@io = RangesIO.new open("#{TEST_DIR}/test_storage.rb"), ranges, :close_parent => true
-	end
-
-	def teardown
-		@io.close
-	end
-
-	def test_basic
-		assert_equal 160, @io.size
-		# this will map to the start of the file:
-		@io.pos = 100
-		assert_equal '#! /usr/bi', @io.read(10)
-	end
-
-	# should test range_and_offset specifically
-
-	def test_reading
-		# test selection of initial range, offset within that range
-		pos = 100
-		@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 60, chunked.length
-		@io.seek pos
-		# comparing with a flat read
-		assert_equal chunked, @io.read(60)
-	end
-end
-
 # 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
@@ -60,6 +26,10 @@ class TestStorageRead < Test::Unit::TestCase
 		@ole.close
 	end
 
+	def test_invalid
+		assert_raises(Ole::Storage::FormatError) { Ole::Storage.open StringIO.new(0.chr * 1024) }
+	end
+
 	def test_header
 		# should have further header tests, testing the validation etc.
 		assert_equal 17,  @ole.header.to_a.length
@@ -72,9 +42,9 @@ class TestStorageRead < Test::Unit::TestCase
 	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.table.reject { |i| i >= (1 << 32) - 3 }, 'bbat'
+		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.table.reject { |i| i >= (1 << 32) - 3 }, 'sbat'
+		assert_equal sbat_table, @ole.sbat.reject { |i| i >= (1 << 32) - 3 }, 'sbat'
 	end
 
 	def test_directories
@@ -88,10 +58,10 @@ class TestStorageRead < Test::Unit::TestCase
 		assert_equal 'WordDocument', @ole.root.children[2].name
 	end
 
-	def test_data
+	def test_read
 		# test the ole storage type
 		type = 'Microsoft Word 6.0-Dokument'
-		assert_equal type, @ole.root["\001CompObj"].read[/^.{32}([^\x00]+)/m, 1]
+		assert_equal type, (@ole.root/"\001CompObj").read[/^.{32}([^\x00]+)/m, 1]
 		# i was actually not loading data correctly before, so carefully check everything here
 		hashes = [-482597081, 285782478, 134862598, -863988921]
 		assert_equal hashes, @ole.root.children.map { |child| child.read.hash }
@@ -99,9 +69,15 @@ class TestStorageRead < Test::Unit::TestCase
 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
@@ -111,29 +87,41 @@ class TestStorageWrite < Test::Unit::TestCase
 	def test_write_hash
 		io = StringIO.open File.read("#{TEST_DIR}/test_word_6.doc")
 		assert_equal '9974e354def8471225f548f82b8d81c701221af7', sha1(io.string)
-		Ole::Storage.open(io) { }
+		Ole::Storage.open(io, :update_timestamps => false) { }
 		assert_equal 'efa8cfaf833b30b1d1d9381771ddaafdfc95305c', sha1(io.string)
 		# add a repack test here
-		Ole::Storage.open io, &:repack
+		Ole::Storage.open io, :update_timestamps => false, &:repack
 		assert_equal 'c8bb9ccacf0aaad33677e1b2a661ee6e66a48b5a', sha1(io.string)
 	end
 
 	def test_plain_repack
 		io = StringIO.open File.read("#{TEST_DIR}/test_word_6.doc")
 		assert_equal '9974e354def8471225f548f82b8d81c701221af7', sha1(io.string)
-		Ole::Storage.open io, &:repack
+		Ole::Storage.open io, :update_timestamps => false, &:repack
 		# note equivalence to the above flush, repack, flush
 		assert_equal 'c8bb9ccacf0aaad33677e1b2a661ee6e66a48b5a', sha1(io.string)
 	end
 
 	def test_create_from_scratch_hash
 		io = StringIO.new
-		Ole::Storage.new(io) { }
+		Ole::Storage.open(io) { }
 		assert_equal '6bb9d6c1cdf1656375e30991948d70c5fff63d57', sha1(io.string)
 		# more repack test, note invariance
-		Ole::Storage.open io, &:repack
+		Ole::Storage.open io, :update_timestamps => false, &:repack
 		assert_equal '6bb9d6c1cdf1656375e30991948d70c5fff63d57', sha1(io.string)
 	end
-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
 

data/test/test_support.rb

@@ -0,0 +1,121 @@
+#! /usr/bin/ruby
+
+$: << File.dirname(__FILE__) + '/../lib'
+
+require 'test/unit'
+require 'ole/support'
+
+class TestSupport < Test::Unit::TestCase
+	TEST_DIR = File.dirname __FILE__
+
+	def test_file
+		assert_equal 4096, open("#{TEST_DIR}/oleWithDirs.ole") { |f| f.size }
+		# point is to have same interface as:
+		assert_equal 4096, StringIO.open(File.read("#{TEST_DIR}/oleWithDirs.ole")).size
+	end
+
+	def test_enumerable
+		expect = {0 => [2, 4], 1 => [1, 3]}
+		assert_equal expect, [1, 2, 3, 4].group_by { |i| i & 1 }
+		assert_equal 10, [1, 2, 3, 4].sum
+		assert_equal %w[1 2 3 4], [1, 2, 3, 4].map(&:to_s)
+	end
+
+	def test_logger
+		io = StringIO.new
+		log = Logger.new_with_callstack io
+		log.warn 'test'
+		expect = %r{^\[\d\d:\d\d:\d\d \./test/test_support\.rb:\d+:test_logger\]\nWARN   test$}
+		assert_match expect, io.string.chomp
+	end
+
+	def test_io
+		str = 'a' * 5000 + 'b'
+		src, dst = StringIO.new(str), StringIO.new
+		IO.copy src, dst
+		assert_equal str, dst.string
+	end
+
+	def test_string
+		str = "aa aa ||| aa aa"
+		assert_equal [0, 3, 10, 13], str.indexes('aa')
+		# this is mostly a check that regexp quote is used.
+		assert_equal [6, 7, 8], str.indexes('|')
+		# note not [6, 7] - no overlaps
+		assert_equal [6], str.indexes('||')
+	end
+end
+
+class TestRecursivelyEnumerable < Test::Unit::TestCase
+	class Container
+		include RecursivelyEnumerable
+	
+		def initialize *children
+			@children = children
+		end
+	
+		def each_child(&block)
+			@children.each(&block)
+		end
+	
+		def inspect
+			"#<Container>"
+		end
+	end
+	
+	def setup
+		@root = Container.new(
+			Container.new(1),
+			Container.new(2,
+				Container.new(
+					Container.new(3)
+				)
+			),
+			4,
+			Container.new()
+		)
+	end
+
+	def test_find
+		i = 0
+		found = @root.recursive.find do |obj|
+			i += 1
+			obj == 4
+		end
+		assert_equal found, 4
+		assert_equal 9, i
+
+		i = 0
+		found = @root.recursive(:breadth_first).find do |obj|
+			i += 1
+			obj == 4
+		end
+		assert_equal found, 4
+		assert_equal 4, i
+
+		# this is to make sure we hit the breadth first child cache
+		i = 0
+		found = @root.recursive(:breadth_first).find do |obj|
+			i += 1
+			obj == 3
+		end
+		assert_equal found, 3
+		assert_equal 10, i
+	end
+
+	def test_to_tree
+		assert_equal <<-'end', @root.to_tree
+- #<Container>
+  |- #<Container>
+  |  \- 1
+  |- #<Container>
+  |  |- 2
+  |  \- #<Container>
+  |     \- #<Container>
+  |        \- 3
+  |- 4
+  \- #<Container>
+		end
+	end
+end
+

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: ruby-ole
 version: !ruby/object:Gem::Version 
-  version: 1.2.1
-date: 2007-05-21 00:00:00 +10:00
+  version: 1.2.2
+date: 2007-11-06 00:00:00 +11:00
 summary: Ruby OLE library.
 require_paths: 
 - lib
@@ -31,13 +31,17 @@ authors:
 files: 
 - Rakefile
 - bin/oletool
+- lib/ole/ranges_io.rb
+- lib/ole/property_set.rb
 - lib/ole/types.rb
 - lib/ole/file_system.rb
 - lib/ole/support.rb
 - lib/ole/storage.rb
-- lib/ole/io_helpers.rb
 - lib/ole/base.rb
+- test/test_ranges_io.rb
+- test/test_support.rb
 - test/test_storage.rb
+- test/test_filesystem.rb
 - test/test_word_6.doc
 - test/test_word_95.doc
 - test/test_word_97.doc