|
Sponsored Links: |
Assumption # 1. The developers have tried the code unit.
Fundamentally both monitoring & top-down approach, the most common assumption by the state testers when they start testing the following: "The developers have tested the unit code. Of work I say this in all my testing agreements, & is always in my contracts a requirement to check.
Top-Down Broad-Focused Integration Testing:
When testing, I have no particular interest in one part of the process but I am interested in the whole process. After all, my job is usually to verify & validate the process. The process includes components & applications programmed using any kind of object-oriented programming (OOP) for the assembler language of the batch. Communication protocols network transactions between these components through various routers, switches, databases, & security layers.
The process is not a finite state machine, is a partnership of components constantly interact with a dynamic group of stimuli. It is virtually impossible to know all the stimuli & the interactions happening in even a little group of components at a given instant. The Heisenberg uncertainty principle, which states that "the more precisely the position is determined, the less precisely the momentum is known in this instant, & vice versa," certainly applies here is only to show that these elements are not the state that are at a particular time.In the same way as no single algorithm is sufficient for a map of all paths through a complex process, no single type of evidence used by itself will give a positive result in this case. The traditional process testing, the kind that explores in depth the individual components of a process can ignore things like user interface. Function tests, or from finish to finish testing, may miss the systems problems that can cause total paralysis in the production environment. & although I am sure there's, I personally know of no company willing to pay for the different groups of experts to undertake the unit, integration, process, finish to finish function, cargo, utility & user acceptance testing for the same process.As a result, making any tests are appropriate for the situation. The types of tests performed should be clearly illustrated in the inventory of evidence. For examples of the types of tests to be performed, see Chapter 4, "The most important testing (MITS) Method", where each type of check is represented in the task list itself. The experts, moreover, each has a specialty, a fixation on those who are clearly biased.Try the professional of today must be, among other things, an integrator whose focus may take the entire process. Testers who have no training in testing techniques & a lovely command of the check will measure a difficult time with this challenge.Bias is a mental leaning or inclination, bias or prejudice. It is natural & healthy for specialists to be biased in their views of your project. Like a proud brother, the bias of the experts, gives a tight focus that ensures the highest quality on your project. However, all these projects kid should grow up to function as an integrated process in the real world. Modern program tester must ensure that they do this.
Organizational Strategies for Locating the Test Group:
I have consulted in all types of organizations, and I am constantly amazed by the variety of places to stick comes with managing the check group. My experience tells me that no matter where the check group is shown in the flowchart, it is important to choose a location on your organization to maximize the lovely communications and the free flow of information. Each place has its pros and cons, as I point out in the following paragraphs.
Have an Independent Test Group under Their Own Management:
This approach sounds nice, but unfortunately has some major flaws. First is the fact that the check group can be compressed between development & operations groups. If communications fail, the evaluators may encounter confrontational situations on both sides. If developers are late with the code, which the evaluators will must either time or explain delays in operations. Testers need allies, & this strategy of the organization has a tendency to put them in a situation where they are continually the bearers of bad news & often made to be scapegoats.
Put the Test Group in Development:
There is a serious problem with these two reasons. The developers certainly have experience in the process, in general, they are the ones who wrote it or maintain it. Both strategies to accomplish the same result, "having the fox guard the henhouse." Even if developers do have evidence of training in program testing, which is rare in the best of them suffer from the prejudices mentioned above. Not only are likely to miss errors that forbids them to see their prejudices, it is unlikely that the check outside their area of expertise. A check of the process by itself can not eliminate errors in the user interface function or sequence of steps, but these errors are the first errors that finish users can see.Currently there is a tendency to move the check functions in the development area & away from an independent testing group. There's two dominant themes of this trend. The first is to break down barriers between the two groups to permit better communication. The other reason is along the lines that the check group is not competent to perform process testing, therefore, developers are going to perform or assist in performing process testing.Another example is the situation in which developers do not see anything wrong with a menu option that says: Document Writer, but it takes users a window titled Able Baker, since there's several other menu items in the same application windows to be equally matched with titles. Never mind that the design guide recommends strongly against such labels confusing. After all, if the development changed two of these labels would probably must change them all. Without doubt, the query can not be that important. It is to reach an argument that will convince developers & management that the fix worth the cost & hard work.Any appraiser who has had to try to convince us that the development of an application that ties the whole PC for a couple of minutes, while making a database query is a serious error knows exactly what I mean. A tester argue this point, without citing any rule is unlikely to be heard. all users of interface design guide recommends constant user feedback & response times of less than 5 seconds. Usability lab studies indicate that the user believes that the application hangs after a period of 20 seconds of inactivity. But even the tester citing a design guide for standard response time is likely to find either that the recommendations of the design guide have been waived or that developers are not obliged to follow any of the design guidelines in all the above. The preference for the developer can come from knowing how much trouble would make it work so well as they does. They can not be to take time away from current commitments to try again, when setting the error can mean a massive rewrite.The other thing that these successful efforts have in common is that the systems being tested by developers for developers were little independent systems, such as firmware station phone operators, paging firmware, & program for medical images is runs on a single platform. When this testing strategy is used in large systems, or components that run on large systems, the system fails. Even if the check is done, in this situation, which only accounts for a check drive, because when this product is introduced in to a larger process to be incorporated in to the larger process. This brings me to the next interesting trend I have observed in large networks, supporting the product with support.However, after stating the types of problems that can arise when the stress check in the development moves, I must also say I have seen work well. The environments in which this approach is prosperous is little, competent program groups of two to ten programmers, producers of high-reliability program or firmware class. Typically these projects last 6 to 12 months, & after unit testing, testing of any promoter of his or her own program.
Don't Have a Test Group At All:
Note:What happens when there is small or no evidence? Users try. But then what? You support it with help.
It is simplistic to assume that companies must check their products or go bankrupt. There's lots of companies who do small or nothing of the evidence & not only survive but prosper. Its prosperity is often the result of a complete programming. These firms often have divided the check group or dissolved. Whatever before production testing is done is done by the development group.These organizations often have multiple layers of support staff. The first layer of support staff are generally lower-level people logging problems, answer common questions, & try to identify the problems & the most difficult route to the next layer of more competent technical support staff. Historically, evaluators often filled with the second layer of support, since they were experts in the process & its problems.Problems can not be resolved by the second level of support will be intensified in the third & most experts in the layer. The third level of support is generally high-level attendees to understand the depth of the process. These people have the best chance to diagnose the difficult problems. In general, it can not fix the plane sent to development, & is likely to get a quick response.The authorities can not see the need to pay for highly qualified & experienced testers, but that is not the case when it comes to support. The typical third-person online support is a high level programmer or systems engineer, while the programmers who write most of the code base of three or three levels below that. The reason is simple: the time of the errors to reach customers & become a priority for the user's demands. The administration is not a problem to justify highly paid technicians to make the customer happy & get the right set of errors. This is a logical consequence of "letting customers test" approach pioneered by the shrink-wrap program industry in the 1990s.It is logical that this situation should arise, given the chain of events I have described, but not obvious to lots of people that the check is often the case after the product has been sent. The support team can check the product & the customer is positive that the product testing. I find it interesting that the support staff would not think of it as evidence, but generally report what they do in terms of tuning the process & correct errors than in terms like testing. Users are doing the tests.Another flavor of this trend is to let customers check the product under the pretext of installing or upgrading the process, while three or more officials of high-level support for managing the method & get the bugs fixed soon.This supportive approach with the support is beautiful to the manager who sent the product without the check. In fact, it requires support. This approach does not need planning controls, no time is spent designing or monitoring tests. & only fix major errors. The problem is that the cost of finding & fixing bugs grows geometrically as the errors get more developers. This is the most expensive way to find & eliminate errors. &, again, only the most important, it eliminates the disagreeable bugs.
Put the Test Group in Operations:
When I am connected to the operations, I can add great value to products released, besides the work check itself. Think about this: When I am testing a process, I am ready for the customer. Often'm writing or reviewing the user guide simultaneously I am trying. If I must write any special instructions for the process of work or products, such as how to change this or that, these are sent to customer service & customer there.I found the setting of the check group in the operations to be a healthy & productive practice. This is the place I prefer. In my experience, operations is the best place to be when you check a process. The people who control the process are my best allies. The propinquity to the person who can help find the problem in a complex process is invaluable.The only way to play check cost effective automation is to ensure that the automated tests get lots of repetitions. In an work of a single check, lots of tests are performed only three times & never again, so it is not worth automating them. However, in this scenario, the automated tests can be incorporated in to the diagnostic suites that run on the production environment to help ensure the process remains healthy. This type of reuse adds value to the work of testers.Finally, a series of tests it is as well as a diagnostic suite. So if I am part of operations, then there is a lovely level of confidence in the veracity of my series of essays, & again the propinquity makes it easy for operators to get expert help in the maintenance & operation of the tests & interpreting the results. In this situation my check suites are reused, sometimes for years.
No comments:
Post a Comment