Thinking maintainability
The demand for script maintenance is not unwanted, but people selling automation tools have not mentioned this. We keep discussing two things at the February Lawst meeting. When the software user interface changes, how much modify the test script will make the script correctly adapt to the software change and test the software? When the software interface language changes (such as English version to the French version), the correction test script makes him correctly adapt to the change in software and how difficult is the test software? What we need is a test strategy for processing version change.
Two strategies are not recommended: Establish test cases use to swim. The most common method is to establish test cases using the automated test tool. This is the most benzene.
Programming the first lesson may learn is not a writer, for example: set a = 2set b = 3Print A B
Hidden constant is very stupid. But that is most useful to us. We create a test script that enters a certain order key value, mouse action, or command by recording. These constants such as 2, 3. The submissions of the software user interface will have an error. The script of simple and easy-catching is not accepted for maintenance. The advantage of caughting the script of the return visit is to help you show how to use the manual test case with automation tools. They are not useless, but if you do the scripts, the greater the risk.
Writing test cases on a specific basis: The test team often creates an automated test case in their spare time. Their program is similar, "Creating Test Samples as possible" ---- There is no uniform plan and theme. Each test case design code is independent, and there will always be a repetitive command sequence in these scripts. This is not perfect.
Successful strategy:
We don't have to lament for the risk of using these tools. Many of us have done a lot in comp.software.testing and other publications. We are here because we have realized that some experiments have established a meaningful process in handling these issues. But the information sharing is not enough. An experiment is obvious for the other is an advanced practice. Now that this is the environment that is both challenges is also clarifying everyone's idea.
Some recommendations for the development of automation recession test tests:
Repropting the expectations that can be beneficial from the automation test. Recognizing Automation Test A Software Development and Utilizing Data Drive System Taking Using Framework System Consider using other types of test tools
1. Reassembly of expectations that can be beneficial from automation testing
We recognize the GUI level automation recession test to perform N-times results, and if you continue this test, you may find more benefits. We all know that there is more benefits to developing a GUI-level automated recession test script after the software releases N times can we get more benefits in the implementation of the software release N 1. I think everyone is very surprised to have such conclusions, because we have heard of (or experience) the theory of returning to investment automation testing.
Software releases N times awareness, for example: automated test A series of acceptance test (smoke test) has a great advantage. You may have to run these scripts 50 to 100 times when developing NSD software. If the development of each test case is 10 times the manual test execution, it takes 10 times time maintenance. This time you create an automated test case. Saved equivalent to hand-performing test cases 30 to 80 times. You can save time, reduce people as wrong, summarize how good tracking automated test configurations and compatibility tests can do. In these cases, you have to run the same test under different environments. If you are compatible with 30 printing test programs, you can reach the benefits of automatic testing. The recession automation script can be used as a reference for processing operating systems and processing different development versions. When automated with short-term profit purposes, automation is easy to have a crisis in the near future. Value proves that each additional test case or a set of test cases. If you are looking for a long-term goal, handle software versions, then you have to think about the goal about version N: If you have a test version N in some specific phases (such as smoke testing and compatibility test). The script we develop will be more effective and strong in software version N 1.
2. Recognizing Automation Test A software development You cannot develop before the next version has not figured out in the next version. You can't extend the test script before you haven't figured out and reality. You can't develop a lot of low-maintenance test scripts before you don't figure out and reality.
Software automation tests like other software development, software test engineers need to write automated scripting code. Even if the automated scripting language is difficult. If you decide to test your application with an application, each test case has its own characteristics.
From the viewpoint of automated software testing, each software (the software being tested) is data. We have studied so many software development projects, software developers (in this example, test engineers) must: understand demand: accept a valid development method, maintenance, and integrated software features and data. Accept and implement standards. (We don't have to choose configuration management such as ISO or CMM, as long as two people can use naming regulations, document structures, handling errors, etc., they can work on a project. Any member must comply with the formulated regulations and standards. )
Compliance: All people, testers must recognize how important to comply with the approximation of software development instead of Quick-And-Dirty's design and implementation methods. Without him, we must have many implementation of the test case failure, the more psychological preparations.
