AXElements 0.6.0beta2 → 0.7.5

data/test/sanity/accessibility/test_factory.rb

@@ -0,0 +1,88 @@
+require 'test/helper'
+require 'accessibility/factory'
+require 'ax/element'
+require 'ax/application'
+
+# Just pretend that you didn't see this
+class AX::Element
+  attr_reader :ref
+end
+
+class TestAccessibilityFactory < MiniTest::Unit::TestCase
+  include Accessibility::Factory
+
+  def window
+    REF.children.find { |x| x.role == KAXWindowRole }
+  end
+
+  def scroll_area
+    window.children.find { |x|
+      x.attributes.include?(KAXDescriptionAttribute) &&
+        x.attribute(KAXDescriptionAttribute) == 'Test Web Area'
+    }
+  end
+
+  def web_area
+    scroll_area.children.find { |x| x.role == 'AXWebArea' }
+  end
+
+  def close_button
+    window.children.find { |x|
+      x.attributes.include?(KAXSubroleAttribute) &&
+        x.attribute(KAXSubroleAttribute) == KAXCloseButtonSubrole
+    }
+  end
+
+  def test_processing_element_refs
+    assert_equal REF, process(REF).ref
+
+    o = process(web_area)
+    assert_instance_of AX::WebArea, o
+
+    # intentionally done a second time to see if the
+    # created class is used again; this guarantees
+    # that the class can be created properly and then
+    # used again when needed
+    2.times do
+      o = process window
+      assert_instance_of AX::StandardWindow, o
+      o = process close_button
+      assert_instance_of AX::CloseButton, o
+    end
+
+    2.times do
+      o = process REF
+      assert_instance_of AX::Application, o
+      o = process scroll_area
+      assert_instance_of AX::ScrollArea, o
+    end
+  end
+
+  def test_processing_arrays
+    assert_equal [],  process_array([])
+    assert_equal [1], process_array([1])
+
+    expected = [AX::Application.new(REF)]
+    assert_equal expected, process_array([REF])
+  end
+
+  def test_processing_arbitrary_objects
+    assert_equal 'test', process('test')
+    assert_equal 42,     process(42)
+
+    now = Time.now
+    assert_equal now, process(now)
+
+    string = NSAttributedString.alloc.initWithString 'hi'
+    assert_equal string, process(string)
+  end
+
+  def test_processing_nil
+    assert_nil process(nil)
+  end
+
+  def bench_process
+    skip 'This is important when we get to optimizing'
+  end
+
+end

data/test/sanity/accessibility/test_pp_inspector.rb

@@ -0,0 +1,110 @@
+# -*- coding: utf-8 -*-
+
+class TestAccessibilityPPInspector < MiniTest::Unit::TestCase
+  include Accessibility::PPInspector
+
+  # expected API for PPInspector module
+  attr_reader :attributes
+  def attribute attr; @attribute; end
+  def size_of   attr; @size_of;   end
+
+  def test_identifier_using_value
+    @attributes = [:value]
+
+    @attribute  = 'cake'
+    assert_match /"cake"/, pp_identifier
+
+    @attribute  = 3.14
+    assert_match /value=3.14/, pp_identifier
+
+    @attribute  = ''
+    assert_match EMPTY_STRING, pp_identifier
+
+    @attribute  = nil
+    assert_match EMPTY_STRING, pp_identifier
+  end
+
+  def test_identifier_using_title
+    @attributes = [:title]
+    @attribute  = 'My Title'
+    assert_match /"My Title"/, pp_identifier
+  end
+
+  def test_identifier_using_title_ui_element
+    @attributes = [:title_ui_element]
+    @attribute  = 'hey'
+    assert_match /"hey"/, pp_identifier
+  end
+
+  # hmmm...
+  def test_identifier_using_description
+    @attributes = [:description]
+
+    @attribute  = 'roflcopter'
+    assert_match /roflcopter/, pp_identifier
+
+    @attribute  = NSString.string
+    assert_equal EMPTY_STRING, pp_identifier
+
+    @attribute  = 26
+    assert_match /26/, pp_identifier
+  end
+
+  def test_identifier_using_identifier
+    @attributes = [:identifier]
+
+    @attribute  = '_NS:151'
+    assert_match /id=_NS:151/, pp_identifier
+
+    @attribute  = 'contact table'
+    assert_match /id=contact table/, pp_identifier
+  end
+
+  def test_identifier_empty_string_as_final_fallback
+    @attributes = NSArray.array
+    assert_equal EMPTY_STRING, pp_identifier
+  end
+
+  def test_position
+    @attribute = CGPointZero
+    assert_match /\(0\.0, 0\.0\)/, pp_position
+
+    @attribute = CGPoint.new(3.14, -5)
+    assert_match /\(3\.14, -5\.0\)/, pp_position
+  end
+
+  # this sometimes happens, even though it shouldn't
+  def test_position_is_nil
+    @attribute = nil
+    assert_equal EMPTY_STRING, pp_position
+  end
+
+  def test_children_pluralizes_properly
+    [[2,    /2 children/   ],
+     [9001, /9001 children/],
+     [3.14, /3.14 children/],
+     [1,    /1 child/      ],
+     [0,    EMPTY_STRING   ]
+    ].each do |size, matcher|
+      @size_of = size
+      assert_match matcher, pp_children
+    end
+  end
+
+  def test_checkbox
+    @attribute = true
+    assert_match /thing\[✔\]/, pp_checkbox(:thing)
+    @attribute = false
+    assert_match /thing\[✘\]/, pp_checkbox(:thing)
+    @attribute = nil
+    assert_match /thing\[✘\]/, pp_checkbox(:thing)
+
+    @attribute = true
+    assert_match /some attr\[✔\]/, pp_checkbox('some attr')
+    @attribute = false
+    assert_match /some attr\[✘\]/, pp_checkbox('some attr')
+    @attribute = nil
+    assert_match /some attr\[✘\]/, pp_checkbox('some attr')
+  end
+
+end

data/test/sanity/accessibility/test_qualifier.rb

@@ -0,0 +1,13 @@
+require 'test/runner'
+require 'accessibility/qualifier'
+
+class TestNSDictionaryExtensions < MiniTest::Unit::TestCase
+
+  def test_ax_pp
+    assert_equal '',                        {}.ax_pp
+    assert_equal '(title: "Hey, listen!")', {title: 'Hey, listen!'}.ax_pp
+    assert_equal '(a: 42, b: [3.14])',      {a: 42, b: [3.14]}.ax_pp
+    assert_equal '(c(d: ":("))',            {c: {d:':('} }.ax_pp
+  end
+
+end

data/test/sanity/accessibility/test_string.rb

@@ -0,0 +1,238 @@
+# -*- coding: utf-8 -*-
+
+require 'test/runner'
+require 'accessibility/string'
+
+class TestAccessibilityStringLexer < MiniTest::Unit::TestCase
+
+  def lex string
+    Accessibility::String::Lexer.new(string).lex
+  end
+
+  def test_lex_simple_string
+    assert_equal [],                                                    lex('')
+    assert_equal ['"',"J","u","s","t"," ","W","o","r","k","s",'"',"™"], lex('"Just Works"™')
+    assert_equal ["M","i","l","k",","," ","s","h","a","k","e","."],     lex("Milk, shake.")
+    assert_equal ["D","B","7"],                                         lex("DB7")
+  end
+
+  def test_lex_single_custom_escape
+    assert_equal [["\\CMD"]], lex("\\CMD")
+    assert_equal [["\\1"]],   lex("\\1")
+    assert_equal [["\\F1"]],  lex("\\F1")
+    assert_equal [["\\*"]],   lex("\\*")
+  end
+
+  def test_lex_hotkey_custom_escape
+    assert_equal [["\\COMMAND",[","]]],             lex("\\COMMAND+,")
+    assert_equal [["\\COMMAND",["\\SHIFT",["s"]]]], lex("\\COMMAND+\\SHIFT+s")
+    assert_equal [["\\COMMAND",["\\+"]]],           lex("\\COMMAND+\\+")
+    assert_equal [["\\FN",["\\F10"]]],              lex("\\FN+\\F10")
+  end
+
+  def test_lex_ruby_escapes
+    assert_equal ["\n","\r","\t","\b"],                                lex("\n\r\t\b")
+    assert_equal ["O","n","e","\n","T","w","o"],                       lex("One\nTwo")
+    assert_equal ["L","i","e","\b","\b","\b","d","e","l","i","s","h"], lex("Lie\b\b\bdelish")
+  end
+
+  def test_lex_complex_string
+    assert_equal ["T","e","s","t",["\\CMD",["s"]]],                          lex("Test\\CMD+s")
+    assert_equal ["Z","O","M","G"," ","1","3","3","7","!","!","1"],          lex("ZOMG 1337!!1")
+    assert_equal ["F","u","u","!","@","#","%",["\\CMD",["a"]],"\b"],         lex("Fuu!@#%\\CMD+a \b")
+    assert_equal [["\\CMD",["a"]],"\b","A","l","l"," ","g","o","n","e","!"], lex("\\CMD+a \bAll gone!")
+  end
+
+  def test_lex_backslash # make sure we handle these edge cases predictably
+    assert_equal ["\\"],             lex("\\")
+    assert_equal ["\\"," "],         lex("\\ ")
+    assert_equal ["\\","h","m","m"], lex("\\hmm")
+    assert_equal [["\\HMM"]],        lex("\\HMM") # the one missed case
+  end
+
+  def test_lex_plus_escape
+    assert_equal [["\\+"]], lex("\\+")
+  end
+
+  def test_lex_bad_custom_escape_sequence
+    assert_raises ArgumentError do
+      lex("\\COMMAND+")
+    end
+  end
+
+end
+
+
+class TestAccessibilityStringEventGenerator < MiniTest::Unit::TestCase
+
+  def gen tokens
+    Accessibility::String::EventGenerator.new(tokens).generate
+  end
+
+  def map; @@map ||= KeyCoder.dynamic_mapping; end
+
+  def t; true; end
+  def f; false; end
+
+  def a; @@a ||= map['a']; end
+  def c; @@c ||= map['c']; end
+  def e; @@e ||= map['e']; end
+  def h; @@h ||= map['h']; end
+  def i; @@i ||= map['i']; end
+  def k; @@k ||= map['k']; end
+  def m; @@m ||= map["m"]; end
+
+  def two;  @@two  ||= map['2']; end
+  def four; @@four ||= map['4']; end
+
+  def retern; @@retern ||= map["\r"]; end
+  def tab;    @@tab    ||= map["\t"]; end
+  def space;  @@space  ||= map["\s"]; end
+
+  def dash;  @@dash  ||= map["-"]; end
+  def comma; @@comma ||= map[","]; end
+  def apos;  @@apos  ||= map["'"]; end
+  def at;    @@at    ||= map["2"]; end
+  def paren; @@paren ||= map["9"]; end
+  def chev;  @@chev  ||= map["."]; end
+
+  def sigma; @@sigma ||= map["w"]; end
+  def tm;    @@tm    ||= map["2"]; end
+  def gbp;   @@gbp   ||= map["3"]; end
+  def omega; @@omega ||= map["z"]; end
+
+  def bslash; @@blash ||= map["\\"]; end
+
+  # key code for the left shift key
+  def sd; [56,t];  end
+  def su; [56,f]; end
+
+  # key code for the left option key
+  def od; [58,t];  end
+  def ou; [58,f]; end
+
+  # key code for the left command key
+  def cd; [0x37,t]; end
+  def cu; [0x37,f]; end
+
+  # key code for right arrow key
+  def rd; [0x7c,t]; end
+  def ru; [0x7c,f]; end
+
+  # key code for left control key
+  def ctrld; [0x3B,t]; end
+  def ctrlu; [0x3B,f]; end
+
+
+  def test_generate_lowercase
+    assert_equal [[a,t],[a,f]],                                     gen(['a'])
+    assert_equal [[c,t],[c,f],[k,t],[k,f]],                         gen(['c','k'])
+    assert_equal [[e,t],[e,f],[e,t],[e,f]],                         gen(['e','e'])
+    assert_equal [[c,t],[c,f],[a,t],[a,f],[k,t],[k,f],[e,t],[e,f]], gen(['c','a','k','e'])
+  end
+
+  def test_generate_uppercase
+    assert_equal [sd,[a,t],[a,f],su],                         gen(['A'])
+    assert_equal [sd,[c,t],[c,f],[k,t],[k,f],su],             gen(['C','K'])
+    assert_equal [sd,[e,t],[e,f],[e,t],[e,f],su],             gen(['E','E'])
+    assert_equal [sd,[c,t],[c,f],[a,t],[a,f],[k,t],[k,f],su], gen(['C','A','K'])
+  end
+
+  def test_generate_numbers
+    assert_equal [[two,t],[two,f]],                   gen(['2'])
+    assert_equal [[four,t],[four,f],[two,t],[two,f]], gen(['4','2'])
+    assert_equal [[two,t],[two,f],[two,t],[two,f]],   gen(['2','2'])
+  end
+
+  def test_generate_ruby_escapes
+    assert_equal [[retern,t],[retern,f]], gen(["\r"])
+    assert_equal [[retern,t],[retern,f]], gen(["\n"])
+    assert_equal [[tab,t],[tab,f]],       gen(["\t"])
+    assert_equal [[space,t],[space,f]],   gen(["\s"])
+    assert_equal [[space,t],[space,f]],   gen([" "])
+  end
+
+  def test_generate_symbols
+    assert_equal [[dash,t],[dash,f]],         gen(["-"])
+    assert_equal [[comma,t],[comma,f]],       gen([","])
+    assert_equal [[apos,t],[apos,f]],         gen(["'"])
+    assert_equal [sd,[at,t],[at,f],su],       gen(["@"])
+    assert_equal [sd,[paren,t],[paren,f],su], gen(["("])
+    assert_equal [sd,[chev,t],[chev,f],su],   gen([">"])
+  end
+
+  def test_generate_unicode # holding option
+    assert_equal [od,[sigma,t],[sigma,f],ou],           gen(["∑"])
+    assert_equal [od,[tm,t],[tm,f],ou],                 gen(["™"])
+    assert_equal [od,[gbp,t],[gbp,f],ou],               gen(["£"])
+    assert_equal [od,[omega,t],[omega,f],ou],           gen(["Ω"])
+    assert_equal [od,[tm,t],[tm,f],[gbp,t],[gbp,f],ou], gen(["™","£"])
+  end
+
+  def test_generate_backslashes
+    assert_equal [[bslash,t],[bslash,f]],                               gen(["\\"])
+    assert_equal [[bslash,t],[bslash,f],[space,t],[space,f]],           gen(["\\"," "])
+    assert_equal [[bslash,t],[bslash,f],[h,t],[h,f],[m,t],[m,f]],       gen(["\\",'h','m'])
+    # is this the job of the parser or the lexer?
+    assert_equal [[bslash,t],[bslash,f],sd,[h,t],[h,f],[m,t],[m,f],su], gen([["\\HM"]])
+  end
+
+  def test_generate_a_custom_escape
+    assert_equal [cd,cu],       gen([["\\COMMAND"]])
+    assert_equal [cd,cu],       gen([["\\CMD"]])
+    assert_equal [ctrld,ctrlu], gen([["\\CONTROL"]])
+    assert_equal [ctrld,ctrlu], gen([["\\CTRL"]])
+  end
+
+  def test_generate_hotkey
+    assert_equal [ctrld,[a,t],[a,f],ctrlu], gen([["\\CONTROL",["a"]]])
+    assert_equal [cd,sd,rd,ru,su,cu],       gen([["\\COMMAND",['\SHIFT',['\->']]]])
+  end
+
+  def test_generate_real_use # a regression
+    assert_equal [ctrld,[a,t],[a,f],ctrlu,[h,t],[h,f]], gen([["\\CTRL",["a"]],"h"])
+  end
+
+  def test_bails_for_unmapped_token
+    # cannot generate snowmen :(
+    e = assert_raises(ArgumentError) { gen(["☃"]) }
+    assert_match /bail/i, e.message
+  end
+
+  def test_generate_arbitrary_nested_array_sequence
+    assert_equal [[c,t],[a,t],[k,t],[e,t],[e,f],[k,f],[a,f],[c,f]], gen([["c",["a",["k",["e"]]]]])
+  end
+
+  def test_generate_command_A
+    assert_equal [cd,sd,[a,t],[a,f],su,cu], gen([["\\COMMAND",["A"]]])
+  end
+
+end
+
+
+# NOTE: DO NOT TEST POSTING EVENTS HERE
+# We only want to test posting events if all the tests in this file pass,
+# otherwise the posted events may be unpredictable depending on what fails.
+# Test event posting in the integration tests.
+class TestAccessibilityString < MiniTest::Unit::TestCase
+  include Accessibility::String
+
+  # basic test to make sure the lexer and generator get along
+  def test_keyboard_events_for
+    events = keyboard_events_for 'cheezburger'
+    assert_kind_of Array, events
+    refute_empty events
+
+    assert_equal true,  events[0][1]
+    assert_equal false, events[1][1]
+  end
+
+  def test_dynamic_map_initialized
+    refute_empty Accessibility::String::EventGenerator::MAPPING
+  end
+
+  def test_can_parse_empty_string
+    assert_equal [], keyboard_events_for('')
+  end
+
+end

data/test/sanity/accessibility/test_translator.rb

@@ -0,0 +1,145 @@
+require 'test/runner'
+require 'accessibility/translator'
+
+
+class TestAccessibilityTranslator < MiniTest::Unit::TestCase
+
+  TRANSLATOR = Accessibility::Translator.instance
+
+  # trivial but important for backwards compat with Snow Leopard
+  def test_identifier_const
+    assert_equal 'AXIdentifier', KAXIdentifierAttribute
+  end
+
+  def test_unprefixing
+    def prefix_test before, after
+      assert_equal after, TRANSLATOR.unprefix(before)
+    end
+
+    prefix_test 'AXButton',               'Button'
+    prefix_test 'MCAXButton',             'Button'
+    prefix_test 'AXURL',                  'URL'
+    prefix_test 'AXTitleUIElement',       'TitleUIElement'
+    prefix_test 'AXIsApplicationRunning', 'ApplicationRunning'
+    prefix_test 'AXAX',                   'AX'
+    prefix_test 'Quick Look',             'QuickLook'
+  end
+
+  def test_lookup
+    def lookup_test key, values, expected
+      assert_equal expected, TRANSLATOR.lookup(key, values)
+    end
+
+    lookup_test :children,         [KAXChildrenAttribute],       KAXChildrenAttribute
+    lookup_test :title_ui_element, [KAXTitleUIElementAttribute], KAXTitleUIElementAttribute
+    lookup_test :focused?,         [KAXFocusedAttribute],        KAXFocusedAttribute
+    lookup_test :flabbergast,      [],                           nil
+    lookup_test :totally_fake,     ['AXTotallyFake'],            'AXTotallyFake'
+  end
+
+  def test_lookup_aliases
+    def lookup_test key, values, expected
+      assert_equal expected, TRANSLATOR.lookup(key, values)
+    end
+
+    lookup_test :id,          [], KAXIdentifierAttribute
+    lookup_test :placeholder, [], KAXPlaceholderValueAttribute
+  end
+
+  def test_rubyize
+    def rubyize_test given, expected
+      assert_equal Array(expected), TRANSLATOR.rubyize(Array(given))
+    end
+
+    rubyize_test KAXMainWindowAttribute,                      :main_window
+    rubyize_test KAXRoleAttribute,                            :role
+    rubyize_test KAXStringForRangeParameterizedAttribute,     :string_for_range
+    rubyize_test [KAXSubroleAttribute, KAXChildrenAttribute], [:subrole, :children]
+  end
+
+  def test_rubyize_doesnt_eat_original_data
+    array = [KAXTitleAttribute, KAXMainWindowAttribute]
+    TRANSLATOR.rubyize array
+    assert_equal [KAXTitleAttribute, KAXMainWindowAttribute], array
+  end
+
+  def test_guess_notification_for
+    def notif_test actual, expected
+      assert_equal expected, TRANSLATOR.guess_notification_for(actual)
+    end
+
+    notif_test 'window_created',            KAXWindowCreatedNotification
+    notif_test :window_created,             KAXWindowCreatedNotification
+    notif_test KAXValueChangedNotification, KAXValueChangedNotification
+    notif_test 'Cheezburger',               'Cheezburger'
+  end
+
+  def test_classify
+    def classify_test actual, expected
+      assert_equal expected, TRANSLATOR.classify(actual)
+    end
+
+    classify_test :buttons,          'Button'
+    classify_test :button,           'Button'
+    classify_test :menu_item,        'MenuItem'
+    classify_test 'floating_window', 'FloatingWindow'
+    classify_test 'outline_rows',    'OutlineRow'
+  end
+
+  def test_singularize
+    def singularize_test actual, expected
+      assert_equal expected, TRANSLATOR.singularize(actual)
+    end
+
+    singularize_test :buttons,     'button'
+    singularize_test :button,      'button'
+    singularize_test :windows,     'window'
+    singularize_test :check_boxes, 'check_box'
+    singularize_test 'classes',    'class'
+  end
+
+
+  def test_unprefixes_are_cached
+    unprefixes = TRANSLATOR.instance_variable_get :@unprefixes
+    unprefixed = unprefixes['AXPieIsTheTruth']
+    assert_includes unprefixes.keys, 'AXPieIsTheTruth'
+    assert_equal    unprefixed, unprefixes['AXPieIsTheTruth']
+  end
+
+  def test_normalizations_are_cached
+    normalizations = TRANSLATOR.instance_variable_get :@normalizations
+    normalized     = normalizations['AXTheAnswer']
+    assert_includes normalizations.keys, 'AXTheAnswer'
+    assert_equal    normalized, normalizations['AXTheAnswer']
+  end
+
+  def test_rubyisms_are_cached
+    rubyisms = TRANSLATOR.instance_variable_get :@rubyisms
+               TRANSLATOR.instance_variable_set :@values, ['AXChocolatePancake']
+    rubyized = rubyisms[:chocolate_pancake]
+    assert_includes rubyisms.keys, :chocolate_pancake
+    assert_equal    rubyized, rubyisms[:chocolate_pancake]
+
+    rubyized = rubyisms[:chocolate_pancake?]
+    assert_includes rubyisms.keys, :chocolate_pancake?
+    assert_equal    rubyized, rubyisms[:chocolate_pancake]
+    assert_equal    rubyized, rubyisms[:chocolate_pancake?]
+  end
+
+  def test_classifications_are_cached
+    classifications = TRANSLATOR.instance_variable_get :@classifications
+
+    classified      = TRANSLATOR.classify 'made_up_class_name'
+    assert_includes classifications.keys, 'made_up_class_name'
+    assert_equal    classified, classifications['made_up_class_name']
+  end
+
+  def test_singularizations_are_cached
+    singulars = TRANSLATOR.instance_variable_get :@singularizations
+
+    singular  = TRANSLATOR.singularize 'buttons'
+    assert_includes singulars.keys, 'buttons'
+    assert_equal    singular, singulars['buttons']
+  end
+
+end

data/test/sanity/ax/test_application.rb

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+require 'test/helper'
+require 'ax/application'
+
+class AX::Element
+  attr_reader :ref
+end
+
+class TestAXApplication < MiniTest::Unit::TestCase
+
+  def app
+    @app ||= AX::Application.new REF
+  end
+
+  def running_app
+    @running_app ||=
+      NSRunningApplication.runningApplicationWithProcessIdentifier app.pid
+  end
+
+  def test_is_a_direct_subclass_of_element
+    assert_equal AX::Element, AX::Application.superclass
+  end
+
+  def test_inspect_includes_pid
+    assert_match /\spid=\d+/, app.inspect
+  end
+
+  def test_inspect_includes_focused
+    assert_match /\sfocused\[(?:✔|✘)\]/, app.inspect
+  end
+
+  def test_terminate
+    got_called = false
+    mock       = Object.new
+    mock.define_singleton_method(:terminate)   { got_called = true }
+    mock.define_singleton_method(:terminated?) { false }
+    app.instance_variable_set :@app, mock
+    app.perform :terminate
+    assert got_called
+  ensure
+    app.instance_variable_set :@app, running_app
+  end
+
+  def test_force_terminate
+    got_called = false
+    mock       = Object.new
+    mock.define_singleton_method(:forceTerminate) { got_called = true }
+    mock.define_singleton_method(:terminated?   ) {             false }
+    app.instance_variable_set :@app, mock
+
+    app.perform :force_terminate
+    assert got_called
+  ensure
+    app.instance_variable_set :@app, running_app
+  end
+
+  def test_overrides_call_super
+    assert_match app.inspect, /children/
+    assert_equal 'AXElementsTester', app.title
+
+    called_super = false
+    app.define_singleton_method :perform do |name|
+      called_super = true if name == :some_action
+    end
+    app.perform :some_action
+    assert called_super
+
+    called_super = false
+    app.define_singleton_method :set do |attr, value|
+      called_super = true if attr == :thingy && value == 'pie'
+    end
+    app.set :thingy, 'pie'
+    assert called_super
+  end
+
+  def test_type_string_forwards_events
+    skip "This strangely causes other tests to fail occassionally"
+    got_callback = false
+    app.ref.define_singleton_method :post do |events|
+      got_callback = true if events.kind_of?(Array)
+    end
+    app.type_string 'test'
+    assert got_callback
+  end
+
+  def test_bundle_identifier
+    assert_equal running_app.bundleIdentifier, app.bundle_identifier
+  end
+
+end