Hi Everyone…here is an article that you all will find useful…

 

Below are given a broader set of characteristics (usually known as James Bach heuristics) that lead to testable software. 

 

 

Categories of Heuristics of software testing

  • Operability

The better it works, the more efficiently it can be tested.The system should have few bugs, no bugs should block the execution of tests and the product should evolve in functional stages (simultaneous development and testing).

  • Observability

What we see is what we test.§         Distinct output should be generated for each input§         Current and past system states and variables should be visible during testing§         All factors affecting the output should be visible.§         Incorrect output should be easily identified.§         Source code should be easily accessible.§         Internal errors should be automatically detected (through self-testing mechanisms) and reported.

  • Controllability

The better we control the software, the more the testing process can be automated and optimized.Check that §         All outputs can be generated and code can be executed through some combination of input.§         Software and hardware states can be controlled directly by the test engineer.§         Inputs and output formats are consistent and structured.§         Test can be conveniently, specified, automated and reproduced.

  • Decomposability

By controlling the scope of testing, we can quickly isolate problems and perform effective and efficient testing.The software system should be built from independent modules which can be tested independently.

  • Simplicity

The less there is to test, the more quickly we can test it.The points to consider in this regard are functional (e.g. minimum set of features), structural (e.g. architecture is modularized) and code (e.g. a coding standard is adopted) simplicity.

  • Stability

The fewer the changes, the fewer are the disruptions to testing.The changes to software should be infrequent, controlled and not invalidating existing tests. The software should be able to recover well from failures.

  • Understandability

The more information we will have, the smarter we will test.The testers should be able to understand well the design, changes to the design and the dependencies between internal, external and shared components.Technical documentation should be instantly accessible, accurate, well organized, specific and detailed.

  • Suitability

The more we know about the intended use of the software, the better we can organize our testing to find important bugs. 

The above heuristics can be used by a software engineer to develop a software configuration (i.e. program, data and documentation) that is convenient to test and verify.

Advertisements