AXElements 0.7.8 → 0.8.0

data/test/integration/accessibility/test_dsl.rb

@@ -14,6 +14,7 @@ class TestAccessibilityDSL < MiniTest::Unit::TestCase
 
   def app;             @@app       ||= AX::Application.new REF                               end
   def text_area;       @@text_area ||= app.main_window.text_area                             end
+  def pop_up;          @@pop_up    ||= app.main_window.pop_up                                end
   def pref_window;     app.children.find { |x| x.attribute(:title) == 'Preferences'   }      end
   def spelling_window; app.children.find { |x| x.attribute(:title).to_s.match(/^Spelling/) } end
 
@@ -144,6 +145,111 @@ class TestAccessibilityDSL < MiniTest::Unit::TestCase
     assert_equal 'AXIsNyan', result.value
   end
 
+  def test_wait_for_invalid_raises_if_wait_for_without_parent_or_ancestor
+    assert_raises(ArgumentError) { dsl.wait_for_invalidation_of(:button) }
+  end
+
+  def test_wait_for_invalid_false_if_timeout
+    refute dsl.wait_for_invalidation_of(:button, parent: app.main_window, timeout: 1)
+  end
+
+  def test_wait_for_invalidation_of_element
+    app.main_window.button(title: 'Yes').perform(:press)
+    Dispatch::Queue.new("herp").after(1) do
+      app.main_window.button(title: 'No').perform(:press)
+    end
+
+    assert dsl.wait_for_invalid(app.main_window.button(title: 'Bye!'))
+  end
+
+  def test_wait_for_invalidation_of_wait_for
+    app.main_window.button(title: 'Yes').perform(:press)
+    Dispatch::Queue.new("herp").after(1) do
+      app.main_window.button(title: 'No').perform(:press)
+    end
+
+    assert dsl.wait_for_invalid(:button, ancestor: app, title: 'Bye!')
+  end
+
+  def test_drag_mouse_to
+    title_element = app.main_window.title_ui_element
+    orig_title_position = title_element.to_point
+    orig_window_position = app.main_window.position
+
+    dsl.drag_mouse_to [100,100], from: title_element
+    assert_in_delta 100, title_element.to_point.x, 1
+    assert_in_delta 100, title_element.to_point.y, 1
+
+    dsl.drag_mouse_to orig_title_position
+    assert_in_delta orig_title_position.x, title_element.to_point.x, 1
+    assert_in_delta orig_title_position.y, title_element.to_point.y, 1
+
+  ensure
+    app.main_window.set :position, orig_window_position if orig_window_position
+  end
+
+  def test_highlight
+    highlighter = dsl.highlight app.main_window, colour: NSColor.blueColor
+    assert_kind_of Accessibility::Highlighter, highlighter
+    assert_equal   NSColor.blueColor,          highlighter.backgroundColor
+    highlighter.stop
+
+    def highlight_test
+      @got_called = true
+    end
+    highlighter = dsl.highlight app.main_window, color: NSColor.greenColor, timeout: 0.1
+    NSNotificationCenter.defaultCenter.addObserver self,
+                                         selector: 'highlight_test',
+                                             name: NSWindowWillCloseNotification,
+                                           object: highlighter
+    sleep 0.1
+    assert @got_called
+  end
+
+  def test_dump_works_for_nested_tab_groups
+    output = dsl.subtree_for app.window.tab_group
+
+    expected = [
+                ['AX::TabGroup',    0],
+                ['AX::RadioButton', 1], ['AX::RadioButton', 1], ['AX::TabGroup', 1],
+                ['AX::RadioButton', 2], ['AX::RadioButton', 2], ['AX::TabGroup', 2],
+                ['AX::RadioButton', 3], ['AX::RadioButton', 3], ['AX::TabGroup', 3],
+                ['AX::RadioButton', 4], ['AX::RadioButton', 4],
+                ['AX::Group',       4],
+                ['AX::TextField',   5], ['AX::StaticText',  6],
+                ['AX::TextField' ,  5], ['AX::StaticText',  6]
+               ]
+
+    refute_empty output
+    output = output.split("\n")
+
+    until output.empty?
+      line           = output.shift
+      klass, indents = expected.shift
+      assert_equal indents, line.match(/^\t*/).to_a.first.length, line
+      line.strip!
+      assert_match /^\#<#{klass}/, line
+    end
+  end
+
+  def test_screenshot
+    path = dsl.screenshot
+    assert File.exists? path
+    FileUtils.rm path
+
+    path = dsl.screenshot "Thing"
+    assert File.exists? path
+    assert_match /\/Thing/, path
+    FileUtils.rm path
+
+    path = dsl.screenshot "Thing", "/tmp"
+    assert File.exists? path
+    assert_match %r{/tmp/Thing-}, path
+    FileUtils.rm path
+  ensure
+    FileUtils.rm path if File.exists? path
+  end
+
   def test_system_wide
     assert_instance_of AX::SystemWide, dsl.system_wide
   end
@@ -203,26 +309,28 @@ class TestAccessibilityDSL < MiniTest::Unit::TestCase
   end
 
   def test_scroll_menu_to
-    pop_up = app.main_window.pop_up_button
-
-    pop_up.perform :press
-    item = wait_for :menu_item, ancestor: pop_up, title: '49'
-    dsl.scroll_menu_to item
-    assert_equal item, element_under_mouse
-    dsl.click
-    assert_equal '49', pop_up.value
-
-    pop_up.perform :press
-    item = wait_for :menu_item, ancestor: pop_up, title: 'Togusa'
-    dsl.scroll_menu_to item
-    assert_equal item, element_under_mouse
-    dsl.click
-    assert_equal 'Togusa', pop_up.value
+    ['49', 'Togusa'].each do |title|
+      pop_up.perform :press
+      item = wait_for :menu_item, ancestor: pop_up, title: title
+      dsl.scroll_menu_to item
+      assert_equal item, element_under_mouse
+      dsl.click
+      assert_equal title, pop_up.value
+    end
+  ensure
+    pop_up.menu_item.perform :cancel unless pop_up.children.empty?
+  end
 
+  def test_scroll_menu_to_using_single_click
+    ['40', 'Batou', '49', 'Motoko'].each do |title|
+      dsl.click pop_up do
+        item = wait_for :menu_item, title: title, ancestor: pop_up
+        dsl.scroll_menu_to item
+      end
+      assert_equal title, pop_up.value
+    end
   ensure
-    unless pop_up.children.empty?
-      pop_up.menu_item.perform :cancel
-    end if pop_up
+    pop_up.menu_item.perform :cancel unless pop_up.children.empty?
   end
 
 end

data/test/integration/accessibility/test_errors.rb

@@ -27,7 +27,7 @@ class TestAccessibilityErrors < MiniTest::Unit::TestCase
   end
 
   def test_search_failure_includes_subtree_in_debug_mode
-    assert Accessibility::Debug.on?, 'Someone turned debugging off'
+    assert Accessibility.debug?, 'Someone turned debugging off'
     l = AX::DOCK.children.first
     e = Accessibility::SearchFailure.new(l, :trash_dock_item, nil)
     def e.backtrace; []; end

data/test/integration/ax/test_element.rb

@@ -6,6 +6,14 @@ class TestAXElement < MiniTest::Unit::TestCase
     @@app ||= AX::Application.new PID
   end
 
+  def test_path_returns_correct_elements_in_correct_order
+    list = app.window.close_button.ancestry
+    assert_equal 3, list.size
+    assert_equal app, list.third
+    assert_equal app.window, list.second
+    assert_equal app.window.close_button, list.first
+  end
+
   def test_search_singular_returns_array
     result = app.search(:window)
     assert_kind_of AX::Window, result
@@ -39,4 +47,13 @@ class TestAXElement < MiniTest::Unit::TestCase
     box.set :value, '' if box
   end
 
+  def test_invalid
+    refute app.invalid?
+
+    app.main_window.button(title: 'Yes').perform :press
+    bye = app.main_window.button(title: /Bye/)
+    app.main_window.button(title: 'No').perform :press
+    assert bye.invalid?
+  end
+
 end

data/test/integration/minitest/test_ax_elements.rb

@@ -13,72 +13,69 @@ class TestMiniTestAssertions < MiniTest::Unit::TestCase
     assert_equal expected, assert_has_child(app, :window)
     assert_equal expected, assert_has_child(app, :window, title: 'AXElementsTester')
 
-    result = assert_has_child(app, :window) { |x|
-      @got_called = true
-      x.title == 'AXElementsTester'
-    }
-    assert_equal expected, result
+    assert_has_child(app, :window) { |_| @got_called = true }
     assert @got_called
   end
 
   def test_assert_has_child_raises_in_failure_cases
-    e = assert_raises MiniTest::Assertion do
-      assert_has_child app, :button
-    end
+    e = assert_raises(MiniTest::Assertion) { assert_has_child app, :button }
     assert_match /to have Button as a child/, e.message
 
-    e = assert_raises MiniTest::Assertion do
-      assert_has_child app, :button, title: 'Press Me'
-    end
-    assert_match /to have Button\(title: "Press Me"\) as a child/, e.message
+    e = assert_raises(MiniTest::Assertion) { assert_has_child app, :button, title: "Press" }
+    assert_match %r{to have Button\(title: "Press"\) as a child}, e.message
   end
 
   def test_assert_has_descendent
     expected = app.main_window.check_box
 
     assert_equal expected, assert_has_descendent(app,:check_box)
-    assert_equal expected, assert_has_descendent(app,:check_box,title: /Box/)
+    assert_equal expected, assert_has_descendent(app,:check_box, title: /Box/)
 
-    result = assert_has_descendent app, :check_box do |x|
-      @got_called = true
-      x.title == 'Unchecked Check Box'
-    end
-    assert_equal expected, result
+    assert_has_descendent(app, :check_box) { |_| @got_called = true }
     assert @got_called
   end
 
   def test_assert_has_descendent_raises_in_failure_cases
-    ancestor = app.main_window.slider
-    e        = assert_raises MiniTest::Assertion do
-      assert_has_descendent ancestor, :window, title: /Cake/
-    end
+    e = assert_raises(MiniTest::Assertion) {
+      assert_has_descendent(app.main_window.slider, :window, title: /Cake/)
+    }
     assert_match /to have Window\(title: \/Cake\/\) as a descendent/, e.message
   end
 
+  def test_assert_shortly_has
+    assert_equal app.window, assert_shortly_has(:window, parent: app)
+    assert_equal app.check_box, assert_shortly_has(:check_box, ancestor: app)
+
+    assert_shortly_has(:window, parent: app) { @got_called = true }
+    assert @got_called
+  end
+
+  def test_assert_shortly_has_raises_in_failure_cases
+    e = assert_raises(MiniTest::Assertion) { assert_shortly_has(:button, parent: app, timeout: 0) }
+    assert_match /to have child Button before a timeout occurred/, e.message
+
+    e = assert_raises(MiniTest::Assertion) { assert_shortly_has(:table, ancestor: app.menu_bar_item, timeout: 0) }
+    assert_match /to have descendent Table before a timeout occurred/, e.message
+  end
+
   def test_refute_has_child
-    assert_nil refute_has_child(app,:button)
-    assert_nil refute_has_child(app,:window,title: 'Herp Derp')
+    assert_nil refute_has_child(app, :button)
+    assert_nil refute_has_child(app, :window, title: 'Herp Derp')
 
-    result = refute_has_child app, :window do |x|
-      @got_called = true
-      x.title == 'Herp Derp'
-    end
+    result = refute_has_child(app, :window) { |x| x.title == 'Herp Derp' }
     assert_nil result
-    assert @got_called
   end
 
   def test_refute_has_child_raises_in_failure_cases
-    e = assert_raises MiniTest::Assertion do
-      refute_has_child app, :window
-    end
-    assert_match /not to have #{Regexp.escape(app.window.inspect)} as a child/, e.message
+    e = assert_raises(MiniTest::Assertion) { refute_has_child app, :window }
+    assert_match /NOT to have #{Regexp.escape(app.window.inspect)} as a child/, e.message
   end
 
   def test_refute_has_descendent
     slider = app.main_window.slider
 
-    assert_nil refute_has_descendent(slider,:window)
-    assert_nil refute_has_descendent(slider,:element,title: 'Rhubarb')
+    assert_nil refute_has_descendent(slider, :window)
+    assert_nil refute_has_descendent(slider, :element, title: 'Rhubarb')
 
     result = refute_has_descendent slider, :element do |x|
       @got_called = true
@@ -89,9 +86,7 @@ class TestMiniTestAssertions < MiniTest::Unit::TestCase
   end
 
   def test_refute_has_descendent_raises_in_failure_cases
-    e = assert_raises MiniTest::Assertion do
-      refute_has_descendent app, :window
-    end
+    e = assert_raises(MiniTest::Assertion) { refute_has_descendent app, :window }
     assert_match /#{Regexp.escape(app.window.inspect)} as a descendent/, e.message
   end
 

data/test/integration/rspec/expectations/test_ax_elements.rb

@@ -8,51 +8,100 @@ class TestRSpecMatchers < MiniTest::Unit::TestCase
     @@app ||= AX::Application.new PID
   end
 
+
+
   def test_have_child_should_failure_message
-    m = Accessibility::HasChildMatcher.new(:window, {}) {}
     e = app.main_window.slider
+    m = have_child(:window)
 
-    m.matches? e
-    assert_equal "Expected #{e.inspect} to have child Window[✔]",
-      m.failure_message_for_should
+    refute m.matches?(e)
+    assert_equal "Expected #{e.inspect} to have child Window", m.failure_message_for_should
   end
 
   def test_have_child_should_not_failure_message
-    m = Accessibility::HasChildMatcher.new(:window, {})
     e = app.window
+    m = have_child(:window)
 
-    m.does_not_match? app
-    assert_equal "Expected #{app.inspect} to NOT have child #{e.inspect}",
-      m.failure_message_for_should_not
+    refute m.does_not_match?(app)
+    assert_equal "Expected #{app.inspect} to NOT have child #{e.inspect}", m.failure_message_for_should_not
   end
 
   def test_have_child_description
-    m = Accessibility::HasChildMatcher.new(:window,{}) {}
+    m = have_child(:window) { }
     assert_equal 'should have a child that matches Window[✔]', m.description
   end
 
+
+
   def test_have_descendent_should_failure_message
-    m = Accessibility::HasDescendentMatcher.new(:button, {}) {}
-    q = Accessibility::Qualifier.new(:Button,{}) {}
+    m = have_descendent(:button)
     e = app.main_window.slider
 
-    m.matches? e
-    assert_equal "Expected #{e.inspect} to have descendent Button[✔]",
-      m.failure_message_for_should
+    refute m.matches?(e)
+    assert_equal "Expected #{e.inspect} to have descendent Button", m.failure_message_for_should
   end
 
   def test_have_descendent_should_not_failure_message
-    m = Accessibility::HasDescendentMatcher.new(:window,{})
+    m = have_descendant(:window)
     e = app.window
 
-    m.does_not_match? app
-    assert_equal "Expected #{app.inspect} to NOT have descendent #{e.inspect}",
-      m.failure_message_for_should_not
+    refute m.does_not_match?(app)
+    assert_equal "Expected #{app.inspect} to NOT have descendent #{e.inspect}", m.failure_message_for_should_not
   end
 
   def test_have_descendent_description
-    m = Accessibility::HasDescendentMatcher.new(:button,{})
+    m = have_descendent(:button)
     assert_equal 'should have a descendent matching Button', m.description
   end
 
+
+
+  def test_shortly_have_child_should_failure_message
+    m = shortly_have_child(:button, timeout: 0) { }
+    e = app.main_window.slider
+
+    refute m.matches?(e)
+    assert_equal "Expected #{e.inspect} to have child Button[✔] before a timeout occurred",
+      m.failure_message_for_should
+  end
+
+  def test_shortly_have_child_should_not_failure_message
+    m = shortly_have_child(:window)
+    e = app
+
+    refute m.does_not_match?(e)
+    assert_equal "Expected #{e.inspect} to NOT have child #{e.window.inspect} before a timeout occurred",
+      m.failure_message_for_should_not
+  end
+
+  def test_shortly_have_child_description
+    m = shortly_have_child(:button)
+    assert_equal 'should have a child that matches Button before a timeout occurs', m.description
+  end
+
+
+
+  def test_shortly_have_descendent_should_failure_message
+    m = shortly_have_descendent(:button, timeout: 0)
+    e = app.main_window.slider
+
+    refute m.matches?(e)
+    assert_equal "Expected #{e.inspect} to have descendent Button before a timeout occurred",
+      m.failure_message_for_should
+  end
+
+  def test_shortly_have_descendent_should_not_failure_message
+    m = shortly_have_descendent(:window)
+    e = app
+
+    refute m.does_not_match?(e)
+    assert_equal "Expected #{e.inspect} to NOT have descendent #{e.window.inspect} before a timeout occurred",
+      m.failure_message_for_should_not
+  end
+
+  def test_shortly_have_descendent_description
+    m = shortly_have_descendent(:button)
+    assert_equal 'should have a descendent matching Button before a timeout occurs', m.description
+  end
+
 end

data/test/sanity/accessibility/test_core.rb

@@ -65,7 +65,7 @@ class TestAccessibilityCore < MiniTest::Unit::TestCase
   def test_attribute
     assert_equal 'AXElementsTester',  window.attribute(KAXTitleAttribute  )
     assert_equal false,               window.attribute(KAXFocusedAttribute)
-    assert_equal CGSizeMake(555,483), window.attribute(KAXSizeAttribute   )
+    assert_equal CGSize.new(555,529), window.attribute(KAXSizeAttribute   )
     assert_equal REF,                 window.attribute(KAXParentAttribute )
     assert_equal 10..19,              window.attribute("AXPie"            )
   end
@@ -102,6 +102,15 @@ class TestAccessibilityCore < MiniTest::Unit::TestCase
     assert_equal    slider.attribute(KAXValueAttribute), slider.value
   end
 
+  def test_pid
+    assert_equal PID, REF.pid
+    assert_equal PID, window.pid
+  end
+
+  def test_pid_is_zero_for_system_wide
+    assert_equal 0, REF.system_wide.pid
+  end
+
   def test_size_of
     assert_equal REF.children.size, REF.size_of(KAXChildrenAttribute)
     assert_equal 0,                 pop_up.size_of(KAXChildrenAttribute)
@@ -167,28 +176,26 @@ class TestAccessibilityCore < MiniTest::Unit::TestCase
     assert_empty invalid_ref.parameterized_attributes
   end
 
-  def test_attribute_for_parameter
+  def test_parameterized_attribute
     expected = 'My Li'
 
-    attr = static_text.attribute KAXStringForRangeParameterizedAttribute,
-                  for_parameter: 0..4
+    attr = static_text.parameterized_attribute(KAXStringForRangeParameterizedAttribute, 0..4)
     assert_equal expected, attr
 
-    attr = static_text.attribute KAXAttributedStringForRangeParameterizedAttribute,
-                  for_parameter: 0..4
+    attr = static_text.parameterized_attribute(KAXAttributedStringForRangeParameterizedAttribute, 0..4)
     assert_equal expected, attr.string
   end
 
-  def test_attribute_for_parameter_handles_dead_elements_and_no_value
-    assert_nil invalid_ref.attribute(KAXStringForRangeParameterizedAttribute, for_parameter: 0..0)
+  def test_parameterized_attribute_handles_dead_elements_and_no_value
+    assert_nil invalid_ref.parameterized_attribute(KAXStringForRangeParameterizedAttribute, 0..0)
 
     # Should add a test case to test the no value case, but it will have
     # to be fabricated in the test app.
   end
 
-  def test_attribute_for_parameter_handles_errors
+  def test_parameterized_attribute_handles_errors
     assert_raises(ArgumentError) {
-      REF.attribute(KAXStringForRangeParameterizedAttribute, for_parameter: 0..1)
+      REF.parameterized_attribute(KAXStringForRangeParameterizedAttribute, 0..1)
     }
   end
 
@@ -279,8 +286,8 @@ class TestAccessibilityCore < MiniTest::Unit::TestCase
   # # more than meets the eye
   def test_notification_registration_and_unregistration
     obsrvr = REF.observer { |_,_,_| }
-    assert   REF.register(obsrvr,     to_receive: KAXWindowCreatedNotification)
-    assert REF.unregister(obsrvr, from_receiving: KAXWindowCreatedNotification)
+    assert   REF.register(obsrvr, KAXWindowCreatedNotification)
+    assert REF.unregister(obsrvr, KAXWindowCreatedNotification)
   end
 
   # integration-y
@@ -288,7 +295,7 @@ class TestAccessibilityCore < MiniTest::Unit::TestCase
     obsrvr = REF.observer do |observer, element, notif|
       @notif_triple = [observer, element, notif]
     end
-    REF.register observer, to_receive: 'Cheezburger'
+    REF.register observer, 'Cheezburger'
     source = REF.run_loop_source_for observer
     CFRunLoopAddSource(CFRunLoopGetCurrent(), source, KCFRunLoopDefaultMode)
 
@@ -304,38 +311,24 @@ class TestAccessibilityCore < MiniTest::Unit::TestCase
 
   def test_register_handles_errors
     assert_raises(ArgumentError) {
-      REF.register(nil, to_receive: KAXWindowCreatedNotification)
+      REF.register(nil, KAXWindowCreatedNotification)
     }
     assert_raises(ArgumentError) {
       obsrvr = REF.observer { |_,_,_| }
-      REF.register(obsrvr, to_receive: nil)
+      REF.register(obsrvr, nil)
     }
   end
 
   def test_unregister_handles_errors
     assert_raises(ArgumentError) {
-      REF.unregister(nil, from_receiving: KAXWindowCreatedNotification)
+      REF.unregister(nil, KAXWindowCreatedNotification)
     }
     assert_raises(ArgumentError) {
       obsrvr = REF.observer { |_,_,_| }
-      REF.unregister(obsrvr, from_receiving: nil)
+      REF.unregister(obsrvr, nil)
     }
   end
 
-  def test_enabled?
-    assert REF.enabled?
-    # @todo I guess that's good enough?
-  end
-
-  def test_pid
-    assert_equal PID, REF.pid
-    assert_equal PID, window.pid
-  end
-
-  def test_pid_is_zero_for_system_wide
-    assert_equal 0, REF.system_wide.pid
-  end
-
   def test_system_wide
     assert_equal AXUIElementCreateSystemWide(), REF.system_wide
   end
@@ -375,7 +368,7 @@ class TestAccessibilityCore < MiniTest::Unit::TestCase
       should_raise: ArgumentError,
     with_fragments: [/can't get\/set "cake" with\/to "chocolate"/, app]
 
-    p = CGPointMake(1,3)
+    p = CGPoint.new(1,3)
     assert_error [KAXErrorIllegalArgument, p, nil, nil],
       should_raise: ArgumentError,
     with_fragments: [/The point #{p.inspect}/, app]
@@ -518,7 +511,7 @@ class TestToAXToRubyHooks < MiniTest::Unit::TestCase
 
   def test_to_ruby
     assert_equal CGPointZero,       CGPointZero      .to_ax.to_ruby
-    assert_equal CGSizeMake(10,10), CGSizeMake(10,10).to_ax.to_ruby
+    assert_equal CGSize.new(10,10), CGSize.new(10,10).to_ax.to_ruby
     assert_equal Range.new(1,10),   CFRange.new(1,10).to_ax.to_ruby
   end
 
@@ -533,21 +526,36 @@ end
 class TestMiscCoreExtensions < MiniTest::Unit::TestCase
 
   def test_to_point
-    p = CGPointMake(2,3)
+    p = CGPoint.new(2,3)
     assert_equal p, p.to_point
 
-    p = CGPointMake(1,3)
+    p = CGPoint.new(1,3)
     assert_equal p, p.to_a.to_point
   end
 
   def test_to_size
-    s = CGSizeMake(2,4)
+    s = CGSize.new(2,4)
     assert_equal s, s.to_a.to_size
   end
 
   def test_to_rect
-    r = CGRectMake(6,7,8,9)
+    r = CGRectMake(6, 7, 8, 9)
     assert_equal r, r.to_a.map(&:to_a).flatten.to_rect
   end
 
+  def test_to_url
+    site = 'http://marketcircle.com/'
+    url  = site.to_url
+    refute_nil url
+    assert_equal NSURL.URLWithString(site), url
+
+    file = 'file://localhost/Applications/Calculator.app/'
+    url  = file.to_url
+    refute_nil url
+    assert_equal NSURL.fileURLWithPath('/Applications/Calculator.app/'), url
+
+    void = "not a url at all"
+    assert_nil void.to_url
+  end
+
 end

data/test/sanity/accessibility/test_highlighter.rb

@@ -0,0 +1,56 @@
+require 'test/runner'
+require 'accessibility/highlighter'
+
+class TestHighlighter < MiniTest::Unit::TestCase
+
+  def bounds
+    CGRectMake(100, 100, 100, 100)
+  end
+
+  def test_highlight_returns_created_window
+    w = Accessibility::Highlighter.new bounds
+    assert_kind_of NSWindow, w
+    assert_respond_to w, :stop
+  ensure
+    w.close if w
+  end
+
+  def test_highlight_can_take_a_timeout
+    w = Accessibility::Highlighter.new bounds, timeout: 0.1
+    assert w.visible?
+    sleep 0.15
+    refute w.visible? # Not exactly the assertion I want, but close enough
+  ensure
+    w.close if w
+  end
+
+  def test_highlight_can_have_custom_colour
+    w = Accessibility::Highlighter.new bounds, color: NSColor.cyanColor
+    assert w.backgroundColor == NSColor.cyanColor
+    w.close
+
+    # test both spellings of colour
+    w = Accessibility::Highlighter.new bounds, colour: NSColor.purpleColor
+    assert w.backgroundColor == NSColor.purpleColor
+  end
+
+  def test_highlight_highlights_correct_rect
+    w = Accessibility::Highlighter.new bounds
+    assert_equal w.frame, bounds.flip!
+  end
+
+end
+
+class TestCGRectExtensions < MiniTest::Unit::TestCase
+
+  def test_flipping
+    size = NSScreen.mainScreen.frame.size
+    assert_equal CGRectMake(0,       size.height, 0,     0), CGRectZero.dup.flip!
+    assert_equal CGRectMake(100, size.height-200, 100, 100), CGRectMake(100,100,100,100).flip!
+  end
+
+  def test_flipping_twice_returns_to_original
+    assert_equal CGRectZero.dup, CGRectZero.dup.flip!.flip!
+  end
+
+end