V-Model 

The V-model is a software development process which can be 
presumed to be the extension of the waterfall model. 
Instead of moving down in a linear way, the process steps 
are bent upwards after the coding phase, to form the 
typical V shape. The V-Model demonstrates the relationships 
between each phase of the development life cycle and its 
associated phase of testing.
The V-model deploys a well-structured method in which each 
phase can be implemented by the detailed documentation of 
the previous phase. Testing activities like test designing 
start at the beginning of the project well before coding 
and therefore saves a huge amount of the project time.

There are two type of phases:
1. Verification
2. Validation


Verification Phases:

Requirements analysis

In the Requirements analysis phase, the requirements of the 
proposed system are collected by analyzing the needs of the 
user(s). This phase is concerned about establishing what 
the ideal system has to perform. However it does not 
determine how the software will be designed or built. 
Usually, the users are interviewed and a document called 
the user requirements document is generated.
The user requirements document will typically describe the 
system’s functional, physical, interface, performance, 
data, security requirements etc as expected by the user. It 
is one which the business analysts use to communicate their 
understanding of the system back to the users. The users 
carefully review this document as this document would serve 
as the guideline for the system designers in the system 
design phase. The user acceptance tests are designed in 
this phase. See also functional requirements, and Non-
functional requirements

System Design:

Systems design is the phase where system engineers analyze 
and understand the business of the proposed system by 
studying the user requirements document. They figure out 
possibilities and techniques by which the user requirements 
can be implemented. If any of the requirements are not 
feasible, the user is informed of the issue. A resolution 
is found and the user requirement document is edited 
accordingly.
The software specification document which serves as a 
blueprint for the development phase is generated. This 
document contains the general system organization, menu 
structures, data structures etc. It may also hold example 
business scenarios, sample windows, reports for the better 
understanding. Other technical documentation like entity 
diagrams, data dictionary will also be produced in this 
phase. The documents for system testing is prepared in this 
phase.

Architecture Design:

The phase of the design of computer architecture and 
software architecture can also be referred to as high-level 
design. The baseline in selecting the architecture is that 
it should realize all which typically consists of the list 
of modules, brief functionality of each module, their 
interface relationships, dependencies, database tables, 
architecture diagrams, technology details etc. The 
integration testing design is carried out in this phase.

Module Design:

The module design phase can also be referred to as low-
level design. The designed system is broken up into smaller 
units or modules and each of them is explained so that the 
programmer can start coding directly. The low level design 
document or program specifications will contain a detailed 
functional logic of the module, in pseudocode - database 
tables, with all elements, including their type and size - 
all interface details with complete API references- all 
dependency issues- error message listings- complete input 
and outputs for a module. The unit test design is developed 
in this stage.

Validation Phases:

Unit Testing:

In the V-model of software development, unit testing 
implies the first stage of dynamic testing process. 
According to software development expert Barry Boehm, a 
fault discovered and corrected in the unit testing phase is 
more than a hundred times cheaper than if it is done after 
delivery to the customer.
It involves analysis of the written code with the intention 
of eliminating errors. It also verifies that the codes are 
efficient and adheres to the adopted coding standards. 
Testing is usually white box. It is done using the Unit 
test design prepared during the module design phase. This 
may be carried out by software developers.

Integration Testing:

In integration testing the separate modules will be tested 
together to expose faults in the interfaces and in the 
interaction between integrated components. Testing is 
usually black box as the code is not directly checked for 
errors. It is done using the integration test design 
prepared during the architecture design phase.

System Testing:

System testing will compare the system specifications 
against the actual system. The system test design is 
derived from the system design documents and is used in 
this phase. Sometimes system testing is automated using 
testing tools. Once all the modules are integrated several 
errors may arise. Testing done at this stage is called 
system testing. fg

User Acceptance Testing:

Acceptance testing is the phase of testing used to 
determine whether a system satisfies the requirements 
specified in the the requirements analysis phase. The 
acceptance test design is derived from the requirements 
document. The acceptance test phase is the phase used by 
the customer to determine whether to accept the system or 
not.




Waterfall model:

The waterfall model is a sequential development process, in 
which development is seen as flowing steadily downwards 
(like a waterfall) through the phases of Conception, 
Initiation, Analysis, Design (validation), Construction, 
Testing and maintenance.
The first formal description of the waterfall model is 
often cited to be an article published in 1970 by Winston 
W. Royce (1929–1995),although Royce did not use the 
term "waterfall" in this article. Ironically, Royce was 
presenting this model as an example of a flawed, non-
working model (Royce 1970). This is in fact the way the 
term has generally been used in writing about software 
development - as a way to criticize a commonly used 
software practice.



Model:
In Royce's original waterfall model, the following phases 
are followed in order:
1.	Requirements specification 
2.	Design 
3.	Construction (AKA implementation or coding) 
4.	Integration 
5.	Testing and debugging (AKA Validation) 
6.	Installation 
7.	Maintenance 


To follow the waterfall model, one proceeds from one phase 
to the next in a purely sequential manner. For example, one 
first completes requirements specification, which is set in 
stone. When the requirements are fully completed, one 
proceeds to design. The software in question is designed 
and a blueprint is drawn for implementers (coders) to 
follow — this design should be a plan for implementing the 
requirements given. When the design is fully completed, an 
implementation of that design is made by coders. Towards 
the later stages of this implementation phase, disparate 
software components produced are combined to introduce new 
functionality and remove errors.
Thus the waterfall model maintains that one should move to 
a phase only when its preceding phase is completed and 
perfected. However, there are various modified waterfall 
models (including Royce's final model) that may include 
slight or major variations upon this process.



Regards,
Anoop

waterfall model  model follows the folowing steps:
requirement-->analysis-->Design-->coding-->Testing--
>Maintainance-->final product.testing is the fifth step 
after the coding been performed.

V Model-Verification&Validation model.
customer requirement<------------->Acceptance testing
     specification <-------------->System testing.
       High level design<--------->Integration Testing.
         Low level design<------->Unit Testing.
                           Coding

as given here in V model testing is done at every 
stage.right from Initial Requirement phase till  end phase.
Verification & validation are performed end to end.

your answer correct