GUI testing and review

Sponsored Links:

GUI software testing:
In computing, GUI program testing is the method of testing a product that uses a graphical user interface for ensure it meets your specifications in writing. This is normally completed through the use of a variety of check cases.
Test Case Generation:
To generate a 'good' check case, the experiment designer must make sure that your suite covering all functions of the process must also be sure that all the full exercise of the GUI itself. The difficulty in fulfilling this the task is twofold: six has to deal with the domain size and then six has to deal with strings. In addition, the tester faces more difficulties when they must do regression testing.The size problem can be easily illustrated. Unlike a (command line interface CLI) process, a graphical user interface has lots of operations to be tested. GUI of a small program such as Microsoft WordPad has 325 possible operations [1]. In a giant program, the number of operations can be easily an order of magnitude larger.The second problem is the problem of sequencing. Some process functions can only be done by Following some complex sequence of GUI events. For example, to open a file that a user having to click on the file Menu, then select the operation Open, and then use a dialog box to specify the file name and then focus application in the window that opens. Obviously, the increased number of possible increases in operations sequencing problem exponentially. This can become a serious problem when the tester is to generate check cases by hand.Regression testing becomes a problem with the GUI . This is because the user interface can change significantly through
versions of the application, despite the application can not. A check designed to follow a positive path through the graphical user interface may not be able to follow that path from a button, menu item or dialog can be relocated or appearance.These issues have fueled the problem of testing graphical user interface to automate domain. Lots of different techniques have proposed to automatically generate check suites that are complete and to simulate user behavior.Most techniques used to check attempt to build graphical user interfaces in the techniques historically in the past used to check the CLI programs.However, most of these are problems of scale when applied to the graphical user interface. For example, Finite State Based on modeling systems [2] [3] - in which a process is modeled as a finite state machine as well as a program is used to generate check cases that exercise all states - may work well in a process that has a limited number of countries, but may become excessively complex and difficult to handle for a GUI (see also evidence-based model).

Planning and artificial intelligence:
A new approach for check suite generation, an adaptation of a method for CLI [4] is to use a planning method [5].Planning is a well studied method of artificial intelligence (AI) domain that attempts to solve problems participation of three parameters:

• an initial state,
• a aim state,
• a set of operators, and
• a set of objects to operate.

Planning systems to select a path from the initial state to aim state through the use of operators. A simple planning problem would be one in which there were one words and an operation called 'change of a letter "that has allowed to change one letter in a word to another letter - the aim of the problem would be to change a word to another.To check graphical user interface, the problem is a bit more complex. In [1] The authors used a so-called IPP planner [6] to prove this method. The method is simple to understand. First, the user interface systems is analyzed to select which operations are possible. These operations become the agents used in the planning problem. Following an initial State is determined. Then the target state is determined that the examiner finds that the exercise would enable the method. Finally the planning method is used to select a path from the initial state to aim state. This road becomes the check plan.Using a planner to generate check cases has some specific advantages versus manual generation. A planning method,
by their nature, generate solutions to planning problems in a way that is most beneficial to the Examiner:

1. The designs are still valid. What this means is that the method output can be one of one things, a valid and
right plan operators used to accomplish the aim state or no plan at all. This is beneficial because a lot of time
be wasted when by hand generating a set of tests because of invalid check cases that the idea of working the tester but
did not.
2. A planning method pays attention to the order. Often, to check a particular function, the check case must be complex and
follow a path through the graphical user interface where the operations are performed in a specific order. When performed by hand, this
can lead to errors and can also be and time consuming to do.
3. Finally, and most importantly, a method is goal-oriented planning. What this means and what makes this event so
Importantly, the check generation is concentrated body of evidence on what is most important, check the functionality of
the method.

When by hand generating a set of tests, the examiner focuses more on how to check a function (ie the specific path through the graphical user interface). By using a planning method, the way is carefully and tester can focus on what the role of check. An additional benefit is that a planning method is not limited in any way when generating the path and can often find a path that was not foreseen in the tester. This problem is important to fight.Another interesting method of generating check cases graphical user interface that uses the theory of coverage of a lovely graphical user interface check can be met by simulating a novice user. One can speculate that an expert user of a method will follow a direct and predictable path through a graphical user interface and a novice user could follow a more random way. The theory is that if so used an expert to check the GUI, the method of plenty of possible states would not succeed. A novice user, however,followed by a much more varied and unexpected winding road to reach the same aim and it is therefore more convenient to generate check suites that simulate the use of beginners, and it will check more.The difficulty lies in the generation of check suites that simulate the "use of the method beginners. Using genetic algorithms is a how it intends to solve this problem [7]. Novice paths through the method are not random paths. First, a novice user learn over time and generally do not make the same mistakes repeatedly, and, secondly, a novice user is not analogous to a group of monkeys trying to write Hamlet, but somebody who is following a plan, and probably some domain or method knowledge.Genetic algorithms work as follows: a set of "genes" are created at random and then are subjected to a task. The genes that best complete the task and those that remain are not discarded. The method is repeated with genes are replicated and the remaining survivors of the complete set of genes more random. Finally, a gene (or a tiny set of genes that if there is some set threshold) is the only gene in the set and, of coursework, is the best option for the given problem.For the purposes of testing graphical user interface, the method works as follows. Each gene is essentially a list of random integer the values of some fixed length. Each of these genes represents a path through the graphical user interface. For example, for a given tree players, the first value in the gene (each value is called allele) to select the widget to operate the alleles would be filled following entry to the widget depending on the number of possible entries for the widget (for example of a drop down list would have an input box \., select the list of values). The success of the genes are marked by a criterion that rewards the behavior of the best rookies The method for this check can be extended to any method of windows, but is described in the window method. The X Window Method provides the functionality (by X-Server and the protocol of the editors) dynamically sending information to the graphical user interface GUI and get the output of the program directly without using the GUI. For example, one may callSendEvent () to simulate a click on a drop down menu, and so on. This method allows researchers to automate the generating and testing genes so for any given application to check a set of novice user check cases can be created.

Event Flow Graphs:
Automated GUI testing is a new model called the event-graph graph that represents the events & event interactions. In the same way as a control-graph represents all possible execution paths in a program, & a information flow graph represents all possible definitions & uses of memory, Location of event flow model represents all possible sequences of events that can be executed in the GUI. A graphical user interface is decomposed in to a hierarchy of modal dialogs, this hierarchy is represented as a tree of integration, each transport mode dialogue is represented as an event graph that shows all possible execution paths of events in the dialogue.

Running the test cases:
At first, the strategies have been migrated and adapted from the CLI testing strategies. Two popular method used in the CLI environment is capture / playback. Capture playback is a method on the computer screen is "captured" as a bitmap graph at different times during method testing. This allowed the capture of tester to "play" the testing method and compare the screens on the output stage of the check screens out. This validation can be automated
from the screens would be identical whether the case is different if the case does not.Using capture / playback worked well in the world of the CLI, but there's significant problems when it comes to its application in a GUI-based method [9]. The most obvious problem is that the screen is a graphical user interface can look different, while the underlying method state is the same as automatic validation difficult.This is due to its graphic interface allows graphical objects that vary in appearance and placement on the screen. Sources can be window of different colors, or sizes can vary, but the output of the method is fundamentally the same. This would be obvious to a user, but not obvious to a method of automatic validation.To combat this and other problems, the testers have gone "under the hood and interaction information collected from the GUI underlying window method [10]. By capturing the window of 'events' in the records of interactions with the method are now in a format that is disconnected from the look of the GUI. Now, are captured only if the streams. There
some seepage from streams if necessary, and that the flow of events are usually detailed and most events not directly related to the problem. This approach may be less hard using an MVC architecture, for example,and making the view (ie the GUI here) as simple as possible, while the model and controller to keep all logic.Another approach is to use an HTML interface or a three-tier architecture also enables better separate user interface from the rest of the application.Another way to run tests on a GUI is to build a driver in the graphical user interface for commands or events can be sent to the from another application program [7]. This method of sending directly to events and get events of a method is highly desirable if the check is eliminated, because the entry and exit of the check can be fully automated and user error

No comments: