As soon as developers decide that utilities need a graphical front-end, they start to run into problems. While GUI-based software might seem a little friendlier to those who aren't as familiar with command line-driven environments, they do suffer from UX-related drawbacks.
A command line interface (CLI) doesn't have to concern itself with looks. Those who write front-ends have to poll a device's screen dimensions, the end-user's browser of choice, the operating system and countless other details. Fortunately, there's a way to address most of these problems without sacrificing too much in the way of portability.
Researchers in the field of GUI testing are, in fact, actively developing methods used to streamline the process.
GUI Testing in a Command Line-powered World
You might be asking yourself "what is GUI testing?" if you've previously had more experience with the command line. Text-based apps doesn't have to be interface tested, since they appear more or less the same on each device they're run on. Terminal emulators automatically line up columns, so output always lines up perfectly.
Once the bottom layers of a software development project are straightened out, GUI testers try a beta version of the proposed front-end. Since they're not necessarily experienced with the original back-end code, they end up using this interface precisely the same way an end-user would. They try out every possible task they can think to try with a GUI and look for problems.
A large number of new GUI-based apps use standard HTML5-powered web browsers as an application platform. In this case, these testers try apps out with a variety of different browsers running on countless different configurations.
Automation, however, is what really makes this particular field shine.
Automated GUI Testing Techniques
Technologists have to start by testing apps manually. They wouldn't be able to mimic the patterns of live users otherwise. As soon as they're sure that each checkbox is visible and all of the interface's columns line up, they're ready to try things out automatically.
Menu, sidebar, icon and graphical element testing all require some help from a skilled technician. In fact, GUI testing is by necessity mostly manual. Scripts, however, can run at all hours during the day and can help to reduce the margin of error. Staying focused during a long testing session is a challenge even for the most technically-inclined.
Developers, therefore, can write a shell script that constantly tries different combination inputs. When an error results from one particular type of input, the script records it in a log file and continues testing.
Regression errors are among the most common that these kinds of scripts can find. Generally, only software that's already been thoroughly vetted ever gets tested in this manner, but it can ensure truly bug-free performance under specific circumstances.
Most businesses have found at least one use case that breaks an app they thought performed flawlessly otherwise. Automated testing scripts are there precisely to find those kinds of errors.
Best of all, creating the right kind of framework isn't that difficult as long as an organization has at least some sort of background with both GUI development and script writing.
Creating Testing Scripts from Scratch
Developers that regularly work on these sorts of projects tend to separate all of the manual testing tasks from those that will be handled by an automatic script. Several tools are available that allow testers to develop their own custom virtualized equipment for these situations.
Some are dedicated languages that produce code that's not too different from a traditional bash script. Others feature modules that leverage the power of common dialects like Ruby and Perl to repeat certain sequences of events over and over again.
Macro recorders have found an unlikely usage as well, since they can be used to function in much the same way that a living user might. Regardless of which method is used to test GUI-based software, however, the result should always be the same - a graphically-driven app that works nearly as well as its CLI-based original.
Even though gestures will never replace terminal emulators, it really is possible to put together point-and-click software that performs the same function without ever touching the keyboard.