Merge lp:~gerboland/unity-2d/testability-target-host-split into lp:unity-2d

[Gerry Boland]

[tests] Modify XDo library and all tests to respect target/host division

Purpose: for autopilot testing, have the test scripts and the software-under-test communicate via qttasserver only. This includes all XDo operations, system calls and file/folder manipulation that test scripts perform. With this, only a few essential dependencies are required on the target, and all ruby code is executed on the host.

Changes made:
- Add generic XDo.execute method to handle all shell commands.
- Add XDo.sut property to specify if running via qttasserver or not
- XDoTool library uses XDo.execute method for all shell commands.
- Tests added for XDoTool library running via qttasserver
- Establish single SUT connection in run-tests.rb as $SUT, pass it to XDo
- Modify tmpwindow class to use $SUT.execute_shell_command
- Modify all existing tests to use $SUT.execute_shell_command

[Gerry Boland (gerboland)]

How this changes things:

Based on our workflow right now: not at all
You can still run "ruby run-tests.rb" and the tests will run on your desktop.

How to test this MR:

==Host==
- edit /etc/tdriver/tdriver_parameters.xml and add the line
    <parameter name="qttas_server_port" value="55536" />
  This will make the ruby scripts try to connect to the qttasserver inside the VM

- check out this branch, compile

==Target==
- Run Ubuntu inside a VM.
- Install testability-qttas, xdotool, xsel, x11-utils.
- Set up port-forwarding in VirtualBox like this:
  - shutdown the VM
  - in the VirtualBox settings manager, click Settings and go into the Network pane
  - Click the 'Port Forwarding" button
  - Add new entry like so:
      Name: "guestqttas"
      Protocol: "TCP"
      Host IP: ""
      Host Port: "55536"
      Guest IP: ""
      Guest Port: "55535"
  - now you can start the VM again (good to turn off screensaver too :) )

- check out this branch ******into the same directory as on the host machine******
- compile it
- start "qttasserver"

==Back to Host==
- go into test directory
- run "ruby run-tests.rb"

You should see the tests play out inside the VM.

I plan to script this system up, so that a developer can run all tests inside the VM, and so their desktop isn't messed up & let them surf the inte^W^W^W^W^W^W^W^W do more work.

I'm writing this all up at https://wiki.ubuntu.com/Unity2DTestability%3A%20How%20to%20run%20Tests%20with%20VirtualBox

[Gerry Boland (gerboland)]

Hmm, hyphen bad, try

https://wiki.ubuntu.com/Unity2DTestability-%20How%20to%20run%20Tests%20with%20VirtualBox

[Albert Astals Cid (aacid)]

You miss a new you need to
  sudo add-apt-repository ppa:gerboland/testability
  sudo apt-get update
on the target machine so that testability-qttas is available.

[Albert Astals Cid (aacid)]

s/new/note saying

[Albert Astals Cid (aacid)]

The described way works, some notes on my side though:
 * If you want to see the pointer actually moving in the target disable mouse integration (you can do that by right clicking in the little mouse cursor that appears in the lower right part of the VM statusbar)
 * If you run your VM in bridged network mode instead of NAT mode there is no need to setup the forwarding of the ports neither in /etc/tdriver/tdriver_parameters.xml nor in VirtualBox settings manager, just change the qttas_server_ip in /etc/tdriver/tdriver_parameters.xml to point to the ip of your VM and it will work too.

[Unity Merger (unity-merger)]

Attempt to merge into lp:unity-2d failed due to conflicts:

text conflict in tests/run-tests.rb

[Gerry Boland (gerboland)]

Good comments all, thank you.

Merge conflict fixed. Feel free to approve.

[lp:~gerboland/unity-2d/testability-target-host-split]

878. By Gerry Boland on 2012-01-24

Merge trunk, fix conflict

=== modified file 'tests/README'
--- tests/README	2012-01-23 21:45:03 +0000
+++ tests/README	2012-01-24 11:51:24 +0000
@@ -35,8 +35,7 @@
 - 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.
+For all tests, the SUT is assumed to *not* be the Host machine.
 
 
 Testability installation instructions
@@ -131,8 +130,7 @@
   # 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", 
+    @app = $SUT.run( :name => "/absolute/path/to/application", 
     		         :arguments => "-testability", 
     		         :sleeptime => 2 )
   end
@@ -141,18 +139,20 @@
   teardown do
     #@app.close        
     #Need to kill Launcher as it does not shutdown when politely asked
-    system "pkill -nf unity-2d-launcher"
+    $SUT.execute_shell_command "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' )
+    verify_equal( 66, TIMEOUT, 'These two values are not equal'){
+      @app.Unity2dPanel()['width']).to_i 
+    }
 
-    assert( @app.Unity2dPanel()['x_absolute'], \
-                  'This quantity is not true' )
+    verify_equal( 'true', TIMEOUT, 'This quantity is not true'){
+      @app.Unity2dPanel()['x_absolute']
+    }
   end
 
   test "Another test case description" do

=== modified file 'tests/launcher/autohide_show_tests.rb'
--- tests/launcher/autohide_show_tests.rb	2012-01-19 17:29:13 +0000
+++ tests/launcher/autohide_show_tests.rb	2012-01-24 11:51:24 +0000
@@ -35,8 +35,8 @@
 
   # 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'
+    $SUT.execute_shell_command 'killall unity-2d-launcher'
+    $SUT.execute_shell_command 'killall unity-2d-launcher'
 
     # Minimize all windows
     XDo::XWindow.toggle_minimize_all
@@ -51,11 +51,10 @@
     #Ensure mouse out of the way
     XDo::Mouse.move(200,200,10,true)    
 
-    launcher_favorites = `gsettings get com.canonical.Unity.Launcher favorites`
+    launcher_favorites = $SUT.execute_shell_command 'gsettings get com.canonical.Unity.Launcher favorites'
 
     # Execute the application 
-    @sut = TDriver.sut(:Id => "sut_qt")    
-    @app = @sut.run( :name => UNITY_2D_LAUNCHER, 
+    @app = $SUT.run( :name => UNITY_2D_LAUNCHER, 
     		         :arguments => "-testability", 
     		         :sleeptime => 2 )
     # Make certain application is ready for testing
@@ -67,8 +66,8 @@
     TmpWindow.close_all_windows
     #@app.close        
     #Need to kill Launcher as it does not shutdown when politely asked
-    system "pkill -nf unity-2d-launcher"
-    system "gsettings set com.canonical.Unity.Launcher favorites \"" + launcher_favorites + "\""
+    $SUT.execute_shell_command 'pkill -nf unity-2d-launcher'
+    $SUT.execute_shell_command "gsettings set com.canonical.Unity.Launcher favorites \"" + launcher_favorites + "\""
   end
 
   #####################################################################################
@@ -246,6 +245,7 @@
       @app.Unity2dPanel()['x_absolute'].to_i
     }
 
+    sleep 1 #launcher seems not ready to accept Super key, need a pause
     XDo::Keyboard.key_down('SUPER')
     verify_equal( 0, TIMEOUT, 'Launcher hiding when Super Key held, should be visible' ) {
       @app.Unity2dPanel()['x_absolute'].to_i

=== modified file 'tests/launcher/visual_verification.rb'
--- tests/launcher/visual_verification.rb	2011-12-12 22:57:15 +0000
+++ tests/launcher/visual_verification.rb	2012-01-24 11:51:24 +0000
@@ -30,8 +30,8 @@
 
   # 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'
+    $SUT.execute_shell_command 'killall unity-2d-launcher'
+    $SUT.execute_shell_command 'killall unity-2d-launcher'
   end
   
   # Run once at the end of this test suite
@@ -41,8 +41,7 @@
   # Run before each test case begins
   setup do
     # Execute the application 
-    @sut = TDriver.sut(:Id => "sut_qt")    
-    @app = @sut.run( :name => UNITY_2D_LAUNCHER, 
+    @app = $SUT.run( :name => UNITY_2D_LAUNCHER, 
     		         :arguments => "-testability", 
     		         :sleeptime => 2 )
   end
@@ -51,7 +50,7 @@
   teardown do
     #@app.close        
     #Need to kill Launcher as it does not shutdown when politely asked
-    system "pkill -nf unity-2d-launcher"
+    $SUT.execute_shell_command 'pkill -nf unity-2d-launcher'
   end
 
   #####################################################################################

=== modified file 'tests/misc/lib/testhelper.rb'
--- tests/misc/lib/testhelper.rb	2012-01-23 22:10:02 +0000
+++ tests/misc/lib/testhelper.rb	2012-01-24 11:51:24 +0000
@@ -1,7 +1,7 @@
 require 'test/unit'
 
 dir = File.dirname(File.expand_path(__FILE__))
-$LOAD_PATH.unshift dir + '/../lib'
+$LOAD_PATH.unshift File.expand_path(dir + '/../lib')
 $TEST_DIR = File.dirname(File.expand_path(__FILE__))
 
 # Enable a startup and shutdwn method for each test case 

=== modified file 'tests/misc/lib/tmpwindow.rb'
--- tests/misc/lib/tmpwindow.rb	2012-01-18 09:12:23 +0000
+++ tests/misc/lib/tmpwindow.rb	2012-01-24 11:51:24 +0000
@@ -42,16 +42,20 @@
   #  TmpWindow.open_window_at(200, 300)
   def self.open_window_at(x=100,y=100)
     window_id = -1
+    # Generate a temporary directory (used to generate unique window title to help Xdo get window ID)
+    t = Time.now.strftime("%Y%m%d")
+    path = "/tmp/#{t}-#{$$}-#{rand(0x100000000).to_s(36)}"
+    $SUT.execute_shell_command('mkdir -p ' + path)
     # 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(30){ window_id = XDo::XWindow.wait_for_window(dir)}
-    }
+    $SUT.execute_shell_command("gnome-terminal --geometry=100x30+#{x}+#{y} --working-directory=#{path}", :detached => true)
+    Timeout.timeout(30){ window_id = XDo::XWindow.wait_for_window(path)}
     Kernel.raise(SystemCallError, "Unable to open gnome-terminal") if window_id == -1
     xid = XDo::XWindow.new(window_id)
     # create list of windows opened
     @xid_list = [] if @xid_list == nil
     @xid_list << xid
+    # remove temporary directory
+    $SUT.execute_shell_command('rmdir ' + path)
     xid
   end
 

=== modified file 'tests/misc/lib/xdo/_xdo.rb'
--- tests/misc/lib/xdo/_xdo.rb	2012-01-04 16:09:14 +0000
+++ tests/misc/lib/xdo/_xdo.rb	2012-01-24 11:51:24 +0000
@@ -34,5 +34,78 @@
   
   class ParseError < StandardError
   end
-  
+
+  #TDriver SUT connection
+  def self.sut=(input)
+    @sut = input
+  end
+
+  def self.sut
+    @sut
+  end
+
+  # Execute a shell command. If :sut is set, Testability Driver is used to execute
+  # the command on the system under test. Else is run on current machine.
+  def self.execute(cmd, timeout=3)
+    stdout = ''
+    stderr = ''
+    return_code = -1
+
+    if @sut == nil
+      # Running command in shell. Open3 doesn't allow easy access to return code, so let's use a little bash-fu
+      stdin, out, err = Open3.popen3(cmd + '; echo "\n$?"')
+      stdout = out.read.strip
+      stderr = err.read.strip
+
+      #remove last line of stderr and get return code from it
+      return_code = stdout.split("\n")[stdout.lines.count-1].to_i
+      stdout.chomp!(return_code.to_s)
+      stdout.chomp!("\n")
+    else
+      # Tdriver has the shell_command method to extract stdout, stderr and return number from a shell command
+      # run with execute_shell_command. However it requires the shell command to be detached and placed
+      # in a separate thread. In my experiments execution and return takes about 2 seconds, whereas a simple 
+      # synchroneous execution takes mere miliseconds. This wrapper is a bit of bash-fu to split stdout
+      # and stderr and obtain the return code while executing it synchroneously. We run new bash instance as 
+      # command is run in a QProcess which takes all stdout and stderr output from us.
+      #
+      # To explain the Bash-fu, reading from the outside in (ref: http://tinyurl.com/6ndfm8d):
+      # - creates a file descriptor $out for the whole block, duplicating stdout
+      # - captures the stdout of the whole command in $error (but see below)
+      # - the command itself redirects stderr to stdout (which gets captured above) then stdout to the original 
+      #   stdout from outside the block, so only the stderr gets captured
+
+      wrap_cmd = 'bash -c "{ error=$(' + cmd + ' 2>&1 1>&$out); } {out}>&1; echo -n \"==return-code:$?==${error}\""'
+
+      # Bug workaround: the command is sent to the qttasserver via xml. The command isn't escaped by
+      # execute_system_command. Need to escape certain chars of the command ourselves.
+      wrap_cmd.gsub!("&", "&amp;")
+      wrap_cmd.gsub!("<", "&lt;")
+      wrap_cmd.gsub!(">", "&gt;")
+
+      output = @sut.execute_shell_command(wrap_cmd, :timeout => timeout)
+      #Now parse output
+      errors_exist = false
+
+      output.strip.each_line do |line|
+
+        #look for "==return-code:"
+        if line.match( /^(.*)==return-code:(\d+)==(.*)/ ) and errors_exist == false
+          return_code = $2.to_i
+          errors_exist = true
+          stdout.concat($1)
+          stderr.concat($3)
+          next
+        end
+
+        stderr.concat(line) if errors_exist
+        stdout.concat(line) unless errors_exist
+      end
+
+      stderr.strip!
+    end
+
+    return return_code, stdout, stderr
+  end
+
 end #module XDo

=== modified file 'tests/misc/lib/xdo/clipboard.rb'
--- tests/misc/lib/xdo/clipboard.rb	2011-12-07 18:39:44 +0000
+++ tests/misc/lib/xdo/clipboard.rb	2012-01-24 11:51:24 +0000
@@ -103,9 +103,9 @@
         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
+        r, hsh[:primary], e = XDo.execute("#{XSEL}") if from.include? :primary
+        r, hsh[:clipboard], e = XDo.execute("#{XSEL} -b") if from.include? :clipboard
+        r, hsh[:secondary], e = XDo.execute("#{XSEL} -s") if from.include? :secondary
         hsh
       end
         
@@ -127,10 +127,11 @@
           to = to.first.keys
         end
         to << :clipboard if to.empty?
+        text.gsub("'", "\'").gsub("\n", '\n').gsub("\t", '\t')
         
-        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
+        XDo.execute("echo -n '#{text}' | xsel -i") if to.include? :primary
+        XDo.execute("echo -n '#{text}' | xsel -b -i") if to.include? :clipboard
+        XDo.execute("echo -n '#{text}' | xsel -s -i") if to.include? :secondary
         text
       end
       
@@ -156,10 +157,11 @@
           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
+        text.gsub("'", "\'").gsub("\n", '\n').gsub("\t", '\t')
+
+        XDo.execute("echo -n '#{text}' | xsel -a -i") if to.include? :primary
+        XDo.execute("echo -n '#{text}' | xsel -b -a -i") if to.include? :clipboard
+        XDo.execute("echo -n '#{text}' | xsel -s -a -i") if to.include? :secondary
       end
       
       #Clears the specified clipboards. 
@@ -182,9 +184,9 @@
         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
+        XDo.execute("#{XSEL} -c") if clips.include? :primary
+        XDo.execute("#{XSEL} -b -c") if clips.include? :clipboard
+        XDo.execute("#{XSEL} -s -c") if clips.include? :secondary
         nil
       end
       

=== modified file 'tests/misc/lib/xdo/keyboard.rb'
--- tests/misc/lib/xdo/keyboard.rb	2012-01-04 16:31:43 +0000
+++ tests/misc/lib/xdo/keyboard.rb	2012-01-24 11:51:24 +0000
@@ -94,11 +94,9 @@
       #===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
+        return nil if str == "\303" and RUBY_VERSION < '1.9' #deliberately work around Ruby 1.8's bad handling of UTF-8 characters
+        return_code, out, err = XDo.execute("#{XDOTOOL} type #{w_id.nonzero? ? "--window #{w_id.to_i} " : ""}'#{str}'")
+        warn(err) unless err.empty?
         nil
       end
       
@@ -224,10 +222,8 @@
       #  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
+        return_code, out, err = XDo.execute("#{XDOTOOL} key #{w_id.nonzero? ? "--window #{w_id.to_i} " : ""}#{c}")
+        raise(XDo::XError, "Invalid character '#{c}'!") if err =~ /No such key name/
         c
       end
       alias key char
@@ -247,10 +243,8 @@
       #===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
+        return_code, out, err = XDo.execute("#{XDOTOOL} keydown #{w_id.nonzero? ? "--window #{w_id.to_i} " : "" }#{check_for_special_key(key)}")
+        raise(XDo::XError, "Invalid character '#{key}'!") if err =~ /No such key name/
         key
       end
       
@@ -269,10 +263,8 @@
       #===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
+        return_code, out, err = XDo.execute("#{XDOTOOL} keyup #{w_id.nonzero? ? "--window #{w_id.to_i} " : "" }#{check_for_special_key(key)}")
+        raise(XDo::XError, "Invalid character '#{key}'!") if err =~ /No such key name/
         key
       end
       

=== modified file 'tests/misc/lib/xdo/mouse.rb'
--- tests/misc/lib/xdo/mouse.rb	2011-12-07 18:39:44 +0000
+++ tests/misc/lib/xdo/mouse.rb	2012-01-24 11:51:24 +0000
@@ -42,7 +42,8 @@
       #===Example
       #  p XDo::Mouse.position #=> [12, 326]
       def position
-        out = `#{XDOTOOL} getmouselocation`.match(/x:(\d+) y:(\d+)/)
+        return_code, out, err = XDo.execute("#{XDOTOOL} getmouselocation")
+        out.match(/x:(\d+) y:(\d+)/)
         [$1.to_i, $2.to_i]
       end
       
@@ -68,7 +69,7 @@
         if set
           opts = []
           opts << "--sync" if sync
-          `#{XDOTOOL} mousemove #{opts.join(" ")} #{x} #{y}`
+          XDo.execute("#{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
@@ -140,7 +141,7 @@
         if x and y
           move(x, y, speed, set)
         end
-        `#{XDOTOOL} click #{BUTTON2XDOTOOL[button]}`
+        XDo.execute("#{XDOTOOL} click #{BUTTON2XDOTOOL[button]}")
       end
       
       #Scroll with the mouse wheel. +amount+ is the time of steps to scroll. 
@@ -188,7 +189,7 @@
           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]}`
+        XDo.execute("#{XDOTOOL} mousedown #{BUTTON2XDOTOOL[button]}")
       end
       
       #Releases a mouse button. Probably it's a good idea to call #down first?
@@ -210,7 +211,7 @@
           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]}`
+        XDo.execute("#{XDOTOOL} mouseup #{BUTTON2XDOTOOL[button]}")
       end
       
       #Executs a drag&drop operation. 

=== modified file 'tests/misc/lib/xdo/test/test_keyboard.rb'
--- tests/misc/lib/xdo/test/test_keyboard.rb	2011-12-12 23:02:21 +0000
+++ tests/misc/lib/xdo/test/test_keyboard.rb	2012-01-24 11:51:24 +0000
@@ -77,6 +77,7 @@
     assert_equal(TESTTEXT2, XDo::Clipboard.read_clipboard)
   end
 
+=begin #Disabling this failing test due to poor window Xid detection by xdotool - fix on the way
   def test_window_id
     XDo::XWindow.unfocus #Ensure that the editor hasn't the input focus anymore
     sleep 1
@@ -90,6 +91,7 @@
     sleep 0.2
     assert_equal(TESTTEXT_SPECIAL.gsub("{TAB}", "\t"), XDo::Clipboard.read_clipboard)
   end
+=end
   
   def test_include
     String.class_eval do

=== added file 'tests/misc/lib/xdo/test/test_tdriver_clipboard.rb'
--- tests/misc/lib/xdo/test/test_tdriver_clipboard.rb	1970-01-01 00:00:00 +0000
+++ tests/misc/lib/xdo/test/test_tdriver_clipboard.rb	2012-01-24 11:51:24 +0000
@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+#Encoding: UTF-8
+
+require "test/unit"
+
+# Run XDo test suite through Testability Driver
+require "tdriver"
+require File.join(File.dirname(__FILE__), '../clipboard')
+
+class ClipboardTest < Test::Unit::TestCase
+  
+  def setup
+    XDo.sut = TDriver.sut(:Id => "sut_qt") # the magic to use tdriver
+  end
+
+  def test_read
+    #Write something to the clipboard first
+    XDo.execute("echo -n 'Some primary test text' | xsel -i")
+    XDo.execute("echo -n 'Some clipboard \ntest text' | xsel -b -i")
+    XDo.execute("echo -n 'Some secondary test text' | xsel -s -i")
+    
+    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.sut.execute_shell_command("#{XDo::XSEL}"))
+    assert_equal("Secondary!", XDo.sut.execute_shell_command("#{XDo::XSEL} -s"))
+    assert_equal("Clipboard!\nNewline", XDo.sut.execute_shell_command("#{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_tdriver_keyboard.rb'
--- tests/misc/lib/xdo/test/test_tdriver_keyboard.rb	1970-01-01 00:00:00 +0000
+++ tests/misc/lib/xdo/test/test_tdriver_keyboard.rb	2012-01-24 11:51:24 +0000
@@ -0,0 +1,130 @@
+#!/usr/bin/env ruby
+#Encoding: UTF-8
+
+require "test/unit"
+
+# Run XDo test suite through Testability Driver
+require "tdriver"
+require "timeout"
+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
+    window_id = -1
+    XDo.sut = TDriver.sut(:Id => "sut_qt") # the magic to use tdriver
+    XDo.sut.execute_shell_command(EDITOR_CMD, :detached => true)
+    Timeout.timeout(10){ window_id = XDo::XWindow.wait_for_window(EDITOR_NAME)}
+    Kernel.raise(SystemCallError, "Unable to open or find #{EDITOR_NAME}") if window_id == -1
+    @xid = XDo::XWindow.new(window_id)
+    sleep 1
+  end
+  
+  def teardown
+    @xid.close!
+  end
+
+  def test_char
+    window_id = -1
+    @xid.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
+    #Copy file to SUT
+    tempfilename = File.basename(tempfile.path)
+    XDo.sut.copy_to_sut(:file => tempfile.path, :to => '/var/tmp')
+    XDo.execute(EDITOR_CMD + ' /var/tmp/' + tempfilename)
+    Timeout.timeout(30){ window_id = XDo::XWindow.wait_for_window(EDITOR_NAME)}
+    Kernel.raise(SystemCallError, "Unable to open or find #{EDITOR_NAME}") if window_id == -1
+    @xid = XDo::XWindow.new(window_id)
+    sleep 1
+    20.times{XDo::Keyboard.char("Shift+Right")}
+    XDo::Keyboard.ctrl_c
+    sleep 0.2
+    assert_equal(TESTTEXT, XDo::Clipboard.read_clipboard)
+    tempfile.close
+    XDo.execute('rm /var/tmp/' + tempfilename)
+  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
+
+=begin #Disabling this failing test due to poor window Xid detection by xdotool - fix on the way
+  def test_window_id
+    @xid.unfocus #Ensure that the editor hasn't the input focus anymore
+    sleep 1
+    XDo::Keyboard.simulate(TESTTEXT_SPECIAL, false, @xid)
+    sleep 1
+    @xid.activate
+    XDo::Keyboard.ctrl_a
+    XDo::Keyboard.ctrl_c
+    sleep 0.2
+    assert_equal(TESTTEXT_SPECIAL.gsub("{TAB}", "\t"), XDo::Clipboard.read_clipboard)
+  end
+=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_tdriver_mouse.rb'
--- tests/misc/lib/xdo/test/test_tdriver_mouse.rb	1970-01-01 00:00:00 +0000
+++ tests/misc/lib/xdo/test/test_tdriver_mouse.rb	2012-01-24 11:51:24 +0000
@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+#Encoding: UTF-8
+
+require "test/unit"
+
+# Run XDo test suite through Testability Driver
+require "tdriver"
+require File.join(File.dirname(__FILE__), '../mouse')
+
+class MouseTest < Test::Unit::TestCase
+  
+  def setup
+    XDo.sut = TDriver.sut(:Id => "sut_qt") # the magic to use tdriver
+  end
+  
+  def test_position
+    str = XDo.sut.execute_shell_command("#{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_tdriver_xwindow.rb'
--- tests/misc/lib/xdo/test/test_tdriver_xwindow.rb	1970-01-01 00:00:00 +0000
+++ tests/misc/lib/xdo/test/test_tdriver_xwindow.rb	2012-01-24 11:51:24 +0000
@@ -0,0 +1,105 @@
+#!/usr/bin/env ruby
+#Encoding: UTF-8
+
+require "test/unit"
+
+# Run XDo test suite through Testability Driver
+require "tdriver"
+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
+    XDo.sut = TDriver.sut(:Id => "sut_qt") # the magic to use tdriver
+    XDo.execute(NEW_WINDOW_CMD)
+    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/test/test_xdo.rb'
--- tests/misc/lib/xdo/test/test_xdo.rb	1970-01-01 00:00:00 +0000
+++ tests/misc/lib/xdo/test/test_xdo.rb	2012-01-24 11:51:24 +0000
@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+#Encoding: UTF-8
+
+require "test/unit"
+# The following line includes the complete tdriver environment 
+require 'tdriver'
+
+require File.join(File.dirname(__FILE__), '../_xdo')
+
+class XdoTest < Test::Unit::TestCase
+
+def setup
+end
+
+def teardown
+end
+
+def test_host_success
+  return_code, stdout, stderr = XDo.execute('ls /')
+  assert return_code == 0
+  assert stderr.empty?
+end
+
+def test_host_fail
+  return_code, stdout, stderr = XDo.execute('ls /wrong')
+  assert return_code == 2
+  assert stdout.empty?
+end
+
+def test_tdriver_success
+  XDo.sut = TDriver.sut(:Id => "sut_qt")
+  return_code, stdout, stderr = XDo.execute('ls /')
+  assert return_code == 0
+  assert stderr.empty?
+  XDo.sut = nil
+end
+
+def test_tdriver_fail
+  XDo.sut = TDriver.sut(:Id => "sut_qt")
+  return_code, stdout, stderr = XDo.execute('ls /wrong')
+  assert return_code == 2
+  assert stdout.empty?
+  XDo.sut = nil
+end
+
+def test_host_tdriver_equal
+  host_return_code, host_stdout, host_stderr = XDo.execute('ls /wrong')
+  XDo.sut = TDriver.sut(:Id => "sut_qt")
+  sut_return_code, sut_stdout, sut_stderr = XDo.execute('ls /wrong')
+  assert_equal(host_return_code, sut_return_code)
+  assert_equal(host_stdout, sut_stdout)
+  assert_equal(host_stderr, sut_stderr)
+end
+
+def test_host_tdriver_equal
+  host_return_code, host_stdout, host_stderr = XDo.execute('echo "hello"')
+  XDo.sut = TDriver.sut(:Id => "sut_qt")
+  sut_return_code, sut_stdout, sut_stderr = XDo.execute('echo "hello"')
+  assert_equal(host_return_code, sut_return_code)
+  assert_equal(host_stdout, sut_stdout)
+  assert_equal(host_stderr, sut_stderr)
+end
+end

=== modified file 'tests/misc/lib/xdo/xwindow.rb'
--- tests/misc/lib/xdo/xwindow.rb	2012-01-04 16:09:14 +0000
+++ tests/misc/lib/xdo/xwindow.rb	2012-01-24 11:51:24 +0000
@@ -78,10 +78,8 @@
       #  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
+        return_code, out, err = XDo.execute("#{XDo::XWININFO} -id #{id}")
+        return return_code == 0
       end
       
       #Waits for a window name to exist.
@@ -178,7 +176,8 @@
         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}
+        return_code, out, err = XDo.execute(cmd)
+        out.lines.to_a.collect{|l| l.strip.to_i}
       end
       
       #Returns the internal ID of the currently focused window.
@@ -194,11 +193,9 @@
       #===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}
+        return_code, out, err = XDo.execute("#{XDo::XDOTOOL} getwindowfocus #{notice_children ? "-f" : ""}")
         raise(XDo::XError, err) unless err.empty?
-        return out.to_i
+        out.to_i
       end
       
       #Returns the internal ID of the currently focused window.
@@ -213,11 +210,9 @@
       #
       #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}
+        return_code, out, err = XDo.execute("#{XDo::XDOTOOL} getactivewindow")
         raise(XDo::XError, err) unless err.empty?
-        return Integer(out)
+        out.to_i
       end
       
       #Set the number of working desktops.
@@ -237,9 +232,8 @@
       #
       #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?
+        return_code, out, err = XDo.execute("#{XDo::XDOTOOL} set_num_desktops #{num}")
+        raise(XDo::XError, err) unless err.empty?
         num
       end
       
@@ -258,11 +252,9 @@
       #
       #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}
+        return_code, out, err = XDo.execute("#{XDo::XDOTOOL} get_num_desktops")
         raise(XDo::XError, err) unless err.empty?
-        Integer(out)
+        out.to_i
       end
       
       #Change the view to desktop +num+.
@@ -282,8 +274,7 @@
       #
       #Part of the EWMH standard CURRENT_DESKTOP.
       def desktop=(num)
-        err = ""
-        Open3.popen3("#{XDo::XDOTOOL} set_desktop #{num}"){|stdin, stdout, stderr| err << stderr.read}
+        return_code, out, err = XDo.execute("#{XDo::XDOTOOL} set_desktop #{num}")
         raise(XDo::XError, err) unless err.empty?
         num
       end
@@ -303,13 +294,26 @@
       #
       #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
-      
+        return_code, out, err = XDo.execute("#{XDo::XDOTOOL} get_desktop")
+        raise(XDo::XError, err) unless err.empty?
+        out.to_i
+      end
+
+      #Returns the geometry of the display.
+      #===Return value
+      #The width and height of the display as an array
+      #===Raises
+      #[XError] Error invoking +xdotool+.
+      #===Example
+      #  p XDo::XWindow.display_geometry #=> [1280,800]
+      #  width, height = XDo::XWindow.display_geometry
+      #===Remarks
+      def display_geometry
+        return_code, out, err = XDo.execute("#{XDo::XDOTOOL} getdisplaygeometry")
+        raise(XDo::XError, err) unless err.empty?
+        return out.split(/ /).first.to_i, out.split(/ /).last.to_i
+      end
+
       #Creates a XWindow by calling search with the given parameters.
       #The window is created from the first ID found.
       #===Parameters
@@ -395,11 +399,9 @@
       #===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}
+        return_code, out, err = XDo.execute("#{XDo::XWININFO} -root")
         Kernel.raise(XDo::XError, err) unless err.empty?
-        Integer(out.lines.to_a[0].match(/Window id:(.*?)\(/)[1].strip)
+        return out.lines.to_a[0].match(/Window id:(.*?)\(/)[1].strip.to_i
       end
       
       #Creates a XWindow refering to the root window.
@@ -520,7 +522,8 @@
 
       dirs.each do |d|
         key = "#{root}/#{d}/#{name}"
-        Open3.popen3("#{GCONFTOOL} -g #{key}"){|stdin, stdout, stderr| out << stdout.read.strip; err << stderr.read.strip}
+        return_code, out, err = XDo.execute("#{GCONFTOOL} -g #{key}")
+
         #If key doesn't exist, gconftool prints a message (including the requested key) saying so.
         if err.empty? or !out.empty?
           keystroke = out.to_s
@@ -626,11 +629,10 @@
     #===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}
+      return_code, out, err = XDo.execute("#{XDo::XDOTOOL} windowsize #{opts.join(" ")} #{@id} #{width} #{height}")
       Kernel.raise(XDo::XError, err) unless err.empty?
     end
     
@@ -648,10 +650,9 @@
     #  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}
+      return_code, out, err = XDo.execute("#{XDo::XDOTOOL} windowmove #{opts.join(" ")} #{@id} #{x} #{y}")
       Kernel.raise(XDo::XError, err) unless err.empty?
     end
     
@@ -668,10 +669,9 @@
     #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}
+      return_code, out, err = XDo.execute("#{XDo::XDOTOOL} windowfocus #{opts.join(" ")} #{@id}")
       Kernel.raise(XDo::XError, err) unless err.empty?
     end
     
@@ -698,10 +698,9 @@
     #  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}
+      return_code, out, err = XDo.execute("#{XDo::XDOTOOL} windowmap #{opts.join(" ")} #{@id}")
       Kernel.raise(XDo::XError, err) unless err.empty?
     end
     
@@ -715,10 +714,9 @@
     #===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}
+      return_code, out, err = XDo.execute("#{XDo::XDOTOOL} windowunmap #{opts.join(" ")} #{@id}")
       Kernel.raise(XDo::XError, err) unless err.empty?
     end
     
@@ -731,8 +729,7 @@
     #===Example
     #  xwin.raise
     def raise
-      err = ""
-      Open3.popen3("#{XDo::XDOTOOL} windowraise #{@id}"){|stdin, stdout, stderr| err << stderr.read}
+      return_code, out, err = XDo.execute("#{XDo::XDOTOOL} windowraise #{@id}")
       Kernel.raise(XDo::XError, err) unless err.empty?
     end
     
@@ -754,10 +751,9 @@
     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}
+        return_code, out, err = XDo.execute("#{XDo::XDOTOOL} windowactivate #{opts.join(" ")} #{@id}")
         Kernel.raise(XDo::XError, err) unless err.empty?
       rescue XDo::XError
         #If no window is active, xdotool's windowactivate fails, 
@@ -789,8 +785,7 @@
     #
     #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}
+      return_code, out, err = XDo.execute("#{XDo::XDOTOOL} set_desktop_for_window #{@id} #{num}")
       Kernel.raise(XDo::XError, err) unless err.empty?
     end
     
@@ -809,11 +804,9 @@
     #
     #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}
+      return_code, out, err = XDo.execute("#{XDo::XDOTOOL} get_desktop_for_window #{@id}")
       Kernel.raise(XDo::XError, err) unless err.empty?
-      Integer(out)
+      return out.to_i
     end
     
     #The title of the window or nil if it doesn't have a title.
@@ -824,14 +817,12 @@
     #===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}
+        return_code, out, err = XDo.execute("#{XDo::XWININFO} -id #{@id}")
       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!")
@@ -846,9 +837,7 @@
     #===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}
+      return_code, out, err = XDo.execute("#{XDo::XWININFO} -id #{@id}")
       Kernel.raise(XDo::XError, err) unless err.empty?
       out = out.strip.lines.to_a
       x = out[2].match(/:\s+(\d+)/)[1]
@@ -865,9 +854,7 @@
     #===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}
+      return_code, out, err = XDo.execute("#{XDo::XWININFO} -id #{@id}")
       Kernel.raise(XDo::XError, err) unless err.empty?
       out = out.strip.lines.to_a
       x = out[4].match(/:\s+(\d+)/)[1]
@@ -883,9 +870,7 @@
     #===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}
+      return_code, out, err = XDo.execute("#{XDo::XWININFO} -id #{@id}")
       out = out.strip.lines.to_a
       Kernel.raise(XDo::XError, err) unless err.empty?
       width = out[6].match(/:\s+(\d+)/)[1]
@@ -903,9 +888,7 @@
     #  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}
+      return_code, out, err = XDo.execute("#{XDo::XWININFO} -id #{@id}")
       out = out.strip
       Kernel.raise(XDo::XError, err) unless err.empty?
       return out =~ /IsViewable/
@@ -982,9 +965,7 @@
     #===Example
     #  xwin.kill!
     def kill!
-      out = ""
-      err = ""
-      Open3.popen3("#{XDo::XKILL} -id #{@id}"){|stdin, stdout, stderr| out << stdout.read; err << stderr.read}
+      return_code, out, err = XDo.execute("#{XDo::XKILL} -id #{@id}")
       Kernel.raise(XDo::XError, err) unless err.empty?
       nil
     end
@@ -1038,8 +1019,7 @@
     
     #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}
+      return_code, out, err = XDo.execute("#{XDOTOOL} set_window --#{option} '#{value}' #{@id}")
       Kernel.raise(XDo::XError, err) unless err.empty?
     end
     

=== modified file 'tests/run-tests.rb'
--- tests/run-tests.rb	2012-01-23 21:42:53 +0000
+++ tests/run-tests.rb	2012-01-24 11:51:24 +0000
@@ -63,6 +63,13 @@
 # Require unit test framework: This enables execution of test cases and also includes assertions (Test::Unit::Assertions)
 require 'testhelper'
 
+#Establish connection to qttasserver
+$SUT = TDriver.sut(:Id => "sut_qt")
+
+#Include the XDo common library
+require $library_path + '/xdo/_xdo'
+XDo.sut = $SUT
+
 # Enable reports only with -report switch
 include TDriverReportTestUnit if ARGV.delete('-report')