public void TestObjectNurse_FromTreeNode()
{
_childTestObject.AddChild(_grandChildTestObject);
_parentTestObject.AddChild(_childTestObject);
//Add it to tree
TestObjectNurse rootNurse = new TestObjectNurse(_treeView);
TestObjectNurse parentNurse = rootNurse.AddDecendants(_parentTestObject);
TreeNode treeNode = parentNurse.TreeNode;
TestObjectNurse nurseObject = TestObjectNurse.FromTreeNode(treeNode);
Assert.AreEqual(parentNurse, nurseObject);
TreeNode childNode = treeNode.Nodes[0];
TestObjectNurse childNurseObject = TestObjectNurse.FromTreeNode(childNode);
TestObjectNurse childNurse = parentNurse[0];
Assert.AreEqual(childNurse, childNurseObject);
}
public void StartToUpdate(ITestObject topNurse, ITestObject selfNurse,
ITestObject leftNurse, ITestObject rightNurse)
{
LeftCondition = (TestObjectNurse)leftNurse;
RightCondition = (TestObjectNurse)rightNurse;
SelfCondition = (TestObjectNurse)selfNurse;
TestObjectNurse rootNurse = TestObjectNurse.FromTree(_treeObjects);
bool changed = MergeObjectsToMainTree(rootNurse, (new List <TestObjectNurse>()
{
(TestObjectNurse)topNurse
}).AsReadOnly());
if (changed)
{
RaiseMergeCompleteEvent(true);
}
/*
* if (_selfCondition != null)
* {
* if (_leftCondition != null)
* {
* _selfCondition.UpdateCondition(UIAPropertyKey.LeftCondition, _leftCondition);
* _selfCondition.UpdateCondition(UIAPropertyKey.Left, _leftCondition.NodeName);
* }
* if (_rightCondition != null)
* {
* _selfCondition.UpdateCondition(UIAPropertyKey.RightCondition, _rightCondition);
* _selfCondition.UpdateCondition(UIAPropertyKey.Right, _rightCondition.NodeName);
* }
* }*/
}
public void ModelFileHandler_SaveToModelFile()
{
TreeView treeView = new TreeView();
TestObjectNurse rootNurse = TestObjectNurse.FromTree(treeView);
AppModel model = ModelFileHandler.LoadModelFile("UnitTestObjectModel1.json", rootNurse);
TestObjectNurse nurseNode = (TestObjectNurse)rootNurse.FindRecursive(DescriptorKeys.NodeName, "Test Explorer");
string imageFilePath = AppEnvironment.GetModelResourceFilePath("TestObjectNurseTest.png");
CacheHandler.EnsureFileDirectoryExists(imageFilePath);
Snapshot.CaptureImageToFile(new Rectangle(0, 0, 100, 200), imageFilePath);
Assert.IsTrue(File.Exists(imageFilePath));
nurseNode.ImageFile = "TestObjectNurseTest.png";
//remove from root
nurseNode.Remove();
AppEnvironment.DumpRecyclingBin(rootNurse);
}
public int LoadProperties(DataGridView grid, TestObjectNurse nurseObject)
{
ITestObject testObject = nurseObject.TestObject;
int count = 0;
foreach (KeyValuePair<string, string> pair in nurseObject.CachedProperties)
{
if (!testObject.Properties.ContainsKey(pair.Key) && pair.Key != ControlKeys.ImagePath
&& pair.Key != UIAControlKeys.BoundingRectangle
)
{
string displayName = ControlKeysManager.GetDisplayString(pair.Key);
grid.Rows.Add(new object[] { displayName, pair.Value });
count++;
}
}
if (!_condition.TestObject.Properties.ContainsKey(ControlKeys.Index))
{
grid.Rows.Add(new object[] { ControlKeysManager.GetDisplayString(ControlKeys.Index), 0 });
count++;
}
return count;
}
public void ModelFileHandler_LoadJsonData()
{
TreeView treeView = new TreeView();
TestObjectNurse rootNurse = TestObjectNurse.FromTree(treeView);
ModelFileHandler.LoadModelFile("ObjectModel2.json", rootNurse);
Assert.AreEqual(1, rootNurse.Children.Count, "only one root node");
Assert.AreEqual(1, rootNurse.Children.Count);
TestObjectNurse parentNurse = rootNurse[0];
ITestObject testObject = parentNurse.TestObject;
Assert.AreEqual(1, parentNurse.Children.Count);
Assert.AreEqual("Window", testObject.ControlTypeString);
TestObjectNurse childNurse = parentNurse[0];
ITestObject testObject2 = childNurse.TestObject;
Assert.AreEqual("Document", testObject2.ControlTypeString, "only one child node");
}
private void LoadImage(TestObjectNurse testNurse)
{
if (testNurse == null /* || testNurse.ImageFile == null*/)
{
snapshotBox.Image = null;
snapshotBox2.TestObject = null;
return;
}
snapshotBox.TestObject = snapshotBox2.TestObject = testNurse;
string imageFile = testNurse.ImageFile;
if (imageFile != null)
{
string path = AppEnvironment.GetModelResourceFilePath(imageFile);
Image image = snapshotBox.Image;
if (image != null)
{
if (image.Height > snapshotBox.Height || image.Width > snapshotBox.Width)
{
snapshotBox.SizeMode = PictureBoxSizeMode.Zoom;
}
else
{
snapshotBox.SizeMode = PictureBoxSizeMode.Normal;
}
}
}
}
public static bool SaveToModelFile(TestObjectNurse rootNurse, string filePath)
{
AppModel model = new AppModel();
foreach (TestObjectNurse nurseObject in rootNurse.Children)
{
ITestObject testObject = nurseObject.TestObject;
model.Add(testObject);
}
try
{
WatcherEnable = false;
AppModelManager.Save(model, filePath);
EnsureWatcherCreated(filePath);
AppEnvironment.CurrentModelPath = filePath;
}
finally
{
WatcherEnable = true;
}
return(true);
}
private void DeleteSelectedNode(TreeNode node = null)
{
TreeView tvObject = treeObjects.Visible ? treeObjects : tvSearchResult;
TreeNode nodeToDelete = node ?? tvObject.SelectedNode;
if (nodeToDelete == null)
{
return;
}
TreeNode parentNode = nodeToDelete.Parent;
TestObjectNurse nurseObject = TestObjectNurse.FromTreeNode(nodeToDelete);
nurseObject.Remove();
if (tvObject == tvSearchResult)
{
nodeToDelete.Remove();
}
if (parentNode == null)
{
if (tvObject.Nodes.Count > 0)
{
tvObject.SelectedNode = tvObject.TopNode;
}
}
else
{
tvObject.SelectedNode = parentNode;
}
SelectedNodesChanged(tvObject.SelectedNode);
AppEnvironment.SetModelChanged(true);
}
public void TestObjectNurse_AddChild_NurseObject()
{
UIATestObject grandParentTestObject = new UIATestObject();
TestObjectNurse grandParentNurse = new TestObjectNurse(grandParentTestObject);
TestObjectNurse parentNurse = new TestObjectNurse(_parentTestObject);
grandParentNurse.AddChild(parentNurse);
//Add the child test object to the tree,
TestObjectNurse childNurse = new TestObjectNurse(_childTestObject);
parentNurse.AddChild(childNurse);
Assert.AreEqual(_childTestObject, childNurse.TestObject);
//Assert hierarchy
Assert.AreEqual(childNurse, parentNurse.Children[0]);
Assert.AreEqual(parentNurse, childNurse.Parent);
Assert.AreEqual(_parentTestObject, _childTestObject.Parent);
Assert.AreEqual(_childTestObject, _parentTestObject.Children[0]);
Assert.AreEqual(grandParentNurse.TreeNode, parentNurse.TreeNode.Parent);
Assert.AreEqual(parentNurse.TreeNode, childNurse.TreeNode.Parent);
Assert.AreEqual(childNurse.TreeNode, parentNurse.TreeNode.Nodes[0]);
}
public void TestObjectNurse_Children()
{
//init test objects
UIATestObject childTestObject2 = new UIATestObject();
UIATestObject childTestObject3 = new UIATestObject();
_childTestObject.AddChild(_grandChildTestObject);
_parentTestObject.AddChild(_childTestObject);
_parentTestObject.AddChild(childTestObject2);
_parentTestObject.AddChild(childTestObject3);
//initialize nurse objects
TestObjectNurse parentNurse = new TestObjectNurse(_parentTestObject);
TestObjectNurse childNurse = parentNurse.AddChild(_childTestObject) as TestObjectNurse;
TestObjectNurse childNurse2 = parentNurse.AddChild(childTestObject2) as TestObjectNurse;
TestObjectNurse childNurse3 = parentNurse.AddChild(childTestObject3) as TestObjectNurse;
Assert.AreEqual(3, parentNurse.Children.Count);
Assert.AreEqual(_childTestObject, parentNurse[0].TestObject);
Assert.AreEqual(childTestObject2, parentNurse[1].TestObject);
Assert.AreEqual(childTestObject3, parentNurse[2].TestObject);
}
public void CaptureSnapshot(TestObjectNurse nurseObject)
{
string token = null;
UIATestObject testObject = nurseObject.TestObject as UIATestObject;
if (testObject == null)
{
return; //not the UIA object
}
AutomationElement element = testObject.AutomationElement;
if (SpySettings.CaptureSnapshots)
{
try
{
//capture snapshot of clicked area
SnapshotHelper.CaptureTempSnapshot(element, out token);
}
catch (ElementNotAvailableException)
{
MessageBox.Show(StringResources.LPSpy_SpyMainWindow_CannotFindObjectMsg);
}
catch (ApplicationException ex)
{
MessageBox.Show(ex.Message);
}
}
nurseObject.ImageFile = SnapshotHelper.GetCachedSnapshot(token, nurseObject.ImageFile);
AppEnvironment.SetModelChanged(true);
}
public static bool SaveToModelFile(TestObjectNurse rootNurse)
{
string filePath = AppEnvironment.CurrentModelPath;
bool ret = SaveToModelFile(rootNurse, filePath);
AppEnvironment.DumpRecyclingBin(rootNurse);
return(ret);
}
private void toolStripRefresh_Click(object sender, EventArgs e)
{
if (this.Visible)
{
TestObjectNurse nurseObject = _condition = TestObjectNurse.FromTreeNode((TreeNode)this.Tag);
ReloadElementData(this.propertyGrid, nurseObject);
}
}
/// <summary>
/// Initializes a new instance of the PropertyTable class.
/// </summary>
public TestObjectPropertyBag(TestObjectNurse testNurse)
{
_testNurse = testNurse;
PropertySpec[] specs = AddProperties();
Properties.AddRange(specs);
}
private void mnuCaptureSnapshot_Click(object sender, EventArgs e)
{
TestObjectNurse nurseObject = TestObjectNurse.FromTreeNode(_selectedNode);
SelectedNodesChanged(nurseObject.TreeNode);
_presenterModel.CaptureSnapshot(nurseObject);
}
public ToMethodsViewer(TestObjectNurse nurseObject, System.Windows.Point position)
{
_nurseObject = nurseObject;
_mouseposition = position;
FormBorderStyle = FormBorderStyle.FixedDialog;
InitializeComponent();
InitializelvControl();
buildlvControl();
}
private void ConditionSelectorWindow_Load(object sender, EventArgs e)
{
Debug.Assert(this.Tag != null);
TestObjectNurse nurseObject = TestObjectNurse.FromTreeNode((TreeNode)this.Tag);
UIATestObject testObject = new UIATestObject();
FillListView(testObject);
}
private void treeObjects_OnDropItemIntoTree(object sender, DragEventArgs e)
{
TreeNode myNode = null;
if (e.Data.GetDataPresent(typeof(TreeNode)))
{
myNode = (TreeNode)(e.Data.GetData(typeof(TreeNode)));
}
else
{
return;
}
Point position = new Point(e.X, e.Y);
position = this.treeObjects.PointToClient(position);
TreeNode dropNode = this.treeObjects.GetNodeAt(position);
TreeNode dragNode = null;
bool needUpdate = false;
if ((dropNode != null && dropNode.Parent != myNode && dropNode != myNode) || (dropNode == null))
{
dragNode = myNode;
myNode.Remove();
needUpdate = true;
}
if (dragNode != null && needUpdate)
{
TestObjectNurse dragNurse = TestObjectNurse.FromTreeNode(dragNode);
string newName = "";
if (dropNode == null)
{
newName = SpyWindowHelper.DeriveControlName(RootNurseObject, dragNurse.NodeName);
treeObjects.Nodes.Add(dragNode);
}
else
{
newName = SpyWindowHelper.DeriveControlName(RootNurseObject, dragNurse.NodeName);
dropNode.Nodes.Add(dragNode);
}
if (newName != dragNurse.NodeName)
{
dragNurse.NodeName = newName;
SelectedNodesChanged(dragNode);
MessageBox.Show(string.Format(StringResources.LPSpy_SpyMainWindow_ObjNameSameMsg, newName));
}
treeObjects.SelectedNode = dragNode;
AppEnvironment.SetModelChanged(true);
}
}
public void ModelFileHandler_SaveJson()
{
TreeView treeView = new TreeView();
TestObjectNurse rootNurse = TestObjectNurse.FromTree(treeView);
AppModel model = ModelFileHandler.LoadModelFile("UnitTestObjectModel1.json", rootNurse);
ModelFileHandler.SaveToModelFile(rootNurse, "ObjectModel2.json");
}
private void WebRefreshNodeTag(TreeNode node)
{
SETestObject seTestObject = TestObjectNurse.FromTreeNode(node).TestObject as SETestObject;
seTestObject.WebDriver = _webDriverHost.WebDriver;
foreach (TreeNode node0 in node.Nodes)
{
WebRefreshNodeTag(node0);
}
}
public void TestObjectNurse_NodeName()
{
UIATestObject testObject = new UIATestObject();
testObject.ControlType = ControlType.ComboBox;
TestObjectNurse nurse = new TestObjectNurse(testObject);
nurse.NodeName = "HelloWorld";
Assert.AreEqual("ComboBox: HelloWorld", nurse.TreeNode.Text);
}
private void LoadFile()
{
string tempFilePath = AppEnvironment.CurrentModelPath;
if (File.Exists(tempFilePath))
{
TestObjectNurse testObjectNurse = TestObjectNurse.FromTree(_presenterModel.GetTreeView());
ModelFileHandler.LoadModelFile(tempFilePath, testObjectNurse);
}
}
public static void WantToSave(TestObjectNurse rootNurseObject)
{
if (AppEnvironment.ModelStatus)
{
if (MessageBox.Show(StringResources.LPSpy_SpyMainWindow_SaveWarningMsg, StringResources.WarningTitle,
MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
Save(rootNurseObject);
}
}
}
public void mnuPropertyRemove_Click(object sender, EventArgs e)
{
string key = this.SelectedGridItem.PropertyDescriptor.Name;
TestObjectNurse nurseObject = (TestObjectNurse)this.Tag;
if (SpyWindowHelper.DeleteSelectedProperties(key, nurseObject.TestObject))
{
SetTestObject(nurseObject);
AppEnvironment.SetModelChanged(true);
}
}
private void mnuEditVirtualControls_Click(object sender, EventArgs e)
{
if (treeObjects.SelectedNode == null)
{
MessageBox.Show(StringResources.LPSpy_SpyMainWindow_SelNodeWarningMsg);
return;
}
TreeNode node = treeObjects.SelectedNode;
_presenterModel.EditVirtualControl(TestObjectNurse.FromTreeNode(node));
}
private static TestObjectNurse BuildTestObjectsHierarchy(List <AutomationElement> ancestorElements,
BreadcrumbControl breadcrumbControl,
LAPListViewControl listView,
Bitmap bmpDeskTop
)
{
int ancestorCount = ancestorElements.Count;
int breadcrumbCount = breadcrumbControl.Count;
int indexOfAutomationElement = 0;
UIATestObject topTestObject = UIAUtility.CreateTestObject(ancestorElements[0]);
TestObjectNurse topNurseObject = new TestObjectNurse(topTestObject);
TestObjectNurse currentNurseObject = topNurseObject;
if (ancestorCount > breadcrumbCount)
{
for (indexOfAutomationElement = 1; indexOfAutomationElement < ancestorCount && breadcrumbCount < ancestorCount - indexOfAutomationElement; ++indexOfAutomationElement)
{
AutomationElement element = ancestorElements[indexOfAutomationElement];
if (!string.IsNullOrEmpty(element.Current.Name))
{
UIATestObject childTestObject = UIAUtility.CreateTestObject(element);
currentNurseObject = (TestObjectNurse)currentNurseObject.AddChild(childTestObject);
}
}
}
Breadcrumb[] breadcrumbs = breadcrumbControl.GetItems();
foreach (Breadcrumb breadcrumb in breadcrumbs)
{
if (breadcrumb.Checked)
{
UIATestObject childTestObject = UIAUtility.CreateTestObject((breadcrumb.Tag as ElementProperties).AutomationElement);
currentNurseObject = (TestObjectNurse)currentNurseObject.AddChild(childTestObject);
}
}
ListView.CheckedListViewItemCollection selectedItems = listView.CheckedItems;
foreach (ListViewItem item in selectedItems)
{
if (null == item.Tag)
{
continue;
}
ElementProperties ep = item.Tag as ElementProperties;
TestObjectNurse subNurse = ep.ToNurseObject();
subNurse.ImageFile = SnapshotHelper.SnapshotFileFromBitmap(subNurse.TestObject, bmpDeskTop);
currentNurseObject.AddChild(subNurse);
}
return(topNurseObject);
}
public static bool Save(TestObjectNurse rootNurseObject)
{
bool succeed = ModelFileHandler.SaveToModelFile(rootNurseObject);
if (succeed)
{
AppEnvironment.SetModelChanged(false);
}
SpySettings.Persist();
return(succeed);
}
public void TestObjectNurse_ContainsKeyword()
{
UIATestObject testObject = new UIATestObject("Hello World", ControlType.Button, null);
TestObjectNurse nurse = new TestObjectNurse(testObject);
Assert.IsTrue(nurse.ContainsKeyword("Hello"));
Assert.IsTrue(nurse.ContainsKeyword("WORLD"));
Assert.IsFalse(nurse.ContainsKeyword("HelloWorld"));
Assert.IsTrue(nurse.ContainsKeyword("BUTTON"));
}
public void TestObjectNurse_Clear()
{
_childTestObject.AddChild(_grandChildTestObject);
_parentTestObject.AddChild(_childTestObject);
//root Nurse doesn't contain valid testObject, valid test objects start from its children
TestObjectNurse rootNurse = TestObjectNurse.AddTree(_treeView, _parentTestObject);
rootNurse.Clear();
Assert.AreEqual(0, rootNurse.Children.Count);
Assert.AreEqual(0, rootNurse.Nodes.Count);
}
private void AddButton_Click(object sender, EventArgs e)
{
TestObjectNurse nurseObject = TestObjectNurse.FromTreeNode((TreeNode)this.Tag);
SpyWindowHelper.AddSelectedProperty(propertyGrid, nurseObject);
if (EndUpdating != null)
{
EndUpdating(nurseObject);
}
this.Dispose();
}
