The easiest solution is to create a custom function with the same name, but with the timeout you want. Here's how to create a version with a timeout of 5 seconds; it should go at the top of the test (before main()), and before any calls to the function are made.

originalWaitForObject = waitForObject

def waitForObject(obj, timeout=5000):
    return originalWaitForObject(obj, timeout)

rename waitForObject originalWaitForObject

proc waitForObject {obj} {
    return [originalWaitForObject $obj 5000]
}

We don't currently have solutions for JavaScript or Perl.

The Qt 4.3 series has a bug that mixes up the order of posted events in the internal queue. In some rare cases this breaks text input or mouse click sequences. This problem was scheduled to be solved in Qt 4.4 and possibly also in Qt 4.3.4. A source code patch is available on request.

To build Squish, Qt must be linked as a shared library. When compiling Qt with gcc in IRIX, it is built as a static library by default. To build Qt as a shared library, specify the -shared option when running Qt's configure script.

The reason, why static is the default build is because Qt doesn't link as a shared library on IRIX when being built with gcc. To fix this problem, edit the file src/Makefile after you have run configure. Add the switch -Wl,-LD_LAYOUT:lgot_buffer=100 to the Makefile's LFLAGS variable. The line should then look similar to this one:

LFLAGS = -Wl,-LD_LAYOUT:lgot_buffer=100 -shared -Wl,-soname,libqt-mt.so.3 -Wl,-rpath,/usr/people/reggie/qt32-gcc/lib

After doing this just compile Qt as usual (i.e., by running make). Then compile Squish as documented elsewhere in this manual (Installing from Source Packages (Section 3.1.2)).

	Note
	This fix was been submitted to Trolltech support and was incorporated into Qt in version 3.3.0.

Some Python binary distributions already contain an import library for Python that can be used with MinGW. In such cases you don't have to do anything.

On the other hand, if you don't have the import library you must generate it yourself. For this you need MinGW's pexports and dlltool tools.

In the following example we assume that Python is installed in C:\Python25 and that the Python DLL is C:\WINNT\system32\python25.dll. To generate the import library, do the following:

cd C:\Python25\libs
pexports C:\WINNT\system32\python25.dll > python25.def
dlltool --dllname python25.dll --def python25.def --output-lib libpython25.a

For more information see the MinGW Wiki on Python extensions (just the Basic Setup section).

As mentioned in Installation for testing with a single-threaded Qt library (Section 3.1.2.6), most parts of Squish can be built with a single-threaded Qt library. On Windows there is one problem with this: The single-threaded Qt library is linked against the static LIBC.LIB instead of the shared MSVCRT.LIB. This leads to problems with memory management because of different heaps when using multiple DLLs linked against Qt, and this problem affects Squish.

To work around the problem, open the file %QTDIR%\mkspecs\win32-msvc\qmake.conf (or %QTDIR%\mkspecs\win32-icc\qmake.conf, if you use Intel C++) and change the following lines:

QMAKE_CFLAGS_RELEASE	= -O1
QMAKE_CFLAGS_DEBUG	= -Z7

to:

QMAKE_CFLAGS_RELEASE	= -O1 -MD
QMAKE_CFLAGS_DEBUG	= -Z7 -MDd

After doing this you must regenerate Qt's Makefile and then recompile the Qt:

cd %QTDIR%\src
qmake qt.pro
nmake clean
nmake

Squish only records mouse move events when a mouse button is pressed—even if Qt's mouse tracking is enabled. This is because in most cases mouse move events that take place when no mouse button is pressed can be ignored since they don't need to be replayed for the widgets to function properly. Furthermore, recording these events would produce a lot of script code which would not affect the application, but would make the script harder to read and maintain.

For those rare cases where it is necessary to record all the mouse move events because they are essential for the widget to work correctly, you can change Squish's behavior. For example, let's assume that we have a custom widget of type CanvasView for which we want to record all mouse move events. We can tell Squish to switch on mouse tracking for widgets of this type by creating and registering a suitable init file. For example, we could create a file called myinit.tcl that contained this line:

setMouseTracking CanvasView true

Then we can tell Squish to execute this file at startup:

squishrunner --config addInitScript Qt <absolute_path>/myinit.tcl

After this, when recording a test case, mouse move events on CanvasView widgets will be recorded even if no mouse button is pressed. (See also, Configuring squishrunner (Section 16.5.1.7).)

Squish tries to create the most descriptive names for GUI objects. By default is uses the QObject name. If this property isn't unique (or is empty), other possibly unique properties are examined (window caption, button text, etc.) before falling back to <ObjectType><num>.

One solution (and probably the best!) to get better names in generated scripts is to give all the widgets descriptive, short and unique QObject names in the AUT's source code.

If the custom widgets have other possibly unique properties, like a label, etc., Squish can be told to try using these properties. For example, suppose that we have a custom widget called CanvasView which has a unique label property. To tell Squish about this, create a file called, for example, myinit.tcl that contains the following line:

setUniqueProperty CanvasView label

Then tell Squish to interpret this file at startup:

squishrunner --config addInitScript Qt <absolute_path>/myinit.tcl

After doing this, Squish will attempt to use the CanvasView's label property for identification, if its value is unique. (See also, Configuring squishrunner (Section 16.5.1.7).)

Usually, Squish hooks into the AUT without requiring any special preparations. However, in some cases—such as on AIX—this is not possible due to technical limitations of the operating system. See the chapter Using the Built-in Hook (Section 16.11.2) in the Reference Manual (Chapter 16) for a solution.

Due to the usage of third-party code and imperfect compilers, Squish contains libraries with so called "text relocations". By themselves these are harmless but a "hardened" Linux distribution with SELinux (Security Enhanced Linux) installed may nevertheless disallow such a property.

We are still investigating this problem, but meanwhile one workaround is to change the SELinux policy from enforcing to permissive—on most modern systems this can be done via a GUI configuration tool, or it can be done by manually editing the /etc/selinux/config file, and changing the SELINUX=enforcing entry to SELINUX=permissive. Whichever way the change is made, the system must be rebooted for the change to take effect.

A more fine-grained solution is also possible using the chcon tool. This allows for the setting of the security context for individuals files. Here is a command that a customer gave us that should make things work:

find /path/to/squish -type f -name "*.so" | xargs chcon -t textrel_shlib_t

When a mouse press event is followed by mouse move events (while the button is still pressed), Squish compresses all these events into a single mouseDrag().

Using a mouseDrag() is much more robust in the face of changes in the AUT then recording the individual mouse events. However, during the replay of the mouseDrag(), there is only one mouse move event synthesized, starting from the point where the mouse button was pressed to the point where the mouse button was released.

To enable recording to work properly for applications that depend on all of the individual mouse move events being recorded individually, there's a way to disable the creation of the mouseDrag() calls for a specific widget type. See setRecordMouseDrag for further details.