Abstracting a Grid Wrapper in TestComplete 4

"Flexibility" is a word that gets thrown around a lot when describing TestComplete, but how, exactly, is it flexible?

"Hey, I don't care about the definition of 'flexible', I just want to know if my test scripts will break when the developers start changing the UI under my feet!"

Uhm, right. That's what I mean by "flexible". A test tool's not much good if all my scripts break as soon as something changes in the tested app, so today we'll take a look at a technique that will provide a layer of breakage protection for our tests.

"Cynicism and suspicion?"

Hmm, not so much that (although it's worked for me), but we will be taking the attitude that our developers will eventually change something rather fundamental, thus putting our tests to the test. Using TestComplete's Object-Driven Testing (ODT) feature, we'll build a breakage-control grid wrapper. In other words, we'll create some code that will allow us to manipulate a grid control, but will not be so tightly coupled to the control that we can't quickly flex (hence "flexibility") to deal with the change. As a side benefit, our ODT class will allow us to have a single access point in case more than one type of grid control is used in a single application.

Object-Driven Testing

Ok, by now you may have noticed that if I've written an article, it will have something to do with ODT, so I'll dispense with the introductory material and assume that you've read the required texts before coming to class (in other words, if you're not familiar with ODT, you might want to go read up on the subject in the TestComplete help).

Object-Driven Testing is one of the more robust and powerful parts of TestComplete owing to its rather dynamic and programmatic nature. As a result, there is generally more than one way to solve any particular problem. The approach we're taking for this article involves creating a single ODT class for wrapping several different grid types. Another approach would be to use the ODT ability to re-map an object's methods to point at various implementations, resulting in a sort of inheritance model. You can research that one on your own.

Our example here will wrap the VCL TListView class, the .NET System.Windows.Forms.ListView class, the Developer Express TcxGrid class and the Developer Express.XtraGrid class. For the tested applications, I'm using the Delphi and C# versions of the TestComplete sample application; Orders.exe; the DevExpress sample program for TcxGrid, UnboundSimpleDemo.exe; and for the XtraGrid, the DexExpress sample app, GridMainDemo.exe. The two versions of Orders.exe can be downloaded from the AutomatedQA website at http://www.automatedqa.com/downloads/testcomplete/tc4_samples.asp, while the DevExpress demos are part of the standard installs for those products.

One last thought; the example I'm providing here is only pedagogical and should not be considered as a pattern or a best practice. This is only sample code to show what might be done.

ODT class set up

In this solution, we start out with an abstracted grid wrapper class, rather ingeniously named "GridWrapper". This class will know how to manipulate a grid control (one of any of four different classes) via a set of idealized, and generalized grid-like methods. Then, behind the scenes, we'll specify how to manage particular grid types.

One last note: I've created this class according to some conventions I've developed for managing ODT classes, I'll explain them as I go, and for this paper, I'll even instruct you to follow them, but of course, don't take my conventions as holy writ.

Note - if you're using DelphiScript, you can use the following code to generate the ODT class.

{Automatically generates the declaration of the ODT class. Use this instead of <br /> entering the whole class in the ODT editor.} <br />procedure DefineClass_GridWrapper;<br />var<br /> lClass: Olevariant;<br />begin<br /> lClass := ODT.Classes.Items['GridWrapper'];<br /> if (lClass <> nil) then<br /> ODT.Classes.Delete('GridWrapper');<br /> <br /> lClass := ODT.Classes.Declare('GridWrapper');<br /> <br /> lClass.AddProperty('GridControl');<br /> lClass.AddProperty('GridType');<br /> <br /> lClass.AddMethod('RowCount', 'odtGridWrapper.RowCount');<br /> lClass.AddMethod('ColumnCount', 'odtGridWrapper.ColumnCount');<br /> lClass.AddMethod('CellValue', 'odtGridWrapper.CellValue');<br /> lClass.AddMethod('SetCellValue', 'odtGridWrapper.SetCellValue');<br /> lClass.AddMethod('CellByValue', 'odtGridWrapper.CellByValue');<br /> lClass.AddMethod('SelectRow', 'odtGridWrapper.SelectRow');<br /> lClass.AddMethod('FocusCell', 'odtGridWrapper.FocusCell');<br /> lClass.AddMethod('Picture', 'odtGridWrapper.Picture');<br /> <br /> lClass.AddMethod('pr_Assigned', 'odtGridWrapper.pr_Assigned');<br /> lClass.AddMethod('pr_Annotate', 'odtGridWrapper.pr_Annotate');<br />end; <br />

If you didn't use the code above to create the ODT declaration, then in the ODT panel of TestComplete 4, create a new class called "GridWrapper". Note that since I tend to use the visual part of the ODT panel only for definition of classes, and never create objects visually (rather, in code), I don't really bother with prefixes for my ODT classes, but feel free to use "cls" or "odt" or whatever you like.

For the GridWrapper class, I've added some properties (see figure 1).

figure 1 - GridWrapper properties

Properties:

Name	Note
GridControl	This will hold whatever control that we're wrapping as a grid. Note that because we're abstracting our control, this can actually be non-grid controls (like a ListView, as we'll see in our examples).
GridType	This is a string indicating what type of grid we're working on.

 

A note about visibility: Since TestComplete's ODT classes have no notion of visibility (public, protected, private, etc.), everything is public. Yet, there are times when I really want private properties or methods. As a result, I've taken to "hacking" visibility. If I have a property or method of an ODT class that I want only the objects of that class themselves to call (and NOT the test code developers) I prefix that property or method.
Our grid wrapper doesn't have any private data members, but if it did, I'd prefix the private properties with "F" (for "field - a private data member. I'm falling back on my Delphi upbringing here). For methods, I prefix the method with "pr_" for private. My hope is that the prefix will be annoying enough that I and my fellow coders will not go messing around with those.

I've added a set of methods to the GridWrapper class (note that because there are no read/write access methods for ODT classes, some of these methods might normally be properties in a standard OOP class):

figure 2 - GridWrapper methods

 

If you have much experience with grids in general, you probably recognize this class as just that - a grid; generalized. The methods are what you'd see on most any grid control implementation, which is just the point. We want this grid wrapper to be usable to test a variety of grid classes. Note that with these methods, we could iterate through the entire grid, row by column, getting and/or setting values, and even emulating user interaction by calling SelectRow() or FocusCell() before beginning text entry.

I normally create a new script code unit for each ODT class I define. One class - one unit. This seems to make things a little more clear and manageable. As such, create a new unit in your TestComplete project called odtGridWrapper.sd (Note: my code in this article is in DelphiScript).

We use the following routines in odtGridWrapper (you can just copy the code from the listing to follow unless you're working in another scripting language):

Routine Name	Parameter List	Return Value	Note
RowCount	None	Integer
ColumnCount	None	Integer
CellValue	aRow, aCol: Integer	OleVariant	Returns values of cells.
SetCellValue	aRow, aCol: Integer; aValue: OleVariant	Boolean	Sets a cell value directly
CellByValue	aValue: String; var aRow, aCol: Integer	Void	Gets a cell by its value
SelectRow	aRowIdx: Integer	Void	Selects whole row
FocusCell	aRow, aCol: Integer	Void	Focuses single cell
Picture	None	Onscreen object	Gets TC onscreen object for visual validation purposes
pr_Assigned	None	Boolean	"private" method to validate assignment
pr_Annotate	aMessage: String	Void	Adds messages to log

This is the approach that will use the GridType property we defined. We'll check the value of GridType to direct our actions.
For this approach, we need some grids to implement and demo apps to work with. See the earlier listing of the sample applications used. If you don't have either of the Developer Express components, it's ok, you can still see the point of the demo using the TestComplete Orders.exe applications.
These apps will actually show some of our flexibility. The Orders applications are actually built using ListView controls rather than grids. The DevExpress demos, of course, use their popular grid components.

{These constants are used for indicating what type of "grid" control we're manipulating.<br /> Note that our point here is to abstract our test code from the implementation of the <br /> grids; for example, two of our wrapped classes are not grids at all, but rather <br /> ListViews. }<br /><br />const<br /> cs_VCLLV = 'VCL ListView'; // TListView<br /> cs_CSharp = 'CSharp'; // System.Windows.Forms.ListView<br /> cs_DevExVCL5 = 'DXVCL5'; // TcxGridTableView - NOTICE: not the grid, but individual views!<br /> cs_DevExdotNet = 'DXNET'; // DevExpress.XtraGrid.Views.Grid<br /> <br /><br /><br /> <br />{Automatically generates the declaration of the ODT class. Use this instead of <br /> entering the whole class in the ODT editor.} <br />procedure DefineClass_GridWrapper;<br />var<br /> lClass: Olevariant;<br />begin<br /> lClass := ODT.Classes.Items['GridWrapper'];<br /> if (lClass <> nil) then<br /> ODT.Classes.Delete('GridWrapper');<br /> <br /> lClass := ODT.Classes.Declare('GridWrapper');<br /> <br /> lClass.AddProperty('GridControl');<br /> lClass.AddProperty('GridType');<br /> <br /> lClass.AddMethod('RowCount', 'odtGridWrapper.RowCount');<br /> lClass.AddMethod('ColumnCount', 'odtGridWrapper.ColumnCount');<br /> lClass.AddMethod('CellValue', 'odtGridWrapper.CellValue');<br /> lClass.AddMethod('SetCellValue', 'odtGridWrapper.SetCellValue');<br /> lClass.AddMethod('CellByValue', 'odtGridWrapper.CellByValue');<br /> lClass.AddMethod('SelectRow', 'odtGridWrapper.SelectRow');<br /> lClass.AddMethod('FocusCell', 'odtGridWrapper.FocusCell');<br /> lClass.AddMethod('Picture', 'odtGridWrapper.Picture');<br /> <br /> lClass.AddMethod('pr_Assigned', 'odtGridWrapper.pr_Assigned');<br /> lClass.AddMethod('pr_Annotate', 'odtGridWrapper.pr_Annotate');<br />end; <br /> <br /><br />{Returns a count of the rows in the grid.}<br />function RowCount: Integer;<br />begin<br /> if (Self.pr_Assigned) then<br /> begin<br /> case Self.GridType of<br /> // VCL ListView and C# Forms.ListView<br /> cs_VCLLV, cs_CSharp:<br /> Result := Self.GridControl.wItemCount;<br /><br /> // VCL TcxGrid<br /> cs_DevExVCL5:<br /> Result := Self.GridControl.DataController.RowCount;<br /> <br /> // .NET XtraGrid.Views.Grid<br /> cs_DevExdotNet: <br /> Result := Self.GridControl.MainView.RowCount;<br /><br /> else<br /> Result := -1; <br /> end;<br /><br /> Self.pr_Annotate('Getting row count. Result = ' + VarToStr(Result));<br /> end;<br />end; <br /><br /><br />{Returns a count of the columns in the grid.}<br />function ColumnCount: Integer;<br />begin<br /> if (Self.pr_Assigned) then<br /> begin<br /> case Self.GridType of<br /> cs_VCLLV, cs_CSharp:<br /> Result := Self.GridControl.wColumnCount;<br /><br /> cs_DevExVCL5:<br /> Result := Self.GridControl.ColumnCount;<br /> <br /> cs_DevExdotNet: <br /> Result := Self.GridControl.MainView.Columns.Count;<br /><br /> else<br /> Result := -1;<br /> end; // case<br /><br /> Self.pr_Annotate('Getting column count. Result = ' + VarToStr(Result));<br /> end; <br />end;<br /><br /><br />{Gets the value of the cell indicated by aRow and aCol (x,y)}<br />function CellValue(aRow, aCol: Integer): OleVariant;<br />var<br /> lItem: OleVariant;<br /> lColumn: OleVariant;<br />begin<br /> if (Self.pr_Assigned) then<br /> begin<br /> case Self.GridType of<br /> cs_VCLLV, cs_CSharp:<br /> Result := Self.GridControl.wItem(aRow, aCol);<br /><br /> cs_DevExVCL5:<br /> Result := Self.GridControl.DataController.Values[aRow, aCol];<br /> <br /> cs_DevExdotNet: <br /> begin<br /> lColumn := Self.GridControl.MainView.Columns.Item_2[aCol];<br /> Result := Self.GridControl.MainView.GetRowCellValue(aRow, lColumn).ToString.OleValue;<br /> end;<br /><br /> else<br /> Result := -1;<br /> end; // case<br /><br /> Self.pr_Annotate('Getting CellValue(' + VarToStr(aRow) + ',' + VarToStr(aCol) +<br /> '). Result = ' + VarToStr(Result));<br /> end; <br />end;<br /><br /><br />{Sets the value of the cell indicated by aRow, aCol to the value given in aValue.}<br />function SetCellValue(aRow, aCol: Integer; aValue: OleVariant): Boolean;<br />var<br /> lItem: OleVariant;<br /> lColumn: OleVariant;<br /> lString: OleVariant;<br />begin <br /> if (Self.pr_Assigned) then<br /> begin<br /> case Self.GridType of<br /> cs_VCLLV:<br /> begin<br /> lItem := Self.GridControl.Items.Item[aRow];<br /> if (aCol = 0) then<br /> lItem.Caption := aValue<br /> else<br /> begin<br /> while (lItem.SubItems.GetCount < aCol - 1) do<br /> lItem.SubItems.Add(' ');<br /><br /> lItem.SubItems.Strings[aCol - 1] := aValue;<br /> end;<br /> end;<br /><br /> cs_CSharp:<br /> begin<br /> lItem := Self.GridControl.Items.Item(aRow);<br /> if (aCol = 0) then<br /> lItem.Text := aValue<br /> else<br /> begin<br /> while (lItem.SubItemCount < aCol - 1) do<br /> lItem.SubItems.Add(' ');<br /><br /> lItem.SubItems.Item(aCol - 1).Text := aValue;<br /> end;<br /> end;<br /><br /> cs_DevExVCL5:<br /> Self.GridControl.DataController.Values[aRow, aCol] := aValue;<br /><br /> cs_DevExdotNet: <br /> begin<br /> // here we want a String object, not a string char array. <br /> lString := Sys.Process('GridMainDemo').AppDomain('GridMainDemo.exe').dotNET.System.String.Copy(aValue);<br /> lColumn := Self.GridControl.MainView.Columns.Item_2[aCol];<br /> Self.GridControl.MainView.SetRowCellValue(aRow, lColumn, lString);<br /> end;<br /><br /> else<br /> Result := -1;<br /> end; // case<br /> <br /> Self.pr_Annotate('Setting cell value(' + VarToStr(aRow) + ',' + VarToStr(aCol) +<br /> '). New value = ' + VarToStr(aValue));<br /> <br /> end; <br />end;<br /><br /><br /><br />function CellByValue(aValue: String): Point;<br />var<br /> liColIdx: Integer;<br /> liRowIdx: Integer;<br /> lbFound: Boolean;<br /> lString: OleVariant;<br /> lColumn: OleVariant;<br /> lProcess: OleVariant;<br />begin<br /> Result := Utils.Point;<br /> Result.X := -1;<br /> Result.Y := -1;<br /> lbFound := false;<br /> <br /> if (Self.pr_Assigned) then<br /> begin<br /> Self.pr_Annotate('Getting cell for value "' + aValue + '"');<br /><br /> case Self.GridType of<br /> cs_VCLLV, cs_CSharp:<br /> begin<br /> // should really use FindCaption here, but is not visible to TC.<br /> liRowIdx := 0;<br /> <br /> while ((liRowIdx < Self.GridControl.wItemCount) and (lbFound = false)) do<br /> begin<br /> liColIdx := 0;<br /><br /> while ((liColIdx < Self.GridControl.wColumnCount) and (lbFound = false)) do<br /> begin<br /> if (AnsiSameText(aValue, Self.GridControl.wItem[liRowIdx, liColIdx])) then<br /> lbFound := true<br /> else<br /> Inc(liColIdx);<br /> end;<br /> if (lbFound) then<br /> begin<br /> Result.X := liRowIdx;<br /> Result.Y := liColIdx;<br /> Self.pr_Annotate('Found cell for value "' + aValue + '" at (' + <br /> VarToStr(Result.X) + ',' + VarToStr(Result.Y) + ')');<br /> end<br /> else<br /> Inc(liRowIdx); <br /> end; <br /> end; // cs_VCLLV<br /><br /> cs_DevExVCL5:<br /> begin<br /> liColIdx := 0;<br /> lbFound := false;<br /> while (liColIdx < Self.GridControl.ColumnCount) and (not lbFound) do<br /> begin<br /> liRowIdx := Self.GridControl.DataController.FindRecordIndexByText(0, liColIdx, aValue, false, false, true);<br /> if (liRowIdx > -1) then<br /> begin<br /> lbFound := true;<br /> Result.X := liRowIdx;<br /> Result.Y := liColIdx;<br /> Self.pr_Annotate('Found row for value "' + aValue + '" at (' + <br /> VarToStr(Result.X) + ',' + VarToStr(Result.Y) + ')');<br /> end<br /> else<br /> inc(liColIdx);<br /> end;<br /> end;<br /> cs_DevExdotNet: <br /> begin<br /> liColIdx := 0;<br /> lbFound := false;<br /> while (liColIdx < Self.GridControl.MainView.Columns.Count) and (not lbFound) do<br /> begin<br /> lProcess := Sys.Process('GridMainDemo');//GetProcessForObject(Self.GridControl);<br /> // here we want a String object, not a string char array. <br /> lString := lProcess.AppDomain('GridMainDemo.exe').dotNET.System.String.Copy(aValue);<br /> lColumn := Self.GridControl.MainView.Columns.Item_2[liColIdx];<br /><br /> liRowIdx := Self.GridControl.MainView.LocateByDisplayText(0, lColumn, lString);<br /> if (liRowIdx > -1) then<br /> begin<br /> lbFound := true;<br /> Result.X := liRowIdx;<br /> Result.Y := liColIdx;<br /> Self.pr_Annotate('Found row for value "' + aValue + '" at (' + <br /> VarToStr(Result.X) + ',' + VarToStr(Result.Y) + ')');<br /> end<br /> else<br /> inc(liColIdx);<br /> end;<br /> <br /> end;<br /><br /> end; // case<br /> end; // if pr_Assigned<br />end;<br /><br /><br />procedure SelectRow(aRowIdx: Integer);<br />begin<br /> if (Self.pr_Assigned) then<br /> begin<br /> case Self.GridType of<br /> cs_VCLLV, cs_CSharp:<br /> Self.GridControl.SelectItem(aRowIdx);<br /> <br /> cs_DevExVCL5:<br /> Self.GridControl.DataController.FocusedRowIndex := aRowIdx;<br /><br /> cs_DevExdotNet:<br /> begin<br /> Log.Warning('Can''t select row in this context', <br /> 'Because our demo grid''s view''s OptionsSelection.MultiSelect = false, ' +<br /> 'we apparently can''t select in code. I''d love for someone from DevEx to correct me...'); <br /> Self.GridControl.MainView.SelectRow(aRowIdx); <br /> end<br /> <br /> end;<br /> end;<br />end;<br /><br /><br />procedure FocusCell(aRowIdx, aColIdx: Integer);<br />begin<br /> if (Self.pr_Assigned) then<br /> begin<br /> case Self.GridType of<br /> cs_VCLLV, cs_CSharp:<br /> Self.GridControl.FocusItem(aRowIdx);<br /> <br /> cs_DevExVCL5:<br /> Self.GridControl.DataController.FocusedRowIndex := aRowIdx;<br /> end;<br /> end;<br />end;<br /><br /><br /><br /><br /><br />function Picture: OleVariant;<br />begin<br /> if (Self.GridType = cs_DevExVCL5) then<br /> Result := Self.GridControl.Parent<br /> <br /> else<br /> Result := Self.GridControl;<br />end;<br /><br /><br />function pr_Assigned: Boolean;<br />begin<br /> Result := (VarType(Self.GridControl) <> varNull) and (VarType(Self.GridControl) <> varEmpty); <br /> if (Result <> true) then<br /> Log.Warning('GridControl is not assigned'); <br />end;<br /><br /><br />procedure pr_Annotate(aMessage: String);<br />var<br /> lAttribs: OleVariant;<br />begin<br /> lAttribs := Log.CreateNewAttributes;<br /> <br /> lAttribs.BackColor := BuiltIn.clCream;<br /> lAttribs.FontColor := BuiltIn.clNavy;<br /> lAttribs.Italic := true;<br /> <br /> Log.Message(aMessage, '', pmNormal, lAttribs);<br />end;<br />

If you follow through the code, you'll see that we're simply implementing a case statement in each of the methods, taking the value of Self.GridType (note that "Self" is specific to DelphiScript, for everything else, it's "This") and implementing action based on its value. If we're dealing with a VCL TListView, we take one set of actions; if it's a TcxGrid, we do something else, and so on.
Thus, for the RowCount method, we return a value that represents a count of the "rows" in each type of grid, even if the control in question is not a grid.
As you can see, some of the methods are more complex than others, but each provides uswith an abstraction layer of protection from the internal and specific workings of each control. The benefit is that, if our developers should decide to change their choice of grid controls half-way through application development, our code will not suffer as much as it might have if we were addressing the grid controls directly in our test code.

For an example of use of the abstracted grid, see the Main unit from our test project:

uses<br /> odtGridWrapper;<br /> <br />procedure DoGridTests(aGrid: OleVariant); forward; <br />procedure RunDelphiGridRoutines(aEnabled: Boolean); forward;<br />procedure RunVCSharpGridRoutines(aEnabled: Boolean); forward;<br />procedure RunDevExVCL5GridRoutines(aEnabled: Boolean); forward;<br />procedure RunDevExNETGridRoutines(aEnabled: Boolean); forward;<br />procedure InitDelphiApp; forward;<br />procedure InitCSharpApp; forward; <br />procedure InitDevExVCLApp; forward;<br />procedure InitDevExNETApp; forward;<br /> <br /><br />{Main - Runs when you press F9.<br /> To enable/disable the various grid implementations (depending on what sample apps <br /> you may or may not have), set the lb_ variables to true/false.<br /> The following implementations and sample apps are used:<br /> <br /> VARIABLE SAMPLE APP WRAPPED CLASS<br /> ---------------- <br /> lbDelphi TC's Orders.exe for Delphi TListView<br /> lbVCSharp TC's Orders.exe for C# System.Windows.Forms.ListView<br /> lbDevExVCL UnboundSimpleDemo.exe TcxGrid (VCL/Delphi) (actually a TcxGridView)<br /> lbDevExNET GridMainDemo.exe XtraGrid.Views.Grid <br />}<br />procedure Main;<br />var<br /> lGrid: OleVariant;<br /> lbDelphi: Boolean;<br /> lbVCSharp: Boolean;<br /> lbDevExVCL: Boolean;<br /> lbDevExNET: Boolean;<br />begin<br /> lbDelphi := true;<br /> lbVCSharp := true;<br /> lbDevExVCL := true;<br /> lbDevExNET := true; <br /> <br /> RunDelphiGridRoutines(lbDelphi);<br /> RunVCSharpGridRoutines(lbVCSharp);<br /> RunDevExVCL5GridRoutines(lbDevExVCL);<br /> RunDevExNETGridRoutines(lbDevExNET);<br />end;<br /><br /><br />{uses grid wrapper with Delphi/VCL Orders.exe sample application - implemented<br /> with a TListView control. }<br />procedure RunDelphiGridRoutines(aEnabled: Boolean);<br />var<br /> lGrid: OleVariant;<br />begin<br /> if (aEnabled) then<br /> begin<br /> TestedApps.Orders_Delphi.Run();<br /> InitDelphiApp;<br /> <br /> lGrid := ODT.Classes.New('GridWrapper');<br /> lGrid.GridControl := Sys.Process('Orders').VCLObject('MainForm').VCLObject('ListView');<br /> lGrid.GridType := cs_VCLLV;<br /> <br /> DoGridTests(lGrid); <br /> <br /> TestedApps.Orders_Delphi.Close;<br /> end;<br />end;<br /><br />{uses grid wrapper with C# Orders.exe sample app - implemented by System.Windows.Forms.ListView}<br />procedure RunVCSharpGridRoutines(aEnabled: Boolean);<br />var<br /> lGrid: OleVariant;<br />begin<br /> if (aEnabled) then<br /> begin<br /> TestedApps.Orders_CSharp.Run();<br /> InitCSharpApp;<br /> <br /> lGrid := ODT.Classes.New('GridWrapper');<br /> lGrid.GridControl := Sys.Process('Orders').WinFormsObject('MainForm').WinFormsObject('OrdersView');<br /> lGrid.GridType := cs_CSharp;<br /> <br /> DoGridTests(lGrid); <br /> <br /> TestedApps.Orders_CSharp.Close;<br /> end;<br />end; <br /><br />{Uses grid wrapper with Developer Express' UnboundSimpleDemo.exe demo application<br /> for Express Quantum Grid 5 - implemented by TcxGrid}<br />procedure RunDevExVCL5GridRoutines(aEnabled: Boolean); <br />var<br /> lGrid: OleVariant;<br />begin<br /> if (aEnabled) then<br /> begin<br /> TestedApps.UnboundSimpleDemo.Run();<br /> InitDevExVCLApp;<br /> <br /> lGrid := ODT.Classes.New('GridWrapper');<br /> lGrid.GridControl := Sys.Process('UnboundSimpleDemo').VCLObject('UnboundSimpleDemoMainForm').VCLObject('tvPlanets');<br /> lGrid.GridType := cs_DevExVCL5;<br /> <br /> DoGridTests(lGrid);<br /> <br /> TestedApps.UnboundSimpleDemo.Close; <br /> end;<br />end;<br /><br />{Uses grid wrapper with Developer Express' GridMainDemo.exe demo application<br /> for XtraGrid}<br />procedure RunDevExNETGridRoutines(aEnabled: Boolean); <br />var<br /> lGrid: OleVariant;<br /> lForm;<br /> lContainer;<br />begin<br /> if (aEnabled) then<br /> begin<br /> TestedApps.GridMainDemo.Run();<br /> InitDevExNETApp;<br /> <br /> lGrid := ODT.Classes.New('GridWrapper');<br /> // assigns the GridView control to the wrapper. <br /> lForm := Sys.Process('GridMainDemo').WinFormsObject('frmMain');<br /> lContainer := lForm.WinFormsObject('panelControl1').WinFormsObject('gcContainer');<br /> lGrid.GridControl := lContainer.WinFormsObject('OutlookStyle').WinFormsObject('gridControl1');<br /> lGrid.GridType := cs_DevExdotNet;<br /> <br /> DoGridTests(lGrid);<br /> <br /> TestedApps.GridMainDemo.Close; <br /> end;<br />end;<br /><br />(* Yes, the following are global variables. <br /> These are here, primarily to avoid cluttering up this demo any further than <br /> necessary. I didn't want to create custom demo apps, and I couldn't force all <br /> the sample apps here to have editable string columns in the right place without<br /> cluttering up with more code. So we're pretending that all the grid implementations<br /> are working on the same row and column indexes using these globals. <br /> They're set in the various Init__ routines. *)<br />var<br /> giCol0: Integer;<br /> giCol1: Integer;<br /> <br /><br />{ This method calls the various ODT class' methods. Notice that they're all the<br /> same no matter what the implementing class is. Except for the column, of course.}<br />procedure DoGridTests(aGrid: OleVariant);<br />var<br /> lPoint: Point;<br />begin<br /> Log.AppendFolder('Grid type = ' + aGrid.GridType);<br /><br /> // get count of rows and cells<br /> Log.Message('Rows = ' + VarToStr(aGrid.RowCount)); <br /> Log.Message('Cols = ' + VarToStr(aGrid.ColumnCount));<br /> <br /> // get and set cell values by X,Y index <br /> aGrid.CellValue(0, giCol0);<br /> aGrid.SetCellValue(0, giCol0, 'My Cell Value');<br /><br /> aGrid.CellValue(2, giCol1);<br /> aGrid.SetCellValue(2, giCol1, 'Another Value');<br /> <br /> Log.Picture(aGrid.Picture, 'The grid after setting values.');<br /> <br /> lPoint := aGrid.CellByValue('Another Value');<br /> if (lPoint.X <> -1) then<br /> begin<br /> Log.Message('Found cell for value at (' + VarToStr(lPoint.X) + ',' + VarToStr(lPoint.Y) + ')');<br /> aGrid.SelectRow(lPoint.X);<br /> Log.Picture(aGrid.Picture, 'The grid after selecting row.');<br /> end<br /> else<br /> Log.Error('Could not find cell for value "Another Value"');<br /> <br /> <br /> Log.PopLogFolder;<br />end;<br /><br /><br />{Opens data in the demo app.}<br />procedure InitDelphiApp;<br /> var p1 : OleVariant;<br /> var w1 : OleVariant;<br />begin<br /> p1 := Sys.Process('Orders');<br /> p1.VCLObject('MainForm').VCLObject('ToolButton2').Click(13, 9);<br /> w1 := p1.Window('#32770', 'Open');<br /> p1.Window('#32770', 'Open').Window('ComboBoxEx32').Window('ComboBox').Window('Edit').wText := <br /> 'C:Program FilesAutomated QATestComplete 4SamplesOpen AppsOrdersDemomyTable.tbl';<br /> w1.Window('Button', '&Open').ClickButton;<br /> <br /> // see my note about the following globals where they're declared; above DoGridTests().<br /> giCol0 := 0;<br /> giCol1 := 3;<br />end;<br /><br />{Opens data in the demo app.}<br />procedure InitCSharpApp;<br /> var p1 : OleVariant;<br /> var w1 : OleVariant;<br />begin<br /> p1 := Sys.Process('Orders');<br /> p1.WinFormsObject('MainForm').WinFormsObject('ToolBar').ClickItem(1, false);<br /> w1 := p1.Window('#32770', 'Open');<br /> w1.Window('ComboBoxEx32').Window('ComboBox').Window('Edit').wText := <br /> 'C:Program FilesAutomated QATestComplete 4SamplesOpen AppsOrdersDemomyTable.tbl';<br /> w1.Window('Button', '&Open').ClickButton;<br /> <br /> // see my note about the following globals where they're declared; above DoGridTests().<br /> giCol0 := 0;<br /> giCol1 := 3;<br />end;<br /><br />{The DevEx VCL demo opens with the grid already populated, but we need to <br /> turn off the filter and re-order the columns for our example.}<br />procedure InitDevExVCLApp;<br />begin<br /> Sys.Process('UnboundSimpleDemo').VCLObject('UnboundSimpleDemoMainForm').VCLObject('tvPlanets').DataController.Filter.Active := false;<br /><br /> // see my note about the following globals where they're declared; above DoGridTests().<br /> giCol0 := 0;<br /> giCol1 := 2;<br />end;<br /><br /><br /><br />procedure InitDevExNETApp;<br />begin<br /> Sys.Process('GridMainDemo').WinFormsObject('frmMain').ShowModule('Outlook 2003 Style (new)');<br /> // see my note about the following globals where they're declared; above DoGridTests().<br /> giCol0 := 3;<br /> giCol1 := 4;<br />end;<br />

The point of this unit is to use the abstracted grid on each of the sample applications, executing the same code on each. For each sample application you have access to, set the Boolean variables in the Main routine to turn on or off testing of those applications and then run the project.

If you're unable to run the project or just want to cut to the chase, here's a link to an exported log of the whole project run.

http://www.automatedqa.com/images/blog/rkl_022806_LogSample.zip

At QuickCARE, we're doing a considerable amount of control wrapping since we're still rather early in development and have already changed some implementing controls twice (three times for our menu). This is not a condemnation of our development team, rather it's indicative of real-world development, and it would be unwise for us to not prepare for further adjustments.
Additionally, by creating control wrappers that are defined as "ideal" controls (like our highly simplified grid wrapper here) it saves us from requiring the whole QA team to become experts on all the tested controls. The grid is straightforward and easy to use in tests, regardless of how obfuscated the underlying control may be.

I've commented the code so it should be mostly clear, but I'm open to comments and questions.

Here's the TC project.

Good luck.