All the requirements mentioned in the SRS document are addressed in this phase and work in the direction of designing the solution. The architecture and design is documented in another document called the software design document (SDD).

Like the verification of requirements, the tester is responsible for two parallel activities in this phase as well:

1. The tester verifies the high-level design. Since the system has been decomposed into a number of sub-systems or components, the tester should verify the functionality of these components. Since the system is considered a black box with no low-level details considered here, the stress is also on how the system will interface with the outside world. All the interfaces and interactions of user/customer (or any person who is interfacing with the system) are specified in this phase. The tester verifies that all the components and their interfaces are in tune with requirements of the user. Every requirement in SRS should map the design.

2. The tester also prepares a Function Test Plan which is based on the SRS. This plan will be referenced at the time of Function Testing).

The tester also prepares an Integration Test Plan which will be referred at the time of integration testing.

How to Verify High Level Design

High-level design takes the second place in SDLC, wherein there is a high probability of finding bugs. Therefore, high-level design must be verified as the next step in early testing. Unless the design is specified in a formal way, design cannot be verified. So SDD is referred for design verification. IEEE [19] has provided the standard way of documenting the design in an SDD.

If a bug goes undetected in the high-level design phase, then the cost of fixing increases with every phase. Therefore, verification for high-level design must be done very carefully. This design is divided in three parts.

Data Design: It creates a model of data and/or information that is represented at a high level of abstraction (the customer/user's view of data). The structure of data has always been an important part of software design. At the program component level, the design of data structures and the associated algorithms required to manipulate them is essential to create high-quality applications.

Architectural Design: It focuses on the representation of the structure of software components, their properties, and interactions.

Interface Design: It creates an effective communication medium between the interfaces of different software modules, interfaces between the software system and any other external entity, and interfaces between a user and the software system. Following a set of interface design principles, the design identifies interface objects and actions and then creates a screen layout that forms the basis for a user interface prototype.

Verification of High Level Design

Verification of Data Design

The points considered for verification of data design are as follows:

• Check whether the sizes of data structure have been estimated appropriately.
• Check the provisions of overflow in a data structure.
• Check the consistency of data formats with the requirements.
• Check whether data usage is consistent with its declaration.
• Check the relationships among data objects in a data dictionary.
• Check the consistency of databases and data warehouses with the requirements specified in SRS.

Verification of Architectural Design

The points considered for the verification of architectural design are:

• Check if every functional requirement in the SRS been take care of in this design.
• Check whether all exception handling conditions have been taken care of.
• Verify the process of transform mapping and transaction mapping, used for the transition from requirement model to architectural design.
• Since architectural design deals with the classification of a system into sub-systems or modules, check the functionality of each module according to the requirements specified.

• Check the inter-dependence and interface between the modules.

  In the modular approach of architectural design, there are two issues with modularity- Module Coupling and Module Cohesion. A good design will have low coupling and high cohesion. Testers should verify these factors; otherwise they will affect the reliability and maintainability of the system which are non-functional requirements of the system.

Verification of User-interface Design

The points to be considered for the verification of user-interface design are:

• Check all the interfaces between modules according to the architectural design.
• Check all the interfaces between software and other non-human producer and consumer of information.
• Check all the interfaces between the human and computer.
• Check all the aforementioned interfaces for their consistency.
• Check the response time for all the interfaces are within required ranges. It is very essential for real-time systems where response time is very crucial.

• For a Help Facility, verify the following:

  (i) The representation of Help is in its desired manner

  (ii) The user returns to the normal interaction from Help

• For error messages and warnings, verify the following:

  (i) Whether the message clarifies the problem

  (ii) Whether the message provides constructive advice for recovering from the error

• For typed command interaction, check the mapping between every menu option and their cor responding commands.