Unit test framework – An Introduction

Unit Testing


Unit test frameworks are software tools to support writing and running unit tests, including:

  • a foundation on which to build tests
  • the functionality to execute the tests
  • the functionality to report their results.



Unit tests usually are developed concurrently with production code, but are not built into the final software product. The relationship of unit tests to production code is shown below:

clip_image002

An application is built from software objects linked together and the unit tests use the application’s objects, but exist inside the unit test framework. Advantages of this framework are:

– The production code is not cluttered up with built-in unit tests.
– The size of the compiled application tends to be kept smaller for the same reason.
– The tests can be run separately from the application, so the objects can be tested in isolation.

A single unit test should test a particular behavior within the production code. Its success or failure validates a single unit of code. Well-written tests set up an environment or scenario that is independent of any other conditions, then perform a distinct action and check a definite result. These tests should avoid dependencies on the results of other tests (called test coupling), and they should be short and simple.

By starting with tests of the most basic functionality, then gradually building to tests of compound objects and behaviors, a unit test framework can be used to verify very complex architectures. Having such a test framework to build upon not only is much easier than developing standalone tests, but also produces more thorough, effective tests. A comprehensive suite of unit tests enables rapid application development, since the effects of every change can be immediately and thoroughly verified.

Unit tests are white box (structural) tests, since the test framework is able to access the internal structure of the code being tested.

Most object-oriented languages provide access protection, preventing outside classes from accessing protected or private code elements. Because of this, unit tests often are written to test only the public interfaces of the objects tested. This encourages the design of objects with discrete, testable interfaces and a minimum of complex hidden behavior. Thus, writing testable objects promotes good object-oriented development practices.