The following example describes how FitNesse and Ranorex can be combined to automate GUI testing without having static test scripts. Moreover, it gives a quick overview as to how to manage, maintain and execute test scripts using FitNesse.

First, download and install FitNesse from http://fitnesse.org/FrontPage.FitNesseDevelopment.DownLoad. More information about installing and getting started with FitNesse is provided by the following document written by Gojko Adzic: http://gojko.net/FitNesse/book/. He describes how one implements and executes .NET test cases using FitNesse and demonstrates how one can create human-readable test cases.

Creating Automation Base Library

UPDATED: This example is based on Ranorex 2.2.
To automate and test the VIP application with FitNesse it is necessary to implement a .NET fixture class which does all the GUI automation work.

using System;
using System.Collections.Generic;
using System.Text;
using Ranorex;
namespace NetFit
{
   public class AddVIPTest : fit.ColumnFixture
   {
	///
	/// UI Repository instance for VIP Application
        ///
	private VIPRepo repo = VIPRepo.Instance;
	private string gender;
	private string lastName;
	private string firstName;
	///
	/// Property for FirstName parameter.
	/// By setting the property Ranorex directly clicks
	/// the text box and simulates the keyboard events
	/// Returns the current text value of the text box.
	///
	public string FirstName
	{
	   set
	       	{
	       		this.firstName = value;
	       		repo.VIPApplication.FirstName.Click();
	       		Ranorex.Keyboard.Press(firstName);
	       	}
	       	get
	       	{
	       		return repo.VIPApplication.FirstName.TextValue;
	       	}
	    }
	    ///
	    /// Property for FirstName parameter.
	    /// By setting the property Ranorex directly clicks
	    /// the text box and simulates the keyboard events
	    /// Returns the current text value of the text box.
	    ///
	    public string LastName
	    {
	       	set
	       	{
	       		this.lastName = value;
	       		repo.VIPApplication.LastName.Click();
	       		Ranorex.Keyboard.Press(lastName);
	       	}
	       	get
	       	{
	       		return repo.VIPApplication.LastName.TextValue;
	       	}
	    }
	    ///
	    /// Property for Gender parameter.
	    /// Depending on the given value Ranorex selects
	    /// the right radio button.
	    /// Returns the currently selected gender
	    ///
	    public string Gender
	    {
	    	set
	    	{
	    		gender = value;
	    		if (gender.Equals("Female"))
	    		    repo.VIPApplication.Gender.Female.Click();
	    		else if (gender.Equals("Male"))
	    			repo.VIPApplication.Gender.Male.Click();
	    	}
	    	get
	    	{
	    		if (repo.VIPApplication.Gender.Female.Checked)
	    			return "Female";
	    		else
	    			return "Male";
	    	}
	    }
	    /// Method is used to simulate a click on
	    /// specified button.
	    ///
	    ///
	    /// Specifies the label of the button to press
	    ///
	    public void Action(string button)
	    {
	    	repo.VIPApplication.Self.FindChild(button).Click();
	    }
	    ///
	    ///
	    /// Returns the current text value of
	    /// the status bar.
	    ///
	    public string ValidateStatusBox()
	    {
	         return repo.VIPApplication.StatusBar.TextValue;
	    }
}

The “AddVIPTest” class is derived from a simple FitNesse fit.ColumnFixture class. All public declared fields within this class are accessible through a FitNesse test case as follows:
!|NetFit.AddVIPTest|
|FirstName|LastName|Gender|Action|ValidateStatusBox?|
|Marylin|Monroe|Female|Add|VIP count: 1|
|Bill|Gates|Male|Add|VIP count: 2|
|Hillary|Clinton|Female|Add|VIP count: 3|

All test data is specified in columns and rows, and “FirstName”, “LastName”, “Gender”, and “Action” are declared as test input data. Read test output data by adding the question mark ‘?’ to the “ValidateStatusBox” column. The last column in our example is used to call our “ValidateStatusBox” method and to compare the returned value with an expected value.

FitNesse uses so called “Test Pages” to execute test tables as described above. The next steps describe how to create “Test Pages” with FitNesse using its web application server.

After downloading and installing FitNesse, just start “run.bat”. Start your preferred browser and enter http://localhost/AddVipTest in the address field to create a new FitNesse test called AddVIPTest.

Specifying test

Edit the page and define the command patterns, the test runner and the Ranorex based .NET library as follows:

!!define COMMAND_PATTERN {%m -r fitnesse.fitserver.FitServer,C:\Ranorex\Fitnesse\dotnet2\fit.dll, -c C:\Ranorex\Fitnesse\dotnet2\myConfig.xml %p}
!define TEST_RUNNER {C:\Ranorex\Fitnesse\dotnet2\Runner.exe}
!path C:\Ranorex\Fitnesse\HelloWorld\HelloWorld\bin\Debug\NetFit.dll


!|NetFit.AddVIPTest|
|FirstName|LastName|Gender|Action|ValidateStatusBox?|
|Marylin|Monroe|Female|Add|VIP count: 1|
|Bill|Gates|Male|Add|VIP count: 2|
|Hillary|Clinton|Female|Add|VIP count: 3|

Save the “AddVipTest” page. To enable a “Test” button, set up the page properties within the properties menu.
Now you can start your FitNesse-managed Ranorex automated test script.

Each test case should be passed successfully. Try to force an error by changing one of the expected values. Restart the test and see what happens.

In the following example, I would like to show that in Windows Forms it is quite easy to add accessibility functions to an existing control, even to a rather complex control like a tree view. The control used in the example is the TreeViewAdv, a quite popular open source tree/list control. But please consider that also other complex controls like data grids or list views from other 3rd party vendors (Infragistics, DevExpress, Syncfusion, ComponentOne, Telerik, Janus, …) can be extended the same way as described within the following scenario.

Although it is quite nice to use, it lacks an accessibility implementation, rendering its content totally opaque to most automation tools. (Using Ranorex’ remote invocation capability, one can still extract data from the control, though.)

Here is an example of the control filled with some test data. You can see that in addition to a standard TreeView the TreeViewAdv can have columns as well:

In its original form no information about the content of the control is available. To support automation, we are going to add the following accessibility features:

• Every tree node is represented in the accessibility tree.
• Every column cell is represented in the accessibility tree.
• Every node or cell has geometry and visibility information.
• Every node has a name (for identification) and a value (content for validation).

Let’s have a look at the necessary code. First, a reference to the “Accessibility” assembly, which is part of the .NET framework, has to be added. This assembly provides a managed wrapper and a number of utility classes around the COM-based Microsoft Active Accessibility (MSAA) layer.

MSAA has been around for some time now and is understood by most screen readers and automation tools. It has been superseded by UI Automation, which is especially suited for WPF applications, but still comes in handy for Windows Forms and MFC/ATL applications.

To provide a custom accessibility implementation for a control, the CreateAccessibilityInstance method has to be overridden and has to return a custom AccessibleObject implementation.

// overridden to return custom accessibility object instance
protected override AccessibleObject CreateAccessibilityInstance()
{
    return new TreeViewAdvAccessibleObject(this);
}

For our tree we will provide three classes, all deriving from AccessibleObject:

1. TreeViewAdvAccessibleObject which represents the tree itself and acts as the top-level container. This actually derives from Control.ControlAccessibleObject
   which provides a basic accessibility implementation for control classes, e.g. for its location, size and visibility.
2. AdvNodeAccessibleObject represents a tree node.
3. AdvNodeCellAccessibleObject represents a cell of a certain node column.

Accessibility functionality is then implemented by overriding a number of properties and methods to provide useful information and functionality to an external application. Here is a short overview of the most important properties which need to be implemented:

• Properties:
  • Role: An enumeration of different kinds of GUI objects, for example buttons, checkboxes, listitems, etc. In our example, we use Outline (which represents a tree) and OutlineItem (which represents a tree node) as well as Cell (which represents a table cell).
  • Name: A representative name for the object. It is usually used for (re-)identification purposes (e.g. “SaveAs” button), should not be content dependent, and might even be language-invariant.
  • Value: Represents the object’s content if it has any. For example the text in a text box, the Checked property of a check box, or the contents of a data cell.
  • State: A flag enumeration containing a number of states a GUI object can have, like Selected, Invisible, Expanded, Collapsed or Focused. In our example, Selected, Expanded and Collapsed are especially useful for tree nodes.
  • Bounds: A rectangle representing the bounding box of an object in screen coordinates. This property is very important for correct automation and capture/replay.
  • Parent: The parent of the accessible object. This must be implemented if the object is returned as a child of another accessible object (for consistency; see below).
• Methods:
  • GetChild() and GetChildCount(): Returns a child/the number of children of the object. In our example, tree nodes return their child nodes and tables return cells as child objects. Make sure to implement the Parent property for objects returned by this functions!
  • Select(): Selects an object, if applicable. This method is a bit weird as it takes AccessibleSelection as a parameter which describes what kind of selection to perform. AccessibleSelection.Focus is very useful for automation if implemented, regardless whether an object is selectable or not.
  • HitTest(x,y): Returns the object at coordinates (x,y). This is useful for fast capture/replay and is easily implemented in our example, because TreeViewAdv already has built-in functionality for returning a tree node by coordinates.

Here is a part of the AdvNodeAccessibleObject implementation:

public class AdvNodeAccessibleObject : AccessibleObject
{
	TreeNodeAdv advNode;
	AdvNodeAccessibleObject parent;
	TreeViewAdvAccessibleObject owner;

	public AdvNodeAccessibleObject(TreeNodeAdv advNode, AdvNodeAccessibleObject parent,
									TreeViewAdvAccessibleObject owner) : base()
	{
		...
	}

	public override AccessibleRole Role
	{
		get { return AccessibleRole.OutlineItem; }
	}

	public override Rectangle Bounds
	{
		get
		{
			if (!advNode.IsVisible)
				return Rectangle.Empty;

                        // we need to convert client -> screen here
			Rectangle bounds = advNode.Tree.GetNodeBounds(advNode);
			Point p = advNode.Tree.ScrollPosition;

			int colHeaderY = advNode.Tree.UseColumns ? advNode.Tree.ColumnHeaderHeight : 0;

			bounds.Offset(-p.X, -p.Y * advNode.Tree.RowHeight + colHeaderY);
			return advNode.Tree.RectangleToScreen(bounds);
		}
	}

	public override string Name
	{
		get
		{
			foreach (NodeControlInfo info in advNode.Tree.GetNodeControls(advNode))
			{
				BindableControl ctrl = info.Control as BindableControl;
				if (ctrl != null)
				{
					string val = ctrl.GetValue(advNode) as string;
					if (val != null)
						return val;
				}
			}
			return null;
		}
	}

	public override AccessibleObject GetChild(int index)
	{
		int ctrlCount = advNode.Tree.Columns.Count;

		if (index < ctrlCount)
			return new AdvNodeCellAccessibleObject(advNode, index, this);
		else return new AdvNodeAccessibleObject(advNode.Nodes[index-ctrlCount], this, owner);
	}

	public override int GetChildCount()
	{
		return advNode.Nodes.Count + advNode.Tree.Columns.Count;
	}

	public override AccessibleObject Parent
	{
		get
		{
			if (advNode.Parent != advNode.Tree.Root)
				return parent != null ? parent : new AdvNodeAccessibleObject(advNode.Parent, null, owner);
			else return owner;
		}
	}

	...
}

This might look a bit complicated, but if you are familiar with the control you are extending, most accessibility properties and methods can be implemented in a rather straightforward manner.

The whole implementation for the TreeViewAdv control accessibility support is only about 300 lines of code and a few hours of coding time, but it makes a huge difference in terms of automation.

Here are two screenshots of Ranorex Spy analyzing the newly accessible tree control:

As you can see from the highlighted area on the first screenshot, it is now possible to look “inside” the control. This helps a lot when performing automated data entry, content validation, behavior checking, screen scraping, etc.

You can grab the source package with the accessibility addon for TreeViewAdv and the simple demo app here:

Source package for TreeViewAdv (svn rev 76) with accessibility
TreeViewAdv demo binaries

More information about the Windows Automation APIs can be found here.

Requirements:

NUnit -  http://www.nunit.org/index.php?p=download
(preferred version >= 2.5)

1.) Add the NUnit reference to your project
Right-click on your project and choose ‘Add Reference’
Select ‘nunit.framework’ from the ‘GAC’ tab

2.) Create a new NUnit testcase class
Right-click on your project and choose ‘Add->New Item’
Select ‘new empty file’ and click create

3.) Add the following lines of code:

using NUnit.Framework;

[TestFixture, RequiresSTA]
public class TestCase1
{
	[TestFixtureSetUp]
	public void Init()
	{
	}

	[Test]
	public void Test1()
	{
	}

	[TestFixtureTearDown]
	public void Dispose()
	{
	}
}

4.) Insert the recorded or manual test calls
Write your automation code into the Test1 method
Use the ‘TestFixtureSetUp’ and ‘TearDown’ methods to initialize and set you Software Under Test (SUT) back to its original state

5.) Open your dll/exe with the ‘NUnit GUI Runner’ and start your tests
Navigate to a specific test in the test tree
Right-click on the file node and click ‘Run’ or ‘Run all’

Or:

If you want to call your existing recordings directly, declare them as NUnit tests:

1.) Open the ‘Recording.UserCode’ file
Navigate to the recording node in Project Browser and open the ‘.usercode’ file

2.) Declare your Recording class as ‘[TestFixture]‘
Set the ‘TestFixture’ attribute at the top of the class (see code below)

3.) Create a new NUnit test method
Insert a new method ‘StartRecording’ into the usercode (”Recording1.UserCode.cs” file, see code below)

e.g.

[TestFixture, RequiresSTA]
public partial class Recording1
{
         /*
        ...
        */

        [Test]
        public void StartRecording()
        {
             Recording1.Start();
        }

        /*
        ....
        */
}

Now we are able to call every single test method from the NUnit Test Runner and we don´t have to worry about the build and cleanup of our testing environment. We are also free to choose which test methods we want to execute for each test run.

The Recorder will run the recording and save the Ranorex Report file to the directory where the recording file is located.

1. Open the Recorder, capture your recurring task and save the recording file (e.g. C:\Recordings\Recording1.rxrec)
2. Open start menu and select “All Programs“->”Ranorex 2.X“
3. Drag and drop (with the right mouse button) the “Ranorex Recorder” shortcut to your desktop and choose “Copy Here”
4. Rename your shortcut file (e.g. “Start Recording1″) and open the properties by right-clicking and choosing “Properties”
5. Append following parameters to Target “/quiet /play” and the path of your recording1 file. The Target property should look like then:

   "C:\Program Files\Ranorex 2.1\Bin\Ranorex.Recorder.exe" /quiet /play "C:\Recordings\Recording1.rxrec"

6. Define a shortcut key by clicking into Shortcut Key and press your key combination (e.g. CTRL + ALT + R).
7. You can start your recording by double-clicking on the shortcut or pressing the global shortcut key

int x=0;
int y=0;

// Find 'Notepad' application using RanoreXPath
Ranorex.Form form = "/form[@title='Untitled - Notepad']";
form.Activate();
x = form.ScreenRectangle.Width - 2;
y = form.ScreenRectangle.Height - 2; 

Report.Log(ReportLevel.Info,"",Mouse.CursorName);
Mouse.MoveTo(form,new Location(x,y));
Report.Log(ReportLevel.Info,"",Mouse.CursorName);

// Check if the application window allows it
// resize the form using the ‘CursorName’ property
if (Mouse.CursorName.Equals("SizeNWSE"))
{
	Mouse.ButtonDown(MouseButtons.Left);
	Mouse.MoveTo(form.ScreenRectangle.Right+30,form.ScreenRectangle.Bottom+30);
	Mouse.ButtonUp(MouseButtons.Left);
}

Requirements:

• Ranorex 1.5 and 2.x installed on same machine.
• .NET 3.5 if you are using Ranorex Studio.

Steps:

1. Open an existing project that uses (References) the RanorexNet.DLL (
   .csproj)
2. Select the RanorexNet reference and open the properties. Give it a new alias for example RanorexNet .
3. In all code files where the Ranorex namespace is used add

   extern alias <new alias name>;

   for example

   extern alias RanorexNet;

   to the top of the file before all using statements. Then change

   using Ranorex;

   to

   using RanorexNet.Ranorex;

   
   

4. To use the Ranorex namespace from both the RanorexNet.dll and the Ranorex.Core.dll together in the same code file you will also need to alias the namespace for example

   using RX15 = RanorexNet::Ranorex;

5. If you alias the name space in a code file you will also need to update the code to use the new qualified name. For example, change from

   Logger.LogFileTitle = "Ranorex Log File";

   to

   RX15.Logger.LogFileTitle = "Ranorex Log File";

6. Add a reference to the Ranorex.Core.dll from the GAC. Important, it is not recommended that you alias the Ranorex.Core.dll because the generated code doesn’t add the “extern alias” statement. However, feel free to alias the namespace whenever you need to.

Download Sample Project (11KB)

The first stop is the new taskbar. Running programs are now represented with large icons instead of a labeled small icon.  Although it feels very different,  it is exactly the same from an automation point of view as in XP or Vista. Tasks are still represented as child items (or buttons)  of a toolbar:

An interesting thing to note is that the “Start”-Button has been promoted to a top-level window and is no longer part of the task bar (In this case the RanorexPath is now “/button” instead of “/menubar/button”).

Most of the built-in tools also received an overhaul. As an example, let’s have a look at the Calculator:

It looks like it has been rebuilt from scratch. If you are interested in details, you can have a look at a  Calculator Ranorex Snapshot file (Right click -> Save As and open with Ranorex Spy).

Last but not least, Windows 7 also comes with Internet Explorer 8.  While this browser will also be available for the older Windows versions, it is definitely an integral part of Windows 7:

The good news it that automation works just the same way as it does with IE6 or IE7, so running web tests should not pose a problem.

Download Infragistics Ultragrid Sample (5KB)
The test automation code requires a running DynamicStyling application provided through the Infragistics NetAdvantage demo kit.

Ranorex V2.0 comes with a totally redesigned core automation library. Based on the new possibilities of the core, the features of Ranorex tools like Ranorex Recorder have grown extremely to provide a more comfortable way of UI test automation. But not only the Ranorex tool set benefits from the new core library as following example shows.

The code gives a brief overview of how to work with Ranorex V2.0 core library directly. The example describes how to iterate through a 3rd party Infragistics UltraGrid control.

InfragisticsObj guiObj = InfragisticsObj.Instance;
guiObj.InfragisticsApp.Window.EnsureVisible();
Mouse.MoveTo(guiObj.InfragisticsApp.Window.Element);

foreach (Row  row in guiObj.InfragisticsApp.UltraGridTable.Rows)
{
  // Checks whether current row (node) is collapsed or not
  //System.Windows.Forms.AccessibleStates states = (System.Windows.Forms.AccessibleStates)row.Element.GetAttributeValue("accessiblestate");
  Accessible accObj = row.Element;

  if ( (accObj.State & System.Windows.Forms.AccessibleStates.Collapsed) != 0)
  {
    row.Focus();
    // Using relative coordinates to expand
    // collapsed node
    Mouse.Click(row.Element, new Location(new System.Drawing.Point(8, 8)));
 }

 // Request all cells of the current row
 // using the children property
 foreach (Cell cell in row.Cells)
 {
   cell.Focus();
   Mouse.Click(cell.Element, 2, new TimeSpan(0,0,0,0,10));
   // Simulate select all using keyboard actions
   Keyboard.Press(System.Windows.Forms.Keys.Home);
   Keyboard.Press("{LShiftKey down}{End}{LShiftKey up}");
   Accessible accCell = cell.Element;
   Keyboard.Press(accCell.Value);
 }

 // Request all cells from the subrows
 // using RanoreXPath
 IList allSubCells = row.Element.Find(new RxPath("row/cell"));

 foreach (Cell cell in allSubCells)
 {
   cell.Focus(); // ensures visibility
   // prepare text to set
   // using parent information
   Accessible accCell = cell.Element;

   string cellText = String.Format("Cell ({0},{1})",
                                    ((Accessible)cell.Element.Parent).Name,
                        			((Accessible)cell.Element).Name);

   accCell.Value = cellText;
 }
}

Normally, the previous code should be quite easy to understand. Maybe the code line

 IList allSubCells = row.Element.Find(new RxPath("row/cell"));

requires a more detailed description.

RanoreXPath could be seen as a query string to search for UI elements within the Ranorex element tree shown by RanorexSpy. In case of the current example the search starts from a specific Ranorex.Row item named ‘row’ to retrieve all sub cells regardless to which sub row element they belong.

The use of RanoreXPath allows not only a more flexible search or filtering for UI elements, but also some kind of validation to check attributes or current states of a control. In addition there is always the standard way of automation supported through Ranorex adapters (Tables, Rows, Columns, Cells, …) representing role specific UI elements providing access to their children again. In short, everything you see with RanorexSpy is accessible and available through the Ranorex core interface.

Download Ranorex Studio Excel Sample for Ranorex 2.0 (15KB)

Microsoft Excel is often used to store and manage test cases and test data. Why? Because Excel is a widespread tool. Nearly every Windows based machine has installed Microsoft Office.
Following example describes how to feed a Ranorex test automation process with test data stored within an Excel table. The example consists of 3 main parts:

• Excel sheet containing test data
• Ranorex automation project
• Excel connector to read test data from Excel

Excel Sheet

As usual, we use the Windows calculator in this example of data driven testing. Each row defines a single test case with test data inputs and expected outputs. In addition, each test case has a short description.

ExcelConnector class

To provide a user-friendly interface for retrieving test data from an Excel sheet, we implement an ExcelConnector. This class wraps the functionality of a Microsoft COM library to access rows and cells in a data sheet. Thus we have to add the COM library as reference object to our project.

public class ExcelConnector
{
    private string excelFile = null;
    private Excel.Application excelObj = null;
    private Excel.Workbook workBook = null;
    private Excel.Worksheet worksheet = null;
    private UInt16 currentRowIndex = 0;
    private string[] inputs;
    private string[] outputs;

    public string ExcelFile
    {
        get
        {
            return this.excelFile;
        }
    }
    public UInt16 CurrentRowIndex
    {
        get
        {
            return this.currentRowIndex;
        }
    }       

    public ExcelConnector(string excelFile, string[] inputs, string[] outputs, bool load, UInt16 startRow)
    {
        this.excelFile = excelFile;
        this.inputs = inputs;
        this.outputs = outputs;
        if (load)
           this.LoadFile();
        currentRowIndex = startRow;
    }

    public void LoadFile()
    {
        excelObj = new Excel.Application();
        System.Threading.Thread.CurrentThread.CurrentCulture = new
                                             System.Globalization.CultureInfo("en-US");
        workBook = excelObj.Workbooks.Open(this.excelFile, 0, true, 5, "", "", true,
                                             Excel.XlPlatform.xlWindows, "\t", false, false, 0, true, false, false);
        Excel.Sheets sheets = workBook.Worksheets;
        worksheet = (Excel.Worksheet)sheets.get_Item(1);
    }

    public TestData GetNext()
    {
        string[] arrInputs = new string[inputs.Length];
        string[] arrOutputs = new string[outputs.Length];

        for (int i = 1; i < this.inputs.Length+1; i++)
        {
            Excel.Range cell = (Excel.Range)worksheet.Cells[currentRowIndex, i];
            if ( ((string)cell.Text).Length == 0 )
            	return null;
            arrInputs[i - 1] = (string)cell.Text;
        }
        for (int i = 0; i < this.outputs.Length ; i++)
        {
            Excel.Range cell = (Excel.Range)worksheet.Cells[currentRowIndex, i + inputs.Length + 1];
            if ( ((string)cell.Text).Length == 0 )
             	return null;
            arrOutputs[i] = (string)cell.Text;
        }

        Excel.Range cellComment = (Excel.Range)worksheet.Cells[currentRowIndex,
                                                        inputs.Length+outputs.Length+1];
        currentRowIndex++;
        return new TestData(arrInputs, arrOutputs, (string)cellComment.Text);
    }

    public void Dispose()
    {
        excelObj.Quit();
    }
}

The constructor of the class ‘ExcelConnector’ specifies the name of the Excel file, the amount of in- and outputs defined by each test case and where to start reading test data. The ‘GetNext()’ method returns a simple TestData object representing a single row from the excel sheet.

Ranorex test automation code

The following code shows how to use the ‘ExcelConnector’ class to read test data from the excel sheet.

TestData testData;

openFileDialog.DefaultExt = "xlsx";

openFileDialog.Filter = "XLS file (*.xls)|*.xls|XLSX file (*.xlsx)|*.xlsx|All files (*.*)|*.*";
if ( openFileDialog.ShowDialog() == System.Windows.Forms.DialogResult.OK )
{
    this.tbExcelFile.Text = openFileDialog.FileName;
}

void InitExcelConnection()
{
    string[] testDataInputs = new string[] { "Input1", "Input2", "Input3", "Input4" };
    string[] testDataOutputs = new string[] { "Output1" };
    if (System.IO.File.Exists(tbExcelFile.Text))
         excelConnector = new ExcelConnector(this.tbExcelFile.Text,
                                    testDataInputs, testDataOutputs, true,2);
    else
         throw new RanorexException(null,"Specified file does not exist!");
}

InitExcelConnection();

while ((testData = excelConnector.GetNext()) != null )
{
    Ranorex.Control bt = null;
    foreach (string str in testData.Inputs)
    {
        foreach (char c in str)
        {
            bt = calcForm.FindChildText(c.ToString());
            Mouse.ClickControl(bt);
        }
    }
    bt = calcForm.FindControlId(403);
    // Compare calculator output with expected value
    Ranorex.Validate.HasText(bt, testData.Outputs[0] + ", ",testData.Description + " validation",false);
}

An Excel connector could be a smart solution to reuse existing manual tests stored in excel sheets and to provide an easy to use test case data base, especially for those testers without deeper Ranorex test automation knowledge.

So, if your data are all serializable, then just use the methods listed above. Everything will work just fine and there’s absolutely no sense in writing a blog post about that. … Well, usually most of the control developers don’t care if the types their control properties are serializable or not. That’s why we sometimes need to use a workaround to transfer our data from/to the control.

Ranorex V1.5 introduces a new method called Control.InvokeRemotely that allows us to execute code in the process of the control we want to exchange data with. (Note: This method is also available in Ranorex 2.X. This post and the sample code in it apply both to Ranorex 1.5 and 2.X versions.) Using that method, we can break up the unserializable data into serializable chunks in one process, transfer them, and finally reassemble them at the other process.

Assume that we want to get the text of all items in a ListView. Then we can call InvokeRemotely passing a delegate that collects the text values and stores them in a list (which is serializable):

string[] itemTextValues = (string[])listView.InvokeRemotely(
    delegate(System.Windows.Forms.Control control)
    {
        System.Windows.Forms.ListView remoteListView = (System.Windows.Forms.ListView)control;
        List values = new List();
        foreach (System.Windows.Forms.ListViewItem item in remoteListView.Items)
        {
            values.Add(item.Text);
        }
        return values.ToArray();
    });

If you want to retrieve more info about each list item, then you need to create a serializable data container:

[Serializable]
private class SerializableOutputData
{
    public bool Checked;
    public string Text;
}

private static object GetListViewData(System.Windows.Forms.Control control)
{
    System.Windows.Forms.ListView remoteListView = (System.Windows.Forms.ListView)control;
    List<SerializableOutputData> remoteOutputData = new List<SerializableOutputData>();
    foreach (System.Windows.Forms.ListViewItem item in remoteListView.Items)
    {
        SerializableOutputData data = new SerializableOutputData();
        data.Checked = item.Checked;
        data.Text = item.Text;
        remoteOutputData.Add(data);
    }
    return remoteOutputData.ToArray();
}
...
// call the GetListViewData method from the main method
SerializableOutputData[] outputData = (SerializableOutputData[])listView.InvokeRemotely(GetListViewData);

If you are not using anonymous methods, make sure to declare the delegate method static like in the example above. Or make the method member of a serializable type. This is actually necessary if you want to transfer data to the control. For instance, if you want to get information on all the list items which text property begins with a certain prefix:

[Serializable]
private class SerializableInputData
{
    public string Prefix;
    public object GetListViewData(System.Windows.Forms.Control control)
    {
        System.Windows.Forms.ListView remoteListView = (System.Windows.Forms.ListView)control;
        List<SerializableOutputData> remoteOutputData = new List<SerializableOutputData>();
        foreach (System.Windows.Forms.ListViewItem item in remoteListView.Items)
        {
            if (item.Text.StartsWith(Prefix))
            {
                SerializableOutputData data = new SerializableOutputData();
                data.Checked = item.Checked;
                data.Text = item.Text;
                remoteOutputData.Add(data);
            }
        }
        return remoteOutputData.ToArray();
    }
}
... // in the main method
SerializableInputData inputData = new SerializableInputData();
inputData.Prefix = "i";
SerializableOutputData[] outputData = (SerializableOutputData[])listView.InvokeRemotely(inputData.GetListViewData);

I hope that this post illustrates when and how to use the Control.InvokeRemotely method. If the desired data is not serializable, the GetPropertyValue, SetPropertyValue, and InvokeMethod methods won’t work. The InvokeRemotely method provides a convenient way to split the unserializable data into serializable parts and transfer the data that way.