Merge lp:~unity-2d-team/unity-2d/testability-integration into lp:unity-2d

[Gerry Boland]

[tests] Add Automated User Experience testing using "Testability"

Add support for Testability, a Qt application automated testing framework, with some boilerplate code to allow easy writing of tests using Ruby's Test::Util library. Also added is a Ruby library called XDo which allows control of the X server and fake mouse, keyboard and window management.

A couple of sample tests for the launcher have been written. This required the addition of some objectName definitions to the launcher.

[Gerry Boland (gerboland)]

A quick guide to setting up your machine to for testing this MR:

$ sudo add-apt-repo ppa:gerboland/testability
$ sudo apt-get update
$ sudo apt-get install rubygems testability-qttas \
  ruby-testability-driver-qt-sut-plugin testability-visualizer \
  librmagick-ruby1.8 xdotool xsel xkill xwininfo

Edit /etc/tdriver/tdriver_parameters.xml to just contain:

<parameters>
   <sut id="sut_qt" template="qt">
       <!-- use default values -->
       <parameter name="qttas_server_ip" value="127.0.0.1" />
   </sut>

   <!-- overload default behaviours parameter (see generic.xml in defaults folder) -->
   <!-- parameter name="tmp_folder" value="C:\tdriver\temp_folder"/ -->
   <parameter name="behaviours" value="behaviours.xml"/>
</parameters>

Run Testability server first
$ qttasserver&

To run tests on this source tree, make sure you run cmake & compile. Otherwise
tests will be run on the installed applications.

You run the entire Unity 2D test suite by executing the run-tests.rb script:
$ cd tests
$ ruby run-tests.rb

Consult tests/README for more details

[Gerry Boland (gerboland)]

Why Xdo?
- Best Ruby library I can find to control X. Emulates mouse & keyboard inputs, has basic clipboard support, and excellent abilities to control the window manager.
- Makes use of existing X test-applications (xdotool, xsel..)
- Easily extendible to support host & system-under-test separation (using @sut.execute_shell_command). Right now, it is required that we test on the host machine.

Why a copy in the tree?
- Rubygems are developer packages, we cannot depend on their stability
- As above, want to modify the library for our own needs. Good to push any fixes to original project however.

[lp:~unity-2d-team/unity-2d/testability-integration]

838. By Gerry Boland on 2011-12-14

Fix required packages and command in README

839. By Gerry Boland on 2011-12-14

Improve window ID detection. Passing gnome-terminal a (temporary) unique
directory to work from, which sets the window title to contain a known
string we can then reliably search for.

840. By Gerry Boland on 2011-12-15

Rebase with trunk

841. By Gerry Boland on 2011-12-15

Launcher is 65 pixels wide, not 66. Update test cases

842. By Gerry Boland on 2011-12-15

Open gnome-terminal in background for tests.

If no instance of gnome-terminal was running, the system call would block and hang the tests.

843. By Gerry Boland on 2011-12-15

Ensure binart_dir.txt generated in source directory

844. By Gerry Boland on 2011-12-15

Use WIDTH value in test comment

845. By Gerry Boland on 2011-12-15

Additional checks to ensure Launcher ready to be tested

[Tiago Salem Herrmann (tiagosh)]

Just tested in my environment and everything is working fine.

review: Approve

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2011-12-09 13:09:46 +0000
+++ CMakeLists.txt	2011-12-15 16:55:31 +0000
@@ -89,6 +89,7 @@
 # Tests
 enable_testing()
 add_custom_target(check make test)
+configure_file(tests/misc/binary_dir.txt.in ${CMAKE_CURRENT_SOURCE_DIR}/tests/misc/binary_dir.txt @ONLY)
 
 # Source
 add_subdirectory(libunity-2d-private)
 
=== modified file 'launcher/Launcher.qml'
--- launcher/Launcher.qml	2011-12-08 14:13:21 +0000
+++ launcher/Launcher.qml	2011-12-15 16:55:31 +0000
@@ -91,7 +91,7 @@
 
         LauncherList {
             id: main
-            Accessible.name: "main"
+            objectName: "main"
 
             /* function to position highlighted tile so that the shadow does not cover it */
             function positionMainViewForIndex(index) {
@@ -153,7 +153,7 @@
 
         LauncherList {
             id: shelf
-            Accessible.name: "shelf"
+            objectName: "shelf"
 
             anchors.bottom: parent.bottom
             anchors.bottomMargin: main.anchors.bottomMargin
 
=== modified file 'launcher/LauncherItem.qml'
--- launcher/LauncherItem.qml	2011-11-28 19:40:53 +0000
+++ launcher/LauncherItem.qml	2011-12-15 16:55:31 +0000
@@ -56,6 +56,7 @@
 
     property int tileSize
     property int selectionOutlineSize
+    property alias name: looseItem.objectName
     property string desktopFile: ""
     property alias icon: icon.source
     property alias urgentAnimation: urgentAnimation
@@ -131,6 +132,7 @@
         /* This is the arrow shown at the right of the tile when the application is
            the active one */
         Image {
+            objectName: "active"
             anchors.right: parent.right
             y: item.height - item.selectionOutlineSize / 2 - height / 2
             mirror: isRightToLeft()
@@ -152,6 +154,7 @@
         Repeater {
             model: item.pips
             delegate: Image {
+                objectName: "pips"
                 /* FIXME: It seems that when the image is created (or re-used) by the Repeater
                    for a moment it doesn't have any parent, and therefore warnings are
                    printed for the following two anchor assignements. This fixes the
@@ -191,6 +194,7 @@
                While the application is launching, this will fade out and in. */
             Image {
                 id: tileBackground
+                objectName: "tileBackground"
                 property color color: defaultBackgroundColor
                 anchors.fill: parent
                 smooth: true
@@ -241,6 +245,7 @@
             /* This is just the main icon of the tile */
             Image {
                 id: icon
+                objectName: "icon"
                 anchors.centerIn: parent
                 smooth: true
 
@@ -275,6 +280,7 @@
 
             Image {
                 id: selectionOutline
+                objectName: "selectionOutline"
                 anchors.centerIn: parent
                 smooth: true
                 source: "artwork/round_selected_66x66.png"
@@ -309,6 +315,7 @@
 
             Image {
                 id: progressBar
+                objectName: "progressBar"
                 source: "artwork/progress_bar_trough.png"
                 anchors.verticalCenter: parent.verticalCenter
                 anchors.left: parent.left
 
=== modified file 'launcher/LauncherList.qml'
--- launcher/LauncherList.qml	2011-12-11 16:36:28 +0000
+++ launcher/LauncherList.qml	2011-12-15 16:55:31 +0000
@@ -21,6 +21,7 @@
 
 AutoScrollingListView {
     id: list
+    Accessible.name: objectName
 
     /* The spacing is explicitly set to -8 in order to compensate
        the space added by selectionOutline and round_corner_54x54.png. */
@@ -89,6 +90,7 @@
         }
 
         Accessible.name: accessibleDescription()
+        name: item.name
 
         width: list.width
         tileSize: list.tileSize
 
=== modified file 'launcher/tests/CMakeLists.txt'
--- launcher/tests/CMakeLists.txt	2011-11-25 15:38:51 +0000
+++ launcher/tests/CMakeLists.txt	2011-12-15 16:55:31 +0000
@@ -2,7 +2,7 @@
     set(_test_list "")
     foreach(_test ${ARGN})
         add_test(NAME ${_test} 
-            COMMAND /bin/bash ${CMAKE_SOURCE_DIR}/tests/run-with-xvfb.sh ./${_test}
+            COMMAND /bin/bash ${CMAKE_SOURCE_DIR}/tests/misc/run-with-xvfb.sh ./${_test}
             )
         add_executable(${_test} ${_test}.cpp ${_test}.moc)
         qt4_generate_moc(${_test}.cpp ${_test}.moc)
 
=== added file 'libunity-2d-private/src/testabilityinterface.h'
--- libunity-2d-private/src/testabilityinterface.h	1970-01-01 00:00:00 +0000
+++ libunity-2d-private/src/testabilityinterface.h	2011-12-15 16:55:31 +0000
@@ -0,0 +1,37 @@
+/*************************************************************************** 
+** 
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). 
+** All rights reserved. 
+** Contact: Nokia Corporation ([e-mail]) 
+** 
+** This file is part of TDriver. 
+** 
+** If you have questions regarding the use of this file, please contact 
+** Nokia at [e-mail] . 
+** 
+** This library is free software; you can redistribute it and/or 
+** modify it under the terms of the GNU Lesser General Public 
+** License version 2.1 as published by the Free Software Foundation 
+** and appearing in the file LICENSE.LGPL included in the packaging 
+** of this file.
+**
+****************************************************************************/
+
+#include <QObject>
+#include <QString>
+
+class TestabilityInterface
+{
+public:
+     virtual ~TestabilityInterface() {}
+
+     /*!
+       Initializes the plugin once loaded.
+     */
+     virtual void Initialize() = 0;
+
+};
+
+ Q_DECLARE_INTERFACE(TestabilityInterface,
+                     "com.nokia.testability.TestabilityInterface/1.0")
+
 
=== modified file 'libunity-2d-private/src/unity2dapplication.cpp'
--- libunity-2d-private/src/unity2dapplication.cpp	2011-10-12 19:36:54 +0000
+++ libunity-2d-private/src/unity2dapplication.cpp	2011-12-15 16:55:31 +0000
@@ -41,6 +41,12 @@
 #include <gtk/gtk.h>
 #include <pango/pango.h>
 
+// Testability
+#include <QtPlugin>
+#include <QPluginLoader>
+#include <QLibraryInfo>
+#include "testabilityinterface.h"
+
 // libc
 #include <stdlib.h>
 
@@ -157,6 +163,11 @@
 : QApplication(argc, argv)
 , m_platformFontTracker(new PlatformFontTracker)
 {
+    /* Load Testability Plugin on startup if requested */
+    if (arrayContains(argv, argv + argc, "-testability")) {
+        loadTestabilityPlugin();
+    }
+
     /* Configure translations */
     Unity2dTr::init("unity-2d", INSTALL_PREFIX "/share/locale");
 
@@ -208,4 +219,35 @@
     return QApplication::x11EventFilter(event);
 }
 
+/*
+ * Load the Testability Plugin if available
+ *
+ * Testability is a tool required for UI testing. See tests/ directory.
+ */
+void Unity2dApplication::loadTestabilityPlugin()
+{
+     QString testabilityPlugin = "testability/libtestability";
+     QString testabilityPluginPostfix = ".so";
+
+     testabilityPlugin = QLibraryInfo::location(QLibraryInfo::PluginsPath)
+                         + QObject::tr("/") + testabilityPlugin + testabilityPluginPostfix;
+     QPluginLoader loader(testabilityPlugin.toLatin1().data());
+
+     QObject *plugin = loader.instance();
+     if (plugin) {
+         qDebug("Testability plugin loaded successfully!");
+         testabilityInterface = qobject_cast<TestabilityInterface *>(plugin);
+
+         if (testabilityInterface) {
+             qDebug("Testability interface obtained!");
+             testabilityInterface->Initialize();
+         } else {
+             qDebug("Failed to get testability interface!");
+         }
+     } else {
+         qDebug("Testability plugin %s load failed with error:%s",
+                testabilityPlugin.toLatin1().data(), loader.errorString().toLatin1().data());
+     }
+}
+
 #include <unity2dapplication.moc>
 
=== modified file 'libunity-2d-private/src/unity2dapplication.h'
--- libunity-2d-private/src/unity2dapplication.h	2011-07-27 14:07:00 +0000
+++ libunity-2d-private/src/unity2dapplication.h	2011-12-15 16:55:31 +0000
@@ -29,6 +29,8 @@
 
 class PlatformFontTracker;
 
+class TestabilityInterface;
+
 class AbstractX11EventFilter
 {
 public:
@@ -66,8 +68,10 @@
     bool x11EventFilter(XEvent*);
 
 private:
+    void loadTestabilityPlugin();
     QList<AbstractX11EventFilter*> m_x11EventFilters;
     PlatformFontTracker* m_platformFontTracker;
+    TestabilityInterface* testabilityInterface;
 };
 
 #endif // UNITY2DAPPLICATION_H
 
=== modified file 'libunity-2d-private/tests/CMakeLists.txt'
--- libunity-2d-private/tests/CMakeLists.txt	2011-11-28 13:44:43 +0000
+++ libunity-2d-private/tests/CMakeLists.txt	2011-12-15 16:55:31 +0000
@@ -4,7 +4,7 @@
 include_directories(
     ${libunity-2d-private_SOURCE_DIR}/src
     ${libunity-2d-private_SOURCE_DIR}/Unity2d
-    ${CMAKE_SOURCE_DIR}/tests
+    ${CMAKE_SOURCE_DIR}/tests/misc
     ${CMAKE_CURRENT_BINARY_DIR}
     ${GLIB_INCLUDE_DIRS}
     ${QT_QTTEST_INCLUDE_DIR}
@@ -17,7 +17,7 @@
     set(_test_list "")
     foreach(_test ${ARGN})
         add_test(NAME ${_test} 
-            COMMAND /bin/bash ${CMAKE_SOURCE_DIR}/tests/run-with-xvfb.sh ./${_test}
+            COMMAND /bin/bash ${CMAKE_SOURCE_DIR}/tests/misc/run-with-xvfb.sh ./${_test}
             )
         add_executable(${_test} ${_test}.cpp ${_test}.moc)
         qt4_generate_moc(${_test}.cpp ${_test}.moc)
 
=== modified file 'panel/tests/CMakeLists.txt'
--- panel/tests/CMakeLists.txt	2011-11-23 19:57:05 +0000
+++ panel/tests/CMakeLists.txt	2011-12-15 16:55:31 +0000
@@ -2,7 +2,7 @@
     set(_test_list "")
     foreach(_test ${ARGN})
         add_test(NAME ${_test} 
-            COMMAND /bin/bash ${CMAKE_SOURCE_DIR}/tests/run-with-xvfb.sh ${_test}
+            COMMAND /bin/bash ${CMAKE_SOURCE_DIR}/tests/misc/run-with-xvfb.sh ${_test}
             )
         add_executable(${_test} ${_test}.cpp ${_test}.moc)
         qt4_generate_moc(${_test}.cpp ${_test}.moc)
 
=== added file 'tests/README'
--- tests/README	1970-01-01 00:00:00 +0000
+++ tests/README	2011-12-15 16:55:31 +0000
@@ -0,0 +1,177 @@
+=======================
+User Acceptance Testing
+=======================
+
+Outline
+-------
+Repeatedly and reliably reproducing the inputs a user and comparing the outputs 
+to known good values is an excellent way to maintain the existing functionality 
+of a piece of software. However manually performing these tests is tiresome and 
+prone to error.
+
+Automation is the key! As we use Qt, we are spoiled with a tool called 
+"Testability" which is designed to automate this testing process. We make use of
+this tool for testing Unity 2D.
+
+
+Testability Introduction
+------------------------
+Testability is a UX testing framework, whose core feature for us is that it 
+allows inspection of the tree of QObjects in a Qt application to read properties
+(write to some) and call signals, as well as faking mouse/keyboard/gesture 
+inputs, grabbing visual outputs, and measuring both CPU and graphical 
+performance.
+
+Testability is comprised of the following parts:
+
+On the System Under Test (SUT)
+- A plugin that the Qt-based software to be tested loads - usually with the 
+  “-testability” switch.
+- A server app that allows inspection and interaction with the SUT [qttasserver]
+
+On the Host machine (can be same as the SUT)
+- Ruby libraries to act as client for qttasserver, so that testing is scriptable 
+  [testability-driver & testability-driver-qt-sut-plugin]
+- GUI to allow easy inspection of SUT and writing tests [tdriver-visualizer],  
+  but not needed for running tests.
+
+For the moment, the system is designed assuming that the SUT is also the Host
+machine.
+
+
+Testability installation instructions
+-------------------------------------
+Add this repo to your apt sources:
+
+$ sudo add-apt-repository ppa:gerboland/testability
+$ sudo apt-get update
+
+Testability is comprised of the following parts:
+- testability-qttas
+    The server binary and plugin library for the SUT.
+- ruby-testability-driver
+    Basic client interface for qttasserver
+- ruby-testability-driver-qt-sut-plugin
+    [Depends on ruby-testability-driver]
+    Plugin for testability-driver to add QObject inspection support
+- testability-visualizer
+    User interface - not needed for testing
+
+
+To get started, install all these and additional dependencies with:
+
+$ sudo apt-get install rubygems testability-qttas \
+  ruby-testability-driver-qt-sut-plugin testability-visualizer \
+  librmagick-ruby1.8 xdotool xsel x11-utils
+
+You need to configure Testability for your usage. Assuming you’ll be testing on 
+your host machine, this involves editing /etc/tdriver/tdriver_parameters.xml to 
+just contain:
+
+<parameters>
+   <sut id="sut_qt" template="qt">
+       <!-- use default values -->
+       <parameter name="qttas_server_ip" value="127.0.0.1" />
+   </sut>
+
+   <!-- overload default behaviours parameter (see generic.xml in defaults folder) -->
+   <parameter name="behaviours" value="behaviours.xml" />
+</parameters>
+
+Also to get log output from these processes, you should create the directory 
+/logs/testability [FIXME]
+
+
+Running Tests
+-------------
+Before any test are run, you must start the qttasserver on the SUT:
+$ qttasserver&
+
+To run tests on this source tree, make sure you run cmake & compile. Otherwise 
+tests will be run on the installed applications.
+
+You run the entire Unity 2D test suite by executing the run-tests.rb script:
+$ cd tests
+$ ruby run-tests.rb
+
+This script enters specified subdirectories and runs the tests contained in any 
+ruby script with particular format.
+
+You can run individual test suites (one per file) by entering the directory and 
+calling:
+$ cd launcher
+$ ruby autohide_show_tests.rb
+
+Single test cases ("Position with Empty Desktop") can be run with
+$ ruby autohide_shot_tests.rb --name "test_Position_with_Empty_Desktop"
+
+
+Test Suite Syntax
+-----------------
+Please take a look at this example:
+
+
+
+require '../run-tests.rb' unless $INIT_COMPLETED #include necessary libs, etc
+
+################################# Test Suite ###################################
+context "Test Suite summary" do
+  # Run once at the beginning of this test suite
+  startup do
+  end
+  
+  # Run once at the end of this test suite
+  shutdown do
+  end
+
+  # Run before each test case begins
+  setup do
+    # Execute the application 
+    @sut = TDriver.sut(:Id => "sut_qt")    
+    @app = @sut.run( :name => "/absolute/path/to/application", 
+    		         :arguments => "-testability", 
+    		         :sleeptime => 2 )
+  end
+
+  # Run after each test case completes
+  teardown do
+    #@app.close        
+    #Need to kill Launcher as it does not shutdown when politely asked
+    system "pkill -nf unity-2d-launcher"
+  end
+
+  ##############################################################################
+  # Test cases
+
+  test "Short description of first test case" do
+    assert_equal( Integer(@app.Unity2dPanel()['width']), 66, 
+                  'These two values are not equal' )
+
+    assert( @app.Unity2dPanel()['x_absolute'], \
+                  'This quantity is not true' )
+  end
+
+  test "Another test case description" do
+  end
+end
+
+
+Using Testability Visualizer
+----------------------------
+First off, ensure you're running the "qttasserver"
+
+Run
+$ tdriver_visualizer
+
+In the menu bar, open “Applications” and select “Start New Application” and 
+enter the absolute path to the Qt binary you want to inspect. The application 
+will appear, but also will the Visualizer, with a preview of the application in 
+the left pane. In the center is a tree of QObjects in this application, and on 
+the right you can inspect the properties, methods and signals of each QObject as
+you drill into the tree.
+
+Note you should go to “View” -> “Docks and Toolbars” -> “Code Editor” to get a 
+text editor. See that you can right-click QObjects and you get the option to 
+paste a QObject path from the root - saves time!
+
+Hit F9 to execute the test.
 
=== added directory 'tests/launcher'
=== added file 'tests/launcher/autohide_show_tests.rb'
--- tests/launcher/autohide_show_tests.rb	1970-01-01 00:00:00 +0000
+++ tests/launcher/autohide_show_tests.rb	2011-12-15 16:55:31 +0000
@@ -0,0 +1,193 @@
+#!/usr/bin/env ruby1.8
+=begin
+/*
+ * This file is part of unity-2d
+ *
+ * Copyright 2011 Canonical Ltd.
+ *
+ * Authors:
+ * - Gerry Boland <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+=end
+
+require '../run-tests.rb' unless $INIT_COMPLETED
+require 'xdo/xwindow'
+require 'xdo/keyboard'
+require 'xdo/mouse'
+require 'timeout'
+require 'tmpdir'
+
+# Helper function to open window at certain position
+def open_window_at(x,y)
+  # Open Terminal with position (x,y)
+  Dir.mktmpdir {|dir| # use this to generate unique window title to help Xdo get window ID
+    system "gnome-terminal --geometry=100x30+#{x}+#{y} --working-directory=#{dir} &"
+    Timeout.timeout(3){XDo::XWindow.wait_for_window(dir)}
+  }
+  return XDo::XWindow.from_active
+end
+
+############################# Test Suite #############################
+context "Launcher Autohide and Show Tests" do
+  WIDTH = 65 #launcher bar width
+
+  # Run once at the beginning of this test suite
+  startup do
+    system 'killall unity-2d-launcher > /dev/null 2>&1'
+    system 'killall unity-2d-launcher > /dev/null 2>&1'
+
+    # Minimize all windows
+    XDo::XWindow.toggle_minimize_all
+  end
+  
+  # Run once at the end of this test suite
+  shutdown do
+  end
+
+  # Run before each test case begins
+  setup do
+    #Ensure mouse out of the way
+    XDo::Mouse.move(200,200,10,true)    
+
+    # Execute the application 
+    @sut = TDriver.sut(:Id => "sut_qt")    
+    @app = @sut.run( :name => UNITY_2D_LAUNCHER, 
+    		         :arguments => "-testability", 
+    		         :sleeptime => 2 )
+    # Make certain application is ready for testing
+    verify(10){ @app.Unity2dPanel() }
+  end
+
+  # Run after each test case completes
+  teardown do
+    #@app.close        
+    #Need to kill Launcher as it does not shutdown when politely asked
+    system "pkill -nf unity-2d-launcher"
+  end
+
+  #####################################################################################
+  # Test cases
+
+  test "Position with Empty Desktop" do
+    # check width before proceeding
+    assert_equal( Integer(@app.Unity2dPanel()['width']), WIDTH, 
+                  "Launcher is not #{WIDTH} pixels wide on screen!" )
+
+    assert_equal( Integer(@app.Unity2dPanel()['x_absolute']), 0, \
+                  'Launcher hiding on empty desktop, should be visible' )
+  end
+
+  test "Position with Window not in the way" do
+    # Open Terminal with position 100x100
+    xid = open_window_at(100,100)
+    sleep 0.5
+    assert_equal( Integer(@app.Unity2dPanel()['x_absolute']), 0, \
+                  'Launcher hiding when window not in the way, should be visible' )
+    xid.close!
+  end
+
+  test "Position with Window in the way" do
+    # Open Terminal with position 40x100
+    xid = open_window_at(40,100)
+    sleep 0.5
+    assert_equal( Integer(@app.Unity2dPanel()['x_absolute']), -WIDTH, \
+                  'Launcher visible when window in the way, should be hidden' )
+    xid.close!
+  end
+
+  test "Move window positioning to check launcher action" do
+    # Open Terminal with position 100x100
+    xid = open_window_at(100,100)
+    sleep 0.5
+    assert_equal( Integer(@app.Unity2dPanel()['x_absolute']), 0, \
+                  'Launcher hiding when window not in the way, should be visible' )
+    xid.move(WIDTH-1,100)
+    sleep 1
+    assert_equal( Integer(@app.Unity2dPanel()['x_absolute']), -WIDTH, \
+                  'Launcher visible when window in the way, should be hidden' )
+    xid.move(WIDTH,100)
+    sleep 0.5
+    assert_equal( Integer(@app.Unity2dPanel()['x_absolute']), 0, \
+                  'Launcher hiding when window not in the way, should be visible' )
+    xid.close!
+  end
+  
+  test "Reveal hidden Launcher with mouse" do
+    xid = open_window_at(10,100)
+    sleep 0.5
+    assert_equal( Integer(@app.Unity2dPanel()['x_absolute']), -WIDTH, \
+                  'Launcher visible with window in the way, should be hidden' )
+    XDo::Mouse.move(0,200)
+    sleep 1
+    assert_equal( Integer(@app.Unity2dPanel()['x_absolute']), 0, \
+                  'Launcher hiding when mouse at left edge of screen' )
+    XDo::Mouse.move(WIDTH-1,200)
+    sleep 2
+    assert_equal( Integer(@app.Unity2dPanel()['x_absolute']), 0, \
+                  'Launcher should still be visible as mouse over it' )
+    XDo::Mouse.move(WIDTH,200)
+    sleep 2
+    assert_equal( Integer(@app.Unity2dPanel()['x_absolute']), -WIDTH, \
+                  'Launcher visible with window in the way and mouse moved out, should be hidden' )
+    xid.close!
+  end
+
+  test "Hold Super key down to reveal launcher and shortcut keys" do
+    xid = open_window_at(10,100)
+    sleep 0.5
+    assert_equal( Integer(@app.Unity2dPanel()['x_absolute']), -WIDTH, \
+                  'Launcher visible with window in the way, should be hidden' )
+    XDo::Keyboard.key_down('SUPER')
+    sleep 2
+    assert_equal( Integer(@app.Unity2dPanel()['x_absolute']), 0, \
+                  'Launcher hiding when Super Key held, should be visible' )
+
+    assert_equal( @app.LauncherList( :name => 'main' ) \
+                      .QDeclarativeItem( :name => 'Home Folder' ) \
+                      .QDeclarativeRectangle() \
+                      .QDeclarativeText()['visible'], 'true', \
+                  'Shortcut on Home Folder icon not displaying with Super key held' )
+    XDo::Keyboard.key_up('SUPER')
+    sleep 2
+    assert_equal( Integer(@app.Unity2dPanel()['x_absolute']), -WIDTH, \
+                  'Launcher visible with window in the way and mouse moved out, should be hidden' )
+    xid.close!
+  end
+
+=begin
+  # Test disabled due to bug in Xdo::Keyboard where function keys are not accepted
+  test "Press Alt+F1 to focus Launcher" do
+    xid = open_window_at(10,100)
+    sleep 0.5
+    assert_equal( Integer(@app.Unity2dPanel()['x_absolute']), -WIDTH, \
+                  'Launcher visible with window in the way, should be hidden' )
+    XDo::Keyboard.alt_f1
+    sleep 0.5
+    assert_equal( Integer(@app.Unity2dPanel()['x_absolute']), 0, \
+                  'Launcher hiding after Alt+F1 pressed, should be visible' )
+
+    assert_equal( @app.LauncherList( :name => 'main' ) \
+                      .QDeclarativeItem( :name => 'Dash home' ) \
+                      .QDeclarativeImage( :name => 'selectionOutline' )['visible'], 'true', \
+                  'Dash icon not highlighted after Alt+F1 pressed' )
+    XDo::Keyboard.esc
+    sleep 2
+    assert_equal( Integer(@app.Unity2dPanel()['x_absolute']), -WIDTH, \
+                  'Launcher visible with window in the way and mouse moved out, should be hidden' )
+    xid.close!
+  end
+=end
+
+end
 
=== added directory 'tests/launcher/verification'
=== added file 'tests/launcher/verification/dash-tile.png'
 Binary files tests/launcher/verification/dash-tile.png	1970-01-01 00:00:00 +0000 and tests/launcher/verification/dash-tile.png	2011-12-15 16:55:31 +0000 differ
=== added file 'tests/launcher/visual_verification.rb'
--- tests/launcher/visual_verification.rb	1970-01-01 00:00:00 +0000
+++ tests/launcher/visual_verification.rb	2011-12-15 16:55:31 +0000
@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby1.8
+=begin
+/*
+ * This file is part of unity-2d
+ *
+ * Copyright 2011 Canonical Ltd.
+ *
+ * Authors:
+ * - Gerry Boland <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+=end
+
+require '../run-tests.rb' unless $INIT_COMPLETED
+
+############################# Test Suite #############################
+context "Launcher Autohide and Show Tests" do
+  pwd = File.expand_path(File.dirname(__FILE__)) + '/'
+
+  # Run once at the beginning of this test suite
+  startup do
+    system 'killall unity-2d-launcher > /dev/null 2>&1'
+    system 'killall unity-2d-launcher > /dev/null 2>&1'
+  end
+  
+  # Run once at the end of this test suite
+  shutdown do
+  end
+
+  # Run before each test case begins
+  setup do
+    # Execute the application 
+    @sut = TDriver.sut(:Id => "sut_qt")    
+    @app = @sut.run( :name => UNITY_2D_LAUNCHER, 
+    		         :arguments => "-testability", 
+    		         :sleeptime => 2 )
+  end
+
+  # Run after each test case completes
+  teardown do
+    #@app.close        
+    #Need to kill Launcher as it does not shutdown when politely asked
+    system "pkill -nf unity-2d-launcher"
+  end
+
+  #####################################################################################
+  # Test cases
+
+  test "Visually compare Dash tile with reference" do
+    expected_image = pwd + 'verification/dash-tile.png'
+    
+    dash_tile = @app.Unity2dPanel() \
+        .LauncherList( :name => 'main' ) \
+        .QDeclarativeItem( :name => 'Dash home' ) \
+        .QDeclarativeItem()
+
+    #Check tile visual matches reference image, with some tolerance.
+    assert( dash_tile.find_on_screen(expected_image, 4), \
+        'Dash tile not matching reference image' )
+  end
+  
+  test "Check Dash Tile location in Launcher" do
+    expected_image = pwd + 'verification/dash-tile.png'
+    
+    tile_list = @app.Unity2dPanel().LauncherList( :name => 'main' )
+  
+    # Given the reference image, locate the matching visual in the LauncherList
+    coordinates = tile_list.find_on_screen(expected_image, 4)
+    assert( coordinates, 'Unable to find visual matching Dash tile reference image on screen' )
+    
+    # Dash tile should have these coordinates in the Launcher
+    assert_equal( coordinates, [7,7], 'Dash tile not at correct coordinates' )
+  end
+
+end
 
=== added directory 'tests/manual-tests'
=== added file 'tests/manual-tests/launcher.txt'
--- tests/manual-tests/launcher.txt	1970-01-01 00:00:00 +0000
+++ tests/manual-tests/launcher.txt	2011-12-15 16:55:31 +0000
@@ -0,0 +1,104 @@
+----
+ * Mouse over a tile in the launcher (which displays tooltip). 
+ * Press Super+S
+
+-> Tooltip disappears, spread appears (lp:881458)
+
+----
+ * Have Launcher hidden. 
+ * Bring mouse over panel
+ * Move it directly to the left, so it stays over panel
+
+-> Launcher stays hidden - it should not reveal (lp:891636)
+
+----
+ * RTL: Open Dash
+ * perform a simple search
+ * click on an application icon
+
+-> Application launches - should not crash (lp:836498)
+
+----
+ * Press Alt-F1
+
+-> Launcher revealed with Dash button focused - Pressing Alt-F1 again should toggle the focus between launcher and applications (lp:885304)
+
+----
+ * Launcher visible, scrolled down, hit Super
+
+-> Launcher reposition to beginning - and its tooltips/menus should hide. (lp:876632)
+
+----
+ * Press Alt-F1, select the trash icon using the keyboard.
+
+-> Trash icon gets highlighted - The highlight effect should not be truncated on top and bottom (lp:876589)
+
+----
+ * Launch an application. Open the context menu of the same application tile in launcher. Hit Alt-F4
+
+-> The visible context is updated - closing the application should be notified in launcher menu(lp:784541)
+
+----
+ * Right-click on a non running application tile in the launcher. Click the "Remove from Launcher" option.
+
+-> Launcher is still shown for a while - it should not close immediately  (lp:884410)
+
+----
+ * Press Right Mouse Button over an application tile in the launcher. Do not release.
+
+-> Menu is shown - it should not show on button release (lp:813036)
+
+----
+ * Press Right Mouse Button over an application tile in the launcher, do not release, move mouse up/down
+
+-> Launcher does not scroll (lp:813041)
+
+----
+ * Press Left Mouse Button over an application tile in the launcher, do not release
+ * Move mouse up/down, release Left Mouse Button
+ * while the icons are going back to their original position press Right Mouse Button and try to continue the dragging
+
+-> Launcher keeps going back to its original position - you should not be able to continue a dragging with Right Mouse Button
+
+----
+ * Have the Launcher hidden. Move the mouse over the panel. Move mouse to the left edge the panel.
+
+-> Launcher is not revealed - moving the cursor in the top left corner of the panel shouldn't reveal launcher(lp:891636)
+
+----
+ * Start the launcher with a maximized window under it. 
+ * Watch the launcher autohide. 
+ * Alt+Tab to another maximized window. 
+ * Move the mouse to the leftmost part of the screen. 
+ * Watch launcher show. 
+ * Keeping the mouse at the leftmost part of the screen move to the top panel. 
+ * Wait one second
+
+-> Launcher is hidden - The launcher should not still be visible when you have the mouse on the top panel (lp:892004)
+
+----
+ * Open an application & maximize the same
+ * Hit show-desktop shortcut [Ctrl+Alt+D?] key to see the Desktop
+
+--> Launcher is revealed - Showing the Desktop should reveal launcher (lp:898161)
+
+----
+ 
+ * Drag a file(example .txt) onto a tile(gedit) in the launcher
+
+--> The application should be launched - Launch the application, if it can handle the file(s) dragged and Open the files.  If the application can't handle the files then ignore the drag-n-drop action. (lp:676549)
+
+----
+
+ * Reveal launcher
+ * Place mouse over a tile whose application is running
+
+--> Tooltip appears - The tooltip should be displayed at the center of the tile. (lp:898349)
+
+----
+
+ * Show the desktop (Ctrl+Alt+D ?) 
+
+The panel title Ubuntu Desktop is shown - The desktop title is changed from 'Desktop to 'Ubuntu Desktop'(lp:869873)
+
+----
 
=== added file 'tests/manual-tests/panel.txt'
=== added file 'tests/manual-tests/places.txt'
--- tests/manual-tests/places.txt	1970-01-01 00:00:00 +0000
+++ tests/manual-tests/places.txt	2011-12-15 16:55:31 +0000
@@ -0,0 +1,13 @@
+----
+ * Hit super key to Open Dash.
+
+--> Dash have window buttons to maximize/unmaximize - Clicking on maximize/unmaximize 
+    button should toggle the dash mode between full-screen and netbook mode. If display is 
+    small, Dash should be locked to full-screen mode. (lp:860400)
+
+----
+ * Press Alt+F2
+
+--> Dash opens and "Run a command" is shown in the search field - (lp:883392)
+
+----
 
=== added file 'tests/manual-tests/window-manager.txt'
--- tests/manual-tests/window-manager.txt	1970-01-01 00:00:00 +0000
+++ tests/manual-tests/window-manager.txt	2011-12-15 16:55:31 +0000
@@ -0,0 +1,9 @@
+----
+ * Hit Super+S key. Spread is launched.
+
+-> 1) Mouse hovering and 2) Arrow, Enter and Esc keys - are enabled - Hitting arrow 
+   keys or mouse hovering should switch the highlighted workspaces. The Enter key should 
+   zoom the highlighted workspace while Esc key should simply exit from spread with no 
+   changes.(lp:744978)
+
+----
 
=== added directory 'tests/misc'
=== added file 'tests/misc/binary_dir.txt.in'
--- tests/misc/binary_dir.txt.in	1970-01-01 00:00:00 +0000
+++ tests/misc/binary_dir.txt.in	2011-12-15 16:55:31 +0000
@@ -0,0 +1,1 @@
+@CMAKE_CURRENT_BINARY_DIR@
 
=== added directory 'tests/misc/lib'
=== added file 'tests/misc/lib/testhelper.rb'
--- tests/misc/lib/testhelper.rb	1970-01-01 00:00:00 +0000
+++ tests/misc/lib/testhelper.rb	2011-12-15 16:55:31 +0000
@@ -0,0 +1,162 @@
+require 'test/unit'
+
+dir = File.dirname(File.expand_path(__FILE__))
+$LOAD_PATH.unshift dir + '/../lib'
+$TEST_DIR = File.dirname(File.expand_path(__FILE__))
+
+# Enable a startup and shutdwn method for each test case 
+# From https://github.com/freerange/test_startup
+module TestStartupAndShutdown
+  def startup(&block)
+    install_global_startup
+    @__startup_blocks ||= []
+    @__startup_blocks << block if block_given?
+    @__startup_blocks
+  end
+  
+  def shutdown(&block)
+    install_global_startup
+    @__shutdown_blocks ||= []
+    @__shutdown_blocks << block if block_given?
+    @__shutdown_blocks
+  end
+  
+  attr_reader :__startup_blocks, :__shutdown_blocks
+  
+  def install_global_startup
+    extend(TestSuiteWithGlobalStartup)
+  end
+  
+  module TestSuiteWithGlobalStartup
+    def suite(*args)
+      mysuite = super
+      these_startup_blocks = __startup_blocks
+      these_shutdown_blocks = __shutdown_blocks
+      mysuite.instance_eval { @__startup_blocks = these_startup_blocks }
+      mysuite.instance_eval { @__shutdown_blocks = these_shutdown_blocks }
+      def mysuite.run(*args)
+        (@__startup_blocks || []).each { |block| block.call }
+        super
+        (@__shutdown_blocks || []).each { |block| block.call }
+      end
+      mysuite
+    end
+  end
+end
+
+Test::Unit::TestCase.extend(TestStartupAndShutdown)
+
+##
+# Test::Unit runs test in alphabetical order. This class instead runs them
+# sequentially. Can specify ordering with the line
+# execute :sequentially:
+# Taken from http://wiki.openqa.org/download/attachments/804/testcase.rb
+# Copyright: Bret Pettichord
+
+class TestCase < Test::Unit::TestCase
+  @@order = :sequentially
+  def initialize name
+    throw :invalid_test if name == :default_test && self.class == TestCase
+    super
+  end        
+  class << self
+    attr_accessor :test_methods, :order
+    def test_methods
+      @test_methods ||= []
+    end
+    def order
+      @order || @@order
+    end
+    def default_order= order
+      @@order = order
+    end
+    def sorted_test_methods
+      case order
+      when :alphabetically:          test_methods.sort
+      when :sequentially:            test_methods
+      when :reversed_sequentially:   test_methods.reverse
+      when :reversed_alphabetically: test_methods.sort.reverse
+      else raise ArgumentError, "Execute option not supported: #{@order}"
+      end
+    end
+    def suite
+      suite = Test::Unit::TestSuite.new(name)
+      sorted_test_methods.each do |test|
+        catch :invalid_test do
+          suite << new(test)
+        end
+      end
+      if (suite.empty?)
+        catch :invalid_test do
+          suite << new(:default_test)
+        end
+      end
+      return suite
+    end
+    def method_added id
+      name = id.id2name
+      test_methods << name if name =~ /^test./
+    end
+    def execute order
+      @order = order
+    end
+  end
+end
+
+
+##
+# Snippit from test/spec/mini 5
+# Allows syntatic sugar for tests in the following form:
+#
+#context "It's test/spec/mini!" do
+#  setup do
+#    @name = "Chris"
+#  end
+#
+#  teardown do
+#    @name = nil
+#  end
+#
+#  test "with Test::Unit" do
+#    assert (self.class < Test::Unit::TestCase)
+#  end
+#
+#  test "body-less test cases"
+#
+#  test :symbol_test_names do
+#    assert true
+#  end
+#
+#  xtest "disabled tests" do
+#    assert disabled!
+#  end
+#
+#  context "and of course" do
+#    test "nested contexts!" do
+#      assert_equal "Chris", @name
+#    end
+#  end
+#end
+#
+# http://gist.github.com/307649 ([e-mail])
+#
+
+def context(*args, &block)
+  return super unless (name = args.first) && block
+
+  klass = Class.new(TestCase) do
+    def self.test(name, &block)
+      define_method("test_#{name.to_s.gsub(/\W/,'_')}", &block) if block
+    end
+    def self.xtest(*args) end
+    def self.context(*args, &block) instance_eval(&block) end
+    def self.setup(&block)
+      define_method(:setup) { self.class.setups.each { |s| instance_eval(&s) } }
+      setups << block
+    end
+    def self.setups; @setups ||= [] end
+    def self.teardown(&block) define_method(:teardown, &block) end
+  end
+  (class << klass; self end).send(:define_method, :name) { name.gsub(/\W/,'_') }
+  klass.class_eval &block
+end
 
=== added directory 'tests/misc/lib/xdo'
=== added file 'tests/misc/lib/xdo/README.xdo.rdoc'
--- tests/misc/lib/xdo/README.xdo.rdoc	1970-01-01 00:00:00 +0000
+++ tests/misc/lib/xdo/README.xdo.rdoc	2011-12-15 16:55:31 +0000
@@ -0,0 +1,52 @@
+--
+This file is part of Xdo. 
+Copyright © 2009, 2010 Marvin Gülker
+  Initia in potestate nostra sunt, de eventu fortuna iudicat. 
+++
+=XDo
+XDo is a library to simulate keyboard and mouse input and manipulating windows on the X server. 
+It's wrapped around the command-line tools xdotool[http://www.semicomplete.com/projects/xdotool/], 
+xsel[http://linux.die.net/man/1/xsel], xwininfo[http://linux.die.net/man/1/xwininfo], eject[http://linux.die.net/man/1/eject] and xkill[http://linux.die.net/man/1/xkill], 
+so you will need to have them installed if you want to use Xdo (even if xwininfo, eject and xkill are usually already installed). 
+If not, try to install them via your favourite packaging manager. 
+After they're installed, install XDo via RubyGems: 
+  sudo gem install xdo
+==Usage
+  #Require some of XDo's files
+  require "xdo/keyboard"
+  require "xdo/mouse"
+  require "xdo/xwindow"
+  #Move the cursor
+  XDo::Mouse.move(100, 100)
+  #Simulate text (with special escape sequences!)
+  XDo::Keyboard.simulate("This is{TAB}text.")
+  #Some sequences can be shortened: 
+  XDo::Keyboard.simulate("This ist\ttext.")
+  #And this will move a window containing the string "gedit", 
+  #unless it's maximized. 
+  win = XDo::XWindow.from_title(/gedit/)
+  win.move(200, 200)
+==Files
+You can require the following files in your projects: 
+* xdo/clipboard: Clipboard access
+* xdo/keyboard: Pretty self-explaining
+* xdo/mouse: Automate the mouse
+* xdo/xwindow: Manipulate windows in various ways
+As an helpful extra, I created an executable ruby file "xinfo.rb". Thanks to RubyGems, 
+you can start this GUI tool right from the command line by typing: 
+  xinfo.rb
+It's by far not perfect, maybe not even good, but I think it can be useful sometimes 
+(you will need to have wxRuby installed, try <tt>sudo gem install wxruby-ruby19</tt>). 
+If you're looking for a more professional program, try the "X window information" tool. 
+==Notes
+* If your +xdotool+ seems to reject the --window option, you are not using the current version. Try building the newest one from the source. 
+* I recommand the "X window information" tool to get infos about your windows if you aren't satisfied by the xinfo.rb shipped with this package. 
+==Fairly incomplete
+* I'm sure there are several things I didn't notice that can be automated somehow. If you know about, email me! Please add a description of the possibilities and a sample script. 
+* Another interesting thing are the samples. There are many Linux distrubitions out there, and even many of them rely on X. I cannot test with another than a recent Ubuntu machine, but if you want to contribute and send samples for another OS, I want to encourage you to - I surely won't reject your work. :-)
+==License/Copyright
+  Copyright © 2009, 2010 Marvin Gülker
+  This library is free software; you may redistribute it and/or modify it 
+  under the terms of Ruby's license (see http://www.ruby-lang.org/en/LICENSE.txt). 
+  You can contact me at sutniuq ät gmx Dot net. 
+  Initia in potestate nostra sunt, de eventu fortuna iudicat. 
 
=== added file 'tests/misc/lib/xdo/_xdo.rb'
--- tests/misc/lib/xdo/_xdo.rb	1970-01-01 00:00:00 +0000
+++ tests/misc/lib/xdo/_xdo.rb	2011-12-15 16:55:31 +0000
@@ -0,0 +1,35 @@
+#Encoding: UTF-8
+#This file is part of Xdo. 
+#Copyright © 2009 Marvin Gülker
+#  Initia in potestate nostra sunt, de eventu fortuna iudicat. 
+#
+# This file contains shared definitions for all the xdo scripts
+#
+# Modified by Gerry Boland <gerry dot boland at canonical dot com>
+
+require "open3"
+require "strscan"
+
+#The namespace of this library. 
+module XDo
+  
+  #The command to start xdotool. 
+  XDOTOOL = "xdotool"
+  
+  #The command to start xsel. 
+  XSEL = "xsel"
+  
+  #The command to start xwininfo. 
+  XWININFO = "xwininfo"
+  
+  #The command to start xkill. 
+  XKILL = "xkill"
+  
+  #Class for errors in this library. 
+  class XError < StandardError
+  end
+  
+  class ParseError < StandardError
+  end
+  
+end #module XDo
 
=== added file 'tests/misc/lib/xdo/clipboard.rb'
--- tests/misc/lib/xdo/clipboard.rb	1970-01-01 00:00:00 +0000
+++ tests/misc/lib/xdo/clipboard.rb	2011-12-15 16:55:31 +0000
@@ -0,0 +1,209 @@
+#Encoding: UTF-8
+#This file is part of Xdo. 
+#Copyright © 2009, 2010 Marvin Gülker
+#  Initia in potestate nostra sunt, de eventu fortuna iudicat. 
+#
+# Modified by Gerry Boland <gerry dot boland at canonical dot com> 
+require File.join(File.dirname(__FILE__), '_xdo')
+
+module XDo
+  
+  #A module for interaction with the X clipboard. Please note, that the X clipboard 
+  #consists of three parts: The PRIMARY clipboard, the CLIPBOARD clipboard, and 
+  #the SECONDARY clipboard. The clipboard you access normally via [CTRL]+[C] 
+  #or by right-clicking and selecting "copy", is usually the CLIPBOARD clipboard (but that 
+  #depends on the application you use). The three main methods of this module (#read, #write 
+  #and #clear) take a list symbols of the clipboards to interact with. If you don't want to 
+  #pass in the symbols, use the predefined read_xy, write_xy and clear_xy methods. They cannot 
+  #access more than one clipboard at a time. 
+  #The symbols for the clipboards are: 
+  #[PRIMARY] :primary
+  #[SECONDARY] :secondary
+  #[CLIPBOARD] :clipboard
+  #You cannot store complex objects like images via this interface, only strings. However, 
+  #you could translate an image into a string (packed pixels maybe?) and put that on the 
+  #clipboard -- for your own application this may be fine, but it won't magically allow 
+  #a user to paste that image into a graphics program. 
+  #
+  #The +xsel+ program used by this module is quite outdated. As far as I can see, it's 
+  #last update happened in 2002 and since I do not believe that software exists that 
+  #won't break over a period of 8 years without a single modification while updating systems I'm about to 
+  #switch to a newer one. +xclip+ is likely, but that one got it's last update in early 
+  #2009... 
+  module Clipboard
+    
+    class << self
+      
+      ##
+      # :singleton-method: read_primary
+      #Returns the contents of the PRIMARY clipboard. 
+      #See #read for an explanation. 
+      
+      ##
+      # :singleton-method: read_clipboard
+      #Returns the contents of the CLIPBOARD clipboard. 
+      #See #read for an explanation. 
+      
+      ##
+      # :singleton-method: read_secondary
+      #Returns the contents of the SECONDARY clipboard. 
+      #See #read for an explanation. 
+      
+      ##
+      # :singleton-method: write_primary
+      #Writes to the PRIMARY clipboard. 
+      #See #write for an explanation. 
+      
+      ##
+      # :singleton-method: write_clipboard
+      #Writes to the CLIPBOARD clipboard. 
+      #See #write for an explanation. 
+      
+      ##
+      # :singleton-method: write_secondary
+      #Writes to the SECONDARY clipboard. 
+      #See #write for an explanation. 
+      
+      ##
+      # :singleton-method: clear_primary
+      #Clears the PRIMARY clipboard. 
+      #See #clear for an explanation. 
+      
+      ##
+      # :singleton-method: clear_clipboard
+      #Clears the CLIPBOARD clipboard. 
+      #See #clear for an explanation. 
+      
+      ##
+      # :singleton-method: clear_secondary     
+      #Clears the SECONDARY clipboard. 
+      #See #clear for an explanation. 
+      
+      #Reads text from a X clipboard. 
+      #===Parameters
+      #[<tt>*from</tt>] (<tt>:clipboard</tt>, <tt>:primary</tt>, <tt>:secondary</tt>) Specifies from which clipboards you want to read (in 70% of all cases you want to read from <tt>:clipboard</tt>). 
+      #===Return value
+      #A hash of form
+      #  {:clip_sym => "clipboard_content"}
+      #If you didn't pass any arguments to #read, the hash will contain keys for 
+      #all clipboard, i.e. for <tt>:clipboard</tt>, <tt>:primary</tt> and <tt>:secondary</tt>. 
+      #If you did, only those symbols will be included you passed. See 
+      #the _Example_ section for an example of this. 
+      #===Example
+      #  XDo::Clipboard.read #| {:clipboard => "...", :primary => "...", :secondary => "..."}
+      #  XDo::Clipboard.read(:primary) #| {:primary => "..."}
+      #  XDo::Clipboard.read(:clipboard, :secondary) #| {clipboard => "...", :secondary => "..."}
+      #===Remarks
+      #You could also use one of the read_* methods for convenience.       
+      def read(*from)
+        if from.first.kind_of? Hash
+          warn("#{caller.first}: Deprecation warning: Use symbols as a rest argument now!")
+          from = from.first.keys
+        end
+        from.concat([:clipboard, :primary, :secondary]) if from.empty?
+        
+        hsh = {}
+        hsh[:primary] = `#{XSEL}` if from.include? :primary
+        hsh[:clipboard] = `#{XSEL} -b` if from.include? :clipboard
+        hsh[:secondary] = `#{XSEL} -s` if from.include? :secondary
+        hsh
+      end
+        
+      
+      #Writes text to a X clipboard. 
+      #===Parameters
+      #[<tt>*to</tt>] (<tt>:clipboard</tt>) Specifies to what clipboards you want to wrote to. 
+      #===Return value
+      #The text written. 
+      #===Example
+      #  XDo::Clipboard.write("I love Ruby") #You can now paste this via [CTRL] + [V]
+      #  XDo::Clipboard.write("I love Ruby", :primary) #You can now paste this via a middle-mouse-button click
+      #  XDo::Clipboard.write("I love Ruby", :clipboard, :primary) #Both of the above
+      #===Remarks
+      #You could also use one of the write_* methods for convenience. 
+      def write(text, *to)
+        if to.first.kind_of? Hash
+          warn("#{caller.first}: Deprecation warning: Use symbols as a rest argument now!")
+          to = to.first.keys
+        end
+        to << :clipboard if to.empty?
+        
+        IO.popen("xsel -i", "w"){|io| io.write(text)} if to.include? :primary
+        IO.popen("xsel -b -i", "w"){|io| io.write(text)} if to.include? :clipboard
+        IO.popen("xsel -s -i", "w"){|io| io.write(text)} if to.include? :secondary
+        text
+      end
+      
+      #Appends text to a X clipboard. 
+      #===Parameters
+      #[+text+] The text to append. 
+      #[<tt>*to</tt>] (<tt>:clipboard</tt>) The clipboards to which you want to append. 
+      #===Return value
+      #Undefined. 
+      #===Example
+      #  XDo::Clipboard.write("I love ")
+      #  XDo::Clipboard.append("Ruby")
+      #  puts XDo::Clipboard.read(:clipboard)[:clipboard] #=> I love Ruby
+      #  
+      #  XDo::Clipboard.write("I love", :primary)
+      #  XDo::Clipboard.append("Ruby", :primary, :clipboard)
+      #  #If you now paste via [CTRL] + [V], you'll get 'Ruby'. If you 
+      #  #paste via the middle mouse button, you'll get 'I love Ruby' 
+      #  #(Assuming you didn't execute the first block of code, of course). 
+      def append(text, *to)
+        if to.first.kind_of? Hash
+          warn("#{caller.first}: Deprecation warning: Use symbols as a rest argument now!")
+          to = to.first.keys
+        end
+        to << :clipboard if to.empty?
+        
+        IO.popen("xsel -a -i", "w"){|io| io.write(text)} if to.include? :primary
+        IO.popen("xsel -b -a -i", "w"){|io| io.write(text)} if to.include? :clipboard
+        IO.popen("xsel -s -a -i", "w"){|io| io.write(text)} if to.include? :secondary
+      end
+      
+      #Clears the specified clipboards. 
+      #===Parameters
+      #[<tt>*clips</tt>] (<tt>:primary</tt>, <tt>:clipboard</tt>, <tt>:secondary</tt>) The clipboards you want to clear. 
+      #===Return value
+      #nil. 
+      #===Example
+      #  XDo::Clipboard.write("I love Ruby")
+      #  XDo::Clipboard.clear
+      #  #Nothing can be pasted anymore
+      #  
+      #  XDo::Clipboard.write("I love Ruby", :clipboard, :primary)
+      #  XDo::Clipboard.clear(:primary)
+      #  #You can still paste via [CTRL] + [V], but not with the middle mouse button
+      def clear(*clips)
+        if clips.first.kind_of? Hash
+          warn("#{caller.first}: Deprecation warning: Use symbols as a rest argument now!")
+          clips = clips.first.keys
+        end
+        clips.concat([:primary, :clipboard, :secondary]) if clips.empty?
+        
+        `#{XSEL} -c` if clips.include? :primary
+        `#{XSEL} -b -c` if clips.include? :clipboard
+        `#{XSEL} -s -c` if clips.include? :secondary
+        nil
+      end
+      
+      [:primary, :clipboard, :secondary].each do |sym|
+        
+        define_method(:"read_#{sym}") do
+          read(sym)[sym]
+        end
+        
+        define_method(:"write_#{sym}") do |text|
+          write(text, sym)
+        end
+        
+        define_method(:"clear_#{sym}") do
+          clear(sym)
+        end
+        
+      end
+      
+    end
+  end
+end
 
=== added file 'tests/misc/lib/xdo/keyboard.rb'
--- tests/misc/lib/xdo/keyboard.rb	1970-01-01 00:00:00 +0000
+++ tests/misc/lib/xdo/keyboard.rb	2011-12-15 16:55:31 +0000
@@ -0,0 +1,387 @@
+#Encoding: UTF-8
+#This file is part of Xdo. 
+#Copyright © 2009, 2010 Marvin Gülker
+#  Initia in potestate nostra sunt, de eventu fortuna iudicat.
+#
+# Modified by Gerry Boland <gerry dot boland at canonical dot com> 
+require File.join(File.dirname(__FILE__), '_xdo')
+
+module XDo
+  
+  #A namespace encabsulating methods to simulate keyboard input. You can 
+  #send input to special windows, just pass in the window's ID or a XWindow 
+  #object via the +w_id+ parameter. 
+  module Keyboard
+    
+    #Aliases for key names in escape sequences. 
+    ALIASES = {
+      "BS" => "BackSpace", 
+      "BACKSPACE" => "BackSpace", 
+      "DEL" => "Delete", 
+      "ESC" => "Escape", 
+      "INS" => "Insert", 
+      "PGUP" => "Prior", 
+      "PGDN" => "Next", 
+      "NUM1" => "KP_End", 
+      "NUM2" => "KP_Down", 
+      "NUM3" => "KP_Next", 
+      "NUM4" => "KP_Left", 
+      "NUM5" => "KP_Begin", 
+      "NUM6" => "KP_Right", 
+      "NUM7" => "KP_Home", 
+      "NUM8" => "KP_Up", 
+      "NUM9" => "KP_Prior", 
+      "NUM_DIV" => "KP_Divide", 
+      "NUM_MUL" => "KP_Multiply", 
+      "NUM_SUB" => "KP_Subtract", 
+      "NUM_ADD" => "KP_Add", 
+      "NUM_ENTER" => "KP_Enter", 
+      "NUM_DEL" => "KP_Delete", 
+      "NUM_COMMA" => "KP_Separator", 
+      "NUM_INS" => "KP_Insert", 
+      "NUM0" => "KP_0", 
+      "CTRL" => "Control_L", 
+      "ALT" => "Alt_L", 
+      "ALT_GR" => "ISO_Level3_Shift", 
+      "WIN" => "Super_L", 
+      "SUPER" => "Super_L"
+    }.freeze
+    
+    #The names of some keyboard symbols. The latest release of 
+    #xdotool is capable of sending keysymbols directly, i.e. 
+    #  xdotool key Adiaeresis
+    #results in Ä being sent. 
+    #This hash defines how those special characters can be 
+    #sent. Feel free to add characters that are missing! You 
+    #can use the +xev+ program to obtain their keycodes. 
+    SPECIAL_CHARS = {
+      "ä" => "adiaeresis", 
+      "Ä" => "Adiaeresis", 
+      "ö" => "odiaeresis", 
+      "Ö" => "Odiaeresis", 
+      "ü" => "udiaeresis", 
+      "Ü" => "Udiaeresis", 
+      "ë" => "ediaeresis", 
+      "Ë" => "Ediaeresis", #Does not work with xdotool
+      "ï" => "idiaeresis", 
+      "Ï" => "Idiaeresis", #Does not work with xdotool
+      "ß" => "ssharp", 
+      "\n" => "Return", 
+      "\t" => "Tab", 
+      "\b" => "BackSpace", 
+      "§" => "section", 
+      "[" => "bracketleft", 
+      "]" => "bracketright", 
+      "{" => "braceright", 
+      "}" => "braceleft", 
+      "@" => "at", 
+      "€" => "EuroSign", 
+      "|" => "bar", 
+      "?" => "question"
+    }
+    
+    class << self
+      
+      #Types a character sequence, but without any special chars. 
+      #===Parameters
+      #[+str+] The string to type. 
+      #[+w_id+] (0) The ID of the window you want the input send to (or an XWindow object). 0 means the active window. 
+      #===Return value
+      #nil. 
+      #===Example
+      #  XDo::Keyboard.type("test")
+      #  XDo::Keyboard.type("täst") #=> I don't what key produces '�', skipping. 
+      #===Remarks
+      #This function is a bit faster then #simulate. 
+      def type(str, w_id = 0)
+        out = Open3.popen3("#{XDOTOOL} type #{w_id.nonzero? ? "--window #{w_id.to_i} " : ""}'#{str}'") do |stdin, stdout, stderr|
+          stdin.close_write
+          str = stderr.read
+          warn(str) unless str.empty?
+        end
+        nil
+      end
+      
+      #Types a character sequence. You can use the escape sequence {...} to send special 
+      #keystrokes. 
+      #===Parameters
+      #[+str+] The string to simulate. 
+      #[+raw+] (false) If true, escape sequences via {...} are disabled. See _Remarks_. 
+      #[+w_id+] (0) The ID of the window you want the input send to (or an XWindow object). 0 means the active window. 
+      #===Return value
+      #The string that was simulated. 
+      #===Raises
+      #[ParseError] Your string was invalid. 
+      #===Example
+      #  XDo::Keyboard.simulate("test")
+      #  XDo::Keyboard.simulate("täst")
+      #  XDo::Keyboard.simulate("tex{BS}st")
+      #===Remarks
+      #This method recognizes many special chars like ? and ä, even if you disable 
+      #the escape syntax {..} via setting the +raw+ parameter to true (that's the only way to send the { and } chars). 
+      #
+      #+str+ may contain escape sequences in braces { and }. The letters between those two indicate 
+      #what special character to send - this way you can simulate non-letter keypresses like [ESC]!
+      #You may use the following escape sequences: 
+      #  Escape seq. | Keystroke         | Comment
+      #  ============+===================+=================
+      #  ALT         | [Alt_L]           |
+      #  ------------+-------------------------------------
+      #  ALT_GR      | [ISO_Level3_Shift]| Not on USA 
+      #              |                   | keyboard
+      #  ------------+-------------------------------------
+      #  BS          | [BackSpace]       |
+      #  ------------+-------------------------------------
+      #  BACKSPACE   | [BackSpace]       |
+      #  ------------+-------------------------------------
+      #  CTRL        | [Control_L]       |
+      #  ------------+-------------------------------------
+      #  DEL         | [Delete]          |
+      #  ------------+-------------------------------------
+      #  END         | [End]             |
+      #  ------------+-------------------------------------
+      #  ESC         | [Escape]          |
+      #  ------------+-------------------------------------
+      #  INS         | [Insert]          |
+      #  ------------+-------------------------------------
+      #  HOME        | [Home]            |
+      #  ------------+-------------------------------------
+      #  MENU        | [Menu]            | Usually right-
+      #              |                   | click menu
+      #  ------------+-------------------------------------
+      #  NUM0..NUM9  | [KP_0]..[KP_9]    | Numpad keys
+      #  ------------+-------------------------------------
+      #  NUM_DIV     | [KP_Divide]       | Numpad key
+      #  ------------+-------------------------------------
+      #  NUM_MUL     | [KP_Multiply]     | Numpad key
+      #  ------------+-------------------------------------
+      #  NUM_SUB     | [KP_Subtract]     | Numpad key
+      #  ------------+-------------------------------------
+      #  NUM_ADD     | [KP_Add]          | Numpad key
+      #  ------------+-------------------------------------
+      #  NUM_ENTER   | [KP_Enter]        | Numpad key
+      #  ------------+-------------------------------------
+      #  NUM_DEL     | [KP_Delete]       | Numpad key
+      #  ------------+-------------------------------------
+      #  NUM_COMMA   | [KP_Separator]    | Numpad key
+      #  ------------+-------------------------------------
+      #  NUM_INS     | [KP_Insert]       | Numpad key
+      #  ------------+-------------------------------------
+      #  PAUSE       | [Pause]           |
+      #  ------------+-------------------------------------
+      #  PGUP        | [Prior]           | Page up
+      #  ------------+-------------------------------------
+      #  PGDN        | [Next]            | Page down
+      #  ------------+-------------------------------------
+      #  PRINT       | [Print]           |
+      #  ------------+-------------------------------------
+      #  SUPER       | [Super_L]         | Windows key
+      #  ------------+-------------------------------------
+      #  TAB         | [Tab]             |
+      #  ------------+-------------------------------------
+      #  WIN         | [Super_L]         | Windows key
+      def simulate(str, raw = false, w_id = 0)
+        raise(XDo::XError, "Invalid number of open and close braces!") unless str.scan(/\{/).size == str.scan(/\}/).size
+        
+        tokens = tokenize(str)
+        
+        tokens.each do |sym, s|
+          case sym
+            when :plain then type(s, w_id.to_i)
+            when :esc then 
+              if raw
+                type("{#{s}}", w_id.to_i) #The braces should be preserved when using +raw+. 
+              else
+                if ALIASES.has_key?(s)
+                  key(ALIASES[s]) 
+                else
+                  char(s.split("_").map(&:capitalize).join("_"), w_id.to_i)
+                end
+              end
+            when :special then
+              if SPECIAL_CHARS.has_key?(s)
+                char(SPECIAL_CHARS[s], w_id.to_i)
+              else
+                raise(XDo::ParseError, "No key symbol known for '#{s}'!")
+              end
+          else #Write a bug report if you get here. That really shouldn't happen. 
+            raise(XDo::ParseError, "Invalid token named #{sym.inspect}! This is an internal error - please write a bug report at http://github.com/Quintus/Automations/issues or email me at sutniuq@@gmx@net.")
+          end
+        end
+        str
+      end
+      
+      #Simulate a single char directly via the +key+ command of +xdotool+. 
+      #===Parameters
+      #[+c+] A single char like "a" or a combination like "shift+a". 
+      #[+w_id+] (0) The ID of the window you want the input send to (or an XWindow object). 0 means the active window. 
+      #===Return value
+      #The +c+ you passed in. 
+      #===Raises
+      #[XError] Invalid keyname. 
+      #===Example
+      #  XDo::Keyboard.char("a") #=> a
+      #  XDo::Keyboard.char("A") #=> A
+      #  XDo::Keyboard.char("ctrl+c")
+      def char(c, w_id = 0)
+        Open3.popen3("#{XDOTOOL} key #{w_id.nonzero? ? "--window #{w_id.to_i} " : ""}#{c}") do |stdin, stdout, stderr|
+          stdin.close_write
+          raise(XDo::XError, "Invalid character '#{c}'!") if stderr.read =~ /No such key name/
+        end
+        c
+      end
+      alias key char
+      
+      #Holds a key down. 
+      #===Parameters
+      #[+key+] The key to hold down. 
+      #[+w_id+] (0) The ID of the window you want the input send to (or an XWindow object). 0 means the active window. 
+      #===Return value
+      #+key+. 
+      #===Raises
+      #[XError] Invalid keyname. 
+      #===Example
+      #  XDo::Keyboard.key_down("a")
+      #  sleep 2
+      #  XDo::Keyboard.key_up("a")
+      #===Remarks
+      #You should release the key sometime via Keyboard.key_up. 
+      def key_down(key, w_id = 0)
+        Open3.popen3("#{XDOTOOL} keydown #{w_id.nonzero? ? "--window #{w_id.to_i} " : "" }#{check_for_special_key(key)}") do |stdin, stdout, stderr|
+          stdin.close_write
+          raise(XDo::XError, "Invalid character '#{key}'!") if stderr.read =~ /No such key name/
+        end
+        key
+      end
+      
+      #Releases a key hold down by #key_down. 
+      #===Parameters
+      #[+key+] The key to release. 
+      #[+w_id+] (0) The ID of the window you want the input send to (or an XWindow object). 0 means the active window. 
+      #===Return value
+      #+key+. 
+      #===Raises
+      #[XError] Invalid keyname. 
+      #===Example
+      #  XDo::Keyboard.key_down("a")
+      #  sleep 2
+      #  XDo::Keyboard.key_up("a")
+      #===Remarks
+      #This has no effect on already released keys. 
+      def key_up(key, w_id = 0)
+        Open3.popen3("#{XDOTOOL} keyup #{w_id.nonzero? ? "--window #{w_id.to_i} " : "" }#{check_for_special_key(key)}") do |stdin, stdout, stderr|
+          stdin.close_write
+          raise(XDo::XError, "Invalid character '#{key}'!") if stderr.read =~ /No such key name/
+        end
+        key
+      end
+      
+      #Deletes a char. 
+      #===Parameters
+      #[right] (false) If this is true, +del_char+ uses the DEL key for deletion, otherwise the BackSpace key. 
+      #===Return value
+      #nil. 
+      #===Example
+      #  XDo::Keyboard.delete
+      #  XDo::Keyboard.delete(true)
+      def delete(right = false)
+        Keyboard.simulate(right ? "\b" : "{DEL}")
+        nil
+      end
+      
+      #Allows you to things like this: 
+      #  XDo::Keyboard.ctrl_c
+      #The string will be capitalized and every _ will be replaced by a + and then passed into #char. 
+      #You can't use this way to send whitespace or _ characters. 
+      def method_missing(sym, *args, &block)
+        super if args.size > 1 or block
+        char(sym.to_s.capitalize.gsub("_", "+"), args[0].nil? ? 0 : args[0])
+      end
+      
+      private
+      
+      #Tokenizes a string into an array of form
+      #  [[:plain, "nonspecial"], [:special, "a"], [:esc, "INS"], ...]
+      def tokenize(str)
+        tokens = []
+        #We need a binary version of our string as StringScanner isn't able to work 
+        #with encodings. 
+        ss = StringScanner.new(RUBY_VERSION >= '1.9' ? str.dup.force_encoding("BINARY") : str.dup) #String#force_encoding always returns self
+        until ss.eos?
+          pos = ss.pos
+          if ss.scan_until(/\{/)
+            #Get the string between the last and the recent match. We have to subtract 2 here, 
+            #since a StringScanner position is always ahead of the string character by 1 (since 0 in 
+            #a SmallScanner means "before the first character") and the matched brace shouldn't be 
+            #included. 
+            tokens << [:plain, ss.string[Range.new(pos, ss.pos - 2)]] unless ss.pos == 1 #This means, the escape sequence is at the beginning of the string - no :plain text before. 
+            pos = ss.pos
+            ss.scan_until(/\}/)
+            tokens << [:esc, ss.string[Range.new(pos, ss.pos - 2)]] #See above for comment on -2
+          else #We're behind the last escape sequence now - there must be some characters left, otherwise this wouldn't be triggered. 
+            tokens << [:plain, ss.rest]
+            ss.terminate
+          end
+        end
+        #Now hunt for special character like ä which can't be send using xdotool's type command. 
+        regexp = Regexp.union(*SPECIAL_CHARS.keys.map{|st| st}) #Regexp.union escapes automatically, no need for Regexp.escape
+        tokens.map! do |ary|
+          #But first, we have to remedy from that insane forced encoding for StringScanner. 
+          #Force every string's encoding back to the original encoding. 
+          ary[1].force_encoding(str.encoding) if RUBY_VERSION >= '1.9'
+          next([ary]) unless ary[0] == :plain #Extra array since we flatten(1) it afterwards
+          tokens2 = []
+          ss = StringScanner.new(ary[1])
+          until ss.eos?
+            pos = ss.pos
+            if ss.scan_until(regexp)
+              #Same as for the first StringScanner encoding problem goes here, but since I now have to use a UTF-8 regexp 
+              #I have to put the string into the StringScanner as UTF-8, but because the StringScanner returns positions for 
+              #a BINARY-encoded string I have to get the string, grep the position from the BINARY version and then reforce 
+              #it to the correct encoding. 
+              if RUBY_VERSION >= '1.9'
+                tokens2 << [:plain, ss.string.dup.force_encoding("BINARY")[Range.new(pos, ss.pos - 2)].force_encoding(str.encoding)] unless ss.pos == 1
+              else
+                tokens2 << [:plain, ss.string.dup[Range.new(pos, ss.pos - 2)]] unless ss.pos == 1
+              end
+              tokens2 << [:special, ss.matched]
+              pos = ss.pos
+            else
+              tokens2 << [:plain, ss.rest]
+              ss.terminate
+            end
+          end
+          tokens2
+        end
+        #Make the token sequence 1-dimensional
+        tokens.flatten!(1)
+        #Now delete empty :plain tokens, they don't have to be handled. 
+        #They are created by strings like "abc{ESC}{ESC}", where they are 
+        #recognized between the two escapes. 
+        #Empty escape sequences are an error in any case. 
+        tokens.delete_if do |sym, st|
+          if st.empty?
+            if sym == :esc
+              raise(XDo::ParseError, "Empty escape sequence found!")
+            else
+              true
+            end
+          end
+        end
+        
+        #Return the tokens array. 
+        tokens
+      end
+      
+      #Checks wheather +key+ is a special character (i.e. contained 
+      #in the SPECIAL_CHARS hash) and returns the key symbol for it if so, 
+      #otherwise returns +key+. 
+      def check_for_special_key(key)
+        SPECIAL_CHARS.has_key?(key) ? SPECIAL_CHARS[key] : key
+      end
+      
+    end
+    
+  end
+  
+end
 
=== added file 'tests/misc/lib/xdo/mouse.rb'
--- tests/misc/lib/xdo/mouse.rb	1970-01-01 00:00:00 +0000
+++ tests/misc/lib/xdo/mouse.rb	2011-12-15 16:55:31 +0000
@@ -0,0 +1,254 @@
+#Encoding: UTF-8
+#This file is part of Xdo. 
+#Copyright © 2009 Marvin Gülker
+#  Initia in potestate nostra sunt, de eventu fortuna iudicat. 
+#
+# Modified by Gerry Boland <gerry dot boland at canonical dot com> 
+require File.join(File.dirname(__FILE__), '_xdo')
+
+module XDo
+  
+  #Automate your mouse! You can simulate every click you can do with 
+  #your fingers - it's kind of funny, but don't forget to create USEFUL 
+  #applications, not ones annoying your users (e. g. you could make 
+  #his/her mouse unusable). 
+  module Mouse
+    
+    #Left mouse button. 
+    LEFT = 1
+    #Middle mouse button (as if you click your mouse wheel). 
+    MIDDLE = 2
+    #Right mouse button. 
+    RIGHT = 3
+    #Mouse wheel up. 
+    UP = 4
+    #Mouse wheel down. 
+    DOWN = 5
+    
+    #Maps the button's symbols to the numbers xdotool uses. 
+    BUTTON2XDOTOOL = {
+      :left => 1, 
+      :middle => 2, 
+      :right => 3, 
+      :up => 4, 
+      :down => 5
+    }.freeze
+    
+    class << self
+      
+      #Gets the current cursor position. 
+      #===Return value
+      #A two-element array of form <code>[x, y]</code>. 
+      #===Example
+      #  p XDo::Mouse.position #=> [12, 326]
+      def position
+        out = `#{XDOTOOL} getmouselocation`.match(/x:(\d+) y:(\d+)/)
+        [$1.to_i, $2.to_i]
+      end
+      
+      #Moves the mouse cursor to the given position. 
+      #===Parameters
+      #[+x+] The goal X coordinate. 
+      #[+x+] The goal Y coordinate. 
+      #[+speed+] (2) Cursor move speed, in pixels per iteration. The higher the value, the more inaccurate the movement (but you can be sure the cursor is always at the position you specified at the end). 
+      #[+set+] (false) If true, the +speed+ parameter is ignored and the cursor is directly set to the given position. 
+      #[+sync+] (true) If true, this method blocks until the cursor has reached the given position. 
+      #===Return value
+      #The position you specified, as a two-dimensional array of form <tt>[x, y]</tt>. 
+      #===Raises
+      #[ArgumentError] The value of +speed+ was lower or equal to zero. 
+      #===Example
+      #  #Move to (10|10)
+      #  XDo::Mouse.move(10, 10)
+      #  #Move fast to (10|10)
+      #  XDo::Mouse.move(10, 10, 10)
+      #  #Directly set the cursor to (10|10) without any movement
+      #  XDo::Mouse.move(10, 10, 1, true)
+      def move(x, y, speed = 2, set = false, sync = true)
+        if set
+          opts = []
+          opts << "--sync" if sync
+          `#{XDOTOOL} mousemove #{opts.join(" ")} #{x} #{y}`
+          return [x, y]
+        else
+          raise(ArgumentError, "speed has to be > 0 (default is 2), was #{speed}!") if speed <= 0
+          pos = position #Current cursor position
+          act_x = pos[0]
+          act_y = pos[1]
+          aim_x = x
+          aim_y = y
+          #Create the illusion of a fluent movement (hey, that statement sounds better in German, really! ;-))
+          loop do
+            #Change position as indiciated by +speed+
+            if act_x > aim_x
+              act_x -= speed
+            elsif act_x < aim_x
+              act_x += speed
+            end
+            if act_y > aim_y
+              act_y -= speed
+            elsif act_y < aim_y
+              act_y += speed
+            end
+            #Move to computed position
+            move(act_x, act_y, speed, true)
+            #Check wheather the cursor's current position is inside an 
+            #acceptable area around the goal position. The size of this 
+            #area is defined by +speed+; this check ensures we don't get 
+            #an infinite loop for unusual conditions. 
+            if ((aim_x - speed)..(aim_x + speed)).include? act_x
+              if ((aim_y - speed)..(aim_y + speed)).include? act_y
+                break
+              end #if in Y-Toleranz
+            end #if in X-Toleranz
+          end #loop
+          #Correct the cursor position to point to the exact point specified. 
+          #This is for the case the "acceptable area" condition above triggers. 
+          if position != [x, y]
+            move(x, y, 1, true)
+          end #if position != [x, y]
+          
+        end #if set
+        [x, y]
+      end #def move
+      
+      #Simulates a mouse click. If you don't specify a X AND a Y position, 
+      #the click will happen at the current cursor position. 
+      #===Parameters
+      #[+x+] (nil) The goal X position. Specify together with +y+. 
+      #[+y+] (nil) The goal Y position. 
+      #[+button+] (:left) The button to click with. One of the following symbols: <tt>:left</tt>, <tt>:right</tt>, <tt>:middle</tt>. 
+      #The other arguments are the same as for #move. 
+      #===Return value
+      #Undefined. 
+      #===Example
+      #  #Click at the current position
+      #  XDo::Mouse.click
+      #  #Click at (10|10)
+      #  XDo::Mouse.click(10, 10)
+      #  #Click at the current position with the right mouse button
+      #  XDo::Mouse.click(nil, nil, :right)
+      #  #Move fast to (10|10) and click with the right mouse button
+      #  XDo::Mouse.click(10, 10, :right, 10)
+      #  #Directly set the cursor to (10|10) and click with the middle mouse button
+      #  XDo::Mouse.click(10, 10, :middle, 1, true)
+      def click(x = nil, y = nil, button = :left, speed = 1, set = false)
+        if button.kind_of?(Numeric)
+          warn("#{caller.first}: Deprecation warning: Use symbols such as :left for the button parameter.")
+          button = BUTTON2XDOTOOL.keys[button - 1] #indices are 0-based
+        end
+        if x and y
+          move(x, y, speed, set)
+        end
+        `#{XDOTOOL} click #{BUTTON2XDOTOOL[button]}`
+      end
+      
+      #Scroll with the mouse wheel. +amount+ is the time of steps to scroll. 
+      #===Parameters
+      #[+dir+] The direction to scroll into. Either :up or :down. 
+      #[+amount+] The number of steps to scroll. These are *not* meant to be full wheel rounds. 
+      #===Return value
+      #Undefined. 
+      #===Example
+      #  #Scroll up
+      #  XDo::Mouse.wheel(:up, 4)
+      #  #Scroll down 4 steps
+      #  XDo::Mouse.wheel(:down, 4)
+      #===Remarks
+      #The X Server handles wheel up and wheel down events like mouse click 
+      #events and if you take a look in the source code of this function you will see, that 
+      #it calls #click passing through the +dir+ parameter. So, if you want to be funny, 
+      #write something like 
+      #  XDo::Mouse.click(nil, nil, :up)
+      #. 
+      def wheel(dir, amount)
+        if button.kind_of?(Numeric)
+          warn("#{caller.first}: Deprecation warning: Use symbols such as :up for the dir parameter.")
+          button = BUTTON2XDOTOOL.keys[button - 1] #indices are 0-based
+        end
+        amount.times{click(nil, nil, dir)}
+      end
+      
+      #Holds a mouse button down. Don't forget to release it some time. 
+      #===Parameters
+      #[+button+] (:left) The button to hold down. 
+      #===Return value
+      #Undefined. 
+      #===Example
+      #  #Hold down the left mouse button for a second
+      #  XDo::Mouse.down
+      #  sleep 1
+      #  XDo::Mouse.up
+      #  #Hold down the right mouse button for a second
+      #  XDo::Mouse.down(:right)
+      #  sleep 1
+      #  XDo::Mouse.up(:right)
+      def down(button = :left)
+        if button.kind_of?(Numeric)
+          warn("#{caller.first}: Deprecation warning: Use symbols such as :left for the button parameter.")
+          button = BUTTON2XDOTOOL.keys[button - 1] #indices are 0-based
+        end
+        `#{XDOTOOL} mousedown #{BUTTON2XDOTOOL[button]}`
+      end
+      
+      #Releases a mouse button. Probably it's a good idea to call #down first?
+      #===Parameters
+      #[+button+] (:left) The button to release.  
+      #===Return value
+      #Undefined. 
+      #===Example
+      #  #Hold down the left mouse button for a second
+      #  XDo::Mouse.down
+      #  sleep 1
+      #  XDo::Mouse.up
+      #  #Hold down the right mouse button for a second
+      #  XDo::Mouse.down(:right)
+      #  sleep 1
+      #  XDo::Mouse.up(:right)
+      def up(button = :left)
+        if button.kind_of?(Numeric)
+          warn("#{caller.first}: Deprecation warning: Use symbols such as :left for the button parameter.")
+          button = BUTTON2XDOTOOL.keys[button - 1] #indices are 0-based
+        end
+        `#{XDOTOOL} mouseup #{BUTTON2XDOTOOL[button]}`
+      end
+      
+      #Executs a drag&drop operation. 
+      #===Parameters
+      #[+x1+] Start X coordinate. Set to the current cursor X coordinate if set to nil. Pass together with +y1+. 
+      #[+y1+] Start Y coordinate. Set to the current cursor Y coordinate if set to nil. 
+      #[+x2+] Goal X coordinate. 
+      #[+y2+] Goal Y coordinate. 
+      #[+button+] (:left) The button to hold down. 
+      #The rest of the parameters is the same as for #move. 
+      #===Return value
+      #nil. 
+      #===Example
+      #  #Drag from (10|10) to (37|56)
+      #  XDo::Mouse.drag(10, 10, 37, 56)
+      #  #Drag from (10|10) to (37|56) holding the right mouse button down
+      #  XDo::Mouse.drag(10, 10, 37, 56, :right) 
+      def drag(x1, y1, x2, y2, button = :left, speed = 2, set = false)
+        if button.kind_of?(Numeric)
+          warn("#{caller.first}: Deprecation warning: Use symbols such as :left for the button parameter.")
+          button = BUTTON2XDOTOOL.keys[button - 1] #indices are 0-based
+        end
+        #If x1 and y1 aren't passed, assume the current position
+        if x1.nil? and y1.nil?
+          x1, y1 = position
+        end
+        #Go to the given start position
+        move(x1, y1, speed, set)
+        #Hold button down
+        down(button)
+        #Move to the goal position
+        move(x2, y2, speed, set)
+        #Release button
+        up(button)
+        nil
+      end
+      
+    end #class << self
+    
+  end #module Mouse
+end
 
=== added file 'tests/misc/lib/xdo/simulatable.rb'
--- tests/misc/lib/xdo/simulatable.rb	1970-01-01 00:00:00 +0000
+++ tests/misc/lib/xdo/simulatable.rb	2011-12-15 16:55:31 +0000
@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+#Encoding: UTF-8
+#This file is part of Xdo. 
+#Copyright © 2009, 2010 Marvin Gülker
+#  Initia in potestate nostra sunt, de eventu fortuna iudicat. 
+#
+# Modified by Gerry Boland <gerry dot boland at canonical dot com> 
+require File.join(File.dirname(__FILE__), '_xdo')
+require File.join(File.dirname(__FILE__), 'keyboard')
+
+module XDo
+  
+  #Mixin that allows String-like objects to be directly 
+  #simulated. You can use it with Ruby's String class: 
+  #  require "xdo/simulatable"
+  #  
+  #  class String
+  #    include XDo::Simulatable
+  #    def to_xdo
+  #      to_s
+  #    end
+  #  end
+  #
+  #  "abc".simulate
+  #Every method in this module calls #to_xdo on +self+ 
+  #first, so make sure this method returns a xdo-usable 
+  #String (i.e. no invisible characters except newline, tab and space). 
+  module Simulatable
+    
+    #Simulates +self+ as keystrokes. Escape sequences are allowed. 
+    #===Parameters
+    #[raw] (+false+) If true, escape sequences are ignored. 
+    #[w_id] (+nil+) The window's ID to send the keystrokes to. Either an integer or a XWindow object. 
+    #===Return value
+    #self.
+    #===Raises
+    #[ParseError] Your string was invalid. 
+    #===Example
+    #  "This is an{BS} test".simulate
+    #  win = XDo::XWindow.from_title(/gedit/)
+    #  "This is an{BS} test".simulate(false, win)
+    def simulate(raw = false, w_id = nil)
+      XDo::Keyboard.simulate(to_xdo, raw, w_id)
+    end
+    
+    #Types +self+ as keystrokes. Ignores escape sequences. 
+    #===Parameters
+    #[w_id] The window's ID to send the keystrokes to. Either an integer or a XWindow object. 
+    #===Return value
+    #nil. 
+    #===Example
+    #  "Some test text".type
+    #  win = XDo::XWindow.from_title(/gedit/)
+    #  "Some test text".type(win)
+    def type(w_id = nil)
+      XDo::Keyboard.type(to_xdo, w_id)
+    end
+    
+    #Holds the the key corresponding to the first character in +self+ down. 
+    #===Parameters
+    #[w_id] The window in which to hold a key down. Either an integer ID or a XWindow object. 
+    #===Return value
+    #The character of the key hold down. 
+    #===Raises
+    #[XError] Invalid keyname.
+    #===Example
+    #  "a".down
+    #  win = XDo::XWindow.from_title(/gedit/)
+    #  "a".down(win)
+    def down(w_id = nil)
+      XDo::Keyboard.key_down(to_xdo[0], w_id)
+    end
+    
+    #Releases the key corresponding to the first character in +self+. 
+    #===Parameters
+    #[w_id] The window in which to release a key. Either an integer ID or a XWindow object. 
+    #===Return value
+    #The character of the key released. 
+    #===Raises
+    #[XError] Invalid keyname. 
+    #===Example
+    #  "a".up
+    #  win = XDo::XWindow.from_title(/gedit/)
+    #  "a".up(win)
+    def up(w_id = nil)
+      XDo::Keyboard.key_up(to_xdo[0], w_id)
+    end
+    
+  end
+  
+end
 
=== added directory 'tests/misc/lib/xdo/test'
=== added file 'tests/misc/lib/xdo/test/test_clipboard.rb'
--- tests/misc/lib/xdo/test/test_clipboard.rb	1970-01-01 00:00:00 +0000
+++ tests/misc/lib/xdo/test/test_clipboard.rb	2011-12-15 16:55:31 +0000
@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+#Encoding: UTF-8
+
+require "test/unit"
+require File.join(File.dirname(__FILE__), '../clipboard')
+
+class ClipboardTest < Test::Unit::TestCase
+  
+  def test_read
+    #Write something to the clipboard first
+    IO.popen("#{XDo::XSEL} -i", "w"){|io| io.write("Some primary test text")}
+    IO.popen("#{XDo::XSEL} -b -i", "w"){|io| io.write("Some clipboard \ntest text")}
+    IO.popen("#{XDo::XSEL} -s -i", "w"){|io| io.write("Some secondary test text")}
+    
+    clip = XDo::Clipboard.read
+    assert_equal("Some primary test text", XDo::Clipboard.read_primary)
+    assert_equal(XDo::Clipboard.read_primary, clip[:primary])
+    assert_equal("Some clipboard \ntest text", XDo::Clipboard.read_clipboard)
+    assert_equal(XDo::Clipboard.read_clipboard, clip[:clipboard])
+    assert_equal("Some secondary test text", XDo::Clipboard.read_secondary)
+    assert_equal(XDo::Clipboard.read_secondary, clip[:secondary])
+  end
+  
+  def test_write
+    XDo::Clipboard.write_primary "Primary!"
+    XDo::Clipboard.write_clipboard "Clipboard!\nNewline"
+    XDo::Clipboard.write_secondary "Secondary!"
+    
+    assert_equal("Primary!", `#{XDo::XSEL}`)
+    assert_equal("Secondary!", `#{XDo::XSEL} -s`)
+    assert_equal("Clipboard!\nNewline", `#{XDo::XSEL} -b`)
+    
+    XDo::Clipboard.write("XYZ", :primary, :secondary, :clipboard)
+    assert_equal({ :primary => "XYZ", :secondary => "XYZ", :clipboard => "XYZ"}, XDo::Clipboard.read)
+  end
+  
+  def test_append
+    ["primary", "secondary", "clipboard"].each{|m| XDo::Clipboard.send(:"write_#{m}", "This is... ")}
+    XDo::Clipboard.append("a Test!", :primary, :secondary, :clipboard)
+    ["primary", "secondary", "clipboard"].each{|m| assert_equal(XDo::Clipboard.send(:"read_#{m}"), "This is... a Test!")}
+  end
+  
+  def test_clear
+    XDo::Clipboard.write("ABC", :primary, :secondary, :clipboard)
+    ["primary", "secondary", "clipboard"].each{|m| XDo::Clipboard.send("clear_#{m}")}
+    ["primary", "secondary", "clipboard"].each{|m| assert_equal("", XDo::Clipboard.send("read_#{m}"))}
+  end
+  
+end
 
=== added file 'tests/misc/lib/xdo/test/test_keyboard.rb'
--- tests/misc/lib/xdo/test/test_keyboard.rb	1970-01-01 00:00:00 +0000
+++ tests/misc/lib/xdo/test/test_keyboard.rb	2011-12-15 16:55:31 +0000
@@ -0,0 +1,114 @@
+#!/usr/bin/env ruby
+#Encoding: UTF-8
+
+require "test/unit"
+require "tempfile"
+require File.join(File.dirname(__FILE__), '../keyboard')
+require File.join(File.dirname(__FILE__), '../clipboard')
+require File.join(File.dirname(__FILE__), '../xwindow')
+require File.join(File.dirname(__FILE__), '../simulatable')
+
+class TestKeyboard < Test::Unit::TestCase
+  
+  #Command to start a simple text editor
+  EDITOR_CMD = "gedit -s"
+  EDITOR_NAME = "gedit"
+  
+  TESTTEXT = "This is test\ntext."
+  TESTTEXT2 = "WXY"
+  TESTTEXT_RAW = "ä{TAB}?b"
+  TESTTEXT_SPECIAL = "ab{TAB}c{TAB}{TAB}d"
+  
+  def setup
+    @editor_pipe = IO.popen(EDITOR_CMD, 'r')
+    sleep 3
+  end
+  
+  def teardown
+    Process.kill 'TERM', @editor_pipe.pid
+    @editor_pipe.close
+  end
+
+  def test_char
+    Process.kill 'TERM', @editor_pipe.pid
+    @editor_pipe.close #Special file need to be opened
+    tempfile = Tempfile.open("XDOTEST")
+    tempfile.write(TESTTEXT)
+    tempfile.flush
+    sleep 3 #Wait for the buffer to be written out
+    @editor_pipe = IO.popen(EDITOR_CMD + ' ' + tempfile.path, 'r') #So it's automatically killed by #teardown
+    sleep 3
+    tempfile.close
+    20.times{XDo::Keyboard.char("Shift+Right")}
+    XDo::Keyboard.ctrl_c
+    sleep 0.2
+    assert_equal(TESTTEXT, XDo::Clipboard.read_clipboard)
+  end
+  
+  def test_simulate
+    XDo::Keyboard.simulate("A{BS}#{TESTTEXT2}")
+    XDo::Keyboard.ctrl_a
+    XDo::Keyboard.ctrl_c
+    sleep 0.2
+    assert_equal(TESTTEXT2, XDo::Clipboard.read_clipboard)
+    
+    XDo::Keyboard.ctrl_a
+    XDo::Keyboard.delete
+    XDo::Keyboard.simulate(TESTTEXT_SPECIAL)
+    XDo::Keyboard.ctrl_a
+    XDo::Keyboard.ctrl_c
+    sleep 0.2
+    assert_equal(TESTTEXT_SPECIAL.gsub("{TAB}", "\t"), XDo::Clipboard.read_clipboard)
+    
+    XDo::Keyboard.ctrl_a
+    XDo::Keyboard.delete
+    XDo::Keyboard.simulate(TESTTEXT_RAW, true)
+    XDo::Keyboard.ctrl_a
+    XDo::Keyboard.ctrl_c
+    sleep 0.2
+    assert_equal(TESTTEXT_RAW, XDo::Clipboard.read_clipboard)
+  end
+  
+  def test_type
+    XDo::Keyboard.type(TESTTEXT2)
+    XDo::Keyboard.ctrl_a
+    XDo::Keyboard.ctrl_c
+    sleep 0.2
+    assert_equal(TESTTEXT2, XDo::Clipboard.read_clipboard)
+  end
+
+  def test_window_id
+    XDo::XWindow.unfocus #Ensure that the editor hasn't the input focus anymore
+    sleep 1
+    edit_id = XDo::XWindow.search(EDITOR_NAME).last
+    xwin = XDo::XWindow.new(edit_id)
+    XDo::Keyboard.simulate(TESTTEXT_SPECIAL, false, edit_id)
+    sleep 1
+    xwin.activate
+    XDo::Keyboard.ctrl_a
+    XDo::Keyboard.ctrl_c
+    sleep 0.2
+    assert_equal(TESTTEXT_SPECIAL.gsub("{TAB}", "\t"), XDo::Clipboard.read_clipboard)
+  end
+  
+  def test_include
+    String.class_eval do
+      include XDo::Simulatable
+      
+      def to_xdo
+        to_s
+      end
+    end
+    
+    XDo::Keyboard.ctrl_a
+    XDo::Keyboard.delete
+    "Ein String".simulate
+    XDo::Keyboard.ctrl_a
+    sleep 0.2
+    XDo::Keyboard.ctrl_c
+    sleep 0.2
+    clip = XDo::Clipboard.read_clipboard
+    assert_equal("Ein String", clip, "Simulated typed string fails to match")
+  end
+  
+end
 
=== added file 'tests/misc/lib/xdo/test/test_mouse.rb'
--- tests/misc/lib/xdo/test/test_mouse.rb	1970-01-01 00:00:00 +0000
+++ tests/misc/lib/xdo/test/test_mouse.rb	2011-12-15 16:55:31 +0000
@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+#Encoding: UTF-8
+
+require "test/unit"
+require File.join(File.dirname(__FILE__), '../mouse')
+
+class MouseTest < Test::Unit::TestCase
+  
+  def test_position
+    str = `#{XDo::XDOTOOL} getmouselocation`
+    xdpos = []
+    xdpos << str.match(/x:\s?(\d+)/)[1]
+    xdpos << str.match(/y:\s?(\d+)/)[1]
+    xdpos.collect!{|o| o.to_i}
+    assert_equal(xdpos, XDo::Mouse.position)
+  end
+  
+  def test_move
+    XDo::Mouse.move(200, 200)
+    assert_equal([200, 200], XDo::Mouse.position)
+    XDo::Mouse.move(0, 0)
+    assert_equal([0, 0], XDo::Mouse.position)
+    XDo::Mouse.move(0, 200)
+    assert_equal([0, 200], XDo::Mouse.position)
+    XDo::Mouse.move(100, 100)
+    assert_equal([100, 100], XDo::Mouse.position)
+  end
+  
+end
 
=== added file 'tests/misc/lib/xdo/test/test_xwindow.rb'
--- tests/misc/lib/xdo/test/test_xwindow.rb	1970-01-01 00:00:00 +0000
+++ tests/misc/lib/xdo/test/test_xwindow.rb	2011-12-15 16:55:31 +0000
@@ -0,0 +1,101 @@
+#!/usr/bin/env ruby
+#Encoding: UTF-8
+
+require "test/unit"
+require File.join(File.dirname(__FILE__), '../xwindow')
+require File.join(File.dirname(__FILE__), '../keyboard')
+
+class WindowTest < Test::Unit::TestCase
+  
+  attr_accessor :xwindow
+  
+  #The command used to create new windows. 
+  #The program MUST NOT start maximized. xdotool has no possibility of 
+  #acting on maximized windows.
+  NEW_WINDOW_NAME = "Home"
+  NEW_WINDOW_CMD = "nautilus"
+  
+  @@xwin = nil
+  
+  def setup
+    @editor_pipe = IO.popen(NEW_WINDOW_CMD, 'r')
+    XDo::XWindow.wait_for_window(Regexp.new(Regexp.escape(NEW_WINDOW_NAME)))
+    @@xwin = XDo::XWindow.from_title(Regexp.new(Regexp.escape(NEW_WINDOW_NAME)))
+  end
+  
+  def teardown
+    @@xwin.focus
+    @@xwin.close!
+#    Process.kill 'TERM', @editor_pipe.pid
+#    @editor_pipe.close
+  end
+  
+  def test_ewmh_active_window
+    begin
+      XDo::XWindow.from_active
+    rescue XDo::XError
+      #Standard not available
+     notify $!.message
+    end
+  end
+  
+  def test_ewmh_wm_desktop
+    begin
+      XDo::XWindow.desktop_num
+    rescue XDo::XError
+      #Standard not available
+      notify $!.message
+    end
+  end
+  
+  def test_ewmh_current_desktop
+    begin
+      XDo::XWindow.desktop
+    rescue XDo::XError
+      #Standard not available
+      notify $!.message
+    end
+  end
+  
+  def test_exists
+    assert_equal(true, XDo::XWindow.exists?(@@xwin.title))
+  end
+  
+  def test_unfocus
+    XDo::XWindow.unfocus
+  #  assert_not_equal(@@xwin.id, XDo::XWindow.from_focused.id) # not supported by WM
+  #  assert_raise(XDo::XError){XDo::XWindow.from_active} #Nothing's active anymore    
+  end
+  
+  def test_active
+    @@xwin.activate
+    assert_equal(@@xwin.id, XDo::XWindow.from_active.id)
+  end
+  
+  def test_focused
+    @@xwin.unfocus
+    @@xwin.focus
+    assert_equal(@@xwin.id, XDo::XWindow.from_focused.id)
+  end
+  
+  def test_move
+    @@xwin.move(87, 57)
+    assert_in_delta(87, 3, @@xwin.abs_position[0])
+    assert_in_delta(57, 3, @@xwin.abs_position[1])
+    # assert_equal(@@xwin.abs_position, @@xwin.rel_position) - why should this succeed?
+  end
+  
+  def test_resize
+    @@xwin.resize(500, 500)
+    assert_equal([500, 500], @@xwin.size)
+  end
+
+  def test_map
+    @@xwin.unmap
+    assert_equal(nil, @@xwin.visible?)
+    @@xwin.map
+    assert_block("Window is not visible."){@@xwin.visible?.kind_of?(Integer)}    
+  end
+  
+end
+ 
 
=== added file 'tests/misc/lib/xdo/xwindow.rb'
--- tests/misc/lib/xdo/xwindow.rb	1970-01-01 00:00:00 +0000
+++ tests/misc/lib/xdo/xwindow.rb	2011-12-15 16:55:31 +0000
@@ -0,0 +1,1009 @@
+#Encoding: UTF-8
+#This file is part of Xdo.
+#Copyright © 2009, 2010 Marvin Gülker
+#  Initia in potestate nostra sunt, de eventu fortuna iudicat.
+#
+# Modified by Gerry Boland <gerry dot boland at canonical dot com> 
+require File.join(File.dirname(__FILE__), '_xdo')
+require "open3"
+
+module XDo
+  
+  #This class represents a window on the screen. Each window is uniquely identified by
+  #an internal ID; before you can create a reference to a window (a XWindow object) you
+  #have to obtain the internal ID of that window and pass it into XWindow.new.
+  #Or you use the class methods of this class, notably XWindow.active_window.
+  #
+  #Via the XWindow object you get you can manipulate a window in serveral ways, e.g.
+  #you can move or resize it. Some methods are not available on every window
+  #manager: XWindow.active_window, XWindow.desktop_num, XWindow.desktop_num=, XWindow.desktop,
+  #XWindow.desktop=, XWindow.from_active, #raise, #activate, #desktop, #desktop=.
+  #Some of them may be available, some not. On my machine (an Ubuntu Lucid) for
+  #example I can use active_window, desktop_num and #activate, but not #raise or #desktop=.
+  #Those methods are tagged with the sentence "Part of the EWMH standard XY". Not all
+  #parts of the EWMH standard are provided by every window manager.
+  #
+  #As of version 0.0.4 the way to search for window is about to change. The old version
+  #where you passed a hash with symbols has been deprecated (and you get warnings
+  #about this if you use it) in favor of passing those symbols as a rest argument. See
+  #XWindow.search for more details.
+  #
+  #You should also be aware of the fact that XDo is about to support Regexp objects
+  #in XWindow.search. In future versions (i.e. after the next minor release) strings
+  #*always* mean an exact title/class/whatever match. For parts, you have to use
+  #Regular Expressions. There is a culprit, though. +xdotool+ doesn't use Ruby's
+  #Regular Expressions engine Oniguruma and expects C-style regexps. I don't know
+  #about the differences - but if you're absolutely sure your window title matches
+  #that wonderful three-line extended regexp and +xdotool+ doesn't find it, you
+  #may email me at sutniuq@@gmx@net explaining which construct defeats +xdotool+.
+  #I will then setup a list over time which states which constructs don't work.
+  #
+  #Be <i>very careful</i> with the methods that are part of the two desktop EWMH standards.
+  #After I set the number of desktops and changed the current desktop, I had to reboot my
+  #system to get the original configuration back. I don't know if I'm not using +xdotool+ correct,
+  #but neither my library nor +xdotool+ itself could rescue my desktop settings. Btw, that's the
+  #reason why it's not in XDo's unit tests (but it should work; at least in one way...).
+  class XWindow
+    #The internal ID of the window.
+    attr_reader :id
+    
+    class << self
+      
+      #Checks if a window exists.
+      #===Parameters
+      #[+name+] The name of the window to look for. Either a string or a Regular Expression; however, there's no guaranty that +xdotool+ gets the regexp right. Simple ones should work, though.
+      #[<tt>*opts</tt> (<tt>[:name, :class, :classname]</tt>) Search parameters. See XWindow.search.
+      #===Return value
+      #true or false.
+      #===Example
+      #  p XWindow.exists?("gedit") #=> true
+      #  p XWindow.exists?(/^gedit/) #=> false
+      #===Remarks
+      #It may be a good idea to pass :onlyvisible as a search parameter.
+      def exists?(name, *opts)
+        if opts.first.kind_of?(Hash)
+          warn("#{caller.first}: Deprecation Warning: Using a hash as further arguments is deprecated. Pass the symbols directly.")
+          opts = opts.first.keys
+        end
+        
+        !search(name, *opts).empty?
+      end
+      
+      #Checks wheather the given ID exists or not.
+      #===Parameters
+      #[+id+] The ID to check for.
+      #===Return value
+      #true or false.
+      #===Example
+      #  p XWindow.id_exits?(29360674) #=> true
+      #  p XWindow.id_exists?(123456) #=> false
+      def id_exists?(id)
+        err = ""
+        Open3.popen3("#{XDo::XWININFO} -id #{id}"){|stdin, stdout, stderr| err << stderr.read}
+        return false unless err.empty?
+        return true
+      end
+      
+      #Waits for a window name to exist.
+      #===Parameters
+      #[+name+] The name of the window to look for. Either a string or a Regular Expression; however, there's no guaranty that +xdotool+ gets the regexp right. Simple ones should work, though.
+      #[<tt>*opts</tt> (<tt>[:name, :class, :classname]</tt>) Search parameters. See XWindow.search.
+      #===Return value
+      #The ID of the newly appeared window.
+      #===Example
+      #  #Wait for a window with "gedit" somewhere in it's title:
+      #  XDo::XWindow.wait_for_window("gedit")
+      #  #Wait for a window that ends with "ends_with_this":
+      #  XDo::XWindow.wait_for_window(/ends_with_this$/)
+      #  #It's useful to combine this method with the Timeout module:
+      #  require "timeout"
+      #  Timeout.timeout(3){XDo::XWindow.wait_for_window("gedit")}
+      #===Remarks
+      #Returns immediately if the window does already exist.
+      def wait_for_window(name, *opts)
+        if opts.first.kind_of?(Hash)
+          warn("#{caller.first}: Deprecation Warning: Using a hash as further arguments is deprecated. Pass the symbols directly.")
+          opts = opts.first.keys
+        end
+        
+        loop{break if exists?(name, *opts);sleep(0.5)}
+        search(name, *opts).first
+      end
+      
+      #Waits for a window to close.
+      #===Parameters
+      #[+name+] The name of the window to look for. Either a string or a Regular Expression; however, there's no guaranty that +xdotool+ gets the regexp right. Simple ones should work, though.
+      #[<tt>*opts</tt> (<tt>[:name, :class, :classname]</tt>) Search parameters. See XWindow.search.
+      #===Return value
+      #nil.
+      #===Example
+      #  #Wait for a window with "gedit" somewhere in it's title
+      #  XDo::XWindow.wait_for_close("gedit")
+      #  #Waits for a window whose title ends with "ends_with_this":
+      #  XDo::XWindow.wait_for_close(/ends_with_this$/)
+      #  #It's quite useful to combine this method with the Timeout module:
+      #  require "timeout"
+      #  Timeout.timeout(3){XDo::XWindow.wait_for_close("gedit")}
+      def wait_for_close(name, *opts)
+        if opts.first.kind_of?(Hash)
+          warn("#{caller.first}: Deprecation Warning: Using a hash as further arguments is deprecated. Pass the symbols directly.")
+          opts = opts.first.keys
+        end
+        
+        loop{break if !exists?(name, *opts);sleep(0.5)}
+        nil
+      end
+      
+      #Search for a window name to get the internal ID of a window.
+      #===Parameters
+      #[+str+] The name of the window to look for. Either a string or a Regular Expression; however, there's no guaranty that +xdotool+ gets the regexp right. Simple ones should work, though.
+      #[<tt>*opts</tt> (<tt>[:name, :class, :classname]</tt>) Search parameters.
+      #====Possible search parameters
+      #Copied from the +xdotool+ manpage:
+      #[class] Match against the window class.
+      #[classname] Match against the window classname.
+      #[name] Match against the window name. This is the same string that is displayed in the window titlebar.
+      #[onlyvisible] Show only visible windows in the results. This means ones with map state IsViewable.
+      #===Return value
+      #An array containing the IDs of all found windows or an empty array
+      #if none was found.
+      #===Example
+      #  #Look for every window with "gedit" in it's title, class or classname
+      #  XDo::XWindow.search("gedit")
+      #  #Look for every window whose title, class or classname ends with "SciTE"
+      #  XDo::XWindow.search(/SciTE$/)
+      #  #Explicitly only search the titles of visible windows
+      #  XDo::XWindow.search("gedit", :name, :onlyvisible)
+      def search(str, *opts)
+        if opts.first.kind_of?(Hash)
+          warn("#{caller.first}: Deprecation Warning: Using a hash as further arguments is deprecated. Pass the symbols directly.")
+          opts = opts.first.keys
+        end
+        opts = [:name, :class, :classname] if opts.empty?
+        
+        #Allow Regular Expressions. Since I can't pass them directly to the command line,
+        #I need to get their source. Otherwise we want an exact match, therefore the line
+        #begin and line end anchors need to be set around the given string.
+        str = str.source if str.kind_of?(Regexp)
+        #TODO
+        #The following is the new behaviour that will be activated with the next minor version.
+        #See DEPRECATE.rdoc.
+        #str = if str.kind_of?(Regexp)
+          #str.source
+        #else
+          #"^#{str.to_str}$"
+        #end
+        
+        cmd = "#{XDo::XDOTOOL} search "
+        opts.each{|sym| cmd << "--#{sym} "}
+        cmd << "'" << str << "'"
+        #Don't handle errors since we want an empty array in case of an error
+        Open3.popen3(cmd){|stdin, stdout, stderr| stdin.close_write; stdout.read}.lines.to_a.collect{|l| l.strip.to_i}
+      end
+      
+      #Returns the internal ID of the currently focused window.
+      #===Parameters
+      #[+notice_children+] (false) If true, childwindows are noticed and you may get a child window instead of a toplevel window.
+      #===Return value
+      #The internal ID of the found window.
+      #===Raises
+      #[XError] Error invoking +xdotool+.
+      #===Example
+      #  p XDo::XWindow.focused_window #=> 41943073
+      #  p XDo::XWindow.focused_window(true) #=> 41943074
+      #===Remarks
+      #This method may find an invisible window, see active_window for a more reliable method.
+      def focused_window(notice_children = false)
+        err = ""
+        out = ""
+        Open3.popen3("#{XDo::XDOTOOL} getwindowfocus #{notice_children ? "-f" : ""}"){|stdin, stdout, stderr| out << stdout.read; err << stderr.read}
+        raise(XDo::XError, err) unless err.empty?
+        return out.to_i
+      end
+      
+      #Returns the internal ID of the currently focused window.
+      #===Return value
+      #The ID of the found window.
+      #===Raises
+      #[XError] Error invoking +xdotool+.
+      #===Example
+      #  p XDo::XWindow.active_window #=> 41943073
+      #===Remarks
+      #This method is more reliable than #focused_window, but never finds an invisible window.
+      #
+      #Part of the EWMH standard ACTIVE_WINDOW.
+      def active_window
+        err = ""
+        out = ""
+        Open3.popen3("#{XDo::XDOTOOL} getactivewindow"){|stdin, stdout, stderr| out = stdout.read; err = stderr.read}
+        raise(XDo::XError, err) unless err.empty?
+        return Integer(out)
+      end
+      
+      #Set the number of working desktops.
+      #===Parameters
+      #[+num+] The number of desktops you want to exist.
+      #===Return value
+      #+num+.
+      #===Raises
+      #[XError] Error invoking +xdotool+.
+      #===Example
+      #  XDo::XWindow.desktop_num = 2
+      #===Remarks
+      #Although Ubuntu systems seem to have several desktops, that isn't completely true. An usual Ubuntu system only
+      #has a single working desktop, on which Ubuntu sets up an arbitrary number of other "desktop views" (usually 4).
+      #That's kind of cheating, but I have not yet find out why it is like that. Maybe it's due to the nice cube rotating effect?
+      #That's the reason, why the desktop-related methods don't work with Ubuntu.
+      #
+      #Part of the EWMH standard WM_DESKTOP.
+      def desktop_num=(num)
+        err = ""
+        Open3.popen3("#{XDo::XDOTOOL} set_num_desktops #{num}"){|stdin, stdout, stderr| err << stderr.read}
+        raise(XDo::Error, err) unless err.empty?
+        num
+      end
+      
+      #Get the number of working desktops.
+      #===Return value
+      #The number of desktops.
+      #===Raises
+      #[XError] Error invoking +xdotool+.
+      #===Example
+      #  p XDo::XWindow.desktop_num = 1
+      #===Remarks
+      #Although Ubuntu systems seem to have several desktops, that isn't completely true. An usual Ubuntu system only
+      #has a single working desktop, on which Ubuntu sets up an arbitrary number of other "desktop views" (usually 4).
+      #That's kind of cheating, but I have not yet find out why it is like that. Maybe it's due to the nice cube rotating effect?
+      #That's the reason, why the desktop-related methods don't work with Ubuntu.
+      #
+      #Part of the EWMH standard WM_DESKTOP.
+      def desktop_num
+        err = ""
+        out = ""
+        Open3.popen3("#{XDo::XDOTOOL} get_num_desktops"){|stdin, stdout, stderr| out << stdout.read; err << stderr.read}
+        raise(XDo::XError, err) unless err.empty?
+        Integer(out)
+      end
+      
+      #Change the view to desktop +num+.
+      #===Parameters
+      #[+num+] The 0-based index of the desktop you want to switch to.
+      #===Return value
+      #+num+.
+      #===Raises
+      #[XError] Error invoking +xdotool+.
+      #===Example
+      #  XDo::XWindow.desktop = 1
+      #===Remarks
+      #Although Ubuntu systems seem to have several desktops, that isn't completely true. An usual Ubuntu system only
+      #has a single working desktop, on which Ubuntu sets up an arbitrary number of other "desktop views" (usually 4).
+      #That's kind of cheating, but I have not yet find out why it is like that. Maybe it's due to the nice cube rotating effect?
+      #That's the reason, why the desktop-related methods don't work with Ubuntu.
+      #
+      #Part of the EWMH standard CURRENT_DESKTOP.
+      def desktop=(num)
+        err = ""
+        Open3.popen3("#{XDo::XDOTOOL} set_desktop #{num}"){|stdin, stdout, stderr| err << stderr.read}
+        raise(XDo::XError, err) unless err.empty?
+        num
+      end
+      
+      #Returns the number of the active desktop.
+      #===Return value
+      #The number of the currently shown desktop.
+      #===Raises
+      #[XError] Error invoking +xdotool+.
+      #===Example
+      #  p XDo::XWindow.desktop #=> 0
+      #===Remarks
+      #Although Ubuntu systems seem to have several desktops, that isn't completely true. An usual Ubuntu system only
+      #has a single working desktop, on which Ubuntu sets up an arbitrary number of other "desktop views" (usually 4).
+      #That's kind of cheating, but I have not yet find out why it is like that. Maybe it's due to the nice cube rotating effect?
+      #That's the reason, why the desktop-related methods don't work with Ubuntu.
+      #
+      #Part of the EWMH standard CURRENT_DESKTOP.
+      def desktop
+        err = ""
+        out = ""
+        Open3.popen3("#{XDo::XDOTOOL} get_desktop"){|stdin, stdout, stderr| out = stdout.read; err = stderr.read}
+        raise(XDo::XError, err) unless err.empty?
+        Integer(out)
+      end
+      
+      #Creates a XWindow by calling search with the given parameters.
+      #The window is created from the first ID found.
+      #===Parameters
+      #[+name+] The name of the window to look for. Either a string or a Regular Expression; however, there's no guaranty that +xdotool+ gets the regexp right. Simple ones should work, though.
+      #[<tt>*opts</tt> (<tt>[:name, :class, :classname]</tt>) Search parameters. See XWindow.search.
+      #===Return value
+      #The created XWindow object.
+      #===Raises
+      #[XError] Error invoking +xdotool+.
+      #===Example
+      #  #Exact title/class/classname match
+      #  xwin = XDo::XWindow.from_search("xwindow.rb - SciTE")
+      #  #Part match via regexp
+      #  xwin = XDo::XWindow.from_search(/SciTE/)
+      #  #Part match via string - DEPRECATED.
+      #  xwin = XDo::XWindow.from_search("SciTE")
+      #  #Only search the window classes
+      #  xwin = XDo::XWindow.from_search(/SciTE/, :class)
+      def from_search(name, *opts)
+        if opts.first.kind_of?(Hash)
+          warn("#{caller.first}: Deprecation Warning: Using a hash as further arguments is deprecated. Pass the symbols directly.")
+          opts = opts.first.keys
+        end
+        
+        ids = search(name, *opts)
+        raise(XDo::XError, "The window '#{name}' wasn't found!") if ids.empty?
+        new(ids.first)
+      end
+      
+      #_Deprecated_. Use XWindow.from_search or XWindow.from_title instead.
+      def from_name(name, *opts)
+        warn("#{caller.first}: Deprecation Warning: ::from_name is deprecated. Use ::from_search if you want the old behaviour with the ability to specify all search parameters, or ::from_title if you just want to look through the window titles.")
+        from_search(name, *opts)
+      end
+      
+      #Same as XWindow.from_search, but only looks for the window's titles to match.
+      #===Parameters
+      #[+title+] The title of the window to look for. Either a string or a Regular Expression; however, there's no guaranty that +xdotool+ gets the regexp right. Simple ones should work, though.
+      #===Return value
+      #A XWindow object made up from the first window ID found.
+      #===Raises
+      #[XError] Error invoking +xdotool+.
+      #===Example
+      #  #Exact string match
+      #  xwin = XDo::XWindow.from_title("xwindow.rb - SciTE")
+      #  #Part match via regexp
+      #  xwin = XDo::XWindow.from_title(/SciTE/)
+      #  #Part match via string - DEPRECATED.
+      #  xwin = XDo::XWindow.from_title("SciTE")
+      def from_title(title)
+        from_search(title, :name)
+      end
+      
+      #Creates a XWindow by calling XWindow.focused_window with the given parameter.
+      #===Parameters
+      #[+notice_children+] (false) If true, you may get a child window as the active window.
+      #===Return value
+      #The newly created XWindow objects.
+      #===Example
+      #  xwin = XDo::XWindow.from_focused
+      #===Remarks
+      #The XWindow.focused_window method is a bit dangerous, since it may
+      #find an invisible window. Use XWindow.from_active if you don't want that.
+      def from_focused(notice_childs = false)
+        new(focused_window(notice_childs))
+      end
+      
+      #Creates a XWindow by calling active_window.
+      #===Return value
+      #The newly created XWindow object.
+      #===Example
+      #  xwin = XDo::XWindow.from_active
+      #===Remarks
+      #This method does not find invisible nor child windows; if you want that,
+      #you should take a look at XWindow.from_focused.
+      def from_active
+        new(active_window)
+      end
+      
+      #Returns the ID of the root window.
+      #===Return value
+      #The ID of the root window.
+      #===Example
+      #  p XDo::XWindow.root_id #=> 346
+      def root_id
+        out = ""
+        err = ""
+        Open3.popen3("#{XDo::XWININFO} -root"){|stdin, stdout, stderr| out << stdout.read.strip; err << stderr.read.strip}
+        Kernel.raise(XDo::XError, err) unless err.empty?
+        Integer(out.lines.to_a[0].match(/Window id:(.*?)\(/)[1].strip)
+      end
+      
+      #Creates a XWindow refering to the root window.
+      #===Return value
+      #The newly created XWindow object.
+      #===Example
+      #  rwin = XDo::XWindow.from_root
+      def from_root
+        new(root_id)
+      end
+      
+      #Creates a invalid XWindow.
+      #===Return value
+      #The newly created XWindow object.
+      #===Example
+      #  nwin = XDo::XWindow.from_null
+      #===Remarks
+      #The handle the returned XWindow object uses is zero and
+      #therefore invalid. You can't call #move, #resize or other
+      #methods on it, but it may be useful for unsetting focus.
+      #See also the XWindow.unfocus method.
+      def from_null
+        new(0) #Zero never is a valid window ID. Even the root window has another ID.
+      end
+      
+      #Unsets the input focus by setting it to the invalid
+      #NULL window.
+      #===Parameters
+      #[+sync+] (true) If true, this method blocks until the input focus has been unset. 
+      #===Return value
+      #nil.
+      #===Example
+      #  win = XDo::XWindow.from_active
+      #  win.focus
+      #  XDo::XWindow.unfocus
+      def unfocus(sync = true)
+        from_null.focus(sync)
+      end
+      
+      #Deprecated.
+      def desktop_name=(name)
+        warn("#{caller.first}: Deprecation warning: XWindow.desktop_name= doesn't do anything anymore.")
+      end
+      
+      #Deprecated.
+      def desktop_name
+        warn("#{caller.first}: Deprecation warning: XWindow.desktop_name doesn't do anything anymore.")
+        "x-nautilus-desktop"
+      end
+      
+      #Deprecated. Just calls XWindow.unfocus internally.
+      def focus_desktop
+        warn("#{caller.first}: Deprecation warning: XWindow.focus_desktop is deprecated. Use XWindow.unfocus instead.")
+        unfocus
+      end
+      alias activate_desktop focus_desktop
+      
+      #Minimize all windows (or restore, if already) by sending [CTRL]+[ALT]+[D].
+      #Available after requireing  "xdo/keyboard".
+      #===Return value
+      #Undefined.
+      #===Raises
+      #[NotImplementedError] You didn't require 'xdo/keyboard'.
+      #===Example
+      #  #Everything will be minimized:
+      #  XDo::XWindow.toggle_minimize_all
+      #  #And now we'll restore everything.
+      #  XDo::XWindow.toggle_minimize_all
+      def toggle_minimize_all
+        raise(NotImplementedError, "You have to require 'xdo/keyboard' before you can use #{__method__}!") unless defined? XDo::Keyboard
+        XDo::Keyboard.ctrl_alt_d
+      end
+      
+      #Minimizes the active window. There's no way to restore a specific minimized window.
+      #Available after requireing "xdo/keyboard".
+      #===Return value
+      #Undefined.
+      #===Raises
+      #[NotImplementedError] You didn't require 'xdo/keyboard'.
+      #===Example
+      #  XDo::XWindow.minimize
+      def minimize
+        raise(NotImplementedError, "You have to require 'xdo/keyboard' before you can use #{__method__}!") unless defined? XDo::Keyboard
+        XDo::Keyboard.key("Alt+F9")
+      end
+      
+      #Maximize or normalize the active window if already maximized.
+      #Available after requireing "xdo/keyboard".
+      #===Return value
+      #Undefined.
+      #===Raises
+      #[NotImplementedError] You didn't require 'xdo/keyboard'.
+      #===Example
+      #  XDo::XWindow.minimize
+      #  XDo::XWindow.toggle_maximize
+      def toggle_maximize
+        raise(NotImplementedError, "You have to require 'xdo/keyboard' before you can use #{__method__}!") unless defined? XDo::Keyboard
+        XDo::Keyboard.key("Alt+F10")
+      end
+      
+    end
+    
+    ##
+    #  :method: title=
+    #call-seq:
+    #  title = str
+    #  name = str
+    #
+    #Changes a window's title.
+    #===Parameters
+    #[+str+] The new title.
+    #===Return value
+    #+str+.
+    #===Raises
+    #[XError] Error invoking +xdotool+.
+    #===Example
+    #  xwin.title = "Ruby is awesome!"
+    
+    ##
+    # :method: icon_title=
+    #call-seq:
+    #  icon_title = str
+    #  icon_name = str
+    #
+    #Changes the window's icon title, i.e. the string that is displayed in
+    #the task bar or panel where all open windows show up.
+    #===Parameters
+    #[+str+] The string you want to set.
+    #===Return value
+    #+str+.
+    #===Raises
+    #[XError] Error invoking +xdotool+.
+    #===Example
+    #  xwin.icon_title = "This is minimized."
+    
+    ##
+    #  :method: classname=
+    #call-seq:
+    #  classname = str
+    #
+    #Sets a window's classname.
+    #===Parameters
+    #[+str+] The window's new classname.
+    #===Return value
+    #+str+.
+    #===Raises
+    #[XError] Error invoking +xdotool+.
+    #===Example
+    #  xwin.classname = "MyNewClass"
+    
+    #Creates a new XWindow object from an internal ID.
+    #===Parameters
+    #[+id+] The internal ID to create the window from.
+    #===Return value
+    #The newly created XWindow object.
+    #===Example
+    #  id = XWindow.search(/edit/)[1]
+    #  xwin = XWindow.new(id)
+    #===Remarks
+    #See also many class methods of the XWindow class which allow
+    #you to forget about the internal ID of a window.
+    def initialize(id)
+      @id = id.to_i
+    end
+    
+    #Human-readable output of form
+    #  <XDo::XWindow: "title" (window_id)>
+    def inspect
+      %Q|<#{self.class}: "#{title}" (#{id})>|
+    end
+    
+    #Set the size of a window.
+    #===Parameters
+    #[+width+] The new width, usually in pixels.
+    #[+height+] The new height, usually in pixels.
+    #[+use_hints+] (false) If true, window sizing hints are used if they're available. This is usually done when resizing terminal windows to a specific number of rows and columns.
+    #[+sync+] (true) If true, this method blocks until the window has finished resizing. 
+    #===Return value
+    #Undefined.
+    #===Raises
+    #[XError] Error executing +xdotool+.
+    #===Example
+    #  #Resize a window to 400x300px
+    #  xwin.resize(400, 300)
+    #  #Resize a terminal window to 100 rows and 100 columns
+    #  xtermwin.resize(100, 100, true)
+    #===Remarks
+    #This has no effect on maximized winwows.
+    def resize(width, height, use_hints = false, sync = true)
+      err = ""
+      opts = []
+      opts << "--usehints" if use_hints
+      opts << "--sync" if sync
+      Open3.popen3("#{XDo::XDOTOOL} windowsize #{opts.join(" ")} #{@id} #{width} #{height}"){|stdin, stdout, stderr| err << stderr.read}
+      Kernel.raise(XDo::XError, err) unless err.empty?
+    end
+    
+    #Moves a window. +xdotool+ is not really exact with the coordinates,
+    #special windows like Ubuntu's panels make it placing wrong. 
+    #===Parameters
+    #[+x+] The goal X coordinate.
+    #[+y+] The goal Y coordinate.
+    #[+sync+] (true) If true, this method blocks until the window has finished moving. 
+    #===Return value
+    #Undefined.
+    #===Raises
+    #[XError] Error executing +xdotool+.
+    #===Example
+    #  xwin.move(100, 100)
+    #  p xwin.abs_position #=> [101, 101]
+    def move(x, y, sync = true)
+      err = ""
+      opts = []
+      opts << "--sync" if sync
+      Open3.popen3("#{XDo::XDOTOOL} windowmove #{opts.join(" ")} #{@id} #{x} #{y}"){|stdin, stdout, stderr| err << stderr.read}
+      Kernel.raise(XDo::XError, err) unless err.empty?
+    end
+    
+    #Set the input focus to the window (but don't bring it to the front).
+    #===Parameters
+    #[+sync+] (true) If true, this method blocks until the window got the input focus. 
+    #===Return value
+    #Undefined.
+    #===Raises
+    #[XError] Error invoking +xdotool+.
+    #===Example
+    #  xwin.focus
+    #===Remarks
+    #This method may not work on every window manager. You should use
+    ##activate, which is supported by more window managers.
+    def focus(sync = true)
+      err = ""
+      opts = []
+      opts << "--sync" if sync
+      Open3.popen3("#{XDo::XDOTOOL} windowfocus #{opts.join(" ")} #{@id}"){|stdin, stdout, stderr| err << stderr.read}
+      Kernel.raise(XDo::XError, err) unless err.empty?
+    end
+    
+    #The window loses the input focus by setting it to an invalid window.
+    #Parameters
+    #[+sync+] (true) If true, this method blocks until the focus has been set to nothing. 
+    #===Return value
+    #Undefined.
+    #===Example
+    #  xwin.focus
+    #  xwin.unfocus    
+    def unfocus(sync = true)
+      XDo::XWindow.unfocus(sync)
+    end
+    
+    #Maps a window to the screen (makes it visible).
+    #===Parameters
+    #[+sync+] (true) If true, this method blocks until the window has been mapped. 
+    #===Return value
+    #Undefined.
+    #===Raises
+    #[XError] Error invoking +xdotool+.
+    #===Example
+    #  xwin.unmap #Windows are usually mapped
+    #  xwin.map
+    def map(sync = true)
+      err = ""
+      opts = []
+      opts << "--sync" if sync
+      Open3.popen3("#{XDo::XDOTOOL} windowmap #{opts.join(" ")} #{@id}"){|stdin, stdout, stderr| err << stderr.read}
+      Kernel.raise(XDo::XError, err) unless err.empty?
+    end
+    
+    #Unmap a window from the screen (make it invisible).
+    #===Parameters
+    #[+sync+] (true) If true, this method blocks until the window has been unmapped. 
+    #===Return value
+    #Undefined.
+    #===Raises
+    #[XError] Error executing +xdotool+.
+    #===Example
+    #  xwin.unmap
+    def unmap(sync = true)
+      err = ""
+      opts = []
+      opts << "--sync" if sync
+      Open3.popen3("#{XDo::XDOTOOL} windowunmap #{opts.join(" ")} #{@id}"){|stdin, stdout, stderr| err << stderr.read}
+      Kernel.raise(XDo::XError, err) unless err.empty?
+    end
+    
+    #Bring a window to the front (but don't give it the input focus).
+    #Not implemented in all window managers.
+    #===Return value
+    #Undefined.
+    #===Raises
+    #[XError] Error executing +xdotool+.
+    #===Example
+    #  xwin.raise
+    def raise
+      err = ""
+      Open3.popen3("#{XDo::XDOTOOL} windowraise #{@id}"){|stdin, stdout, stderr| err << stderr.read}
+      Kernel.raise(XDo::XError, err) unless err.empty?
+    end
+    
+    #Activate a window. That is, bring it to top and give it the input focus.
+    #===Parameters
+    #[+sync+] (true) If true, this method blocks until the window has been activated. 
+    #===Return value
+    #Undefined.
+    #===Raises
+    #[XError] Error executing +xdotool+.
+    #===Example
+    #  xwin.activate
+    #===Remarks
+    #This is the recommanded method to give a window the input focus, since
+    #it works on more window managers than #focus and also works across
+    #desktops.
+    #
+    #Part of the EWMH standard ACTIVE_WINDOW.
+    def activate(sync = true)
+      tried_focus = false
+      begin
+        err = ""
+        opts = []
+        opts << "--sync" if sync
+        Open3.popen3("#{XDo::XDOTOOL} windowactivate #{opts.join(" ")} #{@id}"){|stdin, stdout, stderr| err << stderr.read}
+        Kernel.raise(XDo::XError, err) unless err.empty?
+      rescue XDo::XError
+        #If no window is active, xdotool's windowactivate fails, 
+        #because it tries to determine which is the currently active window. 
+        unless tried_focus
+          tried_focus = true
+          focus
+          retry
+        else
+          raise
+        end
+      end
+    end
+    
+    #Move a window to a desktop.
+    #===Parameters
+    #[+num+] The 0-based index of the desktop you want the window to move to.
+    #===Return value
+    #Undefined.
+    #===Raises
+    #[XError] Error executing +xdotool+.
+    #===Example
+    #  xwin.desktop = 3
+    #===Remarks
+    #Although Ubuntu systems seem to have several desktops, that isn't completely true. An usual Ubuntu system only
+    #has a single working desktop, on which Ubuntu sets up an arbitrary number of other "desktop views" (usually 4).
+    #That's kind of cheating, but I have not yet find out why it is like that. Maybe it's due to the nice cube rotating effect?
+    #That's the reason, why the desktop-related methods don't work with Ubuntu.
+    #
+    #Part of the EWMH standard CURRENT_DESKTOP.
+    def desktop=(num)
+      err = ""
+      Open3.popen3("#{XDo::XDOTOOL} set_desktop_for_window #{@id} #{num}"){|stdin, stdout, stderr| err << stderr.read}
+      Kernel.raise(XDo::XError, err) unless err.empty?
+    end
+    
+    #Get the desktop the window is on.
+    #===Return value
+    #The 0-based index of the desktop this window resides on.
+    #===Raises
+    #[XError] Error executing +xdotool+.
+    #===Example
+    #  p xwin.desktop #=> 0
+    #===Remarks
+    #Although Ubuntu systems seem to have several desktops, that isn't completely true. An usual Ubuntu system only
+    #has a single working desktop, on which Ubuntu sets up an arbitrary number of other "desktop views" (usually 4).
+    #That's kind of cheating, but I have not yet find out why it is like that. Maybe it's due to the nice cube rotating effect?
+    #That's the reason, why the desktop-related methods don't work with Ubuntu.
+    #
+    #Part of the EWMH standard CURRENT_DESKTOP.
+    def desktop
+      err = ""
+      out = ""
+      Open3.popen3("#{XDo::XDOTOOL} get_desktop_for_window #{@id}"){|stdin, stdout, stderr| out = stdout.read; err << stderr.read}
+      Kernel.raise(XDo::XError, err) unless err.empty?
+      Integer(out)
+    end
+    
+    #The title of the window or nil if it doesn't have a title.
+    #===Return value
+    #The window's title, encoded as UTF-8, or nil if the window doesn't have a title.
+    #===Raises
+    #[XError] Error executing +xwininfo+.
+    #===Example
+    #  p xwin.title #=> "xwindow.rb SciTE"
+    def title
+      err = ""
+      out = ""
+      if @id == XWindow.root_id #This is the root window
+        return "(the root window)"
+      elsif @id.zero?
+        return "(NULL window)"
+      else
+        Open3.popen3("#{XDo::XWININFO} -id #{@id}"){|stdin, stdout, stderr| out << stdout.read; err << stderr.read}
+      end
+      Kernel.raise(XDo::XError, err) unless err.empty?
+      title = out.strip.lines.to_a[0].match(/"(.*)"/)[1] rescue Kernel.raise(XDo::XError, "No window with ID #{@id} found!")
+      return title #Kann auch nil sein, dann ist das Fenster namenlos.
+    end
+    
+    #The absolute position of the window on the screen.
+    #===Return value
+    #A two-element array of form <tt>[x, y]</tt>.
+    #===Raises
+    #[XError] Error executing +xwininfo+.
+    #===Example
+    #  p xwin.abs_position #=> [0, 51]
+    def abs_position
+      out = ""
+      err = ""
+      Open3.popen3("#{XDo::XWININFO} -id #{@id}"){|stdin, stdout, stderr| out << stdout.read; err << stderr.read}
+      Kernel.raise(XDo::XError, err) unless err.empty?
+      out = out.strip.lines.to_a
+      x = out[2].match(/:\s+(\d+)/)[1]
+      y = out[3].match(/:\s+(\d+)/)[1]
+      [x.to_i, y.to_i]
+    end
+    alias position abs_position
+    
+    #The position of the window relative to it's parent window.
+    #===Return value
+    #A two-element array of form <tt>[x, y]</tt>.
+    #===Raises
+    #[XError] Error executing +xdotool+.
+    #===Example
+    #  p xwin.rel_position => [0, 51]
+    def rel_position
+      out = ""
+      err = ""
+      Open3.popen3("#{XDo::XWININFO} -id #{@id}"){|stdin, stdout, stderr| out << stdout.read; err << stderr.read}
+      Kernel.raise(XDo::XError, err) unless err.empty?
+      out = out.strip.lines.to_a
+      x = out[4].match(/:\s+(\d+)/)[1]
+      y = out[5].match(/:\s+(\d+)/)[1]
+      [x.to_i, y.to_i]
+    end
+    
+    #The size of the window.
+    #===Return value
+    #A two-element array of form <tt>[width, height]</tt>.
+    #===Raises
+    #[XError] Error executing +xwininfo+.
+    #===Example
+    #  p xwin.size #=> [1280, 948]
+    def size
+      out = ""
+      err = ""
+      Open3.popen3("#{XDo::XWININFO} -id #{@id}"){|stdin, stdout, stderr| out << stdout.read; err << stderr.read}
+      out = out.strip.lines.to_a
+      Kernel.raise(XDo::XError, err) unless err.empty?
+      width = out[6].match(/:\s+(\d+)/)[1]
+      height = out[7].match(/:\s+(\d+)/)[1]
+      [width.to_i, height.to_i]
+    end
+    
+    #true if the window is mapped to the screen.
+    #===Return value
+    #nil if the window is not mapped, an integer value otherwise.
+    #===Raises
+    #[XError] Error executing +xwininfo+.
+    #===Example
+    #  p xwin.visible? #=> 470
+    #  xwin.unmap
+    #  p xwin.visible? #=> nil
+    def visible?
+      err = ""
+      out = ""
+      Open3.popen3("#{XDo::XWININFO} -id #{@id}"){|stdin, stdout, stderr| out << stdout.read; err << stderr.read}
+      out = out.strip
+      Kernel.raise(XDo::XError, err) unless err.empty?
+      return out =~ /IsViewable/
+    end
+    
+    #Returns true if the window exists.
+    #===Return value
+    #true or false.
+    #===Example
+    #  p xwin.exists? #=> true
+    def exists?
+      XDo::XWindow.id_exists?(@id)
+    end
+    
+    #Closes a window by activating it and then sending [ALT] + [F4].
+    #===Return value
+    #nil.
+    #===Raises
+    #[NotImplementedError] You didn't require "xdo/keyboard".
+    #===Example
+    #  xwin.close
+    #===Remarks
+    #A program could ask to save data.
+    #
+    #Use #kill! to kill the process running the window.
+    #
+    #Available after requireing "xdo/keyboard".
+    def close
+      Kernel.raise(NotImplementedError, "You have to require 'xdo/keyboard' before you can use #{__method__}!") unless defined? XDo::Keyboard
+      activate
+      XDo::Keyboard.char("Alt+F4")
+      sleep 0.5
+      nil
+    end
+    
+    #More aggressive variant of #close. Think of +close!+ as
+    #the middle between #close and #kill!. It first tries
+    #to close the window by calling #close and if that
+    #does not succeed (within +timeout+ seconds), it will call #kill!.
+    #===Paramters
+    #[+timeout+] (2) The time to wait before using #kill!, in seconds.
+    #===Return value
+    #Undefined.
+    #===Raises
+    #[XError] Error executing +xkill+.
+    #===Example
+    #  xwin.close!
+    #===Remarks
+    #Available after requireing "xdo/keyboard".
+    def close!(timeout = 2)
+      Kernel.raise(NotImplementedError, "You have to require 'xdo/keyboard' before you can use #{__method__}!") unless defined? XDo::Keyboard
+      #Try to close normally
+      close
+      #Check if it's deleted
+      if exists?
+        #If not, wait some seconds and then check again
+        sleep timeout
+        if exists?
+          #If it's not deleted after some time, force it to close.
+          kill!
+        end
+      end
+    end
+    
+    #Kills the process that runs a window. The window will be
+    #terminated immediatly, if that isn't what you want, have
+    #a look at #close.
+    #===Return value
+    #nil.
+    #===Raises
+    #[XError] Error executing +xkill+.
+    #===Example
+    #  xwin.kill!
+    def kill!
+      out = ""
+      err = ""
+      Open3.popen3("#{XDo::XKILL} -id #{@id}"){|stdin, stdout, stderr| out << stdout.read; err << stderr.read}
+      Kernel.raise(XDo::XError, err) unless err.empty?
+      nil
+    end
+    
+    #Returns the window's internal ID.
+    #===Return value
+    #An integer describing the window's internal ID.
+    #===Example
+    #  p xwin.to_i #=> 29361095
+    def to_i
+      @id
+    end
+    
+    #Returns a window's title.
+    #===Return value
+    #The window's title.
+    #===Example
+    #  p xwin.to_s #=> "xwindow.rb * SciTE"
+    def to_s
+      title
+    end
+    
+    #true if the internal ID is zero.
+    #===Return value
+    #true or false.
+    #===Example
+    #  p xwin.zero? #=> false
+    def zero?
+      @id.zero?
+    end
+    
+    #true if the internal ID is not zero.
+    #===Return value
+    #nil or the internal ID.
+    #===Example
+    #  p xwin.nonzero? #=> 29361095
+    def nonzero?
+      @id.nonzero?
+    end
+    
+    [:"name=", :"icon_name=", :"classname="].each do |sym|
+      define_method(sym) do |str|
+        set_window(sym.to_s[0..-2].gsub("_", "-"), str.encode("UTF-8"))
+        str
+      end
+    end
+    alias title= name=
+    alias icon_title= icon_name=
+    
+    private
+    
+    #Calls +xdotool+'s set_window command with the given options.
+    def set_window(option, value)
+      err = ""
+      Open3.popen3("#{XDOTOOL} set_window --#{option} '#{value}' #{@id}"){|stdin, stdout, stderr| err << stderr.read}
+      Kernel.raise(XDo::XError, err) unless err.empty?
+    end
+    
+  end
+  
+end
 
=== renamed file 'tests/run-with-xvfb.sh' => 'tests/misc/run-with-xvfb.sh'
=== renamed file 'tests/unitytestmacro.h' => 'tests/misc/unitytestmacro.h'
=== added directory 'tests/other'
=== added directory 'tests/panel'
=== added directory 'tests/places'
=== added file 'tests/run-tests.rb'
--- tests/run-tests.rb	1970-01-01 00:00:00 +0000
+++ tests/run-tests.rb	2011-12-15 16:55:31 +0000
@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby1.8
+=begin
+/*
+ * This file is part of unity-2d
+ *
+ * Copyright 2011 Canonical Ltd.
+ *
+ * Authors:
+ * - Gerry Boland <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+=end
+
+# Testability test suite execution script
+# 
+# Run all tests with
+#   $ ruby run-tests.rb
+
+# Check script being run by Ruby 1.8.x, later versions not supported by TDriver
+abort("Aborted! Ruby 1.9 not supported, use 1.8") unless RUBY_VERSION < '1.9'
+
+# Add ./misc/lib to the list of library locations - need to calculate absolute path
+require 'pathname'
+$library_path = File.expand_path(File.dirname(__FILE__)) + '/misc/lib'
+$LOAD_PATH.unshift $library_path
+
+# If cmake was called, obtain the path to the built binary directory. If not, we test the
+# installed applications instead
+binary_dir_file = $library_path + '/../binary_dir.txt'
+if File.exists?(binary_dir_file)
+    binary_dir = File.open(binary_dir_file).first.strip
+    puts 'Running tests on applications contained within ' + binary_dir
+    UNITY_2D_LAUNCHER = binary_dir + '/launcher/app/unity-2d-launcher'
+    UNITY_2D_PANEL = binary_dir + '/panel/app/unity-2d-panel'
+    UNITY_2D_PLACES = binary_dir + '/places/app/unity-2d-places'
+    UNITY_2D_SPREAD = binary_dir + '/spread/app/unity-2d-spread'
+else
+    puts 'NOTICE: source not configured, tests will be carried out on *installed* applications!'
+    UNITY_2D_LAUNCHER = 'unity-2d-launcher'
+    UNITY_2D_PANEL = 'unity-2d-panel'
+    UNITY_2D_PLACES = 'unity-2d-places'
+    UNITY_2D_SPREAD = 'unity-2d-spread'
+end
+
+# The following line includes the complete tdriver environment 
+require 'tdriver'
+include TDriverVerify
+
+# Require unit test framework: This enables execution of test cases and also includes assertions (Test::Unit::Assertions)
+require 'testhelper'
+
+# List of directories in which to search for test cases
+test_directories = ['launcher', 'panel', 'places', 'spread', 'window-manager', 'other']
+
+# Only run scan for tests if this script is directly called
+if __FILE__ == $0
+    $INIT_COMPLETED = true # Prevent this file being included by test cases
+
+    # Scan through the above directories and execute test cases contained.
+    test_directories.each do | directory |
+        Dir["#{directory}/*.rb"].each { |testCase| require testCase}
+    end
+end
 
=== added directory 'tests/spread'
=== added directory 'tests/window-manager'