The main thing about specification-based techniques is that they derive test instances directly from the standards or from some other kind of style of what the system should do. The foundation of information which to base tests is recognized as the ‘test basis’. If a test basis is well described and adequately organized we can simply identify test conditions from which test situations can be derived. If we set up test instances so that we check that desired behavior actually occurs then we are performing individually of the programmers.

If they have misunderstood the standards or chosen to change it in some way without informing anyone then their implementation will deliver behavior that differs from what the model or standards said the machine behavior should be. Our test, based solely on the standards, will fail and we will have uncovered a problem therefore.

Bear in mind that not absolutely all systems are described by a detailed formal specification. In some instances the model we use may be quite informal. When there is no specification at all, the tester may need to build a style of the proposed system, perhaps by interviewing key stakeholders to understand what their expectations are. Formal or informal the model is However, and nonetheless it is built, it provides a test basis that we can generate tests systematically. Remember, also, that the specification can contain non-functional elements as well as functions; topics such as reliability, usability, and performance are good examples.

These have to be systematically tested as well. What we need, then, are techniques that can explore the given behavior systematically and thoroughly in a manner that is as efficient as we make it. Furthermore, we use what we know about software to ‘home in’ on problems; each one of the test case design techniques is dependent on some simple principles that occur from what we realize generally about software behavior. Equivalence partitioning is dependent on a very simple idea: it is that in many cases the inputs to an application can be ‘chunked’ into sets of similar inputs.

For example, an application that accepts integer values can accept as valid any input that is an integer (i.e. a complete number) and really should reject anything else (like a real number or a personality). The range of integers is infinite, although the computer will limit this to some finite value in both the negative and positive directions (due to the fact it can only handle numbers of a certain size; it is a finite machine). 10,000 (computer systems actually represent numbers in binary form, making the real figures look much less like the ones we are familiar with, but we will adhere to a familiar representation).

  • 3Q: Exactly what does UML stand for
  • Published 2008
  • 7 Tips about What Information to Put on Your Business Card
  • Residency NOT required
  • Benchmarking, and
  • 58 is “not prosperous” in Cantonese
  • Mind your own business

The equivalence partitioning technique requires advantage of the properties of equivalence partitions to reduce the number of test cases we have to write. Since all the values within an equivalence partition are managed in a similar way by the confirmed program, we need only test one of these on your behalf of the partition. In the example given, then, we need any positive integer, any negative integer, and zero.

We generally choose values somewhere close to the middle of every partition, so we might choose, say, −5,000, 0, and 5,000 as our reps. The partitions we’ve identified so far are called valid equivalence partitions because they partition the collection of valid inputs, but there are other possible inputs to the program that could not be valid-real numbers, for example. Non-valid partitions are also important to test. Suppose you have a bank account that offers variable interest rates: 0.5 % for the first £1,000 credit; 1 % for the next £1,000; 1.5 % for the rest. If you wanted to check that the lender was handling your account correctly what valid input partitions might you use?

Just as the insight to an application can be partitioned, so can the result. This program in the exercise above could produce outputs of 0.5 %, 1 %, and 1.5 per cent, so we could use test situations that generate each of these outputs as an alternative to generating insight partitions. An insight value in the number £0.00-£1,000.00 would generate the 0.5 per cent result; a value in the number £1,001.00-£2,000.00 would create the 1 per cent output; a value greater than £2,000.00 would create the 1.5 % output.

Software Testing & QTP
Tagged on: