Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-21T17:40:24Z

Vnpai: /* Integration Testing */

=Introduction=
Unit Testing is given a lot of importance in [[Software Testing]]. But functional and integration testing are essential too. Hence Functional and Integration Testing is discussed here. This page provides an introduction to these testing methods; also including the good practices to write functional and integration tests. Later additional types of software Tests are mentioned which could be used to gain further confidence that one's code is correct.

=Functional Testing=
Functional testing is the process of testing of all the functions of a system, ensuring that the system conforms to the user requirements and specifications. It is sometimes referred to as black box testing, as it does not require understanding of the internal structure of the implementation.

Functional testing can be done by using manual or automated methods[http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1b_4_mv#References]. In both the methods, a series of tests have to be run marking the interaction between the user and the system, ensuring that the system performs as it was supposed to. Since Use cases mainly depict the interaction between the user and system, functional test suites are created from requirement use cases, with each scenario becoming a functional test[http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1b_4_mv#References].

==Functional Test Plan==
[[Image:Functional.jpg|thumb|Functional test plan life cycle]]
"The functional test plan measures the quality of the functional components of the system[http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1b_4_mv#References]". The test plan is written by the Author. The Author lists a number of test cases, containing the input, expected results, and pre and post-test setup. After a module is unit tested, the Tester executes the functional test cases and records the actual results. The Reviewer compares the Actual results with the expected results and reports whether each test case passed or failed the test.

==Steps to write good Functional Tests==
# The test plan must be written by persons who have extensive knowledge of the business requirements. It is advisable that the developers do not write the test plans. This is because developers tend to unknowingly write test cases whose functionality is based on the implementation rather than the initial functional specifications.
# The functional test plans should be created as early as possible, probably as soon as the functional specifications are ready.
# The functional test plan should be updated when there are changes in the business requirements.
# The Author should clearly include the pre-test setup so that the Tester can easily execute the test cases.
# A list of test cases should be defined to verify a set of "clear-defined" functions of the use-case.
# The Author should provide post-test setup which has instructions on how to clear any data that would prevent the test case from being executed more than once.
# As a module is built and unit tested, the Tester should execute the particular test cases.

==Example==
Examples of pre-test setup, test cases and post-test setup are given below. The complete reference for the example can be found at [http://www.developer.com/java/ent/article.php/3623476/Functional-Test-Plans-The-Right-Way.htm Functional Test Plans]

The pre-test setup for Test Case: Create new user profile can be given as:
[UserName: "A": --> username: "A"]
[UserName: "A": --> first name: "John"]
[UserName: "A": --> last name: "Smith"]
[UserName: "A": --> access level: "read-only"]
[UserName: "A": --> password: "profile1"]

The test cases for the function:Verify that only valid users can access the system can be given as:

<table cellspacing="2" width=900 border="1" align="center" >
<tr valign="top" bgcolor="#99ffff">
<th>Test Case #</th>
<th>Required Input</th>
<th>Expected Results</th>
<th>Results</th>

<th>Pass/Fail</th></tr>

<tr valign="top"><td colspan="5">
<ul>
<li>Verify that only valid users can access the system.</li>
<li>Verify that valid users cannot access the system without entering a valid password.</li>
</ul></td></tr>

<tr valign="top"><td>1</td>
<td>Navigate to the login screen</td>
<td>Login screen with release number A is loaded.</td>

<td> </td>
<td> </td></tr>

<tr valign="top"><td>2</td>
<td>Enter user name "INVALIDUSER", password "INVALIDUSER", and click on login button</td>
<td>Error message: 
"User name is not found"</td>
<td> </td>
<td> </td></tr>

<tr valign="top"><td>3</td>
<td>Enter user name for user [UserName: "A":--> username] and password "test"</td>

<td>Error Message: 
"Password for user [UserName: "A": --> username] is invalid"</td>
<td> </td>
<td> </td></tr>

<tr valign="top"><td>4</td>
<td>Enter user name [UserName: "A": --> username] and password [UserName: "A": --> password]</td>

<td>The main page is loaded with a message: 
"Welcome [UserName: "A": --> first name] [UserName: "A": --> last name]</td>
<td> </td>
<td> </td></tr>
</table>

The post-test setup for the above scenario can be given as:
Remove [UserName: "A": --> username: "A"] from the LDAP Server.

=Integration Testing=
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules. Integration testing is an important phase and sometimes there are separate teams which handle integration testing.
 
DEFINITION:Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.[PRESSMAN ISBN 0073655783]
==Integration Test approaches==
Integration testing can be done in a variety of ways [[Image:TopDown_Approach.jpg|thumb|Top Down Approach]]
# '''Top-Down Approach.''' In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed
# '''Bottom Up Approach.''' In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach. [[Image:BottomUp_Approach.jpg|thumb|Bottom Up Approach]]
# '''Umbrella approach.''' Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.
==Prerequisites before Integration Testing==
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.
==Steps to write good Integration Test Cases==
#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.

==How To write good Integration Test Cases and do effective Integration Testing==
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner. The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.

=Beyond Functional and Integration Testing=
[[Image:TestPhase.jpg|thumb|Test Phases]]
Integration and Functional testing are not the only testing that are done for checking the validity of the system. Other test cases includes: 
'''Unit Testing:''' This is the first stage where the developer tests the component he/she is creating. More can be found at [http://en.wikipedia.org/wiki/Unit_testing Unit Testing] 
'''Validation Testing:''' After integration Testing, validation testing takes place wherein checks are made to ensure that the functional requirements are satisfied. 
'''Alpha and Beta Testing:'''When the product about to be released, it is first exposed to some end users who test the application. This is alpha beta testing. More can be found at [http://www.majordojo.com/uploads/AlphaBetaTesting.pdf Alpha and Beta Testing] 
'''Recovery Testing:''' In this phase the system is made to crash and is used to check to see if it recovers in the proper manner. More can be found at [http://en.wikipedia.org/wiki/Recovery_testing Recovery Testing] 
'''Security Testing:''' Systems that store and record sensitive information need to be protected from threats, in this phase the systems protection mechanisms are tested. More can be found at [http://en.wikipedia.org/wiki/Security_testing Security Testing] 
'''Stress Testing:'''The system is overloaded with data and it is checked to whether it crashes. More can be found at [http://en.wikipedia.org/wiki/Stress_testing Stress Testing] 
'''Performance Testing:''' It tests the run time performance of software within the context of the system. More can be found at [http://en.wikipedia.org/wiki/Performance_testing Performance Testing] 
'''Smoke Testing:''' smoke testing is a preliminary to further testing, which should reveal simple failures severe enough to reject a prospective software release. More can be found at [http://en.wikipedia.org/wiki/Smoke_test Smoke Test] 
'''Acceptance Testing:''' acceptance testing performed by the customer is known as user acceptance testing (UAT). This is also known as end-user testing, site (acceptance) testing, or field (acceptance) testing. More can be found at [http://en.wikipedia.org/wiki/Acceptance_testing Acceptance Testing]

=References=

# [http://www.segue.com/pdf/automated_functional_testing.pdf Automated Functional Testing]
# [http://searchsoftwarequality.techtarget.com/generic/0,295582,sid92_gci1303938,00.html# Functional Tests to ensure Software Quality]
# [http://www.developer.com/tech/article.php/3623476/Functional-Test-Plans-The-Right-Way.htm Functional Test Plans]

=External Links=

# [http://en.wikipedia.org/wiki/Unit_testing Unit Testing]
# [http://www.majordojo.com/uploads/AlphaBetaTesting.pdf Alpha Beta Testing]
# [http://en.wikipedia.org/wiki/Recovery_testing Recovery Testing]
# [http://en.wikipedia.org/wiki/Security_testing Security Testing]
# [http://en.wikipedia.org/wiki/Stress_testing Stress Testing]
# [http://en.wikipedia.org/wiki/Performance_testing Performance Testing]
# [http://en.wikipedia.org/wiki/Smoke_test Smoke Test]
# [http://en.wikipedia.org/wiki/Acceptance_testing Acceptance Testing]

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-21T17:34:33Z

Vnpai: /* Integration Testing */

=Introduction=
Unit Testing is given a lot of importance in [[Software Testing]]. But functional and integration testing are essential too. Hence Functional and Integration Testing is discussed here. This page provides an introduction to these testing methods; also including the good practices to write functional and integration tests. Later additional types of software Tests are mentioned which could be used to gain further confidence that one's code is correct.

=Functional Testing=
Functional testing is the process of testing of all the functions of a system, ensuring that the system conforms to the user requirements and specifications. It is sometimes referred to as black box testing, as it does not require understanding of the internal structure of the implementation.

Functional testing can be done by using manual or automated methods[http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1b_4_mv#References]. In both the methods, a series of tests have to be run marking the interaction between the user and the system, ensuring that the system performs as it was supposed to. Since Use cases mainly depict the interaction between the user and system, functional test suites are created from requirement use cases, with each scenario becoming a functional test[http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1b_4_mv#References].

==Functional Test Plan==
[[Image:Functional.jpg|thumb|Functional test plan life cycle]]
"The functional test plan measures the quality of the functional components of the system[http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1b_4_mv#References]". The test plan is written by the Author. The Author lists a number of test cases, containing the input, expected results, and pre and post-test setup. After a module is unit tested, the Tester executes the functional test cases and records the actual results. The Reviewer compares the Actual results with the expected results and reports whether each test case passed or failed the test.

==Steps to write good Functional Tests==
# The test plan must be written by persons who have extensive knowledge of the business requirements. It is advisable that the developers do not write the test plans. This is because developers tend to unknowingly write test cases whose functionality is based on the implementation rather than the initial functional specifications.
# The functional test plans should be created as early as possible, probably as soon as the functional specifications are ready.
# The functional test plan should be updated when there are changes in the business requirements.
# The Author should clearly include the pre-test setup so that the Tester can easily execute the test cases.
# A list of test cases should be defined to verify a set of "clear-defined" functions of the use-case.
# The Author should provide post-test setup which has instructions on how to clear any data that would prevent the test case from being executed more than once.
# As a module is built and unit tested, the Tester should execute the particular test cases.

==Example==
Examples of pre-test setup, test cases and post-test setup are given below. The complete reference for the example can be found at [http://www.developer.com/java/ent/article.php/3623476/Functional-Test-Plans-The-Right-Way.htm Functional Test Plans]

The pre-test setup for Test Case: Create new user profile can be given as:
[UserName: "A": --> username: "A"]
[UserName: "A": --> first name: "John"]
[UserName: "A": --> last name: "Smith"]
[UserName: "A": --> access level: "read-only"]
[UserName: "A": --> password: "profile1"]

The test cases for the function:Verify that only valid users can access the system can be given as:

<table cellspacing="2" width=900 border="1" align="center" >
<tr valign="top" bgcolor="#99ffff">
<th>Test Case #</th>
<th>Required Input</th>
<th>Expected Results</th>
<th>Results</th>

<th>Pass/Fail</th></tr>

<tr valign="top"><td colspan="5">
<ul>
<li>Verify that only valid users can access the system.</li>
<li>Verify that valid users cannot access the system without entering a valid password.</li>
</ul></td></tr>

<tr valign="top"><td>1</td>
<td>Navigate to the login screen</td>
<td>Login screen with release number A is loaded.</td>

<td> </td>
<td> </td></tr>

<tr valign="top"><td>2</td>
<td>Enter user name "INVALIDUSER", password "INVALIDUSER", and click on login button</td>
<td>Error message: 
"User name is not found"</td>
<td> </td>
<td> </td></tr>

<tr valign="top"><td>3</td>
<td>Enter user name for user [UserName: "A":--> username] and password "test"</td>

<td>Error Message: 
"Password for user [UserName: "A": --> username] is invalid"</td>
<td> </td>
<td> </td></tr>

<tr valign="top"><td>4</td>
<td>Enter user name [UserName: "A": --> username] and password [UserName: "A": --> password]</td>

<td>The main page is loaded with a message: 
"Welcome [UserName: "A": --> first name] [UserName: "A": --> last name]</td>
<td> </td>
<td> </td></tr>
</table>

The post-test setup for the above scenario can be given as:
Remove [UserName: "A": --> username: "A"] from the LDAP Server.

=Integration Testing=
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules. Integration testing is an important phase and sometimes there are separate teams which handle integration testing.
 
DEFINITION:Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.[PRESSMAN]
==Integration Test approaches==
Integration testing can be done in a variety of ways [[Image:TopDown_Approach.jpg|thumb|Top Down Approach]]
# '''Top-Down Approach.''' In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed
# '''Bottom Up Approach.''' In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach. [[Image:BottomUp_Approach.jpg|thumb|Bottom Up Approach]]
# '''Umbrella approach.''' Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.
==Prerequisites before Integration Testing==
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.
==Steps to write good Integration Test Cases==
#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.

==How To write good Integration Test Cases and do effective Integration Testing==
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner. The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.

=Beyond Functional and Integration Testing=
[[Image:TestPhase.jpg|thumb|Test Phases]]
Integration and Functional testing are not the only testing that are done for checking the validity of the system. Other test cases includes: 
'''Unit Testing:''' This is the first stage where the developer tests the component he/she is creating. More can be found at [http://en.wikipedia.org/wiki/Unit_testing Unit Testing] 
'''Validation Testing:''' After integration Testing, validation testing takes place wherein checks are made to ensure that the functional requirements are satisfied. 
'''Alpha and Beta Testing:'''When the product about to be released, it is first exposed to some end users who test the application. This is alpha beta testing. More can be found at [http://www.majordojo.com/uploads/AlphaBetaTesting.pdf Alpha and Beta Testing] 
'''Recovery Testing:''' In this phase the system is made to crash and is used to check to see if it recovers in the proper manner. More can be found at [http://en.wikipedia.org/wiki/Recovery_testing Recovery Testing] 
'''Security Testing:''' Systems that store and record sensitive information need to be protected from threats, in this phase the systems protection mechanisms are tested. More can be found at [http://en.wikipedia.org/wiki/Security_testing Security Testing] 
'''Stress Testing:'''The system is overloaded with data and it is checked to whether it crashes. More can be found at [http://en.wikipedia.org/wiki/Stress_testing Stress Testing] 
'''Performance Testing:''' It tests the run time performance of software within the context of the system. More can be found at [http://en.wikipedia.org/wiki/Performance_testing Performance Testing] 
'''Smoke Testing:''' smoke testing is a preliminary to further testing, which should reveal simple failures severe enough to reject a prospective software release. More can be found at [http://en.wikipedia.org/wiki/Smoke_test Smoke Test] 
'''Acceptance Testing:''' acceptance testing performed by the customer is known as user acceptance testing (UAT). This is also known as end-user testing, site (acceptance) testing, or field (acceptance) testing. More can be found at [http://en.wikipedia.org/wiki/Acceptance_testing Acceptance Testing]

=References=

# [http://www.segue.com/pdf/automated_functional_testing.pdf Automated Functional Testing]
# [http://searchsoftwarequality.techtarget.com/generic/0,295582,sid92_gci1303938,00.html# Functional Tests to ensure Software Quality]
# [http://www.developer.com/tech/article.php/3623476/Functional-Test-Plans-The-Right-Way.htm Functional Test Plans]

=External Links=

# [http://en.wikipedia.org/wiki/Unit_testing Unit Testing]
# [http://www.majordojo.com/uploads/AlphaBetaTesting.pdf Alpha Beta Testing]
# [http://en.wikipedia.org/wiki/Recovery_testing Recovery Testing]
# [http://en.wikipedia.org/wiki/Security_testing Security Testing]
# [http://en.wikipedia.org/wiki/Stress_testing Stress Testing]
# [http://en.wikipedia.org/wiki/Performance_testing Performance Testing]
# [http://en.wikipedia.org/wiki/Smoke_test Smoke Test]
# [http://en.wikipedia.org/wiki/Acceptance_testing Acceptance Testing]

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-21T17:30:02Z

Vnpai:

=Introduction=
Unit Testing is given a lot of importance in [[Software Testing]]. But functional and integration testing are essential too. Hence Functional and Integration Testing is discussed here. This page provides an introduction to these testing methods; also including the good practices to write functional and integration tests. Later additional types of software Tests are mentioned which could be used to gain further confidence that one's code is correct.

=Functional Testing=
Functional testing is the process of testing of all the functions of a system, ensuring that the system conforms to the user requirements and specifications. It is sometimes referred to as black box testing, as it does not require understanding of the internal structure of the implementation.

Functional testing can be done by using manual or automated methods[http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1b_4_mv#References]. In both the methods, a series of tests have to be run marking the interaction between the user and the system, ensuring that the system performs as it was supposed to. Since Use cases mainly depict the interaction between the user and system, functional test suites are created from requirement use cases, with each scenario becoming a functional test[http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1b_4_mv#References].

==Functional Test Plan==
[[Image:Functional.jpg|thumb|Functional test plan life cycle]]
"The functional test plan measures the quality of the functional components of the system[http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1b_4_mv#References]". The test plan is written by the Author. The Author lists a number of test cases, containing the input, expected results, and pre and post-test setup. After a module is unit tested, the Tester executes the functional test cases and records the actual results. The Reviewer compares the Actual results with the expected results and reports whether each test case passed or failed the test.

==Steps to write good Functional Tests==
# The test plan must be written by persons who have extensive knowledge of the business requirements. It is advisable that the developers do not write the test plans. This is because developers tend to unknowingly write test cases whose functionality is based on the implementation rather than the initial functional specifications.
# The functional test plans should be created as early as possible, probably as soon as the functional specifications are ready.
# The functional test plan should be updated when there are changes in the business requirements.
# The Author should clearly include the pre-test setup so that the Tester can easily execute the test cases.
# A list of test cases should be defined to verify a set of "clear-defined" functions of the use-case.
# The Author should provide post-test setup which has instructions on how to clear any data that would prevent the test case from being executed more than once.
# As a module is built and unit tested, the Tester should execute the particular test cases.

==Example==
Examples of pre-test setup, test cases and post-test setup are given below. The complete reference for the example can be found at [http://www.developer.com/java/ent/article.php/3623476/Functional-Test-Plans-The-Right-Way.htm Functional Test Plans]

The pre-test setup for Test Case: Create new user profile can be given as:
[UserName: "A": --> username: "A"]
[UserName: "A": --> first name: "John"]
[UserName: "A": --> last name: "Smith"]
[UserName: "A": --> access level: "read-only"]
[UserName: "A": --> password: "profile1"]

The test cases for the function:Verify that only valid users can access the system can be given as:

<table cellspacing="2" width=900 border="1" align="center" >
<tr valign="top" bgcolor="#99ffff">
<th>Test Case #</th>
<th>Required Input</th>
<th>Expected Results</th>
<th>Results</th>

<th>Pass/Fail</th></tr>

<tr valign="top"><td colspan="5">
<ul>
<li>Verify that only valid users can access the system.</li>
<li>Verify that valid users cannot access the system without entering a valid password.</li>
</ul></td></tr>

<tr valign="top"><td>1</td>
<td>Navigate to the login screen</td>
<td>Login screen with release number A is loaded.</td>

<td> </td>
<td> </td></tr>

<tr valign="top"><td>2</td>
<td>Enter user name "INVALIDUSER", password "INVALIDUSER", and click on login button</td>
<td>Error message: 
"User name is not found"</td>
<td> </td>
<td> </td></tr>

<tr valign="top"><td>3</td>
<td>Enter user name for user [UserName: "A":--> username] and password "test"</td>

<td>Error Message: 
"Password for user [UserName: "A": --> username] is invalid"</td>
<td> </td>
<td> </td></tr>

<tr valign="top"><td>4</td>
<td>Enter user name [UserName: "A": --> username] and password [UserName: "A": --> password]</td>

<td>The main page is loaded with a message: 
"Welcome [UserName: "A": --> first name] [UserName: "A": --> last name]</td>
<td> </td>
<td> </td></tr>
</table>

The post-test setup for the above scenario can be given as:
Remove [UserName: "A": --> username: "A"] from the LDAP Server.

=Integration Testing=
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules. Integration testing is an important phase and sometimes there are separate teams which handle integration testing.
 
DEFINITION:Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.
==Integration Test approaches==
Integration testing can be done in a variety of ways [[Image:TopDown_Approach.jpg|thumb|Top Down Approach]]
# '''Top-Down Approach.''' In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed
# '''Bottom Up Approach.''' In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach. [[Image:BottomUp_Approach.jpg|thumb|Bottom Up Approach]]
# '''Umbrella approach.''' Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.
==Prerequisites before Integration Testing==
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.
==Steps to write good Integration Test Cases==
#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.

==How To write good Integration Test Cases and do effective Integration Testing==
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner. The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.
=Beyond Functional and Integration Testing=
[[Image:TestPhase.jpg|thumb|Test Phases]]
Integration and Functional testing are not the only testing that are done for checking the validity of the system. Other test cases includes: 
'''Unit Testing:''' This is the first stage where the developer tests the component he/she is creating. More can be found at [http://en.wikipedia.org/wiki/Unit_testing Unit Testing] 
'''Validation Testing:''' After integration Testing, validation testing takes place wherein checks are made to ensure that the functional requirements are satisfied. 
'''Alpha and Beta Testing:'''When the product about to be released, it is first exposed to some end users who test the application. This is alpha beta testing. More can be found at [http://www.majordojo.com/uploads/AlphaBetaTesting.pdf Alpha and Beta Testing] 
'''Recovery Testing:''' In this phase the system is made to crash and is used to check to see if it recovers in the proper manner. More can be found at [http://en.wikipedia.org/wiki/Recovery_testing Recovery Testing] 
'''Security Testing:''' Systems that store and record sensitive information need to be protected from threats, in this phase the systems protection mechanisms are tested. More can be found at [http://en.wikipedia.org/wiki/Security_testing Security Testing] 
'''Stress Testing:'''The system is overloaded with data and it is checked to whether it crashes. More can be found at [http://en.wikipedia.org/wiki/Stress_testing Stress Testing] 
'''Performance Testing:''' It tests the run time performance of software within the context of the system. More can be found at [http://en.wikipedia.org/wiki/Performance_testing Performance Testing] 
'''Smoke Testing:''' smoke testing is a preliminary to further testing, which should reveal simple failures severe enough to reject a prospective software release. More can be found at [http://en.wikipedia.org/wiki/Smoke_test Smoke Test] 
'''Acceptance Testing:''' acceptance testing performed by the customer is known as user acceptance testing (UAT). This is also known as end-user testing, site (acceptance) testing, or field (acceptance) testing. More can be found at [http://en.wikipedia.org/wiki/Acceptance_testing Acceptance Testing]

=References=

# [http://www.segue.com/pdf/automated_functional_testing.pdf Automated Functional Testing]
# [http://searchsoftwarequality.techtarget.com/generic/0,295582,sid92_gci1303938,00.html# Functional Tests to ensure Software Quality]
# [http://www.developer.com/tech/article.php/3623476/Functional-Test-Plans-The-Right-Way.htm Functional Test Plans]

=External Links=

# [http://en.wikipedia.org/wiki/Unit_testing Unit Testing]
# [http://www.majordojo.com/uploads/AlphaBetaTesting.pdf Alpha Beta Testing]
# [http://en.wikipedia.org/wiki/Recovery_testing Recovery Testing]
# [http://en.wikipedia.org/wiki/Security_testing Security Testing]
# [http://en.wikipedia.org/wiki/Stress_testing Stress Testing]
# [http://en.wikipedia.org/wiki/Performance_testing Performance Testing]
# [http://en.wikipedia.org/wiki/Smoke_test Smoke Test]
# [http://en.wikipedia.org/wiki/Acceptance_testing Acceptance Testing]

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-21T17:28:54Z

Vnpai:

=Introduction=
Unit Testing is given a lot of importance in [[Software Testing]]. But functional and integration testing are essential too. Hence Functional and Integration Testing is discussed here. This page provides an introduction to these testing methods; also including the good practices to write functional and integration tests. Later additional types of software Tests are mentioned which could be used to gain further confidence that one's code is correct.

=Functional Testing=
Functional testing is the process of testing of all the functions of a system, ensuring that the system conforms to the user requirements and specifications. It is sometimes referred to as black box testing, as it does not require understanding of the internal structure of the implementation.

Functional testing can be done by using manual or automated methods[http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1b_4_mv#References]. In both the methods, a series of tests have to be run marking the interaction between the user and the system, ensuring that the system performs as it was supposed to. Since Use cases mainly depict the interaction between the user and system, functional test suites are created from requirement use cases, with each scenario becoming a functional test[http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1b_4_mv#References].

==Functional Test Plan==
[[Image:Functional.jpg|thumb|Functional test plan life cycle]]
"The functional test plan measures the quality of the functional components of the system[http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1b_4_mv#References]". The test plan is written by the Author. The Author lists a number of test cases, containing the input, expected results, and pre and post-test setup. After a module is unit tested, the Tester executes the functional test cases and records the actual results. The Reviewer compares the Actual results with the expected results and reports whether each test case passed or failed the test.

==Steps to write good Functional Tests==
# The test plan must be written by persons who have extensive knowledge of the business requirements. It is advisable that the developers do not write the test plans. This is because developers tend to unknowingly write test cases whose functionality is based on the implementation rather than the initial functional specifications.
# The functional test plans should be created as early as possible, probably as soon as the functional specifications are ready.
# The functional test plan should be updated when there are changes in the business requirements.
# The Author should clearly include the pre-test setup so that the Tester can easily execute the test cases.
# A list of test cases should be defined to verify a set of "clear-defined" functions of the use-case.
# The Author should provide post-test setup which has instructions on how to clear any data that would prevent the test case from being executed more than once.
# As a module is built and unit tested, the Tester should execute the particular test cases.

==Example==
Examples of pre-test setup, test cases and post-test setup are given below. The complete reference for the example can be found at [http://www.developer.com/java/ent/article.php/3623476/Functional-Test-Plans-The-Right-Way.htm Functional Test Plans]

The pre-test setup for Test Case: Create new user profile can be given as:
[UserName: "A": --> username: "A"]
[UserName: "A": --> first name: "John"]
[UserName: "A": --> last name: "Smith"]
[UserName: "A": --> access level: "read-only"]
[UserName: "A": --> password: "profile1"]

The test cases for the function:Verify that only valid users can access the system can be given as:

<table cellspacing="2" width=900 border="1" align="center" >
<tr valign="top" bgcolor="#99ffff">
<th>Test Case #</th>
<th>Required Input</th>
<th>Expected Results</th>
<th>Results</th>

<th>Pass/Fail</th></tr>

<tr valign="top"><td colspan="5">
<ul>
<li>Verify that only valid users can access the system.</li>
<li>Verify that valid users cannot access the system without entering a valid password.</li>
</ul></td></tr>

<tr valign="top"><td>1</td>
<td>Navigate to the login screen</td>
<td>Login screen with release number A is loaded.</td>

<td> </td>
<td> </td></tr>

<tr valign="top"><td>2</td>
<td>Enter user name "INVALIDUSER", password "INVALIDUSER", and click on login button</td>
<td>Error message: 
"User name is not found"</td>
<td> </td>
<td> </td></tr>

<tr valign="top"><td>3</td>
<td>Enter user name for user [UserName: "A":--> username] and password "test"</td>

<td>Error Message: 
"Password for user [UserName: "A": --> username] is invalid"</td>
<td> </td>
<td> </td></tr>

<tr valign="top"><td>4</td>
<td>Enter user name [UserName: "A": --> username] and password [UserName: "A": --> password]</td>

<td>The main page is loaded with a message: 
"Welcome [UserName: "A": --> first name] [UserName: "A": --> last name]</td>
<td> </td>
<td> </td></tr>
</table>

The post-test setup for the above scenario can be given as:
Remove [UserName: "A": --> username: "A"] from the LDAP Server.

=Integration Testing=
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules. Integration testing is an important phase and sometimes there are separate teams which handle integration testing.
 
DEFINITION:Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.
==Integration Test approaches==
Integration testing can be done in a variety of ways [[Image:TopDown_Approach.jpg|thumb|Top Down Approach]]
# '''Top-Down Approach.''' In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed
# '''Bottom Up Approach.''' In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach. [[Image:BottomUp_Approach.jpg|thumb|Bottom Up Approach]]
# '''Umbrella approach.''' Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.
==Prerequisites before Integration Testing==
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.
==Steps to write good Integration Test Cases==
#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.

==How To write good Integration Test Cases and do effective Integration Testing==
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner. The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.
=Beyond Functional and Integration Testing=
[[Image:TestPhase.gif|thumb|Test Phases]]
Integration and Functional testing are not the only testing that are done for checking the validity of the system. Other test cases includes: 
'''Unit Testing:''' This is the first stage where the developer tests the component he/she is creating. More can be found at [http://en.wikipedia.org/wiki/Unit_testing Unit Testing] 
'''Validation Testing:''' After integration Testing, validation testing takes place wherein checks are made to ensure that the functional requirements are satisfied. 
'''Alpha and Beta Testing:'''When the product about to be released, it is first exposed to some end users who test the application. This is alpha beta testing. More can be found at [http://www.majordojo.com/uploads/AlphaBetaTesting.pdf Alpha and Beta Testing] 
'''Recovery Testing:''' In this phase the system is made to crash and is used to check to see if it recovers in the proper manner. More can be found at [http://en.wikipedia.org/wiki/Recovery_testing Recovery Testing] 
'''Security Testing:''' Systems that store and record sensitive information need to be protected from threats, in this phase the systems protection mechanisms are tested. More can be found at [http://en.wikipedia.org/wiki/Security_testing Security Testing] 
'''Stress Testing:'''The system is overloaded with data and it is checked to whether it crashes. More can be found at [http://en.wikipedia.org/wiki/Stress_testing Stress Testing] 
'''Performance Testing:''' It tests the run time performance of software within the context of the system. More can be found at [http://en.wikipedia.org/wiki/Performance_testing Performance Testing] 
'''Smoke Testing:''' smoke testing is a preliminary to further testing, which should reveal simple failures severe enough to reject a prospective software release. More can be found at [http://en.wikipedia.org/wiki/Smoke_test Smoke Test] 
'''Acceptance Testing:''' acceptance testing performed by the customer is known as user acceptance testing (UAT). This is also known as end-user testing, site (acceptance) testing, or field (acceptance) testing. More can be found at [http://en.wikipedia.org/wiki/Acceptance_testing Acceptance Testing]

=References=

# [http://www.segue.com/pdf/automated_functional_testing.pdf Automated Functional Testing]
# [http://searchsoftwarequality.techtarget.com/generic/0,295582,sid92_gci1303938,00.html# Functional Tests to ensure Software Quality]
# [http://www.developer.com/tech/article.php/3623476/Functional-Test-Plans-The-Right-Way.htm Functional Test Plans]

=External Links=

# [http://en.wikipedia.org/wiki/Unit_testing Unit Testing]
# [http://www.majordojo.com/uploads/AlphaBetaTesting.pdf Alpha Beta Testing]
# [http://en.wikipedia.org/wiki/Recovery_testing Recovery Testing]
# [http://en.wikipedia.org/wiki/Security_testing Security Testing]
# [http://en.wikipedia.org/wiki/Stress_testing Stress Testing]
# [http://en.wikipedia.org/wiki/Performance_testing Performance Testing]
# [http://en.wikipedia.org/wiki/Smoke_test Smoke Test]
# [http://en.wikipedia.org/wiki/Acceptance_testing Acceptance Testing]

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-21T17:28:29Z

Vnpai:

=Introduction=
Unit Testing is given a lot of importance in [[Software Testing]]. But functional and integration testing are essential too. Hence Functional and Integration Testing is discussed here. This page provides an introduction to these testing methods; also including the good practices to write functional and integration tests. Later additional types of software Tests are mentioned which could be used to gain further confidence that one's code is correct.

=Functional Testing=
Functional testing is the process of testing of all the functions of a system, ensuring that the system conforms to the user requirements and specifications. It is sometimes referred to as black box testing, as it does not require understanding of the internal structure of the implementation.

Functional testing can be done by using manual or automated methods[http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1b_4_mv#References]. In both the methods, a series of tests have to be run marking the interaction between the user and the system, ensuring that the system performs as it was supposed to. Since Use cases mainly depict the interaction between the user and system, functional test suites are created from requirement use cases, with each scenario becoming a functional test[http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1b_4_mv#References].

==Functional Test Plan==
[[Image:Functional.gif|thumb|Functional test plan life cycle]]
"The functional test plan measures the quality of the functional components of the system[http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1b_4_mv#References]". The test plan is written by the Author. The Author lists a number of test cases, containing the input, expected results, and pre and post-test setup. After a module is unit tested, the Tester executes the functional test cases and records the actual results. The Reviewer compares the Actual results with the expected results and reports whether each test case passed or failed the test.

==Steps to write good Functional Tests==
# The test plan must be written by persons who have extensive knowledge of the business requirements. It is advisable that the developers do not write the test plans. This is because developers tend to unknowingly write test cases whose functionality is based on the implementation rather than the initial functional specifications.
# The functional test plans should be created as early as possible, probably as soon as the functional specifications are ready.
# The functional test plan should be updated when there are changes in the business requirements.
# The Author should clearly include the pre-test setup so that the Tester can easily execute the test cases.
# A list of test cases should be defined to verify a set of "clear-defined" functions of the use-case.
# The Author should provide post-test setup which has instructions on how to clear any data that would prevent the test case from being executed more than once.
# As a module is built and unit tested, the Tester should execute the particular test cases.

==Example==
Examples of pre-test setup, test cases and post-test setup are given below. The complete reference for the example can be found at [http://www.developer.com/java/ent/article.php/3623476/Functional-Test-Plans-The-Right-Way.htm Functional Test Plans]

The pre-test setup for Test Case: Create new user profile can be given as:
[UserName: "A": --> username: "A"]
[UserName: "A": --> first name: "John"]
[UserName: "A": --> last name: "Smith"]
[UserName: "A": --> access level: "read-only"]
[UserName: "A": --> password: "profile1"]

The test cases for the function:Verify that only valid users can access the system can be given as:

<table cellspacing="2" width=900 border="1" align="center" >
<tr valign="top" bgcolor="#99ffff">
<th>Test Case #</th>
<th>Required Input</th>
<th>Expected Results</th>
<th>Results</th>

<th>Pass/Fail</th></tr>

<tr valign="top"><td colspan="5">
<ul>
<li>Verify that only valid users can access the system.</li>
<li>Verify that valid users cannot access the system without entering a valid password.</li>
</ul></td></tr>

<tr valign="top"><td>1</td>
<td>Navigate to the login screen</td>
<td>Login screen with release number A is loaded.</td>

<td> </td>
<td> </td></tr>

<tr valign="top"><td>2</td>
<td>Enter user name "INVALIDUSER", password "INVALIDUSER", and click on login button</td>
<td>Error message: 
"User name is not found"</td>
<td> </td>
<td> </td></tr>

<tr valign="top"><td>3</td>
<td>Enter user name for user [UserName: "A":--> username] and password "test"</td>

<td>Error Message: 
"Password for user [UserName: "A": --> username] is invalid"</td>
<td> </td>
<td> </td></tr>

<tr valign="top"><td>4</td>
<td>Enter user name [UserName: "A": --> username] and password [UserName: "A": --> password]</td>

<td>The main page is loaded with a message: 
"Welcome [UserName: "A": --> first name] [UserName: "A": --> last name]</td>
<td> </td>
<td> </td></tr>
</table>

The post-test setup for the above scenario can be given as:
Remove [UserName: "A": --> username: "A"] from the LDAP Server.

=Integration Testing=
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules. Integration testing is an important phase and sometimes there are separate teams which handle integration testing.
 
DEFINITION:Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.
==Integration Test approaches==
Integration testing can be done in a variety of ways [[Image:TopDown_Approach.jpg|thumb|Top Down Approach]]
# '''Top-Down Approach.''' In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed
# '''Bottom Up Approach.''' In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach. [[Image:BottomUp_Approach.jpg|thumb|Bottom Up Approach]]
# '''Umbrella approach.''' Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.
==Prerequisites before Integration Testing==
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.
==Steps to write good Integration Test Cases==
#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.

==How To write good Integration Test Cases and do effective Integration Testing==
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner. The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.
=Beyond Functional and Integration Testing=
[[Image:TestPhase.gif|thumb|Test Phases]]
Integration and Functional testing are not the only testing that are done for checking the validity of the system. Other test cases includes: 
'''Unit Testing:''' This is the first stage where the developer tests the component he/she is creating. More can be found at [http://en.wikipedia.org/wiki/Unit_testing Unit Testing] 
'''Validation Testing:''' After integration Testing, validation testing takes place wherein checks are made to ensure that the functional requirements are satisfied. 
'''Alpha and Beta Testing:'''When the product about to be released, it is first exposed to some end users who test the application. This is alpha beta testing. More can be found at [http://www.majordojo.com/uploads/AlphaBetaTesting.pdf Alpha and Beta Testing] 
'''Recovery Testing:''' In this phase the system is made to crash and is used to check to see if it recovers in the proper manner. More can be found at [http://en.wikipedia.org/wiki/Recovery_testing Recovery Testing] 
'''Security Testing:''' Systems that store and record sensitive information need to be protected from threats, in this phase the systems protection mechanisms are tested. More can be found at [http://en.wikipedia.org/wiki/Security_testing Security Testing] 
'''Stress Testing:'''The system is overloaded with data and it is checked to whether it crashes. More can be found at [http://en.wikipedia.org/wiki/Stress_testing Stress Testing] 
'''Performance Testing:''' It tests the run time performance of software within the context of the system. More can be found at [http://en.wikipedia.org/wiki/Performance_testing Performance Testing] 
'''Smoke Testing:''' smoke testing is a preliminary to further testing, which should reveal simple failures severe enough to reject a prospective software release. More can be found at [http://en.wikipedia.org/wiki/Smoke_test Smoke Test] 
'''Acceptance Testing:''' acceptance testing performed by the customer is known as user acceptance testing (UAT). This is also known as end-user testing, site (acceptance) testing, or field (acceptance) testing. More can be found at [http://en.wikipedia.org/wiki/Acceptance_testing Acceptance Testing]

=References=

# [http://www.segue.com/pdf/automated_functional_testing.pdf Automated Functional Testing]
# [http://searchsoftwarequality.techtarget.com/generic/0,295582,sid92_gci1303938,00.html# Functional Tests to ensure Software Quality]
# [http://www.developer.com/tech/article.php/3623476/Functional-Test-Plans-The-Right-Way.htm Functional Test Plans]

=External Links=

# [http://en.wikipedia.org/wiki/Unit_testing Unit Testing]
# [http://www.majordojo.com/uploads/AlphaBetaTesting.pdf Alpha Beta Testing]
# [http://en.wikipedia.org/wiki/Recovery_testing Recovery Testing]
# [http://en.wikipedia.org/wiki/Security_testing Security Testing]
# [http://en.wikipedia.org/wiki/Stress_testing Stress Testing]
# [http://en.wikipedia.org/wiki/Performance_testing Performance Testing]
# [http://en.wikipedia.org/wiki/Smoke_test Smoke Test]
# [http://en.wikipedia.org/wiki/Acceptance_testing Acceptance Testing]

File:TestPhase.jpg

2009-09-21T17:26:52Z

Vnpai: This picture shows us the various phases a software has to go through before it is released to the system. There are various other tests too which have not been shown in the system like stress testing and Regression testing, these also have an important p

This picture shows us the various phases a software has to go through before it is released to the system. There are various other tests too which have not been shown in the system like stress testing and Regression testing, these also have an important part in the deployment of a product.
For simplicity these tests have been ignored but it is worthy to note that they are an important part of the testing cycle too.

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-21T17:06:55Z

Vnpai:

=Introduction=
Unit Testing is given a lot of importance in [[Software Testing]]. But functional and integration testing are essential too. Hence Functional and Integration Testing is discussed here. This page provides an introduction to these testing methods; also including the good practices to write functional and integration tests. Later additional types of software Tests are mentioned which could be used to gain further confidence that one's code is correct.

=Functional Testing=
Functional testing is the process of testing of all the functions of a system, ensuring that the system conforms to the user requirements and specifications. It is sometimes referred to as black box testing, as it does not require understanding of the internal structure of the implementation.

Functional testing can be done by using manual or automated methods[http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1b_4_mv#References]. In both the methods, a series of tests have to be run marking the interaction between the user and the system, ensuring that the system performs as it was supposed to. Since Use cases mainly depict the interaction between the user and system, functional test suites are created from requirement use cases, with each scenario becoming a functional test[http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1b_4_mv#References].

==Functional Test Plan==
[[Image:Functional.gif|thumb|Functional test plan life cycle]]
"The functional test plan measures the quality of the functional components of the system[http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1b_4_mv#References]". The test plan is written by the Author. The Author lists a number of test cases, containing the input, expected results, and pre and post-test setup. After a module is unit tested, the Tester executes the functional test cases and records the actual results. The Reviewer compares the Actual results with the expected results and reports whether each test case passed or failed the test.

==Steps to write good Functional Tests==
# The test plan must be written by persons who have extensive knowledge of the business requirements. It is advisable that the developers do not write the test plans. This is because developers tend to unknowingly write test cases whose functionality is based on the implementation rather than the initial functional specifications.
# The functional test plans should be created as early as possible, probably as soon as the functional specifications are ready.
# The functional test plan should be updated when there are changes in the business requirements.
# The Author should clearly include the pre-test setup so that the Tester can easily execute the test cases.
# A list of test cases should be defined to verify a set of "clear-defined" functions of the use-case.
# The Author should provide post-test setup which has instructions on how to clear any data that would prevent the test case from being executed more than once.
# As a module is built and unit tested, the Tester should execute the particular test cases.

==Example==
Examples of pre-test setup, test cases and post-test setup are given below. The complete reference for the example can be found at [http://www.developer.com/java/ent/article.php/3623476/Functional-Test-Plans-The-Right-Way.htm Functional Test Plans]

The pre-test setup for Test Case: Create new user profile can be given as:
[UserName: "A": --> username: "A"]
[UserName: "A": --> first name: "John"]
[UserName: "A": --> last name: "Smith"]
[UserName: "A": --> access level: "read-only"]
[UserName: "A": --> password: "profile1"]

The test cases for the function:Verify that only valid users can access the system can be given as:

<table cellspacing="2" width=900 border="1" align="center" >
<tr valign="top" bgcolor="#99ffff">
<th>Test Case #</th>
<th>Required Input</th>
<th>Expected Results</th>
<th>Results</th>

<th>Pass/Fail</th></tr>

<tr valign="top"><td colspan="5">
<ul>
<li>Verify that only valid users can access the system.</li>
<li>Verify that valid users cannot access the system without entering a valid password.</li>
</ul></td></tr>

<tr valign="top"><td>1</td>
<td>Navigate to the login screen</td>
<td>Login screen with release number A is loaded.</td>

<td> </td>
<td> </td></tr>

<tr valign="top"><td>2</td>
<td>Enter user name "INVALIDUSER", password "INVALIDUSER", and click on login button</td>
<td>Error message: 
"User name is not found"</td>
<td> </td>
<td> </td></tr>

<tr valign="top"><td>3</td>
<td>Enter user name for user [UserName: "A":--> username] and password "test"</td>

<td>Error Message: 
"Password for user [UserName: "A": --> username] is invalid"</td>
<td> </td>
<td> </td></tr>

<tr valign="top"><td>4</td>
<td>Enter user name [UserName: "A": --> username] and password [UserName: "A": --> password]</td>

<td>The main page is loaded with a message: 
"Welcome [UserName: "A": --> first name] [UserName: "A": --> last name]</td>
<td> </td>
<td> </td></tr>
</table>

The post-test setup for the above scenario can be given as:
Remove [UserName: "A": --> username: "A"] from the LDAP Server.

=Integration Testing=
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules. Integration testing is an important phase and sometimes there are separate teams which handle integration testing.
 
DEFINITION:Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.
==Integration Test approaches==
Integration testing can be done in a variety of ways [[Image:TopDown_Approach.jpg|thumb|Top Down Approach]]
# '''Top-Down Approach.''' In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed
# '''Bottom Up Approach.''' In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach. [[Image:BottomUp_Approach.jpg|thumb|Bottom Up Approach]]
# '''Umbrella approach.''' Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.
==Prerequisites before Integration Testing==
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.
==Steps to write good Integration Test Cases==
#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.

==How To write good Integration Test Cases and do effective Integration Testing==
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner. The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.
=Beyond Funtional and Integration Testing=
Integration and Functional testing are not the only testing that are done for checking the validity of the system. Other test cases includes: 
'''Unit Testing:''' This is the first stage where the developer tests the component he/she is creating. More can be found at [http://en.wikipedia.org/wiki/Unit_testing Unit Testing] 
'''Validation Testing:''' After integration Testing, validation testing takes place wherein checks are made to ensure that the functional requirements are satisfied. 
'''Alpha and Beta Testing:'''When the product about to be released, it is first exposed to some end users who test the application. This is alpha beta testing. More can be found at [http://www.majordojo.com/uploads/AlphaBetaTesting.pdf Alpha and Beta Testing] 
'''Recovery Testing:''' In this phase the system is made to crash and is used to check to see if it recovers in the proper manner. More can be found at [http://en.wikipedia.org/wiki/Recovery_testing Recovery Testing] 
'''Security Testing:''' Systems that store and record sensitive information need to be protected from threats, in this phase the systems protection mechanisms are tested. More can be found at [http://en.wikipedia.org/wiki/Security_testing Security Testing] 
'''Stress Testing:'''The system is overloaded with data and it is checked to whether it crashes. More can be found at [http://en.wikipedia.org/wiki/Stress_testing Stress Testing] 
'''Performance Testing:''' It tests the run time performance of software within the context of the system. More can be found at [http://en.wikipedia.org/wiki/Performance_testing Performance Testing] 
'''Smoke Testing:''' smoke testing is a preliminary to further testing, which should reveal simple failures severe enough to reject a prospective software release. More can be found at [http://en.wikipedia.org/wiki/Smoke_test Smoke Test] 
'''Acceptance Testing:''' acceptance testing performed by the customer is known as user acceptance testing (UAT). This is also known as end-user testing, site (acceptance) testing, or field (acceptance) testing. More can be found at [http://en.wikipedia.org/wiki/Acceptance_testing Acceptance Testing]

=References=

# [http://www.segue.com/pdf/automated_functional_testing.pdf Automated Functional Testing]
# [http://searchsoftwarequality.techtarget.com/generic/0,295582,sid92_gci1303938,00.html# Functional Tests to ensure Software Quality]
# [http://www.developer.com/tech/article.php/3623476/Functional-Test-Plans-The-Right-Way.htm Functional Test Plans]

=External Links=

# [http://en.wikipedia.org/wiki/Unit_testing Unit Testing]
# [http://www.majordojo.com/uploads/AlphaBetaTesting.pdf Alpha Beta Testing]
# [http://en.wikipedia.org/wiki/Recovery_testing Recovery Testing]
# [http://en.wikipedia.org/wiki/Security_testing Security Testing]
# [http://en.wikipedia.org/wiki/Stress_testing Stress Testing]
# [http://en.wikipedia.org/wiki/Performance_testing Performance Testing]
# [http://en.wikipedia.org/wiki/Smoke_test Smoke Test]
# [http://en.wikipedia.org/wiki/Acceptance_testing Acceptance Testing]

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-21T17:05:45Z

Vnpai:

=Introduction=
Unit Testing is given a lot of importance in [[Software Testing]]. But functional and integration testing are essential too. Hence Functional and Integration Testing is discussed here. This page provides an introduction to these testing methods; also including the good practices to write functional and integration tests. Later additional types of software Tests are mentioned which could be used to gain further confidence that one's code is correct.

=Functional Testing=
Functional testing is the process of testing of all the functions of a system, ensuring that the system conforms to the user requirements and specifications. It is sometimes referred to as black box testing, as it does not require understanding of the internal structure of the implementation.

Functional testing can be done by using manual or automated methods[http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1b_4_mv#References]. In both the methods, a series of tests have to be run marking the interaction between the user and the system, ensuring that the system performs as it was supposed to. Since Use cases mainly depict the interaction between the user and system, functional test suites are created from requirement use cases, with each scenario becoming a functional test[http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1b_4_mv#References].

==Functional Test Plan==
[[Image:Functional.gif|thumb|Functional test plan life cycle]]
"The functional test plan measures the quality of the functional components of the system[http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1b_4_mv#References]". The test plan is written by the Author. The Author lists a number of test cases, containing the input, expected results, and pre and post-test setup. After a module is unit tested, the Tester executes the functional test cases and records the actual results. The Reviewer compares the Actual results with the expected results and reports whether each test case passed or failed the test.

==Steps in writing a good Functional Tests==
# The test plan must be written by persons who have extensive knowledge of the business requirements. It is advisable that the developers do not write the test plans. This is because developers tend to unknowingly write test cases whose functionality is based on the implementation rather than the initial functional specifications.
# The functional test plans should be created as early as possible, probably as soon as the functional specifications are ready.
# The functional test plan should be updated when there are changes in the business requirements.
# The Author should clearly include the pre-test setup so that the Tester can easily execute the test cases.
# A list of test cases should be defined to verify a set of "clear-defined" functions of the use-case.
# The Author should provide post-test setup which has instructions on how to clear any data that would prevent the test case from being executed more than once.
# As a module is built and unit tested, the Tester should execute the particular test cases.

==Example==
Examples of pre-test setup, test cases and post-test setup are given below. The complete reference for the example can be found at [http://www.developer.com/java/ent/article.php/3623476/Functional-Test-Plans-The-Right-Way.htm Functional Test Plans]

The pre-test setup for Test Case: Create new user profile can be given as:
[UserName: "A": --> username: "A"]
[UserName: "A": --> first name: "John"]
[UserName: "A": --> last name: "Smith"]
[UserName: "A": --> access level: "read-only"]
[UserName: "A": --> password: "profile1"]

The test cases for the function:Verify that only valid users can access the system can be given as:

<table cellspacing="2" width=900 border="1" align="center" >
<tr valign="top" bgcolor="#99ffff">
<th>Test Case #</th>
<th>Required Input</th>
<th>Expected Results</th>
<th>Results</th>

<th>Pass/Fail</th></tr>

<tr valign="top"><td colspan="5">
<ul>
<li>Verify that only valid users can access the system.</li>
<li>Verify that valid users cannot access the system without entering a valid password.</li>
</ul></td></tr>

<tr valign="top"><td>1</td>
<td>Navigate to the login screen</td>
<td>Login screen with release number A is loaded.</td>

<td> </td>
<td> </td></tr>

<tr valign="top"><td>2</td>
<td>Enter user name "INVALIDUSER", password "INVALIDUSER", and click on login button</td>
<td>Error message: 
"User name is not found"</td>
<td> </td>
<td> </td></tr>

<tr valign="top"><td>3</td>
<td>Enter user name for user [UserName: "A":--> username] and password "test"</td>

<td>Error Message: 
"Password for user [UserName: "A": --> username] is invalid"</td>
<td> </td>
<td> </td></tr>

<tr valign="top"><td>4</td>
<td>Enter user name [UserName: "A": --> username] and password [UserName: "A": --> password]</td>

<td>The main page is loaded with a message: 
"Welcome [UserName: "A": --> first name] [UserName: "A": --> last name]</td>
<td> </td>
<td> </td></tr>
</table>

The post-test setup for the above scenario can be given as:
Remove [UserName: "A": --> username: "A"] from the LDAP Server.

=Integration Testing=
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules. Integration testing is an important phase and sometimes there are separate teams which handle integration testing.
 
DEFINITION:Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.
==Integration Test approaches==
Integration testing can be done in a variety of ways [[Image:TopDown_Approach.jpg|thumb|Top Down Approach]]
# '''Top-Down Approach.''' In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed
# '''Bottom Up Approach.''' In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach. [[Image:BottomUp_Approach.jpg|thumb|Bottom Up Approach]]
# '''Umbrella approach.''' Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.
==Prerequisites before Integration Testing==
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.
==Steps in writing good Integration Test Cases==
#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.

==How To write good Integration Test Cases and do effective Integration Testing==
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner. The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.
=Beyond Funtional and Integration Testing=
Integration and Functional testing are not the only testing that are done for checking the validity of the system. Other test cases includes: 
'''Unit Testing:''' This is the first stage where the developer tests the component he/she is creating. More can be found at [http://en.wikipedia.org/wiki/Unit_testing Unit Testing] 
'''Validation Testing:''' After integration Testing, validation testing takes place wherein checks are made to ensure that the functional requirements are satisfied. 
'''Alpha and Beta Testing:'''When the product about to be released, it is first exposed to some end users who test the application. This is alpha beta testing. More can be found at [http://www.majordojo.com/uploads/AlphaBetaTesting.pdf Alpha and Beta Testing] 
'''Recovery Testing:''' In this phase the system is made to crash and is used to check to see if it recovers in the proper manner. More can be found at [http://en.wikipedia.org/wiki/Recovery_testing Recovery Testing] 
'''Security Testing:''' Systems that store and record sensitive information need to be protected from threats, in this phase the systems protection mechanisms are tested. More can be found at [http://en.wikipedia.org/wiki/Security_testing Security Testing] 
'''Stress Testing:'''The system is overloaded with data and it is checked to whether it crashes. More can be found at [http://en.wikipedia.org/wiki/Stress_testing Stress Testing] 
'''Performance Testing:''' It tests the run time performance of software within the context of the system. More can be found at [http://en.wikipedia.org/wiki/Performance_testing Performance Testing] 
'''Smoke Testing:''' smoke testing is a preliminary to further testing, which should reveal simple failures severe enough to reject a prospective software release. More can be found at [http://en.wikipedia.org/wiki/Smoke_test Smoke Test] 
'''Acceptance Testing:''' acceptance testing performed by the customer is known as user acceptance testing (UAT). This is also known as end-user testing, site (acceptance) testing, or field (acceptance) testing. More can be found at [http://en.wikipedia.org/wiki/Acceptance_testing Acceptance Testing]

=References=

# [http://www.segue.com/pdf/automated_functional_testing.pdf Automated Functional Testing]
# [http://searchsoftwarequality.techtarget.com/generic/0,295582,sid92_gci1303938,00.html# Functional Tests to ensure Software Quality]
# [http://www.developer.com/tech/article.php/3623476/Functional-Test-Plans-The-Right-Way.htm Functional Test Plans]

=External Links=

# [http://en.wikipedia.org/wiki/Unit_testing Unit Testing]
# [http://www.majordojo.com/uploads/AlphaBetaTesting.pdf Alpha Beta Testing]
# [http://en.wikipedia.org/wiki/Recovery_testing Recovery Testing]
# [http://en.wikipedia.org/wiki/Security_testing Security Testing]
# [http://en.wikipedia.org/wiki/Stress_testing Stress Testing]
# [http://en.wikipedia.org/wiki/Performance_testing Performance Testing]
# [http://en.wikipedia.org/wiki/Smoke_test Smoke Test]
# [http://en.wikipedia.org/wiki/Acceptance_testing Acceptance Testing]

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T18:54:07Z

Vnpai:

=Functional Testing=
Functional testing is the process of testing of all features and functions of a system [software, hardware, etc.] to ensure requirements and specifications are met[http://www.bitpipe.com/tlist/Functional-Testing.html]. Functional testing ensures that the system conforms to the user requirements and specifications. It is sometimes referred to as black box testing[http://searchsoftwarequality.techtarget.com/generic/0,295582,sid92_gci1303938,00.html#], as it does not require understanding of the internal structure of the implementation.

Functional testing can involve either manual or automated methods [http://www.segue.com/pdf/automated_functional_testing.pdf]. In both the methods a series of tests have to be run marking the interaction between the user and the, system ensuring that the system performs as it was supposed to. Since Use cases mainly depict the interaction between the user and system functional test suites are created from requirement use cases, with each scenario becoming a functional test[http://searchsoftwarequality.techtarget.com/generic/0,295582,sid92_gci1303938,00.html#].

==Functional test plan==
[[Image:Functional.gif|thumb|Functional test plan life cycle]]
The functional test plan measures the quality of the functional components of the system[http://www.developer.com/tech/article.php/3623476/Functional-Test-Plans-The-Right-Way.htm]. The test plan is written by the Author. The Author lists a number of test cases, containing the input, expected results, and pre and post-test setup. After a module is unit tested, the Tester executes the functional test cases and records the actual results. The Reviewer compares the Actual results with the expected results and reports whether each test case passed or failed the test.

==Steps in writing a good Functional Tests==
# The test plan must be written by persons who have extensive knowledge of the business requirements. It is advisable that the application developers do not author the test plans. This is because developers tend to unknowingly write test cases whose functionality is based on the implementation rather than the initial functional specifications.
# The functional test plans should be created as early as possible, probably as soon as the functional specifications are ready.
# The functional test plan is a dynamic document changing with changes in the business requirements.
# The Author should clearly include the pre-test setup so that the Tester can easily execute the test cases.

For example the pre-test setup for Test Case: Create new user profile can be given as:
[UserName: "A": --> username: "A"]
[UserName: "A": --> first name: "John"]
[UserName: "A": --> last name: "Smith"]
[UserName: "A": --> access level: "read-only"]
[UserName: "A": --> password: "profile1"]

# A list of test cases should be defined to verify a set of "clear-defined" functions of the use-case.

For example,consider the function:Verify that only valid users can access the system.
The test case can be given as:

<table cellspacing="2" cellpadding="2" border="2">
<tr valign="top" bgcolor="#ffff99">
<th>Test Case #</th>
<th>Required Input</th>
<th>Expected Results</th>
<th>Results</th>
<th>Pass/Fail</th></tr>
<tr valign="top"><td colspan="5">
<ul>
<li>Verify that only valid users can access the system.</li>
<li>Verify that valid users cannot access the system without entering a valid password.</li>
</ul></td></tr>
<tr valign="top"><td>1</td>
<td>Navigate to the login screen</td>
<td>Login screen with release number A is loaded.</td>
<td> </td>
<td> </td></tr>
<tr valign="top"><td>2</td>
<td>Enter user name "INVALIDUSER", password "INVALIDUSER", and click on login button</td>
<td>Error message: 
"User name is not found"</td>
<td> </td>
<td> </td></tr>
<tr valign="top"><td>3</td>
<td>Enter user name for user [UserName: "A":--> username] and password "test"</td>
<td>Error Message: 
"Password for user [UserName: "A": --> username] is invalid"</td>
<td> </td>
<td> </td></tr>
<tr valign="top"><td>4</td>
<td>Enter user name [UserName: "A": --> username] and password [UserName: "A": --> password] </td>

<td>The main page is loaded with a message: 
"Welcome [UserName: "A": --> first name] [UserName: "A": --> last name]</td>
<td> </td>
<td> </td></tr>
</table>

# The Author should provide post-test setup which has instructions on how to clear any data that would prevent the test case from being executed more than once.

For example:
Test Case 1. Remove [UserName: "A": --> username: "A"] from the LDAP Server.

# As a module is built and unit tested, the Tester should execute the particular test cases.

=Integration Testing=
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules. Integration testing is an important phase and sometimes there are separate teams which handle integration testing.
 
DEFINITION:Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.
==Integration Test approaches==
Integration testing can be done in a variety of ways [[Image:TopDown_Approach.jpg|thumb|Top Down Approach]]
# '''Top-Down Approach.''' In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed
# '''Bottom Up Approach.''' In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach. [[Image:BottomUp_Approach.jpg|thumb|Bottom Up Approach]]
# '''Umbrella approach.''' Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.
==Prerequisites before Integration Testing==
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.
==Steps in writing good Integration Test Cases==
#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.

==How To write Good Integration Test Cases and do effective Integration Testing==
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner. The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.
=Beyond=
Integration and Functional testing are not the only testing that are done for checking the validity of the system. Other test cases includes: 
'''Unit Testing:'''[http://en.wikipedia.org/wiki/Unit_testing] This is the first stage where the developer tests the component he/she is creating. 
'''Validation Testing:''' After integration Testing, validation testing takes place wherein checks are made to ensure that the functional requirements are satisfied. 
'''Alpha and Beta Testing:'''[http://www.majordojo.com/uploads/AlphaBetaTesting.pdf] When the product about to be released, it is first exposed to some end users who test the application. This is alpha beta testing. 
'''Recovery Testing:'''[http://en.wikipedia.org/wiki/Recovery_testing] In this phase the system is made to crash and is used to check to see if it recovers in the proper manner. 
'''Security Testing'''[http://en.wikipedia.org/wiki/Security_testing] Systems that store and record sensitive information need to be protected from threats, in this phase the systems protection mechanisms are tested. 
'''Stress Testing:'''[http://en.wikipedia.org/wiki/Stress_testing] The system is overloaded with data and it is checked to whether it crashes. 
'''Performance Testing:'''[http://en.wikipedia.org/wiki/Performance_testing] It tests the run time performance of software within the context of the system. 
'''Smoke Testing''' [http://en.wikipedia.org/wiki/Smoke_test] smoke testing is a preliminary to further testing, which should reveal simple failures severe enough to reject a prospective software release. 
'''Acceptance Testing:'''[http://en.wikipedia.org/wiki/Acceptance_testing] acceptance testing performed by the customer is known as user acceptance testing (UAT). This is also known as end-user testing, site (acceptance) testing, or field (acceptance) testing.

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T18:51:59Z

Vnpai:

=Problem Statement=
<blockquote>We have focused mainly on unit tests in this course. But functional and integration testing are also important. How does one write good functional and integration tests? Are there any kinds of tests beyond unit, functional, and integration that one should implement to gain confidence that one's code is correct?
</blockquote>
=Different stages of Software Testing=
http://www.aptest.com/testtypes.html (either use reference to this place or type in our own words)
=Functional Testing=
Functional testing is the process of testing of all features and functions of a system [software, hardware, etc.] to ensure requirements and specifications are met[http://www.bitpipe.com/tlist/Functional-Testing.html]. Functional testing ensures that the system conforms to the user requirements and specifications. It is sometimes referred to as black box testing[http://searchsoftwarequality.techtarget.com/generic/0,295582,sid92_gci1303938,00.html#], as it does not require understanding of the internal structure of the implementation.

Functional testing can involve either manual or automated methods [http://www.segue.com/pdf/automated_functional_testing.pdf]. In both the methods a series of tests have to be run marking the interaction between the user and the, system ensuring that the system performs as it was supposed to. Since Use cases mainly depict the interaction between the user and system functional test suites are created from requirement use cases, with each scenario becoming a functional test[http://searchsoftwarequality.techtarget.com/generic/0,295582,sid92_gci1303938,00.html#].

==Functional test plan==
[[Image:Functional.gif|thumb|Functional test plan life cycle]]
The functional test plan measures the quality of the functional components of the system[http://www.developer.com/tech/article.php/3623476/Functional-Test-Plans-The-Right-Way.htm]. The test plan is written by the Author. The Author lists a number of test cases, containing the input, expected results, and pre and post-test setup. After a module is unit tested, the Tester executes the functional test cases and records the actual results. The Reviewer compares the Actual results with the expected results and reports whether each test case passed or failed the test.

==Steps in writing a good Functional Tests==
# The test plan must be written by persons who have extensive knowledge of the business requirements. It is advisable that the application developers do not author the test plans. This is because developers tend to unknowingly write test cases whose functionality is based on the implementation rather than the initial functional specifications.
# The functional test plans should be created as early as possible, probably as soon as the functional specifications are ready.
# The functional test plan is a dynamic document changing with changes in the business requirements.
# The Author should clearly include the pre-test setup so that the Tester can easily execute the test cases.

For example the pre-test setup for Test Case: Create new user profile can be given as:
[UserName: "A": --> username: "A"]
[UserName: "A": --> first name: "John"]
[UserName: "A": --> last name: "Smith"]
[UserName: "A": --> access level: "read-only"]
[UserName: "A": --> password: "profile1"]

# A list of test cases should be defined to verify a set of "clear-defined" functions of the use-case.

For example,consider the function:Verify that only valid users can access the system.
The test case can be given as:

<table cellspacing="2" cellpadding="2" border="2">
<tr valign="top" bgcolor="#ffff99">
<th>Test Case #</th>
<th>Required Input</th>
<th>Expected Results</th>
<th>Results</th>
<th>Pass/Fail</th></tr>
<tr valign="top"><td colspan="5">
<ul>
<li>Verify that only valid users can access the system.</li>
<li>Verify that valid users cannot access the system without entering a valid password.</li>
</ul></td></tr>
<tr valign="top"><td>1</td>
<td>Navigate to the login screen</td>
<td>Login screen with release number A is loaded.</td>
<td> </td>
<td> </td></tr>
<tr valign="top"><td>2</td>
<td>Enter user name "INVALIDUSER", password "INVALIDUSER", and click on login button</td>
<td>Error message: 
"User name is not found"</td>
<td> </td>
<td> </td></tr>
<tr valign="top"><td>3</td>
<td>Enter user name for user [UserName: "A":--> username] and password "test"</td>
<td>Error Message: 
"Password for user [UserName: "A": --> username] is invalid"</td>
<td> </td>
<td> </td></tr>
<tr valign="top"><td>4</td>
<td>Enter user name [UserName: "A": --> username] and password [UserName: "A": --> password] </td>

<td>The main page is loaded with a message: 
"Welcome [UserName: "A": --> first name] [UserName: "A": --> last name]</td>
<td> </td>
<td> </td></tr>
</table>

# The Author should provide post-test setup which has instructions on how to clear any data that would prevent the test case from being executed more than once.

For example:
Test Case 1. Remove [UserName: "A": --> username: "A"] from the LDAP Server.

# As a module is built and unit tested, the Tester should execute the particular test cases.

=Integration Testing=
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules. Integration testing is an important phase and sometimes there are separate teams which handle integration testing.
 
DEFINITION:Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.
==Integration Test approaches==
Integration testing can be done in a variety of ways [[Image:TopDown_Approach.jpg|thumb|Top Down Approach]]
# '''Top-Down Approach.''' In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed
# '''Bottom Up Approach.''' In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach. [[Image:BottomUp_Approach.jpg|thumb|Bottom Up Approach]]
# '''Umbrella approach.''' Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.
==Prerequisites before Integration Testing==
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.
==Steps in writing good Integration Test Cases==
#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.

==How To write Good Integration Test Cases and do effective Integration Testing==
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner. The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.
=Beyond=
Integration and Functional testing are not the only testing that are done for checking the validity of the system. Other test cases includes: 
'''Unit Testing:'''[http://en.wikipedia.org/wiki/Unit_testing] This is the first stage where the developer tests the component he/she is creating. 
'''Validation Testing:''' After integration Testing, validation testing takes place wherein checks are made to ensure that the functional requirements are satisfied. 
'''Alpha and Beta Testing:'''[http://www.majordojo.com/uploads/AlphaBetaTesting.pdf] When the product about to be released, it is first exposed to some end users who test the application. This is alpha beta testing. 
'''Recovery Testing:'''[http://en.wikipedia.org/wiki/Recovery_testing] In this phase the system is made to crash and is used to check to see if it recovers in the proper manner. 
'''Security Testing'''[http://en.wikipedia.org/wiki/Security_testing] Systems that store and record sensitive information need to be protected from threats, in this phase the systems protection mechanisms are tested. 
'''Stress Testing:'''[http://en.wikipedia.org/wiki/Stress_testing] The system is overloaded with data and it is checked to whether it crashes. 
'''Performance Testing:'''[http://en.wikipedia.org/wiki/Performance_testing] It tests the run time performance of software within the context of the system. 
'''Smoke Testing''' [http://en.wikipedia.org/wiki/Smoke_test] smoke testing is a preliminary to further testing, which should reveal simple failures severe enough to reject a prospective software release. 
'''Acceptance Testing:'''[http://en.wikipedia.org/wiki/Acceptance_testing] acceptance testing performed by the customer is known as user acceptance testing (UAT). This is also known as end-user testing, site (acceptance) testing, or field (acceptance) testing.

File:Functional.gif

2009-09-20T18:26:53Z

Vnpai:

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T06:16:13Z

Vnpai:

=Problem Statement=
<blockquote>We have focused mainly on unit tests in this course. But functional and integration testing are also important. How does one write good functional and integration tests? Are there any kinds of tests beyond unit, functional, and integration that one should implement to gain confidence that one's code is correct?
</blockquote>
=Different stages of Software Testing=
http://www.aptest.com/testtypes.html (either use reference to this place or type in our own words)
=Functional Testing=
Testing software based on its functional requirements. It ensures that the program physically works the way it was intended and all required menu options are present. It also ensures that the program conforms to the industry standards relevant to that environment; for example, in a Windows program, pressing F1 brings up help.
[http://msdn.microsoft.com/en-us/library/aa292128%28VS.71%29.aspx]
 
DEFINITION: Testing of all features and functions of a system [software, hardware, etc.] to ensure requirements and specifications are met.
Use cases are generally developed from the user specifications. These use cases are useful in providing the guidelines for functional testing.
==Prerequisites before Functional Testing==
# Build Functional test cases from uses cases, with each use case scenario becoming a functional test.
# As a module is built and unit tested apply the particular test case.
# Prioritize the test cases.
# it should be geared towards a non-technical audience. Therefore, references to underlying programming languages must not be present in the final document
# The author of the functional test plan must be a person who has in-depth knowledge of the business requirements. It is preferable that application developers do not compose functional test plans. The reason behind such an approach is simple: The developer's interpretation of the requirements might differ from those of the person who initially created them.
=Integration Testing=
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules. Integration testing is an important phase and sometimes there are separate teams which handle integration testing.
 
DEFINITION:Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.
==Integration Test approaches==
Integration testing can be done in a variety of ways [[Image:TopDown_Approach.jpg|thumb|Top Down Approach]]
# '''Top-Down Approach.''' In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed
# '''Bottom Up Approach.''' In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach. [[Image:BottomUp_Approach.jpg|thumb|Bottom Up Approach]]
# '''Umbrella approach.''' Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.
==Prerequisites before Integration Testing==
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.
==Steps in writing good Integration Test Cases==
#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.

==How To write Good Integration Test Cases and do effective Integration Testing==
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner. The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.
=Beyond=
Integration and Functional testing are not the only testing that are done for checking the validity of the system. Other test cases includes: 
'''Unit Testing:'''[http://en.wikipedia.org/wiki/Unit_testing] This is the first stage where the developer tests the component he/she is creating. 
'''Validation Testing:''' After integration Testing, validation testing takes place wherein checks are made to ensure that the functional requirements are satisfied. 
'''Alpha and Beta Testing:'''[http://www.majordojo.com/uploads/AlphaBetaTesting.pdf] When the product about to be released, it is first exposed to some end users who test the application. This is alpha beta testing. 
'''Recovery Testing:'''[http://en.wikipedia.org/wiki/Recovery_testing] In this phase the system is made to crash and is used to check to see if it recovers in the proper manner. 
'''Security Testing'''[http://en.wikipedia.org/wiki/Security_testing] Systems that store and record sensitive information need to be protected from threats, in this phase the systems protection mechanisms are tested. 
'''Stress Testing:'''[http://en.wikipedia.org/wiki/Stress_testing] The system is overloaded with data and it is checked to whether it crashes. 
'''Performance Testing:'''[http://en.wikipedia.org/wiki/Performance_testing] It tests the run time performance of software within the context of the system. 
'''Smoke Testing''' [http://en.wikipedia.org/wiki/Smoke_test] smoke testing is a preliminary to further testing, which should reveal simple failures severe enough to reject a prospective software release. 
'''Acceptance Testing:'''[http://en.wikipedia.org/wiki/Acceptance_testing] acceptance testing performed by the customer is known as user acceptance testing (UAT). This is also known as end-user testing, site (acceptance) testing, or field (acceptance) testing.

http://www.davenicolette.net/articles/ftdd.pdf

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T06:15:31Z

Vnpai:

=Problem Statement=
<blockquote>We have focused mainly on unit tests in this course. But functional and integration testing are also important. How does one write good functional and integration tests? Are there any kinds of tests beyond unit, functional, and integration that one should implement to gain confidence that one's code is correct?
</blockquote>
=Different stages of Software Testing=
http://www.aptest.com/testtypes.html (either use reference to this place or type in our own words)
=Functional Testing=
Testing software based on its functional requirements. It ensures that the program physically works the way it was intended and all required menu options are present. It also ensures that the program conforms to the industry standards relevant to that environment; for example, in a Windows program, pressing F1 brings up help.
[http://msdn.microsoft.com/en-us/library/aa292128%28VS.71%29.aspx]
 
DEFINITION: Testing of all features and functions of a system [software, hardware, etc.] to ensure requirements and specifications are met.
Use cases are generally developed from the user specifications. These use cases are useful in providing the guidelines for functional testing.
==Prerequisites before Functional Testing==
# Build Functional test cases from uses cases, with each use case scenario becoming a functional test.
# As a module is built and unit tested apply the particular test case.
# Prioritize the test cases.
# it should be geared towards a non-technical audience. Therefore, references to underlying programming languages must not be present in the final document
# The author of the functional test plan must be a person who has in-depth knowledge of the business requirements. It is preferable that application developers do not compose functional test plans. The reason behind such an approach is simple: The developer's interpretation of the requirements might differ from those of the person who initially created them.
=Integration Testing=
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules. Integration testing is an important phase and sometimes there are separate teams which handle integration testing.
 
DEFINITION:Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.
==Integration Test approaches==
Integration testing can be done in a variety of ways [[Image:TopDown_Approach.jpg|thumb|Top Down Approach]]
# '''Top-Down Approach.''' In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed
# '''Bottom Up Approach.''' In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach. [[Image:BottomUp_Approach.jpg|thumb|Bottom Up Approach]]
# '''Umbrella approach.''' Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.
==Prerequisites before Integration Testing==
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.
==Steps in writing good Integration Test Cases==
#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.

==How To write Good Integration Test Cases and do effective Integration Testing==
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner. The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.
=Beyond=
Integration and Functional testing are not the only testing that are done for checking the validity of the system. Other test cases includes: 
'''Unit Testing:'''[http://en.wikipedia.org/wiki/Unit_testing] This is the first stage where the developer tests the component he/she is creating. 
'''Validation Testing:''' After integration Testing, validation testing takes place wherein checks are made to ensure that the functional requirements are satisfied. 
'''Alpha and Beta Testing:'''[http://www.majordojo.com/uploads/AlphaBetaTesting.pdf] When the product about to be released, it is first exposed to some end users who test the application. This is alpha beta testing. 
'''Recovery Testing:'''[http://en.wikipedia.org/wiki/Recovery_testing] In this phase the system is made to crash and is used to check to see if it recovers in the proper manner. 
'''Security Testing'''[http://en.wikipedia.org/wiki/Security_testing] Systems that store and record sensitive information need to be protected from threats, in this phase the systems protection mechanisms are tested. 
'''Stress Testing:'''[http://en.wikipedia.org/wiki/Stress_testing] The system is overloaded with data and it is checked to whether it crashes. 
'''Performance Testing:'''[http://en.wikipedia.org/wiki/Performance_testing] It tests the run time performance of software within the context of the system.
'''Smoke Testing''' [http://en.wikipedia.org/wiki/Smoke_test] smoke testing is a preliminary to further testing, which should reveal simple failures severe enough to reject a prospective software release.
'''Acceptance Testing:'''[http://en.wikipedia.org/wiki/Acceptance_testing] acceptance testing performed by the customer is known as user acceptance testing (UAT). This is also known as end-user testing, site (acceptance) testing, or field (acceptance) testing.

http://www.davenicolette.net/articles/ftdd.pdf

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T06:11:32Z

Vnpai:

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T06:02:04Z

Vnpai:

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T05:59:54Z

Vnpai:

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T05:58:48Z

Vnpai:

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T05:15:50Z

Vnpai:

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T04:54:52Z

Vnpai:

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T04:48:27Z

Vnpai:

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T04:36:57Z

Vnpai:

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T04:32:46Z

Vnpai:

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T04:32:00Z

Vnpai:

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T04:30:51Z

Vnpai:

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T04:28:06Z

Vnpai:

==Problem Statement==
<blockquote>We have focused mainly on unit tests in this course. But functional and integration testing are also important. How does one write good functional and integration tests? Are there any kinds of tests beyond unit, functional, and integration that one should implement to gain confidence that one's code is correct?
</blockquote>

==Different stages of Software Testing==
http://www.aptest.com/testtypes.html (either use reference to this place or type in our own words)

==Functional Testing==
Testing software based on its functional requirements. It ensures that the program physically works the way it was intended and all required menu options are present. It also ensures that the program conforms to the industry standards relevant to that environment; for example, in a Windows program, pressing F1 brings up help.
[http://msdn.microsoft.com/en-us/library/aa292128%28VS.71%29.aspx]
 
DEFINITION: Testing of all features and functions of a system [software, hardware, etc.] to ensure requirements and specifications are met.

Use cases are generally developed from the user specifications. These use cases are useful in providing the guidelines for functional testing.

==Prerequisites before Functional Testing==
# Build Functional test cases from uses cases, with each use case scenario becoming a functional test.
# As a module is built and unit tested apply the particular test case.
# Prioritize the test cases.
# it should be geared towards a non-technical audience. Therefore, references to underlying programming languages must not be present in the final document
# The author of the functional test plan must be a person who has in-depth knowledge of the business requirements. It is preferable that application developers do not compose functional test plans. The reason behind such an approach is simple: The developer's interpretation of the requirements might differ from those of the person who initially created them.

==Integration Testing==
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules. Integration testing is an important phase and sometimes there are separate teams which handle integration testing.
 
DEFINITION:Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.

==Integration Test approaches== [[Image:TopDown_Approach.jpg|thumb|Top Down Approach]]
Integration testing can be done in a variety of ways
# Top-Down Approach. In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed
# Bottom Up Approach. In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach. [[Image:BottomUp_Approach.jpg|thumb|Bottom Up Approach]]

# Umbrella approach. Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.

==Prerequisites before Integration Testing==
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.

==Steps in writing good Integration Test Cases==

#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.

==How To write Good Integration Test Cases and do effective Integration Testing==
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner. The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.

Functional Tests:
Functioanl Test usually check whether the code is running according to what the user/client needs.

http://www.davenicolette.net/articles/ftdd.pdf

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T04:26:23Z

Vnpai:

==Problem Statement==
<blockquote>We have focused mainly on unit tests in this course. But functional and integration testing are also important. How does one write good functional and integration tests? Are there any kinds of tests beyond unit, functional, and integration that one should implement to gain confidence that one's code is correct?
</blockquote>

==Different stages of Software Testing==
http://www.aptest.com/testtypes.html (either use reference to this place or type in our own words)

==Functional Testing==
Testing software based on its functional requirements. It ensures that the program physically works the way it was intended and all required menu options are present. It also ensures that the program conforms to the industry standards relevant to that environment; for example, in a Windows program, pressing F1 brings up help.
[http://msdn.microsoft.com/en-us/library/aa292128%28VS.71%29.aspx]
DEFINITION: Testing of all features and functions of a system [software, hardware, etc.] to ensure requirements and specifications are met.

Use cases are generally developed from the user specifications. These use cases are useful in providing the guidelines for functional testing.

==Prerequisites before Functional Testing==
# Build Functional test cases from uses cases, with each use case scenario becoming a functional test.
# As a module is built and unit tested apply the particular test case.
# Prioritize the test cases.
# it should be geared towards a non-technical audience. Therefore, references to underlying programming languages must not be present in the final document
# The author of the functional test plan must be a person who has in-depth knowledge of the business requirements. It is preferable that application developers do not compose functional test plans. The reason behind such an approach is simple: The developer's interpretation of the requirements might differ from those of the person who initially created them.

==Integration Testing==
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules. Integration testing is an important phase and sometimes there are separate teams which handle integration testing.

DEFINITION:Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.

==Integration Test approaches== [[Image:TopDown_Approach.jpg|thumb|Top Down Approach]]
Integration testing can be done in a variety of ways
# Top-Down Approach. In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed
# Bottom Up Approach. In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach. [[Image:BottomUp_Approach.jpg|thumb|Bottom Up Approach]]

# Umbrella approach. Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.

==Prerequisites before Integration Testing==
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.

==Steps in writing good Integration Test Cases==

#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.

==How To write Good Integration Test Cases and do effective Integration Testing==
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner. The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.

Functional Tests:
Functioanl Test usually check whether the code is running according to what the user/client needs.

http://www.davenicolette.net/articles/ftdd.pdf

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T04:25:40Z

Vnpai:

==Problem Statement==
<blockquote>We have focused mainly on unit tests in this course. But functional and integration testing are also important. How does one write good functional and integration tests? Are there any kinds of tests beyond unit, functional, and integration that one should implement to gain confidence that one's code is correct?
</blockquote>

==Different stages of Software Testing==
http://www.aptest.com/testtypes.html (either use reference to this place or type in our own words)

==Functional Testing==
Testing software based on its functional requirements. It ensures that the program physically works the way it was intended and all required menu options are present. It also ensures that the program conforms to the industry standards relevant to that environment; for example, in a Windows program, pressing F1 brings up help.
[http://msdn.microsoft.com/en-us/library/aa292128%28VS.71%29.aspx]
DEFINITION: Testing of all features and functions of a system [software, hardware, etc.] to ensure requirements and specifications are met.

Use cases are generally developed from the user specifications. These use cases are useful in providing the guidelines for functional testing.

==Prerequisites before Functional Testing==
# Build Functional test cases from uses cases, with each use case scenario becoming a functional test.
# As a module is built and unit tested apply the particular test case.
# Prioritize the test cases.
# it should be geared towards a non-technical audience. Therefore, references to underlying programming languages must not be present in the final document
# The author of the functional test plan must be a person who has in-depth knowledge of the business requirements. It is preferable that application developers do not compose functional test plans. The reason behind such an approach is simple: The developer's interpretation of the requirements might differ from those of the person who initially created them.

==Integration Testing==
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules. Integration testing is an important phase and sometimes there are separate teams which handle integration testing.

DEFINITION:Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.

==Integration Test approaches==
Integration testing can be done in a variety of ways [[Image:TopDown_Approach.jpg|thumb|Top Down Approach]]
# Top-Down Approach. In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed [[Image:BottomUp_Approach.jpg|thumb|Bottom Up Approach]]
# Bottom Up Approach. In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach.

# Umbrella approach. Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.

==Prerequisites before Integration Testing==
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.

==Steps in writing good Integration Test Cases==

#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.

==How To write Good Integration Test Cases and do effective Integration Testing==
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner. The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.

Functional Tests:
Functioanl Test usually check whether the code is running according to what the user/client needs.

http://www.davenicolette.net/articles/ftdd.pdf

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T04:24:16Z

Vnpai:

==Problem Statement==
<blockquote>We have focused mainly on unit tests in this course. But functional and integration testing are also important. How does one write good functional and integration tests? Are there any kinds of tests beyond unit, functional, and integration that one should implement to gain confidence that one's code is correct?
</blockquote>

==Different stages of Software Testing==
http://www.aptest.com/testtypes.html (either use reference to this place or type in our own words)

==Functional Testing==
Testing software based on its functional requirements. It ensures that the program physically works the way it was intended and all required menu options are present. It also ensures that the program conforms to the industry standards relevant to that environment; for example, in a Windows program, pressing F1 brings up help.
[http://msdn.microsoft.com/en-us/library/aa292128%28VS.71%29.aspx]
DEFINITION: Testing of all features and functions of a system [software, hardware, etc.] to ensure requirements and specifications are met.

Use cases are generally developed from the user specifications. These use cases are useful in providing the guidelines for functional testing.

==Prerequisites before Functional Testing==
# Build Functional test cases from uses cases, with each use case scenario becoming a functional test.
# As a module is built and unit tested apply the particular test case.
# Prioritize the test cases.
# it should be geared towards a non-technical audience. Therefore, references to underlying programming languages must not be present in the final document
# The author of the functional test plan must be a person who has in-depth knowledge of the business requirements. It is preferable that application developers do not compose functional test plans. The reason behind such an approach is simple: The developer's interpretation of the requirements might differ from those of the person who initially created them.

==Integration Testing==
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules. Integration testing is an important phase and sometimes there are separate teams which handle integration testing.

DEFINITION:Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.

==Integration Test approaches==
Integration testing can be done in a variety of ways
# Top-Down Approach. In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed [[Image:TopDown_Approach.jpg|thumb|Top Down Approach]]
# Bottom Up Approach. In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach. [[Image:BottomUp_Approach.jpg|thumb|Bottom Up Approach]]

# Umbrella approach. Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.

==Prerequisites before Integration Testing==
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.

==Steps in writing good Integration Test Cases==

#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.

==How To write Good Integration Test Cases and do effective Integration Testing==
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner. The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.

Functional Tests:
Functioanl Test usually check whether the code is running according to what the user/client needs.

http://www.davenicolette.net/articles/ftdd.pdf

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T04:22:59Z

Vnpai:

==Problem Statement==
<blockquote>We have focused mainly on unit tests in this course. But functional and integration testing are also important. How does one write good functional and integration tests? Are there any kinds of tests beyond unit, functional, and integration that one should implement to gain confidence that one's code is correct?
</blockquote>

==Different stages of Software Testing==
http://www.aptest.com/testtypes.html (either use reference to this place or type in our own words)

==Functional Testing==
Testing software based on its functional requirements. It ensures that the program physically works the way it was intended and all required menu options are present. It also ensures that the program conforms to the industry standards relevant to that environment; for example, in a Windows program, pressing F1 brings up help.
[http://msdn.microsoft.com/en-us/library/aa292128%28VS.71%29.aspx]
DEFINITION: Testing of all features and functions of a system [software, hardware, etc.] to ensure requirements and specifications are met.

Use cases are generally developed from the user specifications. These use cases are useful in providing the guidelines for functional testing.

==Prerequisites before Functional Testing==
# Build Functional test cases from uses cases, with each use case scenario becoming a functional test.
# As a module is built and unit tested apply the particular test case.
# Prioritize the test cases.
# it should be geared towards a non-technical audience. Therefore, references to underlying programming languages must not be present in the final document
# The author of the functional test plan must be a person who has in-depth knowledge of the business requirements. It is preferable that application developers do not compose functional test plans. The reason behind such an approach is simple: The developer's interpretation of the requirements might differ from those of the person who initially created them.

[[Image:TopDown_Approach.jpg|thumb|Top Down Approach]]
[[Image:BottomUp_Approach.jpg|thumb|Bottom Up Approach]]
==Integration Testing==
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules. Integration testing is an important phase and sometimes there are separate teams which handle integration testing.

DEFINITION:Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.

==Integration Test approaches==
Integration testing can be done in a variety of ways
# Top-Down Approach. In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed
# Bottom Up Approach. In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach.

# Umbrella approach. Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.

==Prerequisites before Integration Testing==
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.

==Steps in writing good Integration Test Cases==

#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.

==How To write Good Integration Test Cases and do effective Integration Testing==
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner. The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.

Functional Tests:
Functioanl Test usually check whether the code is running according to what the user/client needs.

http://www.davenicolette.net/articles/ftdd.pdf

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T04:22:13Z

Vnpai:

<h1><center>Topic: Functional and integration testing and beyond</center></h1>

==Problem Statement==
<blockquote>We have focused mainly on unit tests in this course. But functional and integration testing are also important. How does one write good functional and integration tests? Are there any kinds of tests beyond unit, functional, and integration that one should implement to gain confidence that one's code is correct?
</blockquote>

==Different stages of Software Testing==
http://www.aptest.com/testtypes.html (either use reference to this place or type in our own words)

==Functional Testing==
Testing software based on its functional requirements. It ensures that the program physically works the way it was intended and all required menu options are present. It also ensures that the program conforms to the industry standards relevant to that environment; for example, in a Windows program, pressing F1 brings up help.
[http://msdn.microsoft.com/en-us/library/aa292128%28VS.71%29.aspx]
DEFINITION: Testing of all features and functions of a system [software, hardware, etc.] to ensure requirements and specifications are met.

Use cases are generally developed from the user specifications. These use cases are useful in providing the guidelines for functional testing.

==Prerequisites before Functional Testing==
# Build Functional test cases from uses cases, with each use case scenario becoming a functional test.
# As a module is built and unit tested apply the particular test case.
# Prioritize the test cases.
# it should be geared towards a non-technical audience. Therefore, references to underlying programming languages must not be present in the final document
# The author of the functional test plan must be a person who has in-depth knowledge of the business requirements. It is preferable that application developers do not compose functional test plans. The reason behind such an approach is simple: The developer's interpretation of the requirements might differ from those of the person who initially created them.

[[Image:TopDown_Approach.jpg|thumb|Top Down Approach]]
[[Image:BottomUp_Approach.jpg|thumb|Bottom Up Approach]]
==Integration Testing==
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules. Integration testing is an important phase and sometimes there are separate teams which handle integration testing.

DEFINITION:Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.

==Integration Test approaches==
Integration testing can be done in a variety of ways
# Top-Down Approach. In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed
# Bottom Up Approach. In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach.

# Umbrella approach. Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.

==Prerequisites before Integration Testing==
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.

==Steps in writing good Integration Test Cases==

#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.

==How To write Good Integration Test Cases and do effective Integration Testing==
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner. The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.

Functional Tests:
Functioanl Test usually check whether the code is running according to what the user/client needs.

http://www.davenicolette.net/articles/ftdd.pdf

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T04:19:01Z

Vnpai:

<center>Topic: Functional and integration testing and beyond</center>

<blockquote>
Problem Statement: We have focused mainly on unit tests in this course. But functional and integration testing are also important. How does one write good functional and integration tests? Are there any kinds of tests beyond unit, functional, and integration that one should implement to gain confidence that one's code is correct?
</blockquote>

Different stages of Software Testing
http://www.aptest.com/testtypes.html (either use reference to this place or type in our own words)

==Functional Testing==
Testing software based on its functional requirements. It ensures that the program physically works the way it was intended and all required menu options are present. It also ensures that the program conforms to the industry standards relevant to that environment; for example, in a Windows program, pressing F1 brings up help.
[http://msdn.microsoft.com/en-us/library/aa292128%28VS.71%29.aspx]
DEFINITION: Testing of all features and functions of a system [software, hardware, etc.] to ensure requirements and specifications are met.

Use cases are generally developed from the user specifications. These use cases are useful in providing the guidelines for functional testing.

==Prerequisites before Functional Testing==
# Build Functional test cases from uses cases, with each use case scenario becoming a functional test.
# As a module is built and unit tested apply the particular test case.
# Prioritize the test cases.
# it should be geared towards a non-technical audience. Therefore, references to underlying programming languages must not be present in the final document
# The author of the functional test plan must be a person who has in-depth knowledge of the business requirements. It is preferable that application developers do not compose functional test plans. The reason behind such an approach is simple: The developer's interpretation of the requirements might differ from those of the person who initially created them.

[[Image:TopDown_Approach.jpg|thumb|Top Down Approach]]
[[Image:BottomUp_Approach.jpg|thumb|Bottom Up Approach]]
==Integration Testing==
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules. Integration testing is an important phase and sometimes there are separate teams which handle integration testing.

DEFINITION:Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.

==Integration Test approaches==
Integration testing can be done in a variety of ways
# Top-Down Approach. In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed
# Bottom Up Approach. In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach.

# Umbrella approach. Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.

==Prerequisites before Integration Testing==
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.

==Steps in writing good Integration Test Cases==

#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.

==How To write Good Integration Test Cases and do effective Integration Testing==
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner. The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.

Functional Tests:
Functioanl Test usually check whether the code is running according to what the user/client needs.

http://www.davenicolette.net/articles/ftdd.pdf

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T04:17:57Z

Vnpai:

<center>Topic: Functional and integration testing and beyond</center>

<blockquote>
Problem Statement: We have focused mainly on unit tests in this course. But functional and integration testing are also important. How does one write good functional and integration tests? Are there any kinds of tests beyond unit, functional, and integration that one should implement to gain confidence that one's code is correct?
</blockquote>

Different stages of Software Testing
http://www.aptest.com/testtypes.html (either use reference to this place or type in our own words)

==Functional Testing==
Testing software based on its functional requirements. It ensures that the program physically works the way it was intended and all required menu options are present. It also ensures that the program conforms to the industry standards relevant to that environment; for example, in a Windows program, pressing F1 brings up help.
(http://msdn.microsoft.com/en-us/library/aa292128%28VS.71%29.aspx) 
DEFINITION: Testing of all features and functions of a system [software, hardware, etc.] to ensure requirements and specifications are met.

Use cases are generally developed from the user specifications. These use cases are useful in providing the guidelines for functional testing.

==Prerequisites before Functional Testing==
# Build Functional test cases from uses cases, with each use case scenario becoming a functional test.
# As a module is built and unit tested apply the particular test case.
# Prioritize the test cases.
# it should be geared towards a non-technical audience. Therefore, references to underlying programming languages must not be present in the final document
# The author of the functional test plan must be a person who has in-depth knowledge of the business requirements. It is preferable that application developers do not compose functional test plans. The reason behind such an approach is simple: The developer's interpretation of the requirements might differ from those of the person who initially created them.

[[Image:TopDown_Approach.jpg|thumb|Top Down Approach]]
[[Image:BottomUp_Approach.jpg|thumb|Bottom Up Approach]]
==Integration Testing==
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules. Integration testing is an important phase and sometimes there are separate teams which handle integration testing.

DEFINITION:Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.

==Integration Test approaches==
Integration testing can be done in a variety of ways
# Top-Down Approach. In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed
# Bottom Up Approach. In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach.

# Umbrella approach. Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.

==Prerequisites before Integration Testing==
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.

==Steps in writing good Integration Test Cases==

#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.

==How To write Good Integration Test Cases and do effective Integration Testing==
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner. The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.

Functional Tests:
Functioanl Test usually check whether the code is running according to what the user/client needs.

http://www.davenicolette.net/articles/ftdd.pdf

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T04:14:09Z

Vnpai:

<center>Topic: Functional and integration testing and beyond</center>

<blockquote>
Problem Statement: We have focused mainly on unit tests in this course. But functional and integration testing are also important. How does one write good functional and integration tests? Are there any kinds of tests beyond unit, functional, and integration that one should implement to gain confidence that one's code is correct?
</blockquote>

Different stages of Software Testing
http://www.aptest.com/testtypes.html (either use reference to this place or type in our own words)

Functional Testing
Testing software based on its functional requirements. It ensures that the program physically works the way it was intended and all required menu options are present. It also ensures that the program conforms to the industry standards relevant to that environment; for example, in a Windows program, pressing F1 brings up help.
(http://msdn.microsoft.com/en-us/library/aa292128%28VS.71%29.aspx) 
DEFINITION: Testing of all features and functions of a system [software, hardware, etc.] to ensure requirements and specifications are met.

Use cases are generally developed from the user specifications. These use cases are useful in providing the guidelines for functional testing.
Prerequisites before Functional Testing 
# Build Functional test cases from uses cases, with each use case scenario becoming a functional test.
# As a module is built and unit tested apply the particular test case.
# Prioritize the test cases.
# it should be geared towards a non-technical audience. Therefore, references to underlying programming languages must not be present in the final document
# The author of the functional test plan must be a person who has in-depth knowledge of the business requirements. It is preferable that application developers do not compose functional test plans. The reason behind such an approach is simple: The developer's interpretation of the requirements might differ from those of the person who initially created them.

[[Image:TopDown_Approach.jpg|thumb|Top Down Approach]]
[[Image:BottomUp_Approach.jpg|thumb|Bottom Up Approach]]
Integration Testing
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules. Integration testing is an important phase and sometimes there are separate teams which handle integration testing.

DEFINITION:Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.

Integration testing can be done in a variety of ways
# Top-Down Approach. In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed
# Bottom Up Approach. In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach.

# Umbrella approach. Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.

Prerequisites before Integration Testing 
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.

Steps in writing good Integration Test Cases

#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.

How To write Good Integration Test Cases and do effective Integration Testing 
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner. The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.

Functional Tests:
Functioanl Test usually check whether the code is running according to what the user/client needs.

http://www.davenicolette.net/articles/ftdd.pdf

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T04:12:14Z

Vnpai:

<center>Topic: Functional and integration testing and beyond</center>

<blockquote>
Problem Statement: We have focused mainly on unit tests in this course. But functional and integration testing are also important. How does one write good functional and integration tests? Are there any kinds of tests beyond unit, functional, and integration that one should implement to gain confidence that one's code is correct?
</blockquote>

Different stages of Software Testing
http://www.aptest.com/testtypes.html (either use reference to this place or type in our own words)

Functional Testing
Testing software based on its functional requirements. It ensures that the program physically works the way it was intended and all required menu options are present. It also ensures that the program conforms to the industry standards relevant to that environment; for example, in a Windows program, pressing F1 brings up help.
(http://msdn.microsoft.com/en-us/library/aa292128%28VS.71%29.aspx) 
DEFINITION: Testing of all features and functions of a system [software, hardware, etc.] to ensure requirements and specifications are met.

Use cases are generally developed from the user specifications. These use cases are useful in providing the guidelines for functional testing.
Prerequisites before Functional Testing 
# Build Functional test cases from uses cases, with each use case scenario becoming a functional test.
# As a module is built and unit tested apply the particular test case.
# Prioritize the test cases.
# it should be geared towards a non-technical audience. Therefore, references to underlying programming languages must not be present in the final document
# The author of the functional test plan must be a person who has in-depth knowledge of the business requirements. It is preferable that application developers do not compose functional test plans. The reason behind such an approach is simple: The developer's interpretation of the requirements might differ from those of the person who initially created them.

[[Image:TopDown_Approach.jpg|thumb|Top Down|right]]
[[Image:BottomUp_Approach.jpg|right]]
Integration Testing
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules. Integration testing is an important phase and sometimes there are separate teams which handle integration testing.

DEFINITION:Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.

Integration testing can be done in a variety of ways
# Top-Down Approach. In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed
# Bottom Up Approach. In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach.

# Umbrella approach. Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.

Prerequisites before Integration Testing 
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.

Steps in writing good Integration Test Cases

#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.

How To write Good Integration Test Cases and do effective Integration Testing 
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner. The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.

Functional Tests:
Functioanl Test usually check whether the code is running according to what the user/client needs.

http://www.davenicolette.net/articles/ftdd.pdf

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T03:06:15Z

Vnpai:

<center>Topic: Functional and integration testing and beyond</center>

<blockquote>
Problem Statement: We have focused mainly on unit tests in this course. But functional and integration testing are also important. How does one write good functional and integration tests? Are there any kinds of tests beyond unit, functional, and integration that one should implement to gain confidence that one's code is correct?
</blockquote>

Different stages of Software Testing
http://www.aptest.com/testtypes.html (either use reference to this place or type in our own words)

Functional Testing
Testing software based on its functional requirements. It ensures that the program physically works the way it was intended and all required menu options are present. It also ensures that the program conforms to the industry standards relevant to that environment; for example, in a Windows program, pressing F1 brings up help.
(http://msdn.microsoft.com/en-us/library/aa292128%28VS.71%29.aspx) 
DEFINITION: Testing of all features and functions of a system [software, hardware, etc.] to ensure requirements and specifications are met.

Use cases are generally developed from the user specifications. These use cases are useful in providing the guidelines for functional testing.
Prerequisites before Functional Testing 
# Build Functional test cases from uses cases, with each use case scenario becoming a functional test.
# As a module is built and unit tested apply the particular test case.
# Prioritize the test cases.
# it should be geared towards a non-technical audience. Therefore, references to underlying programming languages must not be present in the final document
# The author of the functional test plan must be a person who has in-depth knowledge of the business requirements. It is preferable that application developers do not compose functional test plans. The reason behind such an approach is simple: The developer's interpretation of the requirements might differ from those of the person who initially created them.

[[Image:TopDown_Approach.jpg|Top Down|right]]
[[Image:BottomUp_Approach.jpg|right]]
Integration Testing
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules. Integration testing is an important phase and sometimes there are separate teams which handle integration testing.

DEFINITION:Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.

Integration testing can be done in a variety of ways
# Top-Down Approach. In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed
# Bottom Up Approach. In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach.

# Umbrella approach. Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.

Prerequisites before Integration Testing 
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.

Steps in writing good Integration Test Cases

#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.

How To write Good Integration Test Cases and do effective Integration Testing 
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner. The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.

Functional Tests:
Functioanl Test usually check whether the code is running according to what the user/client needs.

http://www.davenicolette.net/articles/ftdd.pdf

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T03:05:10Z

Vnpai:

<center>Topic: Functional and integration testing and beyond</center>

<blockquote>
Problem Statement: We have focused mainly on unit tests in this course. But functional and integration testing are also important. How does one write good functional and integration tests? Are there any kinds of tests beyond unit, functional, and integration that one should implement to gain confidence that one's code is correct?
</blockquote>

Different stages of Software Testing
http://www.aptest.com/testtypes.html (either use reference to this place or type in our own words)

Functional Testing
Testing software based on its functional requirements. It ensures that the program physically works the way it was intended and all required menu options are present. It also ensures that the program conforms to the industry standards relevant to that environment; for example, in a Windows program, pressing F1 brings up help.
(http://msdn.microsoft.com/en-us/library/aa292128%28VS.71%29.aspx) 
DEFINITION: Testing of all features and functions of a system [software, hardware, etc.] to ensure requirements and specifications are met.

Use cases are generally developed from the user specifications. These use cases are useful in providing the guidelines for functional testing.
Prerequisites before Functional Testing 
# Build Functional test cases from uses cases, with each use case scenario becoming a functional test.
# As a module is built and unit tested apply the particular test case.
# Prioritize the test cases.
# it should be geared towards a non-technical audience. Therefore, references to underlying programming languages must not be present in the final document
# The author of the functional test plan must be a person who has in-depth knowledge of the business requirements. It is preferable that application developers do not compose functional test plans. The reason behind such an approach is simple: The developer's interpretation of the requirements might differ from those of the person who initially created them.

[[File:TopDown_Approach.jpg|Top Down|right]]
[[File:BottomUp_Approach.jpg|right]]
Integration Testing
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules. Integration testing is an important phase and sometimes there are separate teams which handle integration testing.

DEFINITION:Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.

Integration testing can be done in a variety of ways
# Top-Down Approach. In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed
# Bottom Up Approach. In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach.

# Umbrella approach. Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.

Prerequisites before Integration Testing 
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.

Steps in writing good Integration Test Cases

#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.

How To write Good Integration Test Cases and do effective Integration Testing 
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner. The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.

Functional Tests:
Functioanl Test usually check whether the code is running according to what the user/client needs.

http://www.davenicolette.net/articles/ftdd.pdf

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T03:04:02Z

Vnpai:

<center>Topic: Functional and integration testing and beyond</center>

<blockquote>
Problem Statement: We have focused mainly on unit tests in this course. But functional and integration testing are also important. How does one write good functional and integration tests? Are there any kinds of tests beyond unit, functional, and integration that one should implement to gain confidence that one's code is correct?
</blockquote>

Different stages of Software Testing
http://www.aptest.com/testtypes.html (either use reference to this place or type in our own words)

Functional Testing
Testing software based on its functional requirements. It ensures that the program physically works the way it was intended and all required menu options are present. It also ensures that the program conforms to the industry standards relevant to that environment; for example, in a Windows program, pressing F1 brings up help.
(http://msdn.microsoft.com/en-us/library/aa292128%28VS.71%29.aspx) 
DEFINITION: Testing of all features and functions of a system [software, hardware, etc.] to ensure requirements and specifications are met.

Use cases are generally developed from the user specifications. These use cases are useful in providing the guidelines for functional testing.
Prerequisites before Functional Testing 
# Build Functional test cases from uses cases, with each use case scenario becoming a functional test.
# As a module is built and unit tested apply the particular test case.
# Prioritize the test cases.
# it should be geared towards a non-technical audience. Therefore, references to underlying programming languages must not be present in the final document
# The author of the functional test plan must be a person who has in-depth knowledge of the business requirements. It is preferable that application developers do not compose functional test plans. The reason behind such an approach is simple: The developer's interpretation of the requirements might differ from those of the person who initially created them.

[[Image:TopDown_Approach.jpg|Top Down Approach]]
[[Image:BottomUp_Approach.jpg|Bottom Up Approach]]
Integration Testing
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules. Integration testing is an important phase and sometimes there are separate teams which handle integration testing.

DEFINITION:Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.

Integration testing can be done in a variety of ways
# Top-Down Approach. In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed
# Bottom Up Approach. In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach.

# Umbrella approach. Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.

Prerequisites before Integration Testing 
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.

Steps in writing good Integration Test Cases

#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.

How To write Good Integration Test Cases and do effective Integration Testing 
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner. The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.

Functional Tests:
Functioanl Test usually check whether the code is running according to what the user/client needs.

http://www.davenicolette.net/articles/ftdd.pdf

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T03:01:05Z

Vnpai:

<center>Topic: Functional and integration testing and beyond</center>

<blockquote>
Problem Statement: We have focused mainly on unit tests in this course. But functional and integration testing are also important. How does one write good functional and integration tests? Are there any kinds of tests beyond unit, functional, and integration that one should implement to gain confidence that one's code is correct?
</blockquote>

Different stages of Software Testing
http://www.aptest.com/testtypes.html (either use reference to this place or type in our own words)

Functional Testing
Testing software based on its functional requirements. It ensures that the program physically works the way it was intended and all required menu options are present. It also ensures that the program conforms to the industry standards relevant to that environment; for example, in a Windows program, pressing F1 brings up help.
(http://msdn.microsoft.com/en-us/library/aa292128%28VS.71%29.aspx) 
DEFINITION: Testing of all features and functions of a system [software, hardware, etc.] to ensure requirements and specifications are met.

Use cases are generally developed from the user specifications. These use cases are useful in providing the guidelines for functional testing.
Prerequisites before Functional Testing 
# Build Functional test cases from uses cases, with each use case scenario becoming a functional test.
# As a module is built and unit tested apply the particular test case.
# Prioritize the test cases.
# it should be geared towards a non-technical audience. Therefore, references to underlying programming languages must not be present in the final document
# The author of the functional test plan must be a person who has in-depth knowledge of the business requirements. It is preferable that application developers do not compose functional test plans. The reason behind such an approach is simple: The developer's interpretation of the requirements might differ from those of the person who initially created them.

[[Image:TopDown_Approach.jpg|right|Top Down Approach]]
[[Image:BottomUp_Approach.jpg|right|Bottom Up Approach]]
Integration Testing
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules. Integration testing is an important phase and sometimes there are separate teams which handle integration testing.

DEFINITION:Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.

Integration testing can be done in a variety of ways
# Top-Down Approach. In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed
# Bottom Up Approach. In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach.

# Umbrella approach. Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.

Prerequisites before Integration Testing 
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.

Steps in writing good Integration Test Cases

#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.

How To write Good Integration Test Cases and do effective Integration Testing 
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner. The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.

Functional Tests:
Functioanl Test usually check whether the code is running according to what the user/client needs.

http://www.davenicolette.net/articles/ftdd.pdf

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T02:59:13Z

Vnpai:

<center>Topic: Functional and integration testing and beyond</center>

<blockquote>
Problem Statement: We have focused mainly on unit tests in this course. But functional and integration testing are also important. How does one write good functional and integration tests? Are there any kinds of tests beyond unit, functional, and integration that one should implement to gain confidence that one's code is correct?
</blockquote>

Different stages of Software Testing
http://www.aptest.com/testtypes.html (either use reference to this place or type in our own words)

Functional Testing
Testing software based on its functional requirements. It ensures that the program physically works the way it was intended and all required menu options are present. It also ensures that the program conforms to the industry standards relevant to that environment; for example, in a Windows program, pressing F1 brings up help.
(http://msdn.microsoft.com/en-us/library/aa292128%28VS.71%29.aspx) 
DEFINITION: Testing of all features and functions of a system [software, hardware, etc.] to ensure requirements and specifications are met.

Use cases are generally developed from the user specifications. These use cases are useful in providing the guidelines for functional testing.
Prerequisites before Functional Testing 
# Build Functional test cases from uses cases, with each use case scenario becoming a functional test.
# As a module is built and unit tested apply the particular test case.
# Prioritize the test cases.
# it should be geared towards a non-technical audience. Therefore, references to underlying programming languages must not be present in the final document
# The author of the functional test plan must be a person who has in-depth knowledge of the business requirements. It is preferable that application developers do not compose functional test plans. The reason behind such an approach is simple: The developer's interpretation of the requirements might differ from those of the person who initially created them.

[[Image:TopDown_Approach.jpg|right]]
[[Image:BottomUp_Approach.jpg|right]]
Integration Testing
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules. Integration testing is an important phase and sometimes there are separate teams which handle integration testing.

DEFINITION:Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.

Integration testing can be done in a variety of ways
# Top-Down Approach. In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed
# Bottom Up Approach. In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach.

# Umbrella approach. Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.

Prerequisites before Integration Testing 
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.

Steps in writing good Integration Test Cases

#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.

How To write Good Integration Test Cases and do effective Integration Testing 
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner. The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.

Functional Tests:
Functioanl Test usually check whether the code is running according to what the user/client needs.

http://www.davenicolette.net/articles/ftdd.pdf

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T02:58:38Z

Vnpai:

<center>Topic: Functional and integration testing and beyond</center>

<blockquote>
Problem Statement: We have focused mainly on unit tests in this course. But functional and integration testing are also important. How does one write good functional and integration tests? Are there any kinds of tests beyond unit, functional, and integration that one should implement to gain confidence that one's code is correct?
</blockquote>

Different stages of Software Testing
http://www.aptest.com/testtypes.html (either use reference to this place or type in our own words)

Functional Testing
Testing software based on its functional requirements. It ensures that the program physically works the way it was intended and all required menu options are present. It also ensures that the program conforms to the industry standards relevant to that environment; for example, in a Windows program, pressing F1 brings up help.
(http://msdn.microsoft.com/en-us/library/aa292128%28VS.71%29.aspx) 
DEFINITION: Testing of all features and functions of a system [software, hardware, etc.] to ensure requirements and specifications are met.

Use cases are generally developed from the user specifications. These use cases are useful in providing the guidelines for functional testing.
Prerequisites before Functional Testing 
# Build Functional test cases from uses cases, with each use case scenario becoming a functional test.
# As a module is built and unit tested apply the particular test case.
# Prioritize the test cases.
# it should be geared towards a non-technical audience. Therefore, references to underlying programming languages must not be present in the final document
# The author of the functional test plan must be a person who has in-depth knowledge of the business requirements. It is preferable that application developers do not compose functional test plans. The reason behind such an approach is simple: The developer's interpretation of the requirements might differ from those of the person who initially created them.

[[Image:BottomUp_Approach.jpg|right]]
[[Image:TopDown_Approach.jpg|right]]

Integration Testing
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules. Integration testing is an important phase and sometimes there are separate teams which handle integration testing.

DEFINITION:Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.

Integration testing can be done in a variety of ways
# Top-Down Approach. In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed
# Bottom Up Approach. In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach.

# Umbrella approach. Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.

Prerequisites before Integration Testing 
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.

Steps in writing good Integration Test Cases

#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.

How To write Good Integration Test Cases and do effective Integration Testing 
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner. The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.

Functional Tests:
Functioanl Test usually check whether the code is running according to what the user/client needs.

http://www.davenicolette.net/articles/ftdd.pdf

File:TopDown Approach.jpg

2009-09-20T02:58:26Z

Vnpai: The diagram shows us how the top down approach is performed where A,B,C,D,E,F etc are the individual components

The diagram shows us how the top down approach is performed where A,B,C,D,E,F etc are the individual components

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T02:53:02Z

Vnpai:

<center>Topic: Functional and integration testing and beyond</center>

<blockquote>
Problem Statement: We have focused mainly on unit tests in this course. But functional and integration testing are also important. How does one write good functional and integration tests? Are there any kinds of tests beyond unit, functional, and integration that one should implement to gain confidence that one's code is correct?
</blockquote>

Different stages of Software Testing
http://www.aptest.com/testtypes.html (either use reference to this place or type in our own words)

Functional Testing
Testing software based on its functional requirements. It ensures that the program physically works the way it was intended and all required menu options are present. It also ensures that the program conforms to the industry standards relevant to that environment; for example, in a Windows program, pressing F1 brings up help.
(http://msdn.microsoft.com/en-us/library/aa292128%28VS.71%29.aspx) 
DEFINITION: Testing of all features and functions of a system [software, hardware, etc.] to ensure requirements and specifications are met.

Use cases are generally developed from the user specifications. These use cases are useful in providing the guidelines for functional testing.
Prerequisites before Functional Testing 
# Build Functional test cases from uses cases, with each use case scenario becoming a functional test.
# As a module is built and unit tested apply the particular test case.
# Prioritize the test cases.
# it should be geared towards a non-technical audience. Therefore, references to underlying programming languages must not be present in the final document
# The author of the functional test plan must be a person who has in-depth knowledge of the business requirements. It is preferable that application developers do not compose functional test plans. The reason behind such an approach is simple: The developer's interpretation of the requirements might differ from those of the person who initially created them.

Integration Testing
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules. Integration testing is an important phase and sometimes there are separate teams which handle integration testing.

DEFINITION:Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.

Integration testing can be done in a variety of ways
# Top-Down Approach. In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed
# Bottom Up Approach. In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach. [[Image:BottomUp_Approach.jpg|right]]

# Umbrella approach. Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.

Prerequisites before Integration Testing 
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.

Steps in writing good Integration Test Cases

#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.

How To write Good Integration Test Cases and do effective Integration Testing 
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner. The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.

Functional Tests:
Functioanl Test usually check whether the code is running according to what the user/client needs.

http://www.davenicolette.net/articles/ftdd.pdf

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T02:52:11Z

Vnpai:

<center>Topic: Functional and integration testing and beyond</center>

<blockquote>
Problem Statement: We have focused mainly on unit tests in this course. But functional and integration testing are also important. How does one write good functional and integration tests? Are there any kinds of tests beyond unit, functional, and integration that one should implement to gain confidence that one's code is correct?
</blockquote>

Different stages of Software Testing
http://www.aptest.com/testtypes.html (either use reference to this place or type in our own words)

Functional Testing
Testing software based on its functional requirements. It ensures that the program physically works the way it was intended and all required menu options are present. It also ensures that the program conforms to the industry standards relevant to that environment; for example, in a Windows program, pressing F1 brings up help.
(http://msdn.microsoft.com/en-us/library/aa292128%28VS.71%29.aspx) 
DEFINITION: Testing of all features and functions of a system [software, hardware, etc.] to ensure requirements and specifications are met.

Use cases are generally developed from the user specifications. These use cases are useful in providing the guidelines for functional testing.
Prerequisites before Functional Testing 
# Build Functional test cases from uses cases, with each use case scenario becoming a functional test.
# As a module is built and unit tested apply the particular test case.
# Prioritize the test cases.
# it should be geared towards a non-technical audience. Therefore, references to underlying programming languages must not be present in the final document
# The author of the functional test plan must be a person who has in-depth knowledge of the business requirements. It is preferable that application developers do not compose functional test plans. The reason behind such an approach is simple: The developer's interpretation of the requirements might differ from those of the person who initially created them.

Integration Testing
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules. Integration testing is an important phase and sometimes there are separate teams which handle integration testing.

DEFINITION:Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.

Integration testing can be done in a variety of ways
# Top-Down Approach. In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed
# Bottom Up Approach. In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach. [[Image:BottomUp_Approach.jpg|left]]

# Umbrella approach. Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.

Prerequisites before Integration Testing 
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.

Steps in writing good Integration Test Cases

#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.

How To write Good Integration Test Cases and do effective Integration Testing 
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner. The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.

Functional Tests:
Functioanl Test usually check whether the code is running according to what the user/client needs.

http://www.davenicolette.net/articles/ftdd.pdf

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T02:42:19Z

Vnpai:

<center>Topic: Functional and integration testing and beyond</center>

<blockquote>
Problem Statement: We have focused mainly on unit tests in this course. But functional and integration testing are also important. How does one write good functional and integration tests? Are there any kinds of tests beyond unit, functional, and integration that one should implement to gain confidence that one's code is correct?
</blockquote>

Different stages of Software Testing
http://www.aptest.com/testtypes.html (either use reference to this place or type in our own words)

Functional Testing
Testing software based on its functional requirements. It ensures that the program physically works the way it was intended and all required menu options are present. It also ensures that the program conforms to the industry standards relevant to that environment; for example, in a Windows program, pressing F1 brings up help.
(http://msdn.microsoft.com/en-us/library/aa292128%28VS.71%29.aspx) 
DEFINITION: Testing of all features and functions of a system [software, hardware, etc.] to ensure requirements and specifications are met.

Use cases are generally developed from the user specifications. These use cases are useful in providing the guidelines for functional testing.
Prerequisites before Functional Testing 
# Build Functional test cases from uses cases, with each use case scenario becoming a functional test.
# As a module is built and unit tested apply the particular test case.
# Prioritize the test cases.
# it should be geared towards a non-technical audience. Therefore, references to underlying programming languages must not be present in the final document
# The author of the functional test plan must be a person who has in-depth knowledge of the business requirements. It is preferable that application developers do not compose functional test plans. The reason behind such an approach is simple: The developer's interpretation of the requirements might differ from those of the person who initially created them.

Integration Testing
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules. Integration testing is an important phase and sometimes there are separate teams which handle integration testing.

DEFINITION:Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.

Integration testing can be done in a variety of ways
# Top-Down Approach. In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed
# Bottom Up Approach. In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach. [[Image:BottomUp_Approach.jpg]]

# Umbrella approach. Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.

Prerequisites before Integration Testing 
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.

Steps in writing good Integration Test Cases

#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.

How To write Good Integration Test Cases and do effective Integration Testing 
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner. The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.

Functional Tests:
Functioanl Test usually check whether the code is running according to what the user/client needs.

http://www.davenicolette.net/articles/ftdd.pdf

File:BottomUp Approach.jpg

2009-09-20T02:40:03Z

Vnpai: The diagram shows us how the bottom up approach is done where in A,B,C,D,E are individual modules which are combined at various stages and finally result in the integrated product

The diagram shows us how the bottom up approach is done where in A,B,C,D,E are individual modules which are combined at various stages and finally result in the integrated product

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T02:19:27Z

Vnpai:

<center>Topic: Functional and integration testing and beyond</center>

<blockquote>
Problem Statement: We have focused mainly on unit tests in this course. But functional and integration testing are also important. How does one write good functional and integration tests? Are there any kinds of tests beyond unit, functional, and integration that one should implement to gain confidence that one's code is correct?
</blockquote>

Different stages of Software Testing
http://www.aptest.com/testtypes.html (either use reference to this place or type in our own words)

Functional Testing
Testing software based on its functional requirements. It ensures that the program physically works the way it was intended and all required menu options are present. It also ensures that the program conforms to the industry standards relevant to that environment; for example, in a Windows program, pressing F1 brings up help.
(http://msdn.microsoft.com/en-us/library/aa292128%28VS.71%29.aspx) 
DEFINITION: Testing of all features and functions of a system [software, hardware, etc.] to ensure requirements and specifications are met.

Use cases are generally developed from the user specifications. These use cases are useful in providing the guidelines for functional testing.
Prerequisites before Functional Testing 
# Build Functional test cases from uses cases, with each use case scenario becoming a functional test.
# As a module is built and unit tested apply the particular test case.
# Prioritize the test cases.
# it should be geared towards a non-technical audience. Therefore, references to underlying programming languages must not be present in the final document
# The author of the functional test plan must be a person who has in-depth knowledge of the business requirements. It is preferable that application developers do not compose functional test plans. The reason behind such an approach is simple: The developer's interpretation of the requirements might differ from those of the person who initially created them.

Integration Testing
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules. Integration testing is an important phase and sometimes there are separate teams which handle integration testing.

DEFINITION:Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.

Integration testing can be done in a variety of ways
# Top-Down Approach. In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed
# Bottom Up Approach. In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach.
# Umbrella approach. Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.

Prerequisites before Integration Testing 
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.

Steps in writing good Integration Test Cases

#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.

How To write Good Integration Test Cases and do effective Integration Testing 
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner. The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.

Functional Tests:
Functioanl Test usually check whether the code is running according to what the user/client needs.

http://www.davenicolette.net/articles/ftdd.pdf

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T02:19:03Z

Vnpai:

<center>Topic: Functional and integration testing and beyond</center>

<blockquote>
Problem Statement: We have focused mainly on unit tests in this course. But functional and integration testing are also important. How does one write good functional and integration tests? Are there any kinds of tests beyond unit, functional, and integration that one should implement to gain confidence that one's code is correct?
</blockquote>

Different stages of Software Testing
http://www.aptest.com/testtypes.html (either use reference to this place or type in our own words)

Functional Testing
Testing software based on its functional requirements. It ensures that the program physically works the way it was intended and all required menu options are present. It also ensures that the program conforms to the industry standards relevant to that environment; for example, in a Windows program, pressing F1 brings up help.
(http://msdn.microsoft.com/en-us/library/aa292128%28VS.71%29.aspx)
DEFINITION: Testing of all features and functions of a system [software, hardware, etc.] to ensure requirements and specifications are met.

Use cases are generally developed from the user specifications. These use cases are useful in providing the guidelines for functional testing.
Prerequisites before Functional Testing 
# Build Functional test cases from uses cases, with each use case scenario becoming a functional test.
# As a module is built and unit tested apply the particular test case.
# Prioritize the test cases.
# it should be geared towards a non-technical audience. Therefore, references to underlying programming languages must not be present in the final document
# The author of the functional test plan must be a person who has in-depth knowledge of the business requirements. It is preferable that application developers do not compose functional test plans. The reason behind such an approach is simple: The developer's interpretation of the requirements might differ from those of the person who initially created them.

Integration Testing
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules. Integration testing is an important phase and sometimes there are separate teams which handle integration testing.

DEFINITION:Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.

Integration testing can be done in a variety of ways
# Top-Down Approach. In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed
# Bottom Up Approach. In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach.
# Umbrella approach. Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.

Prerequisites before Integration Testing 
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.

Steps in writing good Integration Test Cases

#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.

How To write Good Integration Test Cases and do effective Integration Testing 
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner. The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.

Functional Tests:
Functioanl Test usually check whether the code is running according to what the user/client needs.

http://www.davenicolette.net/articles/ftdd.pdf

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T01:57:11Z

Vnpai:

<center>Topic: Functional and integration testing and beyond</center>

<blockquote>
Problem Statement: We have focused mainly on unit tests in this course. But functional and integration testing are also important. How does one write good functional and integration tests? Are there any kinds of tests beyond unit, functional, and integration that one should implement to gain confidence that one's code is correct?
</blockquote>

Different stages of Software Testing
http://www.aptest.com/testtypes.html (either use reference to this place or type in our own words)

Functional Testing

Integration Testing
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules.Integration testing is an important phase and sometimes there are separate teams which handle integration testing.

Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.

Integration testing can be done in a variety of ways
# Top-Down Approach. In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed
# Bottom Up Approach. In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach.
# Umbrella approach. Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.

Prerequisites before Integration Testing 
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.

Steps in writing good Integration Test Cases

#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.

How To write Good Integration Test Cases and do effective Integration Testing 
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner. The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.

Functional Tests:
Functioanl Test usually check whether the code is running according to what the user/client needs.

http://www.davenicolette.net/articles/ftdd.pdf

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T01:56:11Z

Vnpai:

<center>Topic: Functional and integration testing and beyond</center>

<blockquote>
Problem Statement: We have focused mainly on unit tests in this course. But functional and integration testing are also important. How does one write good functional and integration tests? Are there any kinds of tests beyond unit, functional, and integration that one should implement to gain confidence that one's code is correct?
</blockquote>

Different stages of Software Testing
http://www.aptest.com/testtypes.html (either use reference to this place or type in our own words)

Functional Testing

Integration Testing
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules.Integration testing is an important phase and sometimes there are separate teams which handle integration testing.

Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.

Integration testing can be done in a variety of ways
# Top-Down Approach. In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed
# Bottom Up Approach. In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach.
# Umbrella approach. Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.

Prerequisites before Integration Testing 
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.

Steps in writing good Integration Test Cases
{{{
#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.
}}}

How To write Good Integration Test Cases and do effective Integration Testing 
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner.The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.

Functional Tests:
Functioanl Test usually check whether the code is running according to what the user/client needs.

http://www.davenicolette.net/articles/ftdd.pdf

CSC/ECE 517 Fall 2009/wiki1b 4 mv

2009-09-20T01:52:09Z

Vnpai:

<center>Topic: Functional and integration testing and beyond</center>

<blockquote>
Problem Statement: We have focused mainly on unit tests in this course. But functional and integration testing are also important. How does one write good functional and integration tests? Are there any kinds of tests beyond unit, functional, and integration that one should implement to gain confidence that one's code is correct?
</blockquote>

Different stages of Software Testing
http://www.aptest.com/testtypes.html (either use reference to this place or type in our own words)

Functional Testing:

Integration Testing:
Integration Testing is a process of testing the application on the whole. After going through the unit testing of the modules, these modules need to be integrated, and during this process things may go wrong, Integration process is the phase wherein these errors are captured and rectified.
It is very common for modules after having successful passed all the unit test cases to fail when they are integrated with other modules.Integration testing is an important phase and sometimes there are separate teams which handle integration testing.

Integration testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components
and build a program structure that has been dictated by design.

Integration testing can be done in a variety of ways
# Top-Down Approach. In this approach the modules higher up in the control hierarchy are integrated first and low-level modules are added later. The advantage of this approach is that the modules with high level logic are tested first and hence bugs in the crucial logic are caught early. Further this approach does not require drivers to be written. Although a number of stubs have to be written and managed
# Bottom Up Approach. In this approach, the low level modules are integrated first and high level logic is tested late. While integrating the low level modules, the control modules are replaced by dummy modules called as drivers. Thus driver codes have to be written and managed while using this approach.
# Umbrella approach. Another approach is called the umbrella approach. It is a hybrid of the top down and the botom up approach, ie both the bottom up and top down approaches are used.In this approach we first test along the functional and control flow paths, for this we use the bottom up approach. The results thus gathered are later integrated in a top down manner. This kind of testing allows creating early prototypes of the system with has limited functionality thereby helping is the creations of the product in an incremental manner. This types of testing also minimizes the use of stubs and drivers which are needed in the top-down and bottom up approaches.

Prerequisites before Integration Testing 
The system that is being tested, all of its modules should be rigorously tested as a component, i.e they should have gone through unit tests.

Steps in writing good Integration Test Cases
#Create a Test Plan
#Create test cases and the sample data against which they would be tested.
#If automated tools are being used, scripts should be created.
#After the components have been integrated, start executing the test cases created in point 2.
#Log the bugs found and rectify the same.
#Retest the code.

How To write Good Integration Test Cases and do effective Integration Testing 
The main focus of integration testing is that it needs to check whether the different components are working smoothly and are interacting with each other in the proper manner.The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
A few thing that needs to be kept in mind for effective integration testing are
# Ensure that the correct versions of the components are integrated together.
# Automate the integration of components so that there is lesser chance for human error.
# Log all the errors that have been found and document them with the solutions as well as the version number so that we could keep track of which build was being tested when the error was discovered.

Functional Tests:
Functioanl Test usually check whether the code is running according to what the user/client needs.

http://www.davenicolette.net/articles/ftdd.pdf