rb-scrpt 1.0.3

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,115 @@
+#!/usr/bin/ruby -w
+
+require 'minitest/autorun'
+require "_aem/aemreference"
+require "_aem/typewrappers"
+require "_aem/codecs"
+
+
+class TC_AEMReferences < Minitest::Test
+
+  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_predicate val, :eql?, val2
+        val2 = DefaultCodecs.unpack(d)
+        assert_equal(val2, val)
+        val2 = DefaultCodecs.unpack(d)
+        assert_predicate val2, :eql?, val
+      rescue
+        puts 'EXPECTED: ' + res
+        raise
+      end
+    end
+    refute_equal(AEMReference::App.property('ctxt').property('ctxt'), AEMReference::Con.property('ctxt').property('ctxt'))
+    refute_equal(AEMReference::App.property('foob').property('ctxt'), AEMReference::App.property('ctxt').property('ctxt'))
+    refute_equal(AEMReference::App.elements('ctxt').property('ctxt'), AEMReference::App.property('ctxt').property('ctxt'))
+    refute_equal(AEMReference::App.elements('ctxt').property('ctxt'), 333)
+    refute_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,149 @@
+#!/usr/local/bin/ruby -w
+
+require 'minitest/autorun'
+require 'rb-scpt'
+
+# rb-appscript 0.5.0+ should no longer require the following kludge:
+#class AS_SafeObject
+#	def self.hide(name)
+#	end
+#end
+
+class TC_AppscriptNewApp < Minitest::Test
+
+  def test_by_name
+    [
+     '/Applications/TextEdit.app',
+     'Finder.app',
+     'System Events'
+    ].each do |name|
+      a = Appscript.app(name)
+      refute_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)
+      refute_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 < Minitest::Test
+
+  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_kind_of(Integer, @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)
+    refute_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,103 @@
+#!/usr/bin/ruby -w
+
+require 'minitest/autorun'
+require "rb-scpt"
+
+class TC_AppscriptReferences < Minitest::Test
+
+  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_predicate val, :eql?, val2
+      end
+    end
+  end
+end

data/test/test_codecs.rb

@@ -0,0 +1,181 @@
+#!/usr/bin/ruby -w
+
+require 'minitest/autorun'
+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 < Minitest::Test
+
+  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_predicate val, :eql?, val2
+      val2 = @c.unpack(d)
+      assert_equal(val2, val)
+      assert_predicate 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

data/test/test_findapp.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/ruby -w
+
+require 'minitest/autorun'
+require "_aem/findapp"
+
+
+class TC_FindApp < Minitest::Test
+
+  def test_find
+    [
+     ['/Applications/iCal.app', '/Applications/iCal.app'],
+     ['ical.app', '/Applications/iCal.app'],
+     ['ICAL', '/Applications/iCal.app'],
+    ].each do |val, res|
+      assert_equal(res, FindApp.by_name(val))
+    end
+    assert_equal('/Applications/TextEdit.app', FindApp.by_creator('ttxt'))
+    assert_equal('/System/Library/CoreServices/Finder.app', FindApp.by_id('com.apple.finder'))
+    assert_raises(FindApp::ApplicationNotFoundError) { FindApp.by_name('NON-EXISTENT-APP') }
+
+    # assert_equal("/Users/has/\306\222\303\270u\314\210.app", FindApp.by_name("\306\222\303\270u\314\210.app")) # utf8 paths work ok
+  end
+end

data/test/test_mactypes.rb

@@ -0,0 +1,77 @@
+#!/usr/bin/ruby -w
+
+require 'minitest/autorun'
+require "_aem/mactypes"
+
+
+class TC_MacTypes < Minitest::Test
+
+  def setup
+    @path1 = `mktemp -t codecs-test`.chomp
+    dir, fname = File.split(@path1)
+    @path2 = File.join(dir, 'moved-' + fname)
+    # puts "path: #{@path1}" # e.g. /tmp/codecs-test.HWr1EnE3
+  end
+
+  def normalize(path)
+    return path.gsub(/\/+/, '/') # quick-n-dirty
+  end
+
+  def test_alias
+    # make alias
+    f = MacTypes::Alias.path(@path1)
+
+
+    assert_equal(MacTypes::Alias.path(@path1), f)
+
+    # get path
+    # note that initial /tmp/codecs-test... path will automatically change to /private/tmp/codecs-test...
+    p1 = normalize('/private'+@path1)
+    p2 = normalize('/private'+@path2)
+
+    assert_equal(p1, normalize(f.path))
+
+    #puts "alias path 1: #{f}" # e.g. /private/tmp/codecs-test.HWr1EnE3
+    assert_equal(p1, f.to_s)
+
+    # get desc
+    #puts f.desc.type, f.desc.data # alis, [binary data]
+    assert_equal('alis', f.desc.type)
+
+
+    # check alias keeps track of moved file
+    `mv #{@path1} #{@path2}`
+    # puts "alias path 2: #{f}" # /private/tmp/moved-codecs-test.HWr1EnE3
+    assert_equal(p2, f.to_s)
+
+    assert_equal(p2, normalize(f.path))
+
+    # check a FileNotFoundError is raised if getting path/FileURL for a filesystem object that no longer exists
+    `rm #{@path2}`
+    assert_raises(MacTypes::FileNotFoundError) { f.to_s } # File not found.
+    assert_raises(MacTypes::FileNotFoundError) { f.to_file_url } # File not found.
+
+    assert_equal(MacTypes::Alias.path("/Library/Scripts/"), MacTypes::Alias.path("/Library/Scripts/"))
+    refute_equal(MacTypes::Alias.path("/Library/Scripts/"), MacTypes::Alias.path("/Applications/"))
+  end
+
+
+  def test_file_url
+
+    g = MacTypes::FileURL.path('/non/existent path')
+
+    assert_equal('/non/existent path', g.to_s)
+
+    assert_equal('furl', g.desc.type)
+    assert_equal('file://localhost/non/existent%20path', g.desc.data)
+
+    assert_equal('MacTypes::FileURL.path("/non/existent path")', g.to_file_url.inspect)
+
+    # check a not-found error is raised if getting Alias for a filesystem object that doesn't exist
+    assert_raises(MacTypes::FileNotFoundError) { g.to_alias } # File "/non/existent path" not found.
+
+    assert_equal(MacTypes::FileURL.path("/Library/Scripts/"), MacTypes::FileURL.path("/Library/Scripts/"))
+    refute_equal(MacTypes::FileURL.path("/Library/Scripts/"), MacTypes::FileURL.path("/Applications/"))
+    refute_equal(MacTypes::FileURL.path("/Library/Scripts/"), MacTypes::Alias.path("/Library/Scripts/"))
+  end
+end