Software Testing

      Today i will be sharing some basics of software testing. As we all know software testing is a very vast area, which has so many categories and technical details in it. This post is going to be an introduction for such critical topic, that is "Software Testing".

Before jumping into software testing let's take a look at "Software Development Life  Cycle (SDLC)". SDLC is simply nothing but a process that describes the steps involved in planning, designing, implementing, testing and maintaining a software product.

According to Rayleigh curve testing phase requires the maximum effort.

Despite of the type of an application testing should be done in an appropriate way. No matter how good the code is but if testing is not done properly then the effort,time and money invested into the project will be of no use.

To get some basic understanding about software testing let's take a look at the "Testing Levels" in this post. There are mainly 4 levels in Software Testing. They are:

1. Unit Testing
2.Integration Testing
3.System Testing

4.Acceptance Testing

In brief if i were to talk about these 4 levels of software testing, unit testing is done for each module, integration testing is done for the integrated component groups, system testing is done for the system as whole and finally acceptance testing is done for the entire system to check whether it meets the client's requirements. 

Now let's see each level in detail.

1. Unit Testing

Unit is the smallest testable part of software.Unit testing is performed for each units and check whether each unit is working accordingly in isolation. As a result we'll get bug free units which can be integrated with other units. The main advantage of doing unit testing is that it will reduces the debugging effort. Also detecting errors in an integrated system would be much more difficult. So it's always better to do the unit testing at the very first level. Normally the developer who developed the unit will do the unit testing. For example testing a function in the source code can be considered as a unit test. 

2. Integration Testing

Integration testing is the place where all the units of a system will be combined together and checked as a system for the first time. This is done after completing the unit testing where we make sure that each unit can work as expected in isolation. Developer or a tester will be in-charge of integration testing. In order to link all the modules and test them, there are several testing strategies available in integration testing. They  are,

1. Top-down approach (depth or breadth first)

2. Bottom up approach

3. Mixed approach

4. Big - Bang approach : Not an appropriate way to do. So we'll skip that :)

2.1. Top-down approach

In this approach we start off from the top. That is we test from the main modules and end up with the sub modules/units. If lower level modules aren't completed we can use something call "stub" instead of those unfinished modules. So that we don't have to wait for all the lower level modules to be completed for testing. But the disadvantage of having stubs is that the stub won't function just as the original module. So that more effort should be spent on building the stubs. 

2.2. Bottom up approach

In this approach we start off from the bottom. We start with lower level modules and reach the main module in the top. So that we don't have to wait for modules to get finish, because by the time we finish the modules the entire system will be ready. If we don't have an upper level module we can develop a sample of that, known as "Drivers". 

2.3. Mixed Approach

IT's a combination of both bottom up and to down approaches. There for it makes use of drivers and stubs. It doesn't strictly follow any software engineering disciplines.  

3. System Testing

This is done once all the modules have been integrated successfully. It's intention is to make sure that it meets all the specified requirements. It also focuses on a system's performance, security, operator and use procedures, etc. 

4. Acceptance Testing

This is where the end user tests the system  and accepts the system. It has 2 levels. They are,

1. Alpha Testing -Tested in a controlled environment 

2. Beta Testing - Tested in the actual environment

So these are the levels of testing a system should go through in its life to be a system that will full fill user's requirements.