Problem with using wildcards in Object finding

I am having a similar problem, and I am using the the wildcard:

'*(\"GridViewCell\", \"*\", 4)'

but I am getting:

WPFObject("GridViewCell", "$0.00", 14)

instead of:

WPFObject("GridViewCell", "zzz", 4)



So something is not parsing correctly

Hi,



Can you post here the exact code line which calls Find in your script?

Are you using the Name property in the find?  I, personally, would avoid that.  I would also avoid, if you're looking for a particular object, using the index as a reference as that is not always a static value (sometimes the same object may return under a different index depending upon how the application under test renders and displays them).



What you should do in your find call is choose properties that, the combination of which, will locate and return the particular object.  For example, you know that the class name is "TextBox" and you are looking for a particular one with a particular caption, I'm assuming.



so, what I would do is the following:

var MyObject = MyApp.FindChild(["WndClass", "WndCaption"], ["TextBox", "1"], 10)

This will return the first child object off the application with a class of TextBox, a caption of 1, and will search down a depth of 10 items.



The Name property is unreliable for a search using Find because the Name property can contain variable values, in this case, the index, which are unreliable in returning what you want.

aChildObjects =VBArray(oInitialObject.FindAllChildren(aProperty, aValue, 30, true)).toArray();

aProperty is an array with the properties (in this case only  "Name", aValue is an array with the search strings (in this case *WPFObject("TextBlock", "*", 8)*    )



-edit-

I notice another answer just while typing this :)



In this case, the only difference is in the Name property. Class is exactly the same. We want to avoid finding objects based on what is actual a caption or text value so we use Name (and often Enabled & Visibility settings), or unique identifiers such as ObjectIdentifier & Uid properties. But those are currently not available in highly dynamic WPF code.

The thing is, the Name property you are using IS using both the class and the caption so you're not really getting anywhere with that.



WndCaption and WndClass are only examples.  You can use the Find method with any combination of properties.  The key is to use a set of properties that will uniquely identify the component you're looking for.  Again, caption, index and name (because name includes both caption and index) are unreliable for unique identification if they are subject to frequent changes.



You can use the wildcard on the caption, but as you noted, that will return more than one potential object since the index is different.  You CAN use the index if you can be assured that the object will ALWAYS have index 8.  In my experience, that is very hard to nail down so I avoid using the index as a search parameter.

This is why I used a * in the place of the caption, so it doesn't matter what is filled. At least, that is how I understand it to work. 

WPFObject("TextBlock", "*", 8)* 

The index is always 8, but still it returns the object with index 7.

To further elaborate:



Example: We have 8 entry fields with values. They are dynamically built so the only way to identify them is by Name (or indeed by caption). But if they have the same caption, you still have the problem that it won't uniquely identify.



If contents in 2 fields is "test" and both objects are TextBlocks you have a problem if you want to check 1 of the 2.

In that case, don't use the caption or the index.  I'm not sure why the name search is not returning but I suspect your use of the wildcarding may have a syntaxing problem where the wildcard is being improperly recognized or applied..  Could you post the whole code block including the assignment of aValue?  



Again, I think your better bet is to use Class (TextBox) and some other property.  Perhaps there's some sort of internal ID that can be used that is always the same.  In any case, the Name property itself is one of the "dynamic" properties of an object and, even though you may wildcard a part of it, that does not guarentee that you'll always return the same object.

The entire function looks like this (don't have too much experience with javascript)

FindObject(xMapping, sProperties)

FindObject(xMapping, sProperties)
{

var aChildObjects, iNumberOfFoundObjects; 

var j, iPropertyCount = 0; 

var aProperty = [], aValue = []; 

 

//Set initial object

var oInitialObject = SetInitialObject(xMapping);

 

//Abort if Initial object can not be set due to incorrect mapping

if (!oInitialObject.Exists)

{

Log.Error(sIndent + "The object with mapping '" + sApplication + "." + xMapping + "' does not exist. Please check mapping.");

return null;

}

 

//Loop through all arguments

for (var i = 1; i < arguments.length; i += 2)

{

//Set the object property/value combination

aProperty[iPropertyCount] = arguments;

aValue[iPropertyCount] = arguments[i + 1];

 

//Add property/value combo count

iPropertyCount++; 

 

//Find object within the mapping 

aChildObjects =VBArray(oInitialObject.FindAllChildren(aProperty, aValue, 30, true)).toArray();

iNumberOfFoundObjects = aChildObjects.length;

 

//No object found

if (iNumberOfFoundObjects === 0)

{

return null;

}

 

//Unique object found 

else if (iNumberOfFoundObjects == 1)

{

return aChildObjects[0];

}

}

 

//Loop finished, but still more than 1 object found 

Log.Message(sIndent + "Object could not be found unique. " + iNumberOfFoundObjects + " objects were found: (Last found object will be returned)");

for (j = 0; j < iNumberOfFoundObjects; j++)

{

Log.Message(sIndent + sIndent + aChildObjects.Name + " was found with initial property '" + arguments[2] + "'.");

}

return aChildObjects[iNumberOfFoundObjects - 1];

}

interesting function, but what I would like to see is the context within which it is called... how is sProperties being passed in to the function?  That's the key, really, in that depending upon how the properties are being defined and the values being used, as to how the FindAllChildren function will return the objects.