CSC/ECE 517 Fall 2009/wiki1b 4 mv: Difference between revisions

From Expertiza_Wiki
Jump to navigation Jump to search
No edit summary
No edit summary
Line 7: Line 7:


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




Functional Testing:  
Functional Testing:  


Integration Testing:
Integration Testing:
Line 22: Line 20:
(http://msdn.microsoft.com/en-us/library/aa292128%28VS.71%29.aspx)
(http://msdn.microsoft.com/en-us/library/aa292128%28VS.71%29.aspx)
Integration testing can be done in a variety of ways
Integration testing can be done in a variety of ways
# The top-down approach to integration testing requires the highest-level modules be test and integrated first. This allows high-level logic and data flow to be tested early in the process and it tends to minimize the need for drivers. However, the need for stubs complicates test management and low-level utilities are tested relatively late in the development cycle. Another disadvantage of top-down integration testing is its poor support for early release of limited functionality.
# 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
# The bottom-up approach requires the lowest-level units be tested and integrated first. These units are frequently referred to as utility modules. By using this approach, utility modules are tested early in the development process and the need for stubs is minimized. The downside, however, is that the need for drivers complicates test management and high-level logic and data flow are tested late. Like the top-down approach, the bottom-up approach also provides poor support for early release of limited functionality.
# 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.
# The third approach, sometimes referred to as the umbrella approach, requires testing along functional data and control-flow paths. First, the inputs for functions are integrated in the bottom-up pattern discussed above. The outputs for each function are then integrated in the top-down manner. The primary advantage of this approach is the degree of support for early release of limited functionality. It also helps minimize the need for stubs and drivers. The potential weaknesses of this approach are significant, however, in that it can be less systematic than the other two approaches, leading to the need for more regression testing.
# 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 minimises the use of stubs and drivers which are needed in the top-down and bottom up approaches.




Revision as of 00:58, 20 September 2009

Topic: Functional and integration testing and beyond

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?


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.

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.

(http://msdn.microsoft.com/en-us/library/aa292128%28VS.71%29.aspx) Integration testing can be done in a variety of ways

  1. 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
  2. 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.
  3. 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 minimises the use of stubs and drivers which are needed in the top-down and bottom up approaches.


How To write Good Integration Test Cases http://www.exforsys.com/tutorials/testing/integration-testing-whywhathow.html ... Link is very elaborate.


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

Retrieved from "https://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2009/wiki1b_4_mv&oldid=20041"