What are the characteristics of testing and a good test?

Testing goal is to find errors. It should exhibit a set of characteristics that achieve the goal of finding the errors with minimum effort. The characteristics of software testing includes:
- How easily a software can be tested? i.e. test-ability
- How efficiently it can be tested? i.e. oper-ability
- What you see is what you test? i.e. observability
- How much we control the software so that testing can be automated and optimized? i.e. controllability
- Isolating problems and perform smarter retesting by controlling scope of testing i.e. decomposability.
- The program should be simple so that it can become easy to test i.e. simplicity.
- The fewer the changes, the fewer the disruptions to testing i.e. stability.
- The more information we have, the smarter we will test i.e. understandability.

A good test has the following characteristics:
- A good test has a high probability of finding an error.
- A good test is not redundant.
- A good test has the highest likelihood of uncovering a whole class of errors.
- A good test should be neither too simple nor too complex.

There are two ways to test an engineered product:
- Knowing the internal workings of product and tests can be conducted that can ensure that internal workings are performed according to specifications and all internal components are exercised properly.
- Knowing the output or the function for which the product is designed, tests are conducted to demonstrate each function is fully operational and checking the errors at the same time.

Two heuristics of Software testing : Visibility and Control

Software testability is how easily, completely and conveniently a computer program can be tested. Software engineers design a computer product, system or program keeping in mind the product testability. Good programmers are willing to do things that will help the testing process and a checklist of possible design points, features and so on can be useful in negotiating with them.
Visibility has already been discussed.

Control refers to our ability to provide inputs and reach states in the software under test. The features to improve controllability are:
- Test Points: Allows the data to be inspected, inserted or modified at points in the software. It is especially useful for data-flow applications. In addition, a pipe and filters architecture provides many opportunities for test points.

- Custom User Interface Controls: Custom UI controls often raise serious testability problems with GUI test drivers. Ensuring testability usually requires adding methods to report necessary information, customizing test tools to make use of these methods, getting a tool expert to advise developers on testability and to build the required support and asking the third party control vendors regarding support by test tools.

- Test Interfaces: Interfaces may be provided specifically for testing e.g. Excel and Xconq etc.Existing interfaces may be able to support significant testing e.g. InstallShield, AutoCad, Tivoli etc.

- Fault Injection: Error seeding, instrumenting low level input/output code to simulate errors makes it much easier to test error handling. It can be handled at both system and application level.

- Installation and Setup: Testers should be notified when installation has completed successfully. They should be able to verify installation, pro grammatically create sample records and run multiple clients, daemons or servers on a single machine.

Two heuristics of Software testing : Visibility and Control

Software testability is how easily, completely and conveniently a computer program can be tested. Software engineers design a computer product, system or program keeping in mind the product testability. Good programmers are willing to do things that will help the testing process and a checklist of possible design points, features and so on can be useful in negotiating with them.
Visibility will be discussed in this section.

The two main heuristics of software testing are :
Visibility:
Visibility is our ability to observe the states and outputs of the software under test. The features to improve the visibility are :
- Access to code: Developers must provide full access(source code, infrastructure, etc) to testers. The code, change records and design documents should be provided to the testing team. The testing team should read and understand the code.
- Event Logging: The events to log include user events, system milestones, error handling and complete transactions. The logs may be stored in files, ring buffers in memory and/or serial ports.
- Error detection mechanisms: Data integrity checking and system level error detection are useful error detection mechanisms. In addition, assertions and probes with the following features are really helpful:
+ Code is added to detect internal errors.
+ Assertions abort an error.
+ Probes log errors.
+ Design by contract theory : It requires assertions be defined for functions. Preconditions apply to input and violations implicate calling functions while post-conditions apply to outputs and violations implicate called functions.
- Resource Monitoring: Memory usage should be monitored to find memory leaks. States of running methods, threads or processes should be watched. In addition, the configuration values should be dumped. Resource monitoring is of particular concern in applications where the load on the application in real time is estimated to be considerable.