public void filteredTree_Siblings_checksFilterstrategy_test()
{
String id_text_filtered = "F6BC5E5ADD3B17478743923733E4BC8C";
guiFuctions.loadGrantProject(treePathUia2);
Object treeCopy = grantTrees.filteredTree.DeepCopy();
OSMElements.OSMElement osm_editNode_old = treeOperation.searchNodes.getFilteredTreeOsmElementById(id_text_filtered).DeepCopy();
IntPtr appHwnd = strategyMgr.getSpecifiedOperationSystem().getHandleOfApplication(strategyMgr.getSpecifiedTree().GetData(strategyMgr.getSpecifiedTree().Child(grantTrees.filteredTree)).properties.processName);
strategyMgr.getSpecifiedOperationSystem().setForegroundWindow(appHwnd);
System.Windows.Forms.SendKeys.SendWait("{ESC}");
System.Windows.Forms.SendKeys.SendWait(osm_editNode_old.properties.nameFiltered + "{+}" + osm_editNode_old.properties.nameFiltered + "1");
System.Windows.Forms.SendKeys.SendWait("^u"); // => Crlt + u => change calc modus
System.Threading.Thread.Sleep(200);
treeOperation.updateNodes.filteredTree(id_text_filtered, TreeScopeEnum.Sibling);
Assert.IsFalse(strategyMgr.getSpecifiedTree().Equals(treeCopy, grantTrees.filteredTree), "The tree shold be changed.");
Assert.IsTrue(strategyMgr.getSpecifiedTree().Count(treeCopy) < strategyMgr.getSpecifiedTree().Count(grantTrees.filteredTree), "Some nodes should be added for the 'new' mode!");
foreach (Object nodeObject_old in strategyMgr.getSpecifiedTree().AllNodes(treeCopy))
{
OSMElements.OSMElement osm_old = strategyMgr.getSpecifiedTree().GetData(nodeObject_old);
OSMElements.OSMElement osm_new = treeOperation.searchNodes.getFilteredTreeOsmElementById(osm_old.properties.IdGenerated);
if (osm_new != null && !osm_new.Equals(new OSMElements.OSMElement()))
{
Assert.AreEqual(osm_old.properties.grantFilterStrategy, osm_new.properties.grantFilterStrategy);
if (osm_old.properties.grantFilterStrategiesChildren != null)
{
Assert.IsTrue(osm_old.properties.grantFilterStrategiesChildren.All(osm_new.properties.grantFilterStrategiesChildren.Contains), "Both 'grantFilterStrategiesChildren' should have the same values! The node withe the id '" + osm_new.properties.IdGenerated + "' hasn't the correct 'grantFilterStrategiesChildren'!"); // Assert.AreEqual(osm_old.properties.grantFilterStrategiesChildren, osm_new.properties.grantFilterStrategiesChildren);
}
}
}
}
public void inspect()
{
if (strategyMgr.getSpecifiedOperationSystem().deliverCursorPosition())
{
try
{
int pointX;
int pointY;
strategyMgr.getSpecifiedOperationSystem().getCursorPoint(out pointX, out pointY);
Console.WriteLine("Pointx: " + pointX);
Console.WriteLine("Pointy: " + pointY);
OSMElements.OSMElement osmElement = strategyMgr.getSpecifiedFilter().getOSMElement(pointX, pointY);
Rectangle rect = strategyMgr.getSpecifiedOperationSystem().getRect(osmElement);
// this.Paint += new System.Windows.Forms.PaintEventHandler(this.Window_Paint);
strategyMgr.getSpecifiedOperationSystem().paintRect(rect);
}
catch (Exception ex)
{
Console.WriteLine("An error occurred: '{0}'", ex);
}
}
}
public void ChangeFilterForNodeTest()
{
HelpFunctions hf = new HelpFunctions(strategyMgr, grantTrees);
hf.filterApplication(applicationName, applicationPathName);
treeOperation.updateNodes.filterSubtreeWithCurrentFilterStrtegy(idTextNodeCalc);
List <Strategy> filterStrategys = Settings.getPossibleFilters();
Type currentFilter = strategyMgr.getSpecifiedFilter().GetType();
int indexNewFilterStrategy = 0;
foreach (Strategy strategy in filterStrategys)
{
if (!strategy.className.Contains(currentFilter.FullName) && !strategy.className.ToLower().Contains("java")) //kann raus wenn Java-Filter vorhanden ist
{
break;
}
indexNewFilterStrategy++;
}
strategyMgr.setSpecifiedFilter(filterStrategys[indexNewFilterStrategy].className);
strategyMgr.getSpecifiedFilter().setTreeOperation(treeOperation);
strategyMgr.getSpecifiedFilter().setGeneratedGrantTrees(grantTrees);
treeOperation.updateNodes.filterSubtreeWithCurrentFilterStrtegy(idTextNodeCalc);
OSMElements.OSMElement textNode = treeOperation.searchNodes.getFilteredTreeOsmElementById(idTextNodeCalc);
if (textNode.properties.grantFilterStrategy == null || !filterStrategys[indexNewFilterStrategy].userName.Equals(textNode.properties.grantFilterStrategy))
{
Assert.Fail("Die Filterstrategie wurde für den Knoten (richtig) nicht geändert!\nBtrachtet wurde der Knoten {0}\nDer filter hätte '{1}' sein sollen", textNode, filterStrategys[indexNewFilterStrategy].userName);
}
}
public void filteredTree_Siblings_test()
{
/*
* 1. change "Textfield"
* 2. change modus
* 3. filter siblings of "Textfild"
* 4. new nodes from new modus should be added BUT textfilt contend shouldn't be changed
*/
String id_text_filtered = "F6BC5E5ADD3B17478743923733E4BC8C";
String idFiltered_VerlaufNode_filtered = "ED842B72B012E86CE468B73FA1378361";
guiFuctions.loadGrantProject(treePathUia2);
Object treeCopy = grantTrees.filteredTree.DeepCopy();
OSMElements.OSMElement osm_editNode_old = treeOperation.searchNodes.getFilteredTreeOsmElementById(id_text_filtered).DeepCopy();
OSMElements.OSMElement osm_VerlaufNode_old = treeOperation.searchNodes.getFilteredTreeOsmElementById(idFiltered_VerlaufNode_filtered).DeepCopy();
IntPtr appHwnd = strategyMgr.getSpecifiedOperationSystem().getHandleOfApplication(strategyMgr.getSpecifiedTree().GetData(strategyMgr.getSpecifiedTree().Child(grantTrees.filteredTree)).properties.processName);
strategyMgr.getSpecifiedOperationSystem().setForegroundWindow(appHwnd);
System.Windows.Forms.SendKeys.SendWait("{ESC}");
System.Windows.Forms.SendKeys.SendWait(osm_editNode_old.properties.nameFiltered + "{+}" + osm_editNode_old.properties.nameFiltered + "1");
System.Windows.Forms.SendKeys.SendWait("^u"); // => Crlt + u => change calc modus
treeOperation.updateNodes.filteredTree(id_text_filtered, TreeScopeEnum.Sibling);
Assert.IsFalse(strategyMgr.getSpecifiedTree().Equals(treeCopy, grantTrees.filteredTree), "The tree shold be changed.");
Assert.IsTrue(strategyMgr.getSpecifiedTree().Count(treeCopy) < strategyMgr.getSpecifiedTree().Count(grantTrees.filteredTree), "Some nodes should be added for the 'new' mode!");
OSMElements.OSMElement osm_editNode_new = treeOperation.searchNodes.getFilteredTreeOsmElementById(id_text_filtered);
OSMElements.OSMElement osm_VerlaufNode_new = treeOperation.searchNodes.getFilteredTreeOsmElementById(idFiltered_VerlaufNode_filtered);
Assert.IsFalse(osm_VerlaufNode_old.Equals(osm_VerlaufNode_new));
Assert.IsTrue(osm_editNode_old.Equals(osm_editNode_new));
}
public void filterCalcTest()
{
HelpFunctions hf = new HelpFunctions(strategyMgr, grantTrees);
IntPtr appHwnd = strategyMgr.getSpecifiedOperationSystem().getHandleOfApplication(applicationName);
Assert.AreNotEqual(IntPtr.Zero, appHwnd, "Es hätte für die anwendung ein HWND ermittelt werden müssen!");
Object treeHWND = strategyMgr.getSpecifiedFilter().filtering(appHwnd, TreeScopeEnum.Application, -1);
Assert.AreNotEqual(null, treeHWND, "Es ist kein gefilterter Baum vorhanden");
#region Punkt in anwendung ermitteln
Object subtreeHWND = null;
if (strategyMgr.getSpecifiedTree().HasChild(treeHWND))
{
subtreeHWND = strategyMgr.getSpecifiedTree().Child(treeHWND);
if (strategyMgr.getSpecifiedTree().HasChild(subtreeHWND))
{
subtreeHWND = strategyMgr.getSpecifiedTree().Child(subtreeHWND);
}
}
Assert.AreNotEqual(null, subtreeHWND, "Es hätte ein Teilbaum gefunden werden müssen!");
OSMElements.OSMElement dataSubtreeHWND = strategyMgr.getSpecifiedTree().GetData(subtreeHWND);
#endregion
Object treePoint = strategyMgr.getSpecifiedFilter().filtering(Convert.ToInt32(dataSubtreeHWND.properties.boundingRectangleFiltered.X), Convert.ToInt32(dataSubtreeHWND.properties.boundingRectangleFiltered.Y), TreeScopeEnum.Application, -1);
Debug.WriteLine("treePoint:\n" + strategyMgr.getSpecifiedTree().ToStringRecursive(treePoint));
foreach (Object node in strategyMgr.getSpecifiedTree().AllChildrenNodes(treeHWND))
{
List <Object> nodes = treeOperation.searchNodes.getNodeList(strategyMgr.getSpecifiedTree().GetData(node).properties.IdGenerated, treePoint);
if (nodes.Count != 1)
{
Assert.Fail("Es wurde nicht die richtige Anzahl an zugehörigen Knoten im geladenen Baum gefunden! Betrachteter Knoten:\n{0}\n\t Anzahl der gefundenen zugehörigen Knoten im geladenen Baum = {1}", node, nodes.Count);
}
bool isEqual = compareToNodes(node, nodes[0]);
if (!isEqual)
{
Assert.Fail("Der geladene Baum enthält den Knoten folgenden Knoten nicht:\n{0}", strategyMgr.getSpecifiedTree().GetData(node));
}
}
foreach (Object node in strategyMgr.getSpecifiedTree().AllChildrenNodes(treePoint))
{
List <Object> nodes = treeOperation.searchNodes.getNodeList(strategyMgr.getSpecifiedTree().GetData(node).properties.IdGenerated, treeHWND);
if (nodes.Count != 1)
{
Assert.Fail("Es wurde nicht die richtige Anzahl an zugehörigen Knoten im gefilterten Baum gefunden! Betrachteter Knoten:\n{0}\n\t Anzahl der gefundenen zugehörigen Knoten im gefilterten Baum = {1}", node, nodes.Count);
}
bool isEqual = compareToNodes(node, nodes[0]);
if (!isEqual)
{
Assert.Fail("Der gefilterte Baum enthält den Knoten folgenden Knoten nicht:\n{0}", strategyMgr.getSpecifiedTree().GetData(node));
}
}
}
public void setSpecialPropertiesOfFirstNodeTest()
{
HelpFunctions hf = new HelpFunctions(strategyMgr, grantTrees);
IntPtr appHwnd = strategyMgr.getSpecifiedOperationSystem().getHandleOfApplication(applicationName);
Assert.AreNotEqual(IntPtr.Zero, appHwnd);
Object treeHWND = strategyMgr.getSpecifiedFilter().filtering(appHwnd, TreeScopeEnum.Application, -1);
Assert.AreNotEqual(null, treeHWND);
Assert.IsTrue(strategyMgr.getSpecifiedTree().HasChild(treeHWND));
OSMElements.OSMElement firstNodeData = strategyMgr.getSpecifiedTree().GetData(strategyMgr.getSpecifiedTree().Child(treeHWND));
Assert.IsNotNull(firstNodeData);
Assert.IsNotNull(firstNodeData.properties);
Assert.IsNotNull(firstNodeData.properties.grantFilterStrategy, "A filter strategy should be set at the first node.");
Assert.AreEqual("calc", firstNodeData.properties.processName, "The name of the process should be set at the first node of calc.");
Assert.IsNotNull(firstNodeData.properties.appPath, "The path of the application should be set at the first node of calc.");
}
public void TestGetNodeByProperties()
{
HelpFunctions hf = new HelpFunctions(strategyMgr, grantTrees);
hf.filterApplication(applicationName, applicationPathName);
Assert.IsNotNull(grantTrees.filteredTree);
foreach (Object node in strategyMgr.getSpecifiedTree().AllNodes(grantTrees.filteredTree))
{
OSMElements.OSMElement osmData = strategyMgr.getSpecifiedTree().GetData(node);
OSMElements.OSMElement osmDataWithoutId = osmData.DeepCopy();
osmDataWithoutId.properties.resetIdGenerated = null;
List <Object> foundObjects = treeOperation.searchNodes.getNodesByProperties(grantTrees.filteredTree, osmDataWithoutId.properties);
Assert.AreEqual(1, foundObjects.Count);
Assert.IsTrue(strategyMgr.getSpecifiedTree().Equals(node, foundObjects[0]));
}
}
public void UpdateNodeTest_grantFilterstrategyChildren()
{
String idPaneNode = "417F2ACC323396E993B4DC2AD2515D5E";
guiFuctions.loadGrantProject(treePathUia2);
OSMElements.OSMElement paneNodeOld = treeOperation.searchNodes.getFilteredTreeOsmElementById(idPaneNode).DeepCopy();
UpdateNodes up = new UpdateNodes(strategyMgr, grantTrees, treeOperation);
up.filteredNodeElementOfApplication(idPaneNode);
OSMElements.OSMElement paneNodeNew = treeOperation.searchNodes.getFilteredTreeOsmElementById(idPaneNode);
Assert.AreEqual(paneNodeOld.properties.grantFilterStrategy, paneNodeNew.properties.grantFilterStrategy);
//Assert.AreEqual(paneNodeOld.properties.grantFilterStrategiesChildren, paneNodeNew.properties.grantFilterStrategiesChildren);
if (!paneNodeOld.properties.grantFilterStrategiesChildren.All(p => paneNodeNew.properties.grantFilterStrategiesChildren.Contains(p))) // check whether 'osmParent.properties.grantFilterStrategiesChildren' is a subset of filterStrategiesChildren
{
Assert.Fail("The update of the 'grantFilterStrategiesChildren' wasn't correct!");
}
}
public void filteredTree_Children_test()
{
/*
* chekcs whether the children was updatet --> change the textfeld but the textfeld isn't part of the children nodes (it's a descendants)
*
*/
guiFuctions.loadGrantProject(treePathUia2);
String id_WindowNode = "29567A6D5962C2D9DD9E359AECE86E39"; // = root
String id_Pane = "417F2ACC323396E993B4DC2AD2515D5E";
String id_titlebar = "41B73937D557B2AB5DA85001ABF0C423";
String id_text = "F6BC5E5ADD3B17478743923733E4BC8C";
OSMElements.OSMElement osm_textNodeOld = treeOperation.searchNodes.getFilteredTreeOsmElementById(id_text).DeepCopy();
OSMElements.OSMElement osm_paneNode = treeOperation.searchNodes.getFilteredTreeOsmElementById(id_Pane).DeepCopy();
IntPtr appHwnd = strategyMgr.getSpecifiedOperationSystem().getHandleOfApplication(applicationName);
strategyMgr.getSpecifiedOperationSystem().setForegroundWindow(appHwnd);
System.Windows.Forms.SendKeys.SendWait("{ESC}");
System.Windows.Forms.SendKeys.SendWait(osm_textNodeOld.properties.nameFiltered + "{+}" + "3" + "{ENTER}");
treeOperation.updateNodes.filteredTree(id_WindowNode, TreeScopeEnum.Children);
OSMElements.OSMElement osm_textNodeNew = treeOperation.searchNodes.getFilteredTreeOsmElementById(id_text);
Assert.IsTrue(osm_textNodeOld.Equals(osm_textNodeNew), "this node shouldn't updated");
OSMElements.OSMElement osm_paneNodeNew = treeOperation.searchNodes.getFilteredTreeOsmElementById(id_Pane);
OSMElements.OSMElement osm_TitlebarNodeNew = treeOperation.searchNodes.getFilteredTreeOsmElementById(id_titlebar);
List <String> grantFSList = new List <string>()
{
"UIA", "UIA2"
};
Assert.AreEqual(2, osm_paneNodeNew.properties.grantFilterStrategiesChildren.Count());
Assert.AreEqual(1, osm_TitlebarNodeNew.properties.grantFilterStrategiesChildren.Count());
if (!osm_paneNodeNew.properties.grantFilterStrategiesChildren.Contains("UIA"))
{
Assert.Fail();
}
if (!osm_paneNodeNew.properties.grantFilterStrategiesChildren.Contains("UIA2"))
{
Assert.Fail();
}
if (!osm_TitlebarNodeNew.properties.grantFilterStrategiesChildren.Contains("UIA"))
{
Assert.Fail();
}
}
/// <summary>
/// Displays properties of the marked tree node of the filtered tree in an table.
/// </summary>
/// <param name="IdGenerated"></param>
void updatePropertiesTable(String IdGenerated)
{
OSMElements.OSMElement osmElement = treeOperations.searchNodes.getFilteredTreeOsmElementById(IdGenerated);
this.filteredPropRoot = new GuiFunctions.MyViewModel(osmElement);
if (filteredTreeProp.Columns.Count == 0)
{
filteredTreeProp.Columns.Clear();
/* int columnIndex = 0;
* foreach (var name in this.filteredPropRoot.ColumnNames)
* {
* filteredTreeProp.Columns.Add(
* new DataGridTextColumn
* {
* Header = name,
* Binding = new Binding(string.Format("Values[{0}]", columnIndex++))
* });
* }*/
filteredTreeProp.Columns.Add(
new DataGridTextColumn
{
Header = "Property",
// Binding = new Binding(string.Format("Values", 0)),
Binding = new Binding("Values.Name")
}
);
filteredTreeProp.Columns.Add(
new DataGridTextColumn
{
Header = "Content",
Binding = new Binding("Values.currentValue")
}
);
}
filteredTreeProp.DataContext = this.filteredPropRoot;
System.Drawing.Rectangle rect = strategyMgr.getSpecifiedOperationSystem().getRect(osmElement);
strategyMgr.getSpecifiedOperationSystem().paintRect(rect);
NodeButton.CommandParameter = IdGenerated;
}
public void FilterSubtreeTest()
{
HelpFunctions hf = new HelpFunctions(strategyMgr, grantTrees);
hf.filterApplication(applicationName, applicationPathName);
treeOperation.updateNodes.filterSubtreeWithCurrentFilterStrtegy(idTextNodeCalc);
IntPtr appHwnd = strategyMgr.getSpecifiedOperationSystem().getHandleOfApplication(applicationName);
strategyMgr.getSpecifiedOperationSystem().setForegroundWindow(appHwnd);
//Send Key -> Inhalt im Textfeld soll sich ändern
System.Windows.Forms.SendKeys.SendWait("{ESC}");
System.Windows.Forms.SendKeys.SendWait("24");
treeOperation.updateNodes.filterSubtreeWithCurrentFilterStrtegy(idTextNodeCalc);
OSMElements.OSMElement textNode = treeOperation.searchNodes.getFilteredTreeOsmElementById(idTextNodeCalc);
if (!textNode.properties.nameFiltered.Equals("24"))
{
Assert.Fail("Der Knoten wurde nicht richtig geändert oder geupdatet!\nBetrachteter Knoten:\n{0}", textNode);
}
}
public void TestGetIdFilteredNodeByHwnd()
{
HelpFunctions hf = new HelpFunctions(strategyMgr, grantTrees);
hf.filterApplication(applicationName, applicationPathName);
Assert.IsNotNull(grantTrees.filteredTree);
foreach (Object node in strategyMgr.getSpecifiedTree().AllNodes(grantTrees.filteredTree))
{
OSMElements.OSMElement osmData = strategyMgr.getSpecifiedTree().GetData(node);
String foundId = treeOperation.searchNodes.getIdFilteredNodeByHwnd(osmData.properties.hWndFiltered);
if (IntPtr.Zero.Equals(osmData.properties.hWndFiltered))
{
Assert.AreEqual(null, foundId);
}
else
{
Assert.AreEqual(osmData.properties.IdGenerated, foundId);
}
}
}
private void ExternalScreenreader_Click(object sender, RoutedEventArgs e)
{
OSMElements.OSMElement osm = strategyMgr.getSpecifiedExternalScreenreader().getScreenreaderContent();
if (osm != null)
{
treeOperations.updateNodes.addNodeExternalScreenreaderInFilteredTree(osm);
filteredTreeOutput.Items.Clear();
root.Items.Clear();
// root.Header = "Filtered - Tree";
guiFunctions.createTreeForOutput(grantTrees.filteredTree, ref root);
SaveButton.IsEnabled = true;
filteredTreeOutput.Items.Add(root);
NodeButton.IsEnabled = false;
/* updatePropertiesTable(strategyMgr.getSpecifiedTree().GetData(strategyMgr.getSpecifiedTree().Child(grantTrees.filteredTree)).properties.IdGenerated);
* ((TreeViewItem)filteredTreeOutput.Items[0]).IsSelected = true;
* ((TreeViewItem)filteredTreeOutput.Items[0]).IsExpanded = true;*/
GuiFunctions.clearTable(filteredTreeProp);
}
else
{
System.Diagnostics.Debug.WriteLine("Can't find content from an external screenreader!");
}
}
private void Window_KeyDown(object sender, System.Windows.Input.KeyEventArgs e)
{
IOperationSystemStrategy operationSystemStrategy = strategyMgr.getSpecifiedOperationSystem();
ITreeStrategy <OSMElements.OSMElement> treeStrategy = strategyMgr.getSpecifiedTree();
if (e.Key == Key.F1)
{
if (operationSystemStrategy.deliverCursorPosition())
{
try
{
IFilterStrategy filterStrategy = strategyMgr.getSpecifiedFilter();
int pointX;
int pointY;
operationSystemStrategy.getCursorPoint(out pointX, out pointY);
Console.WriteLine("Pointx: " + pointX);
Console.WriteLine("Pointy: " + pointY);
OSMElements.OSMElement osmElement = filterStrategy.getOSMElement(pointX, pointY);
System.Drawing.Rectangle rect = operationSystemStrategy.getRect(osmElement);
if (osmElement.properties.isOffscreenFiltered == false)
{
operationSystemStrategy.paintRect(rect);
}
}
catch (Exception ex)
{
Console.WriteLine("An error occurred: '{0}'", ex);
}
}
}
if (e.Key == Key.F5)
{
if (operationSystemStrategy.deliverCursorPosition())
{
try
{
//Filtermethode
IntPtr points = operationSystemStrategy.getHWNDByCursorPosition();
List <Strategy> possibleFilter = Settings.getPossibleFilters();
if (strategyMgr.getSpecifiedFilter() == null)
{
// auslesen aus GUI.....
String cUserFilterName = possibleFilter[0].userName; // der Filter muss dynamisch ermittelt werden
strategyMgr.setSpecifiedFilter(Settings.strategyUserNameToClassName(cUserFilterName));
strategyMgr.getSpecifiedFilter().setGeneratedGrantTrees(grantTrees);
strategyMgr.getSpecifiedFilter().setTreeOperation(treeOperations);
}
guiFunctions.deleteGrantTrees();
IFilterStrategy filterStrategy = strategyMgr.getSpecifiedFilter();
Object tree = filterStrategy.filtering(operationSystemStrategy.getProcessHwndFromHwnd(filterStrategy.deliverElementID(points)));
grantTrees.filteredTree = tree;
filteredTreeOutput.Items.Clear();
root.Items.Clear();
root.Header = "Filtered - Tree";
guiFunctions.createTreeForOutput(tree, ref root);
SaveButton.IsEnabled = true;
filteredTreeOutput.Items.Add(root);
NodeButton.IsEnabled = false;
/* updatePropertiesTable(strategyMgr.getSpecifiedTree().GetData(strategyMgr.getSpecifiedTree().Child(tree)).properties.IdGenerated);
* ((TreeViewItem)filteredTreeOutput.Items[0]).IsSelected = true;
* ((TreeViewItem)filteredTreeOutput.Items[0]).IsExpanded = true;*/
GuiFunctions.clearTable(filteredTreeProp);
}
catch (Exception ex)
{
Console.WriteLine("An error occurred: '{0}'", ex);
}
}
}
}
/// <summary>
/// Prüft, ob zwei Knoten gleich sind, dabei werden die folgenden Eigenschaften ignoriert: runtimeIDFiltered, hWndFiltered, processIdFiltered
/// </summary>
/// <param name="node1"></param>
/// <param name="node2"></param>
/// <returns><c>true</c> falls beide Knoten gleich sind; sonst <c>false</c></returns>
private bool compareToNodes(object node1, object node2)
{
if (strategyMgr.getSpecifiedTree().Depth(node1) != strategyMgr.getSpecifiedTree().Depth(node2))
{
Assert.Fail("Die Tiefe der beiden Knoten stimmt nicht überein!\n node1 = {0}\n node2 = {1}", strategyMgr.getSpecifiedTree().GetData(node1), strategyMgr.getSpecifiedTree().GetData(node2)); return(false);
}
if (strategyMgr.getSpecifiedTree().DirectChildCount(node1) != strategyMgr.getSpecifiedTree().DirectChildCount(node2))
{
Assert.Fail("Die Anzahl der direkten Kinder der beiden Knoten stimmt nicht überein!\n node1 = {0}\n node2 = {1}", strategyMgr.getSpecifiedTree().GetData(node1), strategyMgr.getSpecifiedTree().GetData(node2)); return(false);
}
OSMElements.OSMElement osmNode1 = strategyMgr.getSpecifiedTree().GetData(node1);
OSMElements.OSMElement osmNode2 = strategyMgr.getSpecifiedTree().GetData(node2);
if (osmNode1.properties.acceleratorKeyFiltered != null && !osmNode1.properties.acceleratorKeyFiltered.Equals(osmNode2.properties.acceleratorKeyFiltered))
{
Assert.Fail("Der acceleratorKey der beiden Knoten stimmt nicht überein!\n node1 = {0}\n node2 = {1}", strategyMgr.getSpecifiedTree().GetData(node1), strategyMgr.getSpecifiedTree().GetData(node2)); return(false);
}
if (osmNode1.properties.accessKeyFiltered != null && !osmNode1.properties.accessKeyFiltered.Equals(osmNode2.properties.accessKeyFiltered))
{
Assert.Fail("Der accessKeyFiltered der beiden Knoten stimmt nicht überein!\n node1 = {0}\n node2 = {1}", strategyMgr.getSpecifiedTree().GetData(node1), strategyMgr.getSpecifiedTree().GetData(node2)); return(false);
}
if (osmNode1.properties.autoamtionIdFiltered != null && !osmNode1.properties.autoamtionIdFiltered.Equals(osmNode2.properties.autoamtionIdFiltered))
{
Assert.Fail("Der autoamtionIdFiltered der beiden Knoten stimmt nicht überein!\n node1 = {0}\n node2 = {1}", strategyMgr.getSpecifiedTree().GetData(node1), strategyMgr.getSpecifiedTree().GetData(node2)); return(false);
}
if (osmNode1.properties.classNameFiltered != null && !osmNode1.properties.classNameFiltered.Equals(osmNode2.properties.classNameFiltered))
{
Assert.Fail("Der classNameFiltered der beiden Knoten stimmt nicht überein!\n node1 = {0}\n node2 = {1}", strategyMgr.getSpecifiedTree().GetData(node1), strategyMgr.getSpecifiedTree().GetData(node2)); return(false);
}
if (osmNode1.properties.controlTypeFiltered != null && !osmNode1.properties.controlTypeFiltered.Equals(osmNode2.properties.controlTypeFiltered))
{
Assert.Fail("Der controlTypeFiltered der beiden Knoten stimmt nicht überein!\n node1 = {0}\n node2 = {1}", strategyMgr.getSpecifiedTree().GetData(node1), strategyMgr.getSpecifiedTree().GetData(node2)); return(false);
}
if (osmNode1.properties.appPath != null && !osmNode1.properties.appPath.Equals(osmNode2.properties.appPath))
{
Assert.Fail("Der appPath der beiden Knoten stimmt nicht überein!\n node1 = {0}\n node2 = {1}", strategyMgr.getSpecifiedTree().GetData(node1), strategyMgr.getSpecifiedTree().GetData(node2)); return(false);
}
if (osmNode1.properties.frameWorkIdFiltered != null && !osmNode1.properties.frameWorkIdFiltered.Equals(osmNode2.properties.frameWorkIdFiltered))
{
Assert.Fail("Der frameWorkIdFiltered der beiden Knoten stimmt nicht überein!\n node1 = {0}\n node2 = {1}", strategyMgr.getSpecifiedTree().GetData(node1), strategyMgr.getSpecifiedTree().GetData(node2)); return(false);
}
if (osmNode1.properties.grantFilterStrategy != null && !osmNode1.properties.grantFilterStrategy.Equals(osmNode2.properties.grantFilterStrategy))
{
Assert.Fail("Der grantFilterStrategy der beiden Knoten stimmt nicht überein!\n node1 = {0}\n node2 = {1}", strategyMgr.getSpecifiedTree().GetData(node1), strategyMgr.getSpecifiedTree().GetData(node2)); return(false);
}
if (osmNode1.properties.hasKeyboardFocusFiltered != null && !osmNode1.properties.hasKeyboardFocusFiltered.Equals(osmNode2.properties.hasKeyboardFocusFiltered))
{
Assert.Fail("Der hasKeyboardFocusFiltered der beiden Knoten stimmt nicht überein!\n node1 = {0}\n node2 = {1}", strategyMgr.getSpecifiedTree().GetData(node1), strategyMgr.getSpecifiedTree().GetData(node2)); return(false);
}
if (osmNode1.properties.helpTextFiltered != null && !osmNode1.properties.helpTextFiltered.Equals(osmNode2.properties.helpTextFiltered))
{
Assert.Fail("Der helpTextFiltered der beiden Knoten stimmt nicht überein!\n node1 = {0}\n node2 = {1}", strategyMgr.getSpecifiedTree().GetData(node1), strategyMgr.getSpecifiedTree().GetData(node2)); return(false);
}
if (osmNode1.properties.IdGenerated != null && !osmNode1.properties.IdGenerated.Equals(osmNode2.properties.IdGenerated))
{
Assert.Fail("Der IdGenerated der beiden Knoten stimmt nicht überein!\n node1 = {0}\n node2 = {1}", strategyMgr.getSpecifiedTree().GetData(node1), strategyMgr.getSpecifiedTree().GetData(node2)); return(false);
}
if (osmNode1.properties.isContentElementFiltered != null && !osmNode1.properties.isContentElementFiltered.Equals(osmNode2.properties.isContentElementFiltered))
{
Assert.Fail("Der isContentElementFiltered der beiden Knoten stimmt nicht überein!\n node1 = {0}\n node2 = {1}", strategyMgr.getSpecifiedTree().GetData(node1), strategyMgr.getSpecifiedTree().GetData(node2)); return(false);
}
if (osmNode1.properties.isEnabledFiltered != null && !osmNode1.properties.isEnabledFiltered.Equals(osmNode2.properties.isEnabledFiltered))
{
Assert.Fail("Der isEnabledFiltered der beiden Knoten stimmt nicht überein!\n node1 = {0}\n node2 = {1}", strategyMgr.getSpecifiedTree().GetData(node1), strategyMgr.getSpecifiedTree().GetData(node2)); return(false);
}
if (osmNode1.properties.isKeyboardFocusableFiltered != null && !osmNode1.properties.isKeyboardFocusableFiltered.Equals(osmNode2.properties.isKeyboardFocusableFiltered))
{
Assert.Fail("Der isKeyboardFocusableFiltered der beiden Knoten stimmt nicht überein!\n node1 = {0}\n node2 = {1}", strategyMgr.getSpecifiedTree().GetData(node1), strategyMgr.getSpecifiedTree().GetData(node2)); return(false);
}
if (osmNode1.properties.isOffscreenFiltered != null && !osmNode1.properties.isOffscreenFiltered.Equals(osmNode2.properties.isOffscreenFiltered))
{
Assert.Fail("Der isOffscreenFiltered der beiden Knoten stimmt nicht überein!\n node1 = {0}\n node2 = {1}", strategyMgr.getSpecifiedTree().GetData(node1), strategyMgr.getSpecifiedTree().GetData(node2)); return(false);
}
if (osmNode1.properties.isPasswordFiltered != null && !osmNode1.properties.isPasswordFiltered.Equals(osmNode2.properties.isPasswordFiltered))
{
Assert.Fail("Der isPasswordFiltered der beiden Knoten stimmt nicht überein!\n node1 = {0}\n node2 = {1}", strategyMgr.getSpecifiedTree().GetData(node1), strategyMgr.getSpecifiedTree().GetData(node2)); return(false);
}
if (osmNode1.properties.isRequiredForFormFiltered != null && !osmNode1.properties.isRequiredForFormFiltered.Equals(osmNode2.properties.isRequiredForFormFiltered))
{
Assert.Fail("Der isRequiredForFormFiltered der beiden Knoten stimmt nicht überein!\n node1 = {0}\n node2 = {1}", strategyMgr.getSpecifiedTree().GetData(node1), strategyMgr.getSpecifiedTree().GetData(node2)); return(false);
}
if (osmNode1.properties.isToggleStateOn != null && !osmNode1.properties.isToggleStateOn.Equals(osmNode2.properties.isToggleStateOn))
{
Assert.Fail("Der isToggleStateOn der beiden Knoten stimmt nicht überein!\n node1 = {0}\n node2 = {1}", strategyMgr.getSpecifiedTree().GetData(node1), strategyMgr.getSpecifiedTree().GetData(node2)); return(false);
}
if (osmNode1.properties.itemStatusFiltered != null && !osmNode1.properties.itemStatusFiltered.Equals(osmNode2.properties.itemStatusFiltered))
{
Assert.Fail("Der itemStatusFiltered der beiden Knoten stimmt nicht überein!\n node1 = {0}\n node2 = {1}", strategyMgr.getSpecifiedTree().GetData(node1), strategyMgr.getSpecifiedTree().GetData(node2)); return(false);
}
if (osmNode1.properties.itemTypeFiltered != null && !osmNode1.properties.itemTypeFiltered.Equals(osmNode2.properties.itemTypeFiltered))
{
Assert.Fail("Der itemTypeFiltered der beiden Knoten stimmt nicht überein!\n node1 = {0}\n node2 = {1}", strategyMgr.getSpecifiedTree().GetData(node1), strategyMgr.getSpecifiedTree().GetData(node2)); return(false);
}
if (osmNode1.properties.labeledByFiltered != null && !osmNode1.properties.labeledByFiltered.Equals(osmNode2.properties.labeledByFiltered))
{
Assert.Fail("Der labeledByFiltered der beiden Knoten stimmt nicht überein!\n node1 = {0}\n node2 = {1}", strategyMgr.getSpecifiedTree().GetData(node1), strategyMgr.getSpecifiedTree().GetData(node2)); return(false);
}
if (!osmNode1.properties.localizedControlTypeFiltered.Equals(osmNode2.properties.localizedControlTypeFiltered))
{
Assert.Fail("Der localizedControlTypeFiltered der beiden Knoten stimmt nicht überein!\n node1 = {0}\n node2 = {1}", strategyMgr.getSpecifiedTree().GetData(node1), strategyMgr.getSpecifiedTree().GetData(node2)); return(false);
}
if (osmNode1.properties.processName != null && !osmNode1.properties.processName.Equals(osmNode2.properties.processName))
{
Assert.Fail("Der moduleName der beiden Knoten stimmt nicht überein!\n node1 = {0}\n node2 = {1}", strategyMgr.getSpecifiedTree().GetData(node1), strategyMgr.getSpecifiedTree().GetData(node2)); return(false);
}
if (osmNode1.properties.nameFiltered != null && !osmNode1.properties.nameFiltered.Equals(osmNode2.properties.nameFiltered))
{
Assert.Fail("Der nameFiltered der beiden Knoten stimmt nicht überein!\n node1 = {0}\n node2 = {1}", strategyMgr.getSpecifiedTree().GetData(node1), strategyMgr.getSpecifiedTree().GetData(node2)); return(false);
}
if (!osmNode1.properties.rangeValue.Equals(osmNode2.properties.rangeValue))
{
Assert.Fail("Der rangeValue der beiden Knoten stimmt nicht überein!\n node1 = {0}\n node2 = {1}", strategyMgr.getSpecifiedTree().GetData(node1), strategyMgr.getSpecifiedTree().GetData(node2)); return(false);
}
if (!osmNode1.Equals(osmNode2))
{
Assert.Fail("The nodes aren't equals.");
}
return(true);
}
