TestComplete

cause frustration among the entire team

better support

fixing its issues related to headless testing

running in a uniform manner where the same test fails or passes arbitrarily

better mobile support

Git integration

Compatible with many software products, web applications, mobile applications

A lot of build in actions

Project structure is very good

User cannot sort folders in an individual order

Working in documents is not supported (like Word documents)

Identifying UI objects and application structure

Expandability of tests through scripts and script extensions/plugins

low barrier of entry (you can get started quickly, and other's don't need much explanation to contribute on a basic level)

Possibility of Jira integration for reporting

Relatively few (and usually easy to solve) git conflicts when working simultaneously

easy handling of test data, also for iterative tests

The documentation is lackluster in many areas and especially for scripting, script extensions, and plugins, there's a lot of copy/paste. Trying to grasp a specific aspect is often impossible in these areas and it feels like one would really have to read the documentation from start to finish to not get lost. For example, the documentation for simply expanding a keyword test with a form, so the tester can specify parameters there, is completely overblown and takes a while to be reduced to the important bits.

The Name Mapping can be unstable when editing/renaming/moving objects and can lead to occasional crashes

TestComplete is not fully dpi aware and can have difficulties when operating multiple screens with different resolutions, which can lead to "click" events not hitting the actual button, and the application itself can often be way too large or small when it sized itself based on a screen it is not located on.

Mapping/interacting with objects is only possible when TestComplete can still find them after locating them. Therefore, when windows don't stay open after losing focus (by switching to TestComplete) this can be problematic, especially when trying to access elements that can not be pinpointed (either when they are not visible, have no visible representation, to begin with, or are situated below another object that blocks it)

UI object recognition

Simplicity

Ease of automation and maintenance

Easy to create new test cases

Version 15.xx is little slower compared to the previous versions

There are some issues with capturing the checkpoint of disappearing drop-downs

Recording test steps and generating code for them

Support for multiple languages

Can be used for both desktop and browser applications

Easy for beginners to get started

Missing git integration

No easy way to see where functions and methods are reused throughout the test suite

Users with a development background may find the UI clunky to use compared to an IDE like Visual Studio or JetBrains

Detailed Test Report with Screenshots of Every Actions performed in the Application

Integrates smoothly with all third Party Applications and Software's

It supports various Scripting Languages (VBScript, Python, JavaScript)

License Cost for TestComplete Pro is at the high level.

It supports only Windows

In deep analysis of the program structure and hierarchy

Easy to learn for basic tests

Frequent updates

Application of script based test routines

Integration of Testexecute machines in the main UI

Picture comparison is very fleaky

Object Mapping is really good.

Validation of test cases (checkpoints) is user friendly and intuitive.

Support of different script languages such as python, VBSript, JavaScript, etc.

Help documentation is very detailed and clear.

Grouping of the Test Cases and in detail test reports.

Recording in the case where object mapping is not possible, coordinate recording needs a better approach. Sometimes coordinates are not getting clicked for the desired tab and other tab gets clicked when the test is rerun.

Smoke Test

Functional Test

Unit Test

Azure DevOps integration

Test Suite runs - Running test Suite (improvements)

Name Mapping issue

Scripting

OCR Text Recognition

Easy for manual testers

A lot of languages supported

Python interpreter is POOR - no possibility to install using pip, no terminal...

More support for CI/CD like Jenkins

OCR actions could have more built-in functionality for keyword-in scripts you can easily extend

Auto recording and converting tests to code or steps.

Automated running of tests with exception reports

Run of multiple tests through a single application

To be honest, i cannot think of anything

None

Nothing

Accessing components by name instead of coordinates.

Reporting is detailed enough.

Summary emails are easy to understand.

Plugins documentation is partly missing.

Auto recording is a bit too detailed.

Repetitive mundane sequence of UI actions

Checking UI object's properties

Taking a lot of my time

Name mapping is hard to edit: when the hierarchy or the identifiers properties are wrong, it can be quite painful and time-consuming to correct. Especially when it is not clear which item wrongly matches. A tool to correct such items in name mapping would be useful.

TestComplete isn't multi user friendly, especially when using source control. Even if each user works on different tests, correcting the name mapping file only generates havoc on merge.

KeywordTests' UX is awful: for some items, editing parameters can be done in two clicks, for others we need to click several times to display the edit button, which would be hidden by the tooltip, and then click blindly on this button.

And then some properties can be modified in their text boxes, but other need to display the variable editor to be able to change anything.

Region Checkpoint is mostly useless: such checkpoint would be great for verifying generated images, but then anti-aliasing will never be the same on different rendering and the checkpoint will fail. Increasing the error tolerance will then not detect real issues.

We have redone the checkpoint by using perceptualdiff (https://github.com/myint/perceptualdiff ) and using only the Region Checkpoint feature to save the reference image (and mask). We also added the possibility to change of reference image, as testing on different graphic cards will give other subtle changes (AMD vs Nvidia).

TestExecute is too much limited. We needed to write a tool to deploy our software on the test machine, and then change the TC project file to include or not some test. As some tests are quite flaky, we needed a redo of these, so we only select (automatically) the failed tests for doing another run.

Exception in the test should always mark it failed, and not just discard it as it happens now in some cases.

We needed a color checkpoint to check the display of some status indicators. Quite strange that it was missing in TC.

TestComplete couldn't identify all objects in my software but we could declare some class/function to do this.

We could use the command line to call TestExecute to execute the scripts automatically.

It supports multiple OS and it could update in time once MicroSoft releases new OS.

It doesn't support HTML5 well but i would like to use the same tool to test all the tested software.

It is strongly dependent on the screen resolution. if it could include embedded resolution to execute then it would be better.

Some objects couldn't be identified correctly and we have to spend more time to analysis the reason. If TestComplete could provide more possibilities, then it would be nice.

Great AI system for object spy & recognition

Easy test project suites and code maintenance

Versatile debugging system at detecting potential code errors

Support for multiple programming language

Supports the testing of our large scale data driven projects well

Perhaps could improve with less Memory Hogging & CPU Usage.

Recognition of element on web page or in view app.

Integration with other systems.

Possibility to test applications through Citrix Receiver.

execution of projects on a remote workstation

easy integration with various software such as jenkins

You can load a readyApi project

object recognition (NameMapping)

license management

performance

Web test automation

Object recognition

Test log reporting

Easability to learn the tool, ramping up

Automation

Easy to use.

Economical

Support

Web interface for configuring tests.

Less dependency on multiple servers for TestExecute.

Better way to schedule tests on TestExecute.

Object recognition in multiple environments

Speed

Scripting language flexibility

Needs ability to use global variables in verification points

UI changes verification.

Changes in the code.

Revision update.

Object Verification.

CRL Bridge to access other customized DLLs

Zephyr, Jenkins Integration and Docker support

Selenium Integration and XPATH support to access UI Web Elements

Test Organizer, Descriptive program support (Can find all the UI objects on go without using Name Mapping)

Name Mapping and Aliases

Need to reduce OCR inconsistencies

Extend TestComplete to use it on Linux Platforms as well (we can extend via CLR Bridge for QT application running on Linux Platform)

Have option to import the Name Mapping and Split the Name Mapping

Name Mapping reduces the Performance of TestComplete, hence need to resolve this with high priority.

Easy to learn and easy to use.

Compatible with various programming languages.

The test procedure can be easily recorded as a keyword test and then easily converted into a script in the selected programming language.

With Gherkin language support, the users can create their own robust test language that can significantly speed up the creation of new automated tests.

Speed.

Recognition of tested objects (we are using Delphi and DevExpress controls).

The price of the end user license increases every year.

Smoketest

Functional testing

Testsuite executions

Name Mapping

Windows application testing

Integrates well with other SmartBear products and bug tracking tools

Web testing

Mobile testing

Licensing for automated build machines can be a bit frustrating to configure with the cloud.

configuration for multiple environments requires some homebrew thinking