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. That way, 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.

// Search for WebSpy application
 Form webSpyForm = Application.FindFormTitle("Ranorex WebSpy", SearchMatchMode.MatchExact, true);
// Test 'Options' menu
MenuStrip menu = webSpyForm.FindMenuStrip("menuStripMain");

// Open 'Start page' dialog
menu.SelectItemText("Options", "Set start page ...");

Form startPage = Application.FindFormTitle("Start page", SearchMatchMode.MatchExact, true);
TextBox startUrlTextBox = startPage.FindTextBox("startPageUrlTextBox");
startUrlTextBox.Text = "www.google.com";

// Click 'Default' button
Button useDefaultButton = startPage.FindButton("useDefaultButton");
Mouse.ClickControl(useDefaultButton);

// Click 'OK' button
Button okButton = startPage.FindButton("okButton");
Mouse.ClickControl(okButton);

TextBox textBoxAddress = webSpyForm.FindTextBox("textBoxAddress");
Mouse.ClickControl(textBoxAddress);

// Navigate to www.ranorex.com
textBoxAddress.Text = "www.ranorex.com";
Application.Sleep(500);
Application.SendKeys("{ENTER}");

Not a big challenge until now. But not only the typical GUI elements (menus, buttons, tab controls, …) have to be tested automatically.
The most complex control is the integrated browser control which has to be tested, too. So the key target of our test is to validate the interaction of .NET controls with the web elements of a web site.

// Search for integrated browser
Control browserControl = webSpyForm.FindClassName("Internet Explorer_Server", 1);

// Find link 'Products' within website and move mouse cursor to web element
WebDocument doc = WebDocument.GetDocument(browserControl,2000);
WebElement productLink = doc.FindSingle("//a[text()='Products']");
Mouse.MoveToWebElement(productLink);

// Simulate hot key
Application.SendKeys("{CTRLDOWN}{CTRLUP}", 570);

// Click tabs from WebSpy
Control tabControl = webSpyForm.FindControlName("tabControlElement");
Element[] tabs = tabControl.Element.FindChildren(Role.PageTab);
foreach (Element tab in tabs)
{
    Mouse.ClickElement(tab);
}

// Select 'MouseMoveTo' link item
Element actionsTab = tabControl.Element.FindChild(Role.PageTab, "Actions");
Element link = actionsTab.FindChild(Role.Link, "MouseMoveTo");
Mouse.ClickElement(link);

The big advantage with RanorexNet is that there is no difference between testing web sites with Internet Explorer or testing web sites which are integrated in other applications as shown with Ranorex WebSpy.

using System;
using System.Collections.Generic;
using System.Text;
using Ranorex;
using Ranorex.Web;

namespace WebTestDont
{
    class Program
    {
        static void Main(string[] args)
        {
            // Resource based identification of web elements
            WebDocument exampleDoc = WebDocument.OpenDocument("www.ranorex.com/web-testing-examples", true);

            // Find 'Name' textbox within form
            WebElement name = exampleDoc.FindSingle("//input[@id='testname']");
            Mouse.MoveToWebElement(name);
            name.Value = "Mr. XYZ";

            // Find 'Color' drop down box within form
            WebElement colorSelector = exampleDoc.FindSingle("//select[@id='testcolor']");
            Mouse.MoveToWebElement(colorSelector);
            colorSelector.Value = "blue";

            // ... search for next elements ...
        }
    }
}

I know, the few code lines above don’t give a good example for a long and unreadable test code. But what we can see, is that the example always starts the element search from scratch by calling the method ‘FindSingle’ from the ‘exampleDoc’ object. Another problem is the use of hard-coded RanoreXPath expressions. Due to changes within your AUT (application under test) you may need to update your code lines with new RanoreXPath expressions, to ensure your test is still workable .

For that reason it’s advisable to extract and separate your RanoreXPath search strings from your test codes. There are many different types to generate global mapping/resource information. The next section concentrates on the use of resource files provided by Microsoft Visual Studio.

Visual Studio provides resource files for storing several types of objects (Images, Icons, Strings, …). Our use case only requires a resource table of type string. Simple add a new resource file called ‘GuiMapping’ to your Visual Studio project.

To add a resource file please

• open your Visual Studio project properties and
• add a new resource within the ‘Resource’ tab.

The use of resource files extracts complex search strings from test code and concentrates searching information at one single location. The static ‘GuiMapping’ object is easy to use during coding and provides all necessary RanoreXPath expressions. In addition to that, the following implementation speeds up the search of web elements: In the first step we search for the web element of type ‘form’. After that, each search for web elements located within this form can be done by calling the method ‘FindSingle’ on the form object.

using System;
using System.Collections.Generic;
using System.Text;

using Ranorex;
using Ranorex.Web;

namespace WebTest
{
    // Using 'Properties' namespace to access
    // Resource elements
    using Properties;

    class Program
    {
        [STAThread]
        static void Main(string[] args)
        {
            // Resource based identification of web elements
            WebDocument exampleDoc = WebDocument.OpenDocument(GuiMapping.WebTestUrl, true);
            WebElement form = exampleDoc.FindSingle(GuiMapping.WebTestForm);

            // Find 'Name' textbox within form
            WebElement name = form.FindSingle(GuiMapping.WebTestName);
            Mouse.MoveToWebElement(name);
            name.Value = "Mr. XYZ";

            // Find 'Color' drop down box within form
            WebElement colorSelector = form.FindSingle(GuiMapping.WebTestColors);
            Mouse.MoveToWebElement(colorSelector);
            colorSelector.Value = "blue";
        }
    }
}

For that reason, outsourcing of searching criteria enhances readability and coding maintenance for future extensions.

IronPython

The first option is IronPython, a new implementation of the Python programming language for the .NET framework. Basically, this is a new Python compiler producing .NET intermediate language code. It claims to be fully compatible with the Python Language Reference, but code written for the original CPython may not produce the same output if run with IronPython (see Differences between IronPython 1.0 and CPython 2.4.3).

Python for .NET

The second option is the one I will concentrate on in this blog: Python for .NET. This package provides a bridge for CPython to .NET assemblies (framework as well as user written ones). Python users continue to use the CPython interpreter and classes they are familiar with while additionally gaining access to classes written in any .NET language, e.g the classes in the Ranorex Web Automation API.

Installation

Unfortunately, since the latest release of Python for .NET more than half a year has gone by and some crucial bugs have been fixed meanwhile. That’s why we use the latest version from the SVN repository instead.

1. Check out and build the latest version of Python for .NET from the SVN repository. You need to set the Conditional compilation symbols in the Properties of the Python.Runtime project to match your CPython version (e.g. “PYTHON24,UCS2″ for CPython version 2.4 and “PYTHON25,UCS2″ for version 2.5).
   NOTE: For CPython version 2.3, 2.4, or 2.5 we have done that step for you, so you can download built binaries from the Ranorex web server.
2. Copy the generated/downloaded Python.Runtime.dll file to your CPython installation folder (e.g. C:\Python24) and the clr.pyd file to the DLLs folder of the CPython installation (e.g. C:\Python24\DLLs).
3. (Optional) Copy the RanorexCore.dll, RanorexNet.dll, RanorexSpy.dll, SHDocVw.dll, and Microsoft.mshtml.dll files from the bin\Net2.0-Pro folder of your Ranorex installation into the DLLs folder of the CPython installation. Moreover, copy the RanorexPython.dll from bin\Python2.X-Pro folder (where ‘X’ corresponds to the version of your CPython installation) of your Ranorex installation to the same DLLs folder of the CPython installation and rename it to RanorexPython.pyd. If you omit this step, these six files need to reside in the same directory as the Python scripts you execute.

• Download Python for .NET (built binaries)
• Download Ranorex

Scripting

In order to access Ranorex .NET from your Python scripts, you need to add the following statements at the beginning of each script (in the exact order as shown below):

import RanorexPython
import clr
clr.AddReference("RanorexNet")
from Ranorex import *
from Ranorex.Web import *

You can now access all classes and methods in the Ranorex and RanorexWeb namespaces using the RanorexNet API. Consequently, please refer to the RanorexNet API documentation for the available classes and methods. To get an introduction to Ranorex Web automation please read the corresponding chapter in the Ranorex User Guide.

The following sample code opens the Ranorex web site and navigates to the web automation chapter in the Ranorex User Guide. The RanoreXPaths in this sample have been generated by using the RanorexWebSpy.

document = WebDocument.OpenDocument("www.ranorex.com", True)                      

#  click on 'User Guide' on main page top menu
Mouse.MoveToWebElement(document.FindSingle("//a[text()='Support']"))
Mouse.ClickWebElement(document.FindSingle("//a[text()='User Guide']"), MouseButtonType.LeftButton, Alignment.CenterLeft)                      

# click on 'Web Testing' in left menu
document.WaitForDocumentLoaded()
Mouse.ClickWebElement(document.FindSingle("//li[@class='NO']/a[text()='Web Testing']"))                      

# set background color of Web Testing header and move mouse to it
document.WaitForDocumentLoaded()
header = document.FindSingle("//h2[text()='Ranorex Web Testing']")
header.SetStyleAttribute("background-color", "red")
Mouse.MoveToWebElement(header)

See Also

For more information on Python for .NET visit the project homepage and Readme page.

For the API documentation refer to the RanorexNet API documentation.

Good luck automating your web sites with Python and Ranorex!

Using .NET, it’s very simple. You create a new class in the application under test, which inherits from the control class you want to automate and add some properties or methods you need for automation. Be sure that you instantiate the new class in the form designer instead of the old one.

The new version of Ranorex (V1.4 or higher) allows you to get/set properties and call methods of objects from a test application. This technique can be used with all kinds of 3rd party or custom .NET controls.

Let’s demonstrate this approach with a simple sample.

Step 1: Creating a simple application under test.

Create a new Visual Studio C# project

Extend the form with a TextBox

Drag the TextBox in the ToolBox and drop it into the form.

Add a new class to the project and let it inherit from System.Windows.Forms.TextBox (or from the base class of the control you want to automate)

class MyTextBox : System.Windows.Forms.TextBox { }

Add a new property you want to call from your test application to the class.

class MyTextBox : System.Windows.Forms.TextBox
{
    public String MyValue
    {
        get
        {
            return this.Text;
        }
        set
        {
            this.Text = value;
        }
    }
}

Change the class name from TextBox to MyTextBox in the Form.Designer.cs file

(Instantiate the new class instead of the old one)

private MyTextBox textBox1;

private void InitializeComponent()
{
    this.textBox1 = new MyTextBox();
    ...
}

Compile and start the application under test.

Step 2: Checking the properties with RanorexSpyPro.

Start RanorexSpyPro and select the textbox of the form with the finder tool .
You should see the new property “MyValue” in the RanorexSpyPro application.

Step 3: Automating the control in a test application.

Find the form and set the property MyValue of the TextBox as follows:

Form form = Application.FindFormTitle("Form1");
TextBox textBox = form.FindTextBox("textBox1");
for (int i = 0; i < 20; i++)
{
    textBox.SetPropertyValue("MyValue", i.ToString());
    Application.Sleep(1000);  

}

Step 4: Calling a method of the control.

You can also extend your control class “MyTextBox” with methods and call them from the test application:

class MyTextBox : System.Windows.Forms.TextBox
{
    public void SetValue(String text)
    {
         this.Text = text;  

    }
}

Use InvokeMethod(“MethodName”, params, …) for calling the method from your test script:

textBox.InvokeMethod("SetValue", “22”);

This article describes a simple but general way for automating 3rd party controls.
Developers and testers can work together to make am application fit for automation.
We have tested this approach with several kind of 3rd party controls (Infragistics, DevExpress, DevComponents,…).

Ranorex V1.4 supports accessing properties and methods of .NET derived controls. Following “Design for Testability” sample explains the way of making testing more comfortable. By using the 3rd party UltraTree control from Infragistics the example describes how to access user defined methods for test automation.

In fact there should only be 3 steps required to expand or select a specific node within the tree view control.

1. Searching for the application
2. Finding tree view control within form
3. Invoking method with simple string path “Root/Child_02/”

Form form = Application.FindFormTitle("Design for Testability",
				           SearchMatchMode.MatchFromStart);
Control tree = form.FindControlName("ultraTree1");
tree.InvokeMethod("ExpandNode", null, "Root/Child_02/");

To invoke a method called “ExpandNode” we only have to provide this method within a class derived from the Infragistics UltraTreeView control:

/// Derived class from Infragistics UltraTree control
public class MyTreeView : Infragistics.Win.UltraWinTree.UltraTree
{
    public MyTreeView()
    {}
    /// This method steps through each sub node of
    /// the tree view control.
    public void ExpandNode(UltraTreeNode node, string path)
    {
        string[] nodeList = path.Split('/');
        UltraTreeNode currentNode = null;
        TreeNodesCollection treeNodes = null;
        // Start from controls node list if null
        if (node == null)
            treeNodes = this.Nodes;
        else
            treeNodes = node.Nodes;
        foreach (UltraTreeNode n in treeNodes)
        {
            if (n.Text == nodeList[0])
            {
                currentNode = n;
                // Expand node
                n.Toggle();
                // Select node
                n.Selected = true;
                break;
            }
        }
        if (currentNode == null)
            return;
        // start expanding for sub nodes
        ExpandNode(currentNode,path.Remove(0,currentNode.Text.Length+1));
    }
}

Invoking methods or properties can be a powerful mechanism to simplify automation of 3rd party controls, if developers consider testability during their software design and implementation process.