rb-scpt 1.0.0

data/test/README

@@ -0,0 +1,3 @@
+Some of the code in these tests may not yet be 100% portable (hardcoded paths, etc) so may currently fail for some users, although they have passed for Ruby 1.8.x on OS X 10.3.9, OS X 10.4.x (PPC & i386) and OS X 10.5.1 (i386).
+
+Note that some mactypes unit tests may fail as Alias and FileURL comparisons are rather dumb and don't normalise path strings before comparing/hashing. Future releases may try to remedy this.

data/test/test_aemreference.rb

@@ -0,0 +1,118 @@
+#!/usr/bin/ruby -w
+
+begin; require 'rubygems'; rescue LoadError; end
+
+require 'test/unit'
+require "_aem/aemreference"
+require "_aem/typewrappers"
+require "_aem/codecs"
+
+
+class TC_AEMReferences < Test::Unit::TestCase
+
+	def test_reference_forms
+		[
+			[AEMReference::App.property('ctxt'), 'AEM.app.property("ctxt")', nil],
+			
+			[AEMReference::App.elements('docu'), 'AEM.app.elements("docu")', nil],
+			
+			[AEMReference::App.elements('docu').by_index(1), 
+					'AEM.app.elements("docu").by_index(1)', nil],
+			[AEMReference::App.elements('docu').by_name('foo'), 
+					'AEM.app.elements("docu").by_name("foo")', nil],
+			[AEMReference::App.elements('docu').by_id(300), 
+					'AEM.app.elements("docu").by_id(300)', nil],
+			
+			[AEMReference::App.elements('docu').next('docu'), 
+					'AEM.app.elements("docu").next("docu")', nil],
+			[AEMReference::App.elements('docu').previous('docu'), 
+					'AEM.app.elements("docu").previous("docu")', nil],
+			
+			[AEMReference::App.elements('docu').first, 'AEM.app.elements("docu").first', nil],
+			[AEMReference::App.elements('docu').middle, 'AEM.app.elements("docu").middle', nil],
+			[AEMReference::App.elements('docu').last, 'AEM.app.elements("docu").last', nil],
+			[AEMReference::App.elements('docu').any, 'AEM.app.elements("docu").any', nil],
+			
+			[AEMReference::Con.elements("docu").by_index(3), 'AEM.con.elements("docu").by_index(3)', nil],
+			
+			[AEMReference::App.elements('docu').by_range(
+					AEMReference::Con.elements('docu').by_index(3),
+					AEMReference::Con.elements('docu').by_name('foo')), 
+					'AEM.app.elements("docu").by_range(' +
+					'AEM.con.elements("docu").by_index(3), ' +
+					'AEM.con.elements("docu").by_name("foo"))', nil],
+			
+			[AEMReference::App.elements('docu').by_range(1, 'foo'),
+					'AEM.app.elements("docu").by_range(1, "foo")',
+					AEMReference::App.elements("docu").by_range(
+							AEMReference::Con.elements("docu").by_index(1), 
+							AEMReference::Con.elements("docu").by_name("foo"))],
+			
+			[AEMReference::Its.property('name').eq('foo').and(AEMReference::Its.elements('cwor').eq([])), 
+					'AEM.its.property("name").eq("foo").and(AEM.its.elements("cwor").eq([]))', nil],
+			
+			[AEMReference::Its.elements('cwor').ne([]), 
+					'AEM.its.elements("cwor").ne([])', 
+					AEMReference::Its.elements("cwor").eq([]).not], # i.e. there isn't a KAENotEqual operator, so not-equal tests are actually packed as an equal test followed by not test
+					
+			[AEMReference::Its.elements('cwor').eq(nil), 'AEM.its.elements("cwor").eq(nil)', nil],
+			[AEMReference::Its.elements('cwor').property('leng').gt(0), 
+					'AEM.its.elements("cwor").property("leng").gt(0)', nil],
+			[AEMReference::Its.elements('cwor').le(''), 'AEM.its.elements("cwor").le("")', nil],
+			[AEMReference::Its.elements('cwor').begins_with('foo').not, 
+					'AEM.its.elements("cwor").begins_with("foo").not', nil],
+			
+			
+			[AEMReference::Its.elements('cwor').contains('foo'), 'AEM.its.elements("cwor").contains("foo")', nil],
+			[AEMReference::Its.elements('cwor').is_in('foo'), 'AEM.its.elements("cwor").is_in("foo")', nil],
+			
+			[AEMReference::App.elements('docu').by_filter(AEMReference::Its.property('size').ge(42)), 
+					'AEM.app.elements("docu").by_filter(AEM.its.property("size").ge(42))', nil],
+					
+			[AEMReference::App.elements('docu').by_index(1).property('ctxt') \
+					.elements('cpar').elements('cha ').by_range(
+							AEMReference::Con.elements('cha ').by_index(3), 
+							AEMReference::Con.elements('cha ').by_index(55)
+					).next('cha ').after,
+					'AEM.app.elements("docu").by_index(1).property("ctxt").elements("cpar").elements("cha ")' +
+					'.by_range(AEM.con.elements("cha ").by_index(3), AEM.con.elements("cha ").by_index(55))' +
+					'.next("cha ").after', nil],
+			
+			[AEMReference::Its.property('pnam').ne('foo').and(AEMReference::Its.elements('cfol').eq([])).not,
+					'AEM.its.property("pnam").ne("foo").and(AEM.its.elements("cfol").eq([])).not',
+					AEMReference::Its.property('pnam').eq('foo').not.and(AEMReference::Its.elements('cfol').eq([])).not],
+			
+			[AEMReference::App.elements('docu').beginning, 'AEM.app.elements("docu").beginning', nil],
+			[AEMReference::App.elements('docu').end, 'AEM.app.elements("docu").end', nil],
+			[AEMReference::App.elements('docu').by_index(3).before, 'AEM.app.elements("docu").by_index(3).before', nil],
+			[AEMReference::App.elements('docu').by_name('foo').after, 'AEM.app.elements("docu").by_name("foo").after', nil],
+			
+		].each do |val, res, unpacked_version|
+			begin
+				assert_equal(res, val.to_s)
+				d = DefaultCodecs.pack(val)
+				val = unpacked_version ? unpacked_version : val
+				val2 = DefaultCodecs.unpack(d)
+				assert_equal(val, val2)
+				val2 = DefaultCodecs.unpack(d)
+				assert_block { val.eql?(val2) }
+				val2 = DefaultCodecs.unpack(d)
+				assert_equal(val2, val)
+				val2 = DefaultCodecs.unpack(d)
+				assert_block { val2.eql?(val) }
+			rescue
+				puts 'EXPECTED: ' + res
+				raise
+			end
+		end
+		assert_not_equal(AEMReference::App.property('ctxt').property('ctxt'), AEMReference::Con.property('ctxt').property('ctxt'))
+		assert_not_equal(AEMReference::App.property('foob').property('ctxt'), AEMReference::App.property('ctxt').property('ctxt'))
+		assert_not_equal(AEMReference::App.elements('ctxt').property('ctxt'), AEMReference::App.property('ctxt').property('ctxt'))
+		assert_not_equal(AEMReference::App.elements('ctxt').property('ctxt'), 333)
+		assert_not_equal(333, AEMReference::App.property('ctxt').property('ctxt'))
+#		# by-filter references do basic type checking to ensure an its-based reference is given
+		assert_raises(TypeError) { AEMReference::App.elements('docu').by_filter(1) }
+		
+	end
+end
+

data/test/test_appscriptcommands.rb

@@ -0,0 +1,152 @@
+#!/usr/bin/ruby -w
+
+begin; require 'rubygems'; rescue LoadError; end
+
+require 'test/unit'
+require 'appscript'
+
+# rb-appscript 0.5.0+ should no longer require the following kludge:
+#class AS_SafeObject
+#	def self.hide(name)
+#	end
+#end
+
+class TC_AppscriptNewApp < Test::Unit::TestCase
+
+	def test_by_name
+		[
+				'/Applications/TextEdit.app',
+				'Finder.app',
+				'System Events'
+		].each do |name|
+			a = Appscript.app(name)
+			assert_not_nil(a)
+			assert_instance_of(Appscript::Application, a)
+			assert_instance_of(Appscript::Reference, a.name)
+		end
+		assert_equal('app("/Applications/TextEdit.app")', Appscript.app('TextEdit').to_s)
+		assert_equal('app("/Applications/TextEdit.app")', Appscript.app.by_name('TextEdit').to_s)
+		
+		assert_raises(Appscript::ApplicationNotFoundError) { Appscript.app('/non-existent/app') }
+		assert_raises(Appscript::ApplicationNotFoundError) { Appscript.app('non-existent.app') }
+	end
+	
+	def test_by_id
+		[
+				'com.apple.textedit',
+				'com.apple.finder',
+		].each do |name|
+			a = Appscript.app.by_id(name)
+			assert_not_nil(a)
+			assert_instance_of(Appscript::Application, a)
+			assert_instance_of(Appscript::Reference, a.name)
+		end
+		assert_equal('app("/Applications/TextEdit.app")', Appscript.app.by_id('com.apple.textedit').to_s)
+		
+		assert_raises(Appscript::ApplicationNotFoundError) { Appscript.app.by_id('non.existent.app') }
+	end
+
+	def test_by_creator
+		a = Appscript.app.by_creator('ttxt')
+		assert_instance_of(Appscript::Reference, a.name)
+		assert_equal('app("/Applications/TextEdit.app")', a.to_s)
+		assert_raises(Appscript::ApplicationNotFoundError) { Appscript.app.by_id('!@$o') }
+	end
+	
+	def test_by_pid
+		pid = `top -l1 | grep Finder | awk '{ print $1 }'`.to_i # note: this line will return a bad result if more than one user is logged in
+		a = Appscript.app.by_pid(pid)
+		assert_instance_of(Appscript::Reference, a.name)
+		assert_equal("app.by_pid(#{pid})", a.to_s)
+		assert_equal('Finder', a.name.get)
+	end
+	
+	def test_by_aem_app
+		a = Appscript.app.by_aem_app(AEM::Application.by_path('/Applications/TextEdit.app'))
+		assert_instance_of(Appscript::Reference, a.name)
+		assert_equal('app.by_aem_app(AEM::Application.by_path("/Applications/TextEdit.app"))', a.to_s)
+	end
+end
+
+
+class TC_AppscriptCommands < Test::Unit::TestCase
+
+	def setup
+		@te = Appscript.app('TextEdit')
+		@f = Appscript.app('Finder')
+	end
+	
+	def test_commands_1
+		assert_equal('TextEdit', @te.name.get)
+		d = @te.make(:new=>:document, :with_properties=>{:text=>'test test_commands'})
+		assert_instance_of(Appscript::Reference, d)
+		d.text.end.make(:new=>:word, :with_data=>' test2')
+		assert_equal('test test_commands test2', d.text.get)
+		assert_instance_of(String, 
+				d.text.get(:ignore=>[:diacriticals, :punctuation, :whitespace, :expansion], :timeout=>10))
+		assert_nil(d.get(:wait_reply=>false))
+		
+		
+		# test Ruby 1.9+ String Encoding support
+		version, sub_version = RUBY_VERSION.split('.').collect {|n| n.to_i} [0, 2]
+		if version >= 1 and sub_version >= 9
+			
+			print "(check Encoding support)"
+			s = "\302\251 M. Lef\303\250vre"
+			s.force_encoding('utf-8')
+			d.text.set(s)
+			assert_equal(s, d.text.get)
+		
+			@te.AS_app_data.use_ascii_8bit
+		end
+		
+		d.text.set("\302\251 M. Lef\303\250vre")
+		assert_equal("\302\251 M. Lef\303\250vre", d.text.get)
+		
+		d.close(:saving=>:no)
+	end
+	
+	def test_commands_2
+		d = @te.make(:new=>:document, :at=>@te.documents.end)
+		
+		@te.set(d.text, :to=> 'test1')
+		assert_equal('test1', d.text.get)
+		
+		@te.set(d.text, :to=> 'test2')
+		@te.make(:new=>:word, :at=>Appscript.app.documents[1].paragraphs.end, :with_data=>' test3')
+		assert_equal('test2 test3', d.text.get)
+		
+		d.close(:saving=>:no)
+		
+		assert_raises(Appscript::CommandError) { @te.documents[10000].get }
+		
+		assert_instance_of(Fixnum, @te.documents.count)
+		assert_equal(@te.documents.count, @te.count(:each=>:document))
+	end
+	
+	def test_commands_3
+		assert_equal('Finder', @f.name.get)
+		val = @f.home.folders['Desktop'].get(:result_type=>:alias)
+		assert_instance_of(MacTypes::Alias, val)
+		assert_equal(val, @f.desktop.get(:result_type=>:alias))
+		assert_instance_of(Array, @f.disks.get)
+		
+		r = @f.home.get
+		f = r.get(:result_type=>:file_ref)
+		assert_equal(r, @f.items[f].get)
+		
+		assert_equal(@f.home.items.get, @f.home.items.get)
+		assert_not_equal(@f.disks['non-existent'], @f.disks[1].get)
+	end
+	
+	def test_command_error
+		begin
+			@f.items[10000].get
+		rescue Appscript::CommandError => e
+			assert_equal(-1728, e.to_i)
+			assert_equal("CommandError\n\t\tOSERROR: -1728\n\t\tMESSAGE: Can't get reference.\n\t\tOFFENDING OBJECT: app(\"/System/Library/CoreServices/Finder.app\").items[10000]\n\t\tCOMMAND: app(\"/System/Library/CoreServices/Finder.app\").items[10000].get()\n", e.to_s)
+			assert_instance_of(AEM::EventError, e.real_error)
+		end
+	end
+end
+

data/test/test_appscriptreference.rb

@@ -0,0 +1,106 @@
+#!/usr/bin/ruby -w
+
+begin; require 'rubygems'; rescue LoadError; end
+
+require 'test/unit'
+require "appscript"
+
+class TC_AppscriptReferences < Test::Unit::TestCase
+
+	def setup
+		@te = Appscript.app('TextEdit')
+		@s = @te.to_s
+	end
+
+	def test_reference_forms
+		[
+			
+			[@te.documents[
+					Appscript.con.documents[3],
+					Appscript.con.documents['foo']], 
+					@s+'.documents[' +
+					'con.documents[3], ' +
+					'con.documents["foo"]]', nil],
+					
+					
+					
+			[@te.text, @s+'.text', nil],
+			
+			[@te.documents, @s+'.documents', nil],
+			
+			[@te.documents[1], 
+					@s+'.documents[1]', nil],
+			[@te.documents['foo'], 
+					@s+'.documents["foo"]', nil],
+			[@te.documents.ID(300), 
+					@s+'.documents.ID(300)', nil],
+			
+			[@te.documents.next(:document), 
+					@s+'.documents.next(:document)', nil],
+			[@te.documents.previous(:document), 
+					@s+'.documents.previous(:document)', nil],
+			
+			[@te.documents.first, @s+'.documents.first', nil],
+			[@te.documents.middle, @s+'.documents.middle', nil],
+			[@te.documents.last, @s+'.documents.last', nil],
+			[@te.documents.any, @s+'.documents.any', nil],
+			
+			[Appscript.con.documents[3], 'con.documents[3]', nil],
+			
+			
+			[Appscript.its.name.eq('foo').and(Appscript.its.words.eq([])), 
+					'its.name.eq("foo").and(its.words.eq([]))', nil],
+			
+			[Appscript.its.words.ne([]), 
+					'its.words.ne([])', 
+					Appscript.its.words.eq([]).not], # i.e. there isn't a KAENotEqual operator, so not-equal tests are actually packed as an equal test followed by not test
+					
+			[Appscript.its.words.eq(nil), 'its.words.eq(nil)', nil],
+			[Appscript.its.words.size.gt(0), 
+					'its.words.size.gt(0)', nil],
+			[Appscript.its.words.le(''), 'its.words.le("")', nil],
+			[Appscript.its.words.begins_with('foo').not, 
+					'its.words.begins_with("foo").not', nil],
+			
+			
+			[Appscript.its.words.contains('foo'), 'its.words.contains("foo")', nil],
+			[Appscript.its.words.is_in('foo'), 'its.words.is_in("foo")', nil],
+			
+			[@te.documents[Appscript.its.size.ge(42)], 
+					@s+'.documents[its.size.ge(42)]', nil],
+			
+			[@te.documents[1, 'foo'], 
+					@s+'.documents[1, "foo"]',
+					@te.documents[Appscript.con.documents[1], Appscript.con.documents["foo"]]],
+			
+			[@te.documents[1].text \
+					.paragraphs.characters[
+							Appscript.con.characters[3], 
+							Appscript.con.characters[55]
+					].next(:character).after,
+					@s+'.documents[1].text.paragraphs.characters' +
+					'[con.characters[3], con.characters[55]]' +
+					'.next(:character).after', nil],
+			
+			[Appscript.its.name.ne('foo').and(Appscript.its.words.eq([])).not,
+					'its.name.ne("foo").and(its.words.eq([])).not',
+					Appscript.its.name.eq('foo').not.and(Appscript.its.words.eq([])).not],
+			
+			[@te.documents.beginning, @s+'.documents.beginning', nil],
+			[@te.documents.end, @s+'.documents.end', nil],
+			[@te.documents[3].before, @s+'.documents[3].before', nil],
+			[@te.documents['foo'].after, @s+'.documents["foo"].after', nil],
+			
+		].each do |val, res, unpacked_version|
+			assert_equal(res, val.to_s)
+			d = @te.AS_app_data.pack(val)
+			val = unpacked_version ? unpacked_version : val
+			val2 = @te.AS_app_data.unpack(d)
+			if val.class == @te.AS_app_data.unpack(d).class # note: Appscript::Reference and Appscript::GenericReference currently aren't comparable with each other, so the next test would always fail for those
+				assert_equal(val, val2)
+				assert_block { val.eql?(val2) }
+			end
+		end
+	end
+end
+

data/test/test_codecs.rb

@@ -0,0 +1,186 @@
+#!/usr/bin/ruby -w
+
+begin; require 'rubygems'; rescue LoadError; end
+
+require 'test/unit'
+require 'aem'
+require 'kae'
+require 'ae'
+
+def num(s)
+	if [1].pack('s') == "\001\000" # host system is i386
+		s.reverse
+	else
+		s
+	end
+end
+
+def ut16(s)
+	if [1].pack('s') == "\001\000" # host system is i386
+		i = 0
+		s2 = ''
+		(s.length / 2).times do
+			s2 += s[i, 2].reverse
+			i+=2
+		end
+		s2
+	else
+		s
+	end
+end
+
+
+
+
+class TC_Codecs < Test::Unit::TestCase
+	
+	def setup
+		@c = AEM::Codecs.new
+	end
+	
+	def test_nil
+		d = @c.pack(nil)
+		assert_equal(KAE::TypeNull, d.type)
+		assert_equal('', d.data)
+		assert_nil(@c.unpack(d))
+	end
+	
+	def test_bool
+		[
+			[true, KAE::TypeTrue],
+			[false, KAE::TypeFalse]
+		].each do |val, type|
+			d = @c.pack(val)
+			assert_equal(type, d.type)
+			assert_equal('', d.data)
+			assert_equal(val, @c.unpack(d))
+		end
+		assert_equal(true, @c.unpack(AE::AEDesc.new(KAE::TypeBoolean, "\xfe")))
+		assert_equal(true, @c.unpack(AE::AEDesc.new(KAE::TypeTrue, '')))
+		assert_equal(false, @c.unpack(AE::AEDesc.new(KAE::TypeFalse, '')))
+	end
+	
+	def test_num
+		[ # (mostly testing at threshold points where Codecs switches types when packing integers)
+			[0, "\x00\x00\x00\x00", KAE::TypeInteger],
+			[2, "\x00\x00\x00\x02", KAE::TypeInteger],
+			[-9, "\xff\xff\xff\xf7", KAE::TypeInteger],
+			[2**31-1, "\x7f\xff\xff\xff", KAE::TypeInteger],
+			[-2**31, "\x80\x00\x00\x00", KAE::TypeInteger],
+			[2**31, "\x00\x00\x00\x00\x80\x00\x00\x00", KAE::TypeSInt64],
+			[2**32-1, "\x00\x00\x00\x00\xff\xff\xff\xff", KAE::TypeSInt64],
+			[2**32, "\x00\x00\x00\x01\x00\x00\x00\x00", KAE::TypeSInt64], 
+			[-2**32, "\xff\xff\xff\xff\x00\x00\x00\x00", KAE::TypeSInt64],
+			[2**63-1, "\x7f\xff\xff\xff\xff\xff\xff\xff", KAE::TypeSInt64], 
+			[-2**63, "\x80\x00\x00\x00\x00\x00\x00\x00", KAE::TypeSInt64],
+			[-2**63+1, "\x80\x00\x00\x00\x00\x00\x00\x01", KAE::TypeSInt64],
+			[2**63, "C\xe0\x00\x00\x00\x00\x00\x00", KAE::TypeFloat],
+			[-2**63-1, "\xc3\xe0\x00\x00\x00\x00\x00\x00", KAE::TypeFloat],
+			[0.1, "?\xb9\x99\x99\x99\x99\x99\x9a", KAE::TypeFloat],
+			[-0.9e-9, "\xbe\x0e\xec{\xd5\x12\xb5r", KAE::TypeFloat],
+			[2**300, "R\xb0\x00\x00\x00\x00\x00\x00", KAE::TypeFloat],
+		].each do |val, data, type|
+			data = num(data)
+			d = @c.pack(val)
+			assert_equal(type, d.type)
+			assert_equal(data, d.data)
+			assert_equal(val, @c.unpack(d))
+		end
+	end
+	
+	def test_str
+		s = "\xc6\x92\xe2\x88\x82\xc2\xae\xd4\xb7\xd5\x96\xd4\xb9\xe0\xa8\x89\xe3\x82\xa2\xe3\x84\xbb"
+		# test Ruby 1.9+ String Encoding support
+		version, sub_version = RUBY_VERSION.split('.').collect {|n| n.to_i} [0, 2]
+		if version >= 1 and sub_version >= 9
+			s.force_encoding('utf-8')
+		end
+
+		[
+			# note: aem has to pack UTF8 data as typeUnicodeText (UTF16) as stupid apps expect that type and will error on typeUTF8Text instead of just asking AEM to coerce it to the desired type in advance.
+			# note: UTF16 BOM must be omitted when packing UTF16 data into typeUnicodeText AEDescs, as a BOM will upset stupid apps like iTunes 7 that don't recognise it as a BOM and treat it as character data instead
+			['', ''],
+			['hello', "\000h\000e\000l\000l\000o"],
+			[s, "\x01\x92\"\x02\x00\xae\x057\x05V\x059\n\t0\xa21;"],
+		].each do |val, data|
+			data = ut16(data)
+			d = @c.pack(val)
+			assert_equal(KAE::TypeUnicodeText, d.type)
+			assert_equal(data, d.data)
+			assert_equal(val, @c.unpack(d))
+		end
+		assert_raises(TypeError) { @c.pack("\x88") } # non-valid UTF8 strings should raise error when coercing from typeUTF8Text to typeUnicodeText
+	end
+	
+	def test_date
+		# note: not testing on ST-DST boundaries; this is known to have out-by-an-hour problems due to LongDateTime type being crap
+		[
+			[Time.local(2005, 12, 11, 15, 40, 43), "\x00\x00\x00\x00\xbf\xc1\xf8\xfb"],
+			[Time.local(2005, 5, 1, 6, 51, 7), "\x00\x00\x00\x00\xbe\x9a\x2c\xdb"],
+		].each do |t, data|
+			data = num(data)
+			d = @c.pack(t)
+			assert_equal(KAE::TypeLongDateTime, d.type)
+			assert_equal(data, d.data)
+			assert_equal(t, @c.unpack(AE::AEDesc.new(KAE::TypeLongDateTime, data)))
+		end
+	end
+	
+	def test_file
+		path = '/Applications/TextEdit.app'
+		d = @c.pack(MacTypes::Alias.path(path))
+		assert_equal(path, @c.unpack(d).to_s)
+		
+		path = '/Applications/TextEdit.app'
+		d = @c.pack(MacTypes::FileURL.path(path))
+		assert_equal(path, @c.unpack(d).to_s)
+	end
+	
+	def test_typewrappers
+		[
+			AEM::AEType.new("docu"),
+			AEM::AEEnum.new('yes '),
+			AEM::AEProp.new('pnam'),
+			AEM::AEKey.new('ABCD'),
+		].each do |val|
+			d = @c.pack(val)
+			val2 = @c.unpack(d)
+			assert_equal(val, val2)
+			assert_block { val.eql?(val2) }
+			val2 = @c.unpack(d)
+			assert_equal(val2, val)
+			assert_block { val2.eql?(val) }
+		end
+		assert_raises(ArgumentError) { AEM::AEType.new(3) }
+		assert_raises(ArgumentError) { AEM::AEType.new("docum") }
+	end
+	
+	def test_list
+	end
+	
+	def test_hash
+		val = {'foo' => 1, AEM::AEType.new('foob') => 2, AEM::AEProp.new('barr') => 3}
+		expected_val = {'foo' => 1, AEM::AEType.new('foob') => 2, AEM::AEType.new('barr') => 3} # note that four-char-code keys are always unpacked as AEType
+		d = @c.pack(val)
+		assert_equal(expected_val, @c.unpack(d))
+	end
+	
+	def test_units
+		val = MacTypes::Units.new(3.3, :inches)
+		assert_equal(:inches, val.type)
+		assert_equal(3.3, val.value)
+		d = @c.pack(val)
+		assert_equal('inch', d.type)
+		assert_equal(3.3, @c.unpack(d.coerce(KAE::TypeFloat)))
+		val2 = @c.unpack(d)
+		assert_equal(val, val2)
+		assert_equal(:inches, val2.type)
+		assert_equal(3.3, val2.value)
+	end
+	
+	def test_app
+		val = AEM::Application.by_path(FindApp.by_name('TextEdit'))
+		d = @c.pack(val)
+		assert_equal(KAE::TypeProcessSerialNumber, d.type)
+	end
+end