Test Automation‎ > ‎

Exception messages

Here is a list of exceptions that can occur when using the Friendly libraries.
When this information is not enough, please contact the following address:
Friendly*Codeer.co.jp (Replacing the  * with @)



1.
Message
Failed to connect to application.

Cause
        Occurs attempting to attach a WindowsAppFriend when the target process has already completed.

        // A exception occurs when the target process has already completed
        WindowsAppFriend app = new WindowsAppFriend(process, "4.0");



2.
Message
Failed to connect to the specified process.
The specified CLR version number may be incorrect.
Please bear in mind that the CLR version may be different from the .NET framework version.
Please see the Codeer website to check supported version numbers.

Cause
Occurs when the CLR version of the target process is incorrect when attaching a WindowsAppFriend.
Confusing the CLR version with the .NET framework version is a common cause.

Mistake:
//The CLR version 3.0 does not exist. The CLR version should be 2.0 when .NET framework 3.0 is used.
WindowsAppFriend app = new WindowsAppFriend(process, "3.0");

Correction:
WindowsAppFriend app = new WindowsAppFriend(process, "2.0");

Supported versions
"2.0"
Use this for .NET framework 2.0, 3.0, and 3.5
"4.0"
Use this for .NET framework 4.0 and 4.5




3.
Message
Failed to connect to the specified process.
Installation may have failed.

Cause
        Occurs when DLL execution fails upon attaching a WindowsAppFriend to a target process. 
        Certain installation issues can be the cause of this.



4.
Message
Failed to operate target process. Access to operate the target process was denied, or it may have terminated during connection.

Cause
Occurs when the product process has a higher trust level than the test process when attaching a WindowsAppFriend.
For example, the product process has administrator permissions and the test process has user permissions.
This can be solved by runing the test process as an administrator.
This can also occur when a target application
abnormally terminates during connection.



5.
Message
Platform targets differ between the test target and test process. Please ensure they are the same.

Cause
Occurs when the target CPU differs between the product process and test process.
This can happen when the test process is operating at 32 bits while the product process is operating in 64 bit mode on a 64-bit OS, etc.
For test projects in VisualStudio, the execution environment is x86 by the default.
This requires changing not the build settings, but the test host settings.
Please go here for more information.



6.
Message
Illegal static function call. Operation information requires a type.

Cause
Because AppFriends' FriendlyOperations invoke static methods, they require type information.
This can occur when by accident, only the method name is specified.

// correct call.
app["System.Windows.Forms.Control.FromHandle"](handle);

// illegal call.(Exception occurs.)
app["FromHandle"](handle);



7.
Message
An exception occurred inside the target application.
[Message]
{0}
[Exception type]
{1}
[Error cause]
{2}
[Stack trace]
{3}
[Help]
{4}

Cause
This is sent to a test process when an operation performed by a FriendlyOperation causes
an exception to occur inside a target application. 
For example, given the following code.

Code
AppVar dic = app.Dim(new NewInfo<Dictionary<int, string>>());
dic["Add"](1, "1");
dic["[]"] (2); // KeyNotFoundException occurs because the key 2 iss not contained in dic.

        Message
An exception occurred inside the target application.
[Message]
          The specified key does not exist in the directory.
[Exception type]
System.Collections.Generic.KeyNotFoundException
[Error cause]
mscorlib
[stack trace]
place System.Collections.Generic.Dictionary`2. Get_Item (TKey Key)
[Help]



8.
Message
Communication with the application failed.
The target applcation may be unreachable or you may be trying to send
data that cannot be serialized.

Cause
Although this can be due to two different causes, implementation details can make them impossible to distinguish.

(1) Target application terminated unexpectedly.
It occurs when the target application terminates unexpectedly while the operating it.
This can also happen when a FriendlyApplication synchronously terminates the application.
When intentionally terminating an application, it is better to do so asynchronously or expect an exception and catch it.

WindowControl mainForm = WindowControl.FromZTop(app);
mainForm["Close"] (); // Application terminates while waiting for a response, causing an exception

(2) An attempt was made to send data whose type is not serializable.
Variables that can be passed as arguments should either be serializable or AppVars.
Also, AppVar's Core property can only interact with serializable objects.
This can occur in the following case:

           WindowControl mainForm = WindowControl.FromZTop(app);
 Form f = (Form)mainForm.AppVar.Core; // Exception occurs since Form class cannot be serialized.


9.
Message
The maximum of the number of concurrent transmissions has been exceeded.

Cause

Friendly operations can be nested using special techniques, but this exception can occur when the
nesting depth reaches the maximum uint value.  
This does not usually occur.




10.
Message
[type: {0}][operation: {1} ({2})]
The specified operation name was found but could not be carried out.
The arguments could be incorrect.
Note that numerical types and Enums are strictly differentiated.
(For example, even when passing an int as an argument for a long parameter, they are treated as different types and the call fails.)
When calling a method with a params argument, please pass the argument as an array value.

Cause
Occurs when executing a FriendlyOperation where the operation name is found, but execution fails because the parameters could not be resolved. This can happen in certain unintuitive situations, as shown below.

(1) A literal value is passed to a method that takes a long as a parameter.
For example, the following functions are defined in the target application:
void func(long value)

When calling the FriendlyOperation like this:
appVar["func"](3);

This literal value 3 is interpreted as an int value.
Therefore, the search for a version of the function that takes an int parameter fails.
The call will succeed if corrected as follows:

appVar["func"]((long)3);


(2) When calling a method with a params parameter
For example, the following function is defined in the target application:
void func(params int[] value)

When called as follows with a FriendlyOperation:
appVar["func"](1, 2, 3);

Searching for a method that takes three int arguments fails.
The call will succeed if corrected as follows:

appVar["func"](new int[]{1, 2, 3});

(3) When an Enum is involved
You may have some trouble deciding what to do with an enum defined within the product code.
First, adding a reference to the product assembly is the simplest approach.
If the Enums are defined as internal, this can be solved by making the test application a friend assembly.
If you do not want to add a reference, you can do the following, and pass the enum value in an AppVar.

For example, suppose that a function has a parameter using the following Enum that is defined in the product code:
namespace Product {
    enum MyEnum{
        A,
        B,
    }
}

void func(MyEnum value)

In this case, you can pass this enum value to the product process with the following syntax:
AppVar a = app["Product.MyEnum.A"]();
appVar["func"](a);


11.
Message
[type: {0}][operation: {1} ({2})]
An operation with the specified name was found, but could not be performed.
The specified arguments may be incorrect.
When calling an option with a params argument, please pass the value as an array.
When passing object[] as a parameter, this cannot be distinguished from params object[].
Please pass it as an element of an object[] array in this case.
object[] arg;        // object[] to pass as a single argument.
object[] tmpArg = new object[0];
tmpArg [0] = arg;// Please pass tmpArg after doing this
Cause
Occurs when executing a FriendlyOperation and the specified method (or property, or field) exists, but the arguments cannot be resolved and the call fails. This can happen in unintuitive situations, as shown below.

(1) When calling a method that has a params parameter 
For example, the following function is defined in the target application:
void func(params int[] value)

When called as follows with a FriendlyOperation:
appVar["func"](1, 2, 3);

Searching for a method that takes three int arguments fails.
The call will succeed if corrected as follows:
appVar["func"](new int[]{1, 2, 3});

(2) When passing an object[]
The argument of a FriendlyOperation itself is params object[].
Therefore, if object[] is passed, it will be expanded and the intended value will not be clear anymore.
Therefore, there is a need to explicitly indicate the value as an object[].
The approach to use here is to place the object[] inside another object[] and pass that to the FriendlyOperation.

For example, the following function is defined in the target application
void func(object[] objs)

When called as follows by a FriendlyOperation
appVar["func"](new object[]{1, 3, 3});

The search for a method that takes three int arguments will fail.
The call will succeed if corrected as follows:
appVar["func"](new object[] {new object[]{1, 2, 3}});

It was not an easy decision to have the functionality work this way, but it was kept this way because
there was no easier way to approach it.
We ask for your understanding.



12.
Message
[new {0}({1})]
More than one constructor matching the specified arguments was found.
Please clarify the arguments' types or use OperationTypeInfo.

Cause
Occurs when the arguments passed to a constructor match more than one overloaded version of the constructor.
For example, when the following class is defined in the target application:
namespace Product {
class MyClass {
    internal MyClass(Control c){}
    internal MyClass(string s){}
    }
}

If the constructor is called using a FriendlyOperation, it will not know which one to use, and will fail.
app.Dim(new NewInfo ("Product.MyClass", null)); // Exception occurs because the constructor to call could not be determined

This can be resolved by using OperationTypeInfo
// The constructor that takes a string argument can be called.
app.Dim(new NewInfo("Product.MyClass", null), new OperationTypeInfo("Product.MyClass", "System.String"));


13.
Message
[type: {0}][operation: {1} ({2})]
More than one operation matching the specified arguments was found.
Please clarify arguments' types or use OperationTypeInfo.

Cause
Occurs when the arguments passed to a method match more than one overloaded version of that method.
For example, when the following methods are defined in the target application,
namespace Product {
class MyClass {
    internal void func(Control c){}
    internal void func(string s){}
    }
}

If a call is made as follows by FriendlyOperation, it will fail to determine the method to use and fail.
appVar ["func"] (null); // A exception occurs since the method which should be called cannot be determined.

This can be resolved by using OperationTypeInfo.
The func which takes a string class to an argument can be called.
appVar["func", new OperationTypeInfo("Product.MyClass", "System.String")](null);


14.
Message
[new {0}({1})]
The constructor was not found.
The arguments specified may be incorrect.
Note that numerical types and Enums are strictly differentiated.
(For example, even when passing an int as an argument for a long parameter, they are treated as different types and the call fails.)
When calling a method with a params argument, please pass the argument as an array value.

Cause
Occurs when using NewInfo to create an object instance in the target application and the indicated constructor exists, but execution fails because the arguments could not be resolved.
This can happen in certain unintuitive situations, as shown below.

(1) A literal value is passed to a constructor that takes a long as a parameter.
For example, the following constructor is defined in the target application:
namespace Product {
class MyClass {
    internal MyClass(long value){}
    }
}

When Dim is called as follows:
app.Dim(new NewInfo("Product.MyClass", 3));

The 3 literal value is interpreted as an int value.
Therefore, the search for a constructor that takes an int parameter fails.
It will succeed if corrected as follows:

app.Dim(new NewInfo("Product.MyClass", (long)3));

(2) When calling a constructor with a params parameter.
For example, the following constructor is defined in the target application:
namespace Product {
class MyClass {

    internal MyClass(params int[] value){}* *}
}

When it called as follows with Dim:
app.Dim(new NewInfo("Product.MyClass", 1, 2, 3));

The search for a constructor which takes three int arguments fails within the target application.
It will succeed if corrected as follows:
app.Dim(new NewInfo("Product.MyClass", new int[]{1, 2, 3}));


(3) When an Enum is involved
          You may have some trouble deciding what to do with an enum defined within the product code.
          First, adding a reference to the product assembly is the simplest approach. 
          If the Enums are defined as internal, this can be solved by making the test application a friend assembly. 
          If you do not want to add a reference, you can do the following, and pass the enum value in an AppVar.
      


For example, suppose that a function has a parameter using the following Enum that is defined in the product code.
namespace Product {
enum MyEnum{
    A,
    B,
}

class MyClass {
    internal MyClass(MyEnum value){} }
}

In this case, you can pass this enum value to the product process with the following syntax:
AppVar a = app["Product.MyEnum.A"]();
app.Dim(new NewInfo("Product.MyClass", a));



15.
Message
[new {0}({1})]
A constructor was not found.
The arguments specified may be incorrect.
When calling an option with a params argument, please pass the value as an array.
When passing object[] as a parameter, this cannot be distinguished from params object[].
Please pass it as an element of an object[] array in this case.
object[] arg;       // object[] to pass as a singl argument
object[] tmpArg = new object[0];
tmpArg [0] = arf // please pass tmpArg after doing this
Cause
Occurs when using NewInfo to create an object instance in the target application and the indicated constructor exists, but execution fails because the arguments could not be resolved.
This can happen in certain unintuitive situations, as shown below.


(1) When calling a method that has a params parameter
For example, the following constructor is defined in the target application:
namespace Product {
    class MyClass {   
        
internal*MyClass(params int[] value){}
    }

}

When Dim is called as follows:
app.Dim(new NewInfo("Product.MyClass", 1, 2, 3));

The search for a constructor that takes three int arguments will fail.
It will succeed if corrected as follows:
app.Dim(new NewInfo("Product.MyClass", new int[]{1, 2, 3}));

(2) When passing an object[]
The argument of the NewInfo constructor is itself params object[].
Therefore, if object[] is passed, it will be expanded and the intended value will not be clear anymore.
Therefore, there is a need to explicitly indicate the value as an object[].
The approach to use here is to place the object[] inside another object[] and pass that to the NewInfo constructor.

For example, the following constructor is defined in the target application:
namespace Product {
    class MyClass {
            internal*MyClass(object[] value){}
    }

}

When Dim is called as follows:
app.Dim(new NewInfo("Product.MyClass", new object[]{1, 2, 3}));

The search for a method that takes three int arguments will fail within the target application.
It will succeed if corrected as follows:
app.Dim(new NewInfo("Product.MyClass",*new object[] {new object[]{1, 2, 3}}));

It was not an easy decision to have the functionality work this way, but it was kept this way because
there was no easier way to approach it.
We ask for your understanding.



16.
Message
[type : {0}][operation : {1} ({2})]
The selected operation was not found.

Cause
Occurs when trying to use a FriendlyOperation to access a method, property, or field in the target application and it is not found.
This could be due to a spelling mistake, or the assembly where the type is defined may not be loaded within the target application.
An assembly is not loaded if the type contained in the assembly is not actually used, since .NET uses delayed loading.
When it is in that state, the FriendlyOperation can fail.

This can be resolved by carrying out an action that causes the type to be loaded in the target application, or by using WindowsAppExpander to cause the application to load the assembly.




17.
Message
[OperationTypeInfo.Arguments: ({0})][argument : ({1})]
The specified arguments are incorrect. The number of arguments do not match the number expected by the type.
When calling a method with a params parameter, please place the arguments in an array.

Cause
Occurs when the number of arguments passed to a FriendlyOperation or NewInfo does not match the number of parameters expected by the operation.
Aside from this occurring due to a simple mistake, this could also occur if a params parameter is involved.
In the case of a params parameter, this can be solved by placing the arguments in an array.
For example, the following function is defined in the target application:
namespace Product {
    
class MyClass {

        internal void func(params int[] value){}
    }
}

When it called as follows with a FriendlyOperation:
appVar["func", new OperationTypeInfo("Product.MyClass", "System.Int32[]")](1, 2, 3);

Since the number of the arguments specified in the OperationTypeInfo is 1 and 3 are passed, an exception occurs.
It will work correctly if corrected as follows:
appVar["func", new OperationTypeInfo("Product.MyClass", "System.Int32[]")](new int[]{1, 2, 3});



18.
Message
[OperationTypeInfo.Arguments: ({0})] [argument : ({1})]
The specified arguments are incorrect. The number of arguments do not match the number expected by the type.
When calling a method with a params parameter, please place the arguments in an array.
When passing object[] as a parameter, this cannot be distinguished from params object[].
Please pass it as an element of an object[] array in this case.
object[] arg;         // object[] to pass
object[] tmpArg = new object[0];
tmpArg [0] = arg; // please pass tmpArg after doing this

Cause

Occurs when the number of arguments passed to a FriendlyOperation or NewInfo does not match the
number of parameters expected by the operation.
Aside from this occurring due to a simple mistake, this could also occur if a params parameter is involved.
In the case of a params parameter, this can be solved by placing the arguments in an array.


(1) When calling a method that has a params parameter
For example, suppose the following method is defined in the target application:
namespace Product {
    class MyClass {
        internal void func(params int[] value){}
    }
}

When called as follows with a FriendlyOperation:
appVar["func", new OperationTypeInfo("Product.MyClass",*"System.Int32[]")](1, 2, 3);

Since the number of the arguments specified in the OperationTypeInfo is 1 and 3 are passed, an exception occurs.
It will work correctly if corrected as follows.
appVar["func", new OperationTypeInfo("Product.MyClass",*"System.Int32[]")](new int[]{1, 2, 3});

(2) In the case of an object[] parameter
For example, suppose the following method is defined in the target application:
namespace Product {
    class MyClass {
        internal func(object[] value){}
    }

}

When called as follows with a FriendlyOperation:
appVar["func", new OperationTypeInfo("Product.MyClass",*"System.Object[]")](1, 2, 3);

Since the number of the arguments specified in the OperationTypeInfo is 1 and 3 are passed, an exception occurs.
Additionally, in the case of object[], each element will be treated as a separate arguments when passed to the FriendlyOperation. The object[] needs to be wrapped in yet another object[].
It will work correctly if corrected as follows:
appVar["func", new OperationTypeInfo("Product.MyClass",*"System.Object[]")](new object[]{*new object[]{1, 2, 3}});



19.
Message
The selected variable does not implement IEnumerable.

Cause
The Enumerate class can be used with a foreach loop iterate through the elements of an AppVar passed to Enumerate's constructor.

// This works with arrays and other types that implement IEnumerable
// This can be slow since communication must be sent between the two applications on every iteration.
// IWhen working with many elements, it's better to use WindowsAppExpander to load the code into the target application.
AppVar appVar = app.Dim(new int[]{1, 2, 3});
foreach(AppVar element in new Enumerate(appVar))
{
//...
}

Of course, this is possible when the object stored in AppVar passed to the Enumerate constructor implements IEnumerable.
This exception will occur when this is not the case.

// A exception occurs since the underlying object (int value etc.) does not implement IEnumerable.
AppVar appVar = app.Dim(1);

foreach(AppVar element in new Enumerate(appVar))
{
//...
}



20.
Message
An operation was executed on an AppVar containing a null value.

Cause
Occurs when a FriendlyOperation is executed on an appVar whose internal value is null.

AppVar appVar = app.Dim();    // Declared with no parameters. It is null at this time 
appVar ["func"] ();  // A exception occurs since FriendlyOperation was called while the appVar is in a null state.



21.
Message
The available variable space in the application was exceeded.

Cause
Occurs when the number of AppVars simultaneously in use exceeds the maximum value of uint.
This should not generally happen.



22.
Message
[{0}]
The selected type was not found.
The specified type's full name is incorrect or the module containing the type has not yet been loaded.

Cause
Occurs when performing an operation using a type that does not currently exist in the target application.
Specifically, occurs when an incorrect type is used when calling a static operation using AppFriend's FriendlyOperation, or when creating an instance using NewInfo.
This could be due to a spelling error, or the type may not be loaded in the application.
Due to .NET's delayed loading, an assembly is not loaded until a type contained in the assembly is actually used.
This can cause a failure when trying to call a FriendlyOperation.


23.
Message
This has already been executed. An Async object can only be used once. To call an operation more than once, create a new Async object.

Cause
Occurs when the same instance of Async class is used more than once.
For example, it will occur when the following code is run:
Async async = new Async();
button1.EmulateClick(async);
button2.EmulateClick(async);

This can be resolved by creating a separate instance each time:
Async async1 = new Async();
button1.EmulateClick(async1);
Async async2 = new Async();
button2.EmulateClick(async2);



24.
Message
The specified AppVar belongs to a separate AppFriend's variable pool.

Cause
AppVars are ultimately managed by an AppFriend.
Therefore, AppVars managed by the same AppFriend can be used in the argument of a call.
However, even if two AppFriends are attached to the same process, each manages its own AppVars, and these cannot be intermingled.

WindowsAppFriend app = new WindowsAppFriend(process, "4.0");
AppVar dic = app.Dim(new NewInfo<Dictionary<int, string>>());
dic["Add"](1, "1");
AppVar checkValue = app.Dim();
AppVar isSuccess = dic ["TryGetValue"] (1, checkValue);     // It is possible to use AppVar as an argument in this way.

// One more is attached for the same process.This is possible.
WindowsAppFriend app2 = new WindowsAppFriend(process, "4.0");
// Variable is declared.
AppVar checkValue2 = app.Dim();
// However, they cannot be used together.
dic ["TryGetValue"] (1, checkValue2); // exception occurs.



25.
Message
Invalid completion specification. This method should not generally be called.

Cause
Occurs when a SetCompleted method is called on an instance of an Async class whose operation has already completed.
This method is used for developing libraries and should not generally be called by test code.



26.
Message
Communication with the application failed.
The indicated window in the target thread does not exist or has already been disposed.
In applications that display a splash window, the main window may have become a splash window immediately after starting.
Please specify the handle of the expected window of explicitly.

Cause
Occurs when the carrying out an operation on a specified thread and window handle, but the specified window handle is invalid.
The thread can be specified when using the ExecuteContext class is used when attaching a WindowsAppFriend.
When attaching a WindowsAppFriend and the process is specified, the main window is used as the execution thread.
In the case of an application that displays a splash window, at start-up, the splash window can be the main window. The splash window can disappears during the attach process causing the connection can fail.
To resolve this, you can use a separate approach to verify that the main window has loaded, and then specify that window's handle.


27.
Message
There was a call from an unexpected thread.
Calls can only be made from the thread that created the WindowsAppFriend.
If needed, please generate a separate WindowsAppFriend for each thread.

Cause
AppVars and the AppFriends that manage them can only be accessed from the thread where they were created.
This exception will occur if they are accessed from another thred.
However, since Friendly provides methods for carrying out asynchronous processing, there is rarely a need to use multithreaded tests.
Please consider making use of the Async class.



28.
Message
More than one window with the specified dialog ID were found on the same level.
The window could not be identified.

Cause
Occurs when using the WindowControl class' IdentifyFromDialogId method and two or more windows on the same level have the specified dialog ID. For example, in the case of a child dialog, the dialog ID may have been unspecified and could therefore be a duplicate.
In this case, you can either select the desired window with a different method, or select a window on a lower level using its dialog ID.



29.
Message
Since the selected GUI element does not have a Window handle, the specified method or a constructor cannot be used.
Please use a different acquisition method.

Cause
Occurs when an AppVar which does not have a window handle is passed to the constructor of WindowControl.
Windows that can be manipulated by WindowControl must have a window handle.
This can often happen when a WPF control is passed in. Since these can also also be manipulated using FriendlyOperation, please use that in this case.
Since top-level WPF windows do have window handles, you can use WindowControl to manipulate these.



30.
Message
The appointed operation can only be performed in a top-level window.
It was executed on a window with the following information.
Is this the intended window?
WindowText [{0}]
TypeFullName (.NET) [{1}]
WindowClass [{2}]

Cause
Occurs when WaitForNextZTop or a WaitForNextModal method is used on a WindowControl class assigned to a window other than a top-level window.These methods are methods for waiting until a window becomes modal, or when another windows comes to the front.
This is a way of synchronously waiting without using Sleep.
Therefore, it cannot be used on anything other than a top-level window.



31.
Message
Access by AppVar is not allowed for the specified window.
It was used on a window with the following information.
Is this the intended window?
WindowText [{0}]
TypeFullName (.NET) [{1}]
WindowClass [{2}]

Cause
Occurs when the window specified in a WindowControl is a native window, but has no .NET object.
This can also occur with .NET windows if the CLR version specified in creating th WindowsAppFriend was incorrect.
This can cause a failure in acquiring the .NET object. 


32.
Message
More than one matching windows were found and a single matching window could not be identified.
An operation was attempted on a window with the following details.
Is this the intended window?
WindowText [{0}]
TypeFullName (.NET) [{1}]
WindowClass [{2}]

Cause
Occurs when using WindowControl's Identify() method and more than one window matching the specified criteria are found.
Identify should be used when a window can be specifically identified.
Since tests should be as strict as possible, the use of Identify() is generally recommended.
To deal with the above situation you can use the Get() method, which can select multiple windows for given conditions.



33.
Message
The specified window could not be found.
An operation was attempted on a window with the following details.
Is this the intended window?
WindowText [{0}]
TypeFullName (.NET) [{1}]
WindowClass [{2}]

Cause
Occurs when using WindowControl's Identify() method and no window matching the specified criteria is found.
To locate a timing-dependent top-level window that could have inconsistent accesibility, please use the WaitForIdentify() method.



34.
Message
The specified checked state is not supported.
Radio buttons' checked state cannot be set to OFF.
Please uncheck the specified radio button by checking another in the same group.

Cause
Class and method
Codeer.Friendly.Windows.NativeStandardControls.NativeButton.EmulateClick
Operation
           Occurs when the state specified cannot be applied to the target button
           Points to checke
- Is the window specified as a NativeButton the actual intended window? (Could the incorrect window have been retrieved?)
- Is the value specified for the CheckState argument correct?



35.
Message
Corresponding edit box does not exist.

Cause
Class and property
Codeer.Friendly.Windows.NativeStandardControls.NativeSpinButton.Pos
Operation
           Occurs when the a spin button's value cannot be retrieved, and it does not have an edit box.
Points to check
- Is the window specified as the NativeSpinButton the actual intended window?
  (Could the incorrect window have been retrieved?)
- Does the NativeSpinButton have an edit box?