Showing posts with label Automation Testing. Show all posts
Showing posts with label Automation Testing. Show all posts

Seleniu IDE installation step by step process
  • Open Mozilla Firefox Browser.
  • Type URL : http://seleniumhq.org/download/ in your browser. Selenium IDE download page will get open then click on latest Download version link (Here is 1.3.0) as shown in image bellow. click on that link.
  •  
  •  
  •  When you click on latest Selenium IDE Download version link, Firefox will show one popup saying do you want to allow Mozilla Firefox to install selenium IDE or not. Click on Allow button as shown in image bellow.
  • When you click on allow button, Firefox will automatically install Selenium IDE. after completion of Selenium IDE installation, it will show one pop up saying Selenium IDE installation completed. you need to restart your browser to use selenium IDE. Click on Restart Now button as show in image bellow.
  •  
  • When you click on Restart Now button, Firefox will restart automatically. now click on Tools menu list displayed in top. you can see there Selenium IDE as shown in image bellow.
  •   
  • Click on Selenium IDE as shown in image above. It will launch Selenium IDE window as shown in image bellow. 
So these are the steps to download and install Selenium IDE. Now you can use it to record and play your web application test. Comment here if you face any problem in download and install selenium IDE. I will guide you personally.

download selenium ide, selenium ide download, install selenium ide, selenium, download selenium, selenium testing, selenium ide tutorial, selenium download, selenium documentation, selenium test, free downloads software, open source downloads, selenium tool, download selenium ide for windows, selenium ide extensions, selenium ide plugin, selenium tests, selenium scripts, download ide, using selenium ide, testing selenium, selenium open source, selenium ide help, selenium script, selenium recorder, free download web browser, selenium ide addon, web browser free download, browser free download, selenium plugins, selenium help, selenium ide extension, selenium 2 tutorial, download selenium testing tool, gwt selenium, selenium ide install, selenium linux, 02 downloads, selenium testing software

Protocol testing can be grouped in two categories: Stress & Reliability Tests and Functional Tests.
  • Stress and Reliability Tests include Performance Testing, Load Testing, Stress Testing, Line Speed Testing and Robustness or Security Testing.
  • Functional Tests include Negative Testing, Inopportune Testing, Conformance/Compliance Testing, Syntax and Semantic Testing, Interoperability Testing and Deep-path Testing.


Performance Testing - process of verifying that the performance of the device under test meets an acceptable level. Performance testing is a superset of line speed testing in which performance applies to many aspects of a network device or application, and not just line speed.
Load Testing: Load testing is used to determine how well a system will perform in a typical environment under a specific load. Load testing is useful when you are confident that the application is functionally sound, but you do not know how the application will perform under a specific load.
The example of a load test is a call generator application that generates 1000 calls that a telephone switch must process. Does the switch continue to operate? Does its performance degrade or it crashes?
Stress Testing – process of subjecting the device under test to out of boundary conditions. The device under test should report an error message, gracefully shut down, or reject the input in some other way. In no case, should the device under test crash, reboot, or cause any harm.
An example of stress test can be 50 SNMP managers simultaneously querying one SNMP agent in the device under test. Normally, no more than one to three managers concurrently query an SNMP agent in a device. The device should perform an appropriate action.
Line Speed Testing - process of verifying that a device can operate at its rated line speed, when the bandwidth is 100% utilized or saturated.
For example, if the device is rated as operating at 5 Giga bytes per second, then the device should be able to handle incoming traffic utilizing all the available bandwidth.
Robustness Testing - process of subjecting a device under test to particular input streams. The input streams may be one of three types:
  • Random input streams
  • Valid input streams
  • Invalid input streams
Robustness testing is a form of security testing. Security testing is more broadly defined to include monitoring / surveillance and the detection of specific exploits like IP spoofing or phishing etc.
The example of intelligent robustness test can be adding a trailing dot to the DNS name in the SIP URL. This is legal, but perhaps unexpected. The SIP implementation in the receiving device should process this correctly.
Negative Testing – process to verify that the device under test responds correctly to error conditions or unacceptable input conditions. Negative testing can be challenging because the number of incorrect conditions is unlimited.
Example of a negative test would be using a security protocol for authentication with an incorrect parameter.
Inopportune Testing – process to verify that the device under test is able to react properly when an unexpected protocol event occurs. The event is syntactically correct, but occurs when not expected. Inopportune testing is a specific instance of negative protocol conformance testing.
An example of inopportune testing is a BYE response to a SIP INVITE. The SIP INVITE is expecting a 100 Trying response, but not a BYE response.
Protocol Conformance Testing - process of systematically selecting each requirement in a standards document and then testing to see if the device under test operates according to that requirement. This is done by creating a series of single function tests for each requirement, resulting in thousands of tests.
Conformance testing for computer networking protocols is defined in ISO/IEC 9646-1:1994(E) as "testing both the capabilities and behavior of an implementation, and checking what is observed against the conformance requirements in the relevant International Standards."
An example of a conformance test is to check if the “ping” command operates correctly.
Syntax and Semantic Testing: Protocol conformance testing requires testing both the syntax and the semantics (functionality) of the device under test. Semantic tests force the device under test into a certain condition or state. Often the test cannot verify the correct behavior; it must be verified by an operator.
It’s example can be a test for a router to check whether it is maintaining an accurate count of all erroneous incoming packets of a certain type requires a mechanism for generating the erroneous packets, counting them, directing them to the router, assuring they were received by the router, and then reading the actual counter in the router.
Interoperability Testing - process of testing devices from multiple manufacturers by interacting in such a manner as to exercise the network protocol under test.
Interoperability testing is very useful in the early stages of a new product or new protocol. As products mature, interoperability testing becomes less valuable as it does not uncover enough new bugs to warrant the cost of setting up, configuring and managing network equipment from various manufacturers.
Deep-path testing – process of exercising every path through the code, not just the main path through the code. This is done by maintaining and tracking the protocol conversation very precisely, in a controlled way.
Deep-path testing is useful for forcing a particular path through code that is very difficult to exercise but very important for correct operation.

Usability Testing in Software Testing refers to evaluating the ease with which users can use a new application / software product.


Software Usability is ease with which a product can be used by a specific group of users to achieve specified goals with effectiveness, efficiency and satisfaction in a specified context of use. Usable software enables workers to concentrate on their tasks rather than the software they are using. In other words, we can say a product as usable, if
  • It’s easy to learn
  • Easy to remember
  • Efficient to use
  • Enjoyable to use
  • Pleasing User InterfaceProvides quick recovery from errors
Every design and development decision made throughout the software development life cycle has an impact on that software’s usability.
Achieving the good Usability of a Software Product:
  • Observing users at their jobs and identifying their typical work tasks and procedures.
  • Meeting with users and trying to find out about their preferences and needs.
  • Evaluate the usability of similar products in the market
  • Include the users early in the development phase
  • Evaluate software against accepted usability principles
  • Consider the above points while during the whole Product Development Life Cycle
Benefits of Usability Testing:
  • Results in technical support savings
  • Good usability increases product sales
  • Good usability positively impacts user performance and satisfaction
  • It also improves development productivity through more efficient design and fewer code revisions.
Procedure for Usability Testing: Usability Testing is different from a normal testing or quality assurance. Below are some important points of Usability Testing:
  • Each test has a specific concern that is tested
  • The participants are real users and so real tasks
  • The participants are observed and recorded. The data is analyzed, problems diagnosed and recommendations made.
Tasks in Usability Testing:
  • Identification of participants from user pool.
  • Determining the usability criteria and measures.
  • Creation of test material and writing task scenarios.
  • Identify the test location
  • Pilot testing materials and procedures
  • Introduction of Product and procedures to the participants
  • Executing the task-based tests i.e. participants are asked to complete a series of tasks that address the specific goals and concerns being tested.
  • Participants are asked to articulate their thoughts, feeling and actions.
  • Recording of video images.
  • Analysis of data and documenting findings
  • Making recommendations.
During the Usability Testing, we can able to identify those areas of the system that will cause users to make errors, become less productive or be unable to complete a required activity.

Integration testing is designed to test the structure and the architecture of the software and determine whether all software components interface properly. Integration testing does not verify that the system is functionally correct, only that it performs as designed.

It is the process of identifying errors introduced by combining individual program unit tested modules. Integration Testing should not begin until all units are known to perform according to the unit specifications. It can start with testing several logical units or can incorporate all units in a single integration test.

Below are the four steps of creating integration test cases:

Step 1 - Identify Unit Interfaces: The developer of each program unit identifies and documents the unit’s interfaces for the following unit operations:

- Responding to queries from terminals for information
- Managing transaction data entered for processing
- Obtaining, updating, or creating transactions on computer files
- Passing or receiving information from other logical processing units
- Sending messages to terminals
- Providing the results of processing to some output device or unit

Step 2 - Reconcile Interfaces for Completeness: The information needed for the integration test template is collected for all program units in the software being tested. Whenever one unit interfaces with another, those interfaces are reconciled. For example, if program unit A transmits data to program unit B, program unit B should indicate that it has received that input from program unit A. Interfaces not reconciled are examined before integration tests are executed.

Step 3 - Create Integration Test Conditions: One or more test conditions are prepared for integrating each program unit. After the condition is created, the number of the test condition is documented in the test template.

Step 4 - Evaluate the Completeness of Integration Test Conditions: The following list of questions will help guide evaluation of the completeness of integration test conditions recorded on the integration testing template. This list can also help determine whether test conditions created for the integration process are complete.

Q1. Is an integration test developed for each of the following external inquiries:

- Record test?
- File test?
- Search test?
- Match/merge test?
- Attributes test?
- Stress test?
- Control test?

Q2. Are all interfaces between modules validated so that the output of one is recorded as input to another?

Q3. If file test transactions are developed, do the modules interface with all those indicated files?

Q4. Is the processing of each unit validated before integration testing?

Q5. Do all unit developers agree that integration test conditions are adequate to test each unit’s interfaces?

Q6. Are all software units included in integration testing?

Q7. Are all files used by the software being tested included in integration testing?

Q8. Are all business transactions associated with the software being tested included in integration testing?

Q9. Are all terminal functions incorporated in the software being tested included in integration testing?

Selenium is a portable software testing framework for web applications. The tests can be written as HTML tables or coded in a number of popular programming languages and can be run directly in most modern web browsers. Selenium can be deployed on Windows, Linux, and Macintosh. Selenium is used for UAT (User Acceptance Test).


Selenium consists of

- Selenium Core

- Selenium RC

- Selenium Grid
- Selenium on Rails
- Selenium IDE

Selenium IDE:
Selenium IDE is a complete Integrated Development Environment (IDE) for Selenium tests (previously known as Selenium Recorder). Firefox extension that allows recording and editing of tests. It allows easier development of tests. It can output Ruby for it’s Ruby based (Application Programming Interface) API.

Selenium IDE Features:

- Record and playback

- Intelligent field selection will use IDs, names, or XPath as needed
- Auto complete for all common Selenium commands
- Walk through test cases and test suites.
- Debug and set breakpoints
- Save tests as HTML, Ruby scripts, or other formats
- Support for Selenium user-extensions.js file
- Option to automatically assert the title of every page
- Rollup common commands

Selenium IDE License:
Selenium was developed by a team of programmers and testers at Thought Works. Selenium is open source software, released under the Apache 2.0 license and can be downloaded and used without charge. The Selenium Grid provides a hub allowing the running of multiple Selenium tests concurrently  on any number of local or remote systems, thus minimizing test execution time.

Localization testing is part of software testing focused on internationalization and localization aspects of software.

Localization Test is the process of adapting globalized application to a particular culture/locale. Localizing the application requires a basic understanding of the sets of character commonly employed in modern software development and an apprehension of the risks associated with them.

Localisation testing checks how well the build has been interpreted into a particular target language. This test is founded on the results of globalized validation where the functional support for that particular locale has already been validated. Whenever the product is not globalised enough to support a given language, you probably will not try to focalise it into that language in the first place.

You still have to check that the application you are delivering to a specific market actually works and the following section shows you some of the common areas on which to focus when executing a Localization of test.

Localization testing contains the translation of the application user interface and adapting graphics for a particular culture/locale. The localisation process can also include translating any help content associated with the application program into native language.

Localisation of business solutions needs that you implement the correct business processes and practices for a culture/locale. Differences in how cultures/locales conduct business are to a great extent determined by governmental and regulatory requirements. Hence, localisation of business logic can be a big task.

Things which are often altered during localization, such as the user interfaces and content files. Below is a sample localization testing checklist:

- Spelling Rules
- Sorting Rules
- Upper and Lower case conversions
- Printers
- Size of Papers
- Operating System
- Key boards
- Text Filters
- Hot keys
- Mouse
- Date formats
- Measurements and Rulers
- Available memory

Below is a list of major scenarios for cookies testing of a website. Multiple test cases can be generated from these scenarios by performing various combinations.



  1. Check if the application is writing cookies properly or not.
  2. Test to make sure that no personal or sensitive data is stored in the cookie. If it is there in cookies, it should be in encrypted format.
  3. If the application under test is a public website, there should not be overuse of cookies. It may result in loss of website traffic if browser is prompting for cookies more often.
  4. Close all browsers, delete all previously written cookies and disable the cookies from your browser settings. Navigate or use that part of web site which use cookies. It should display appropriate messages like "For smooth functioning of this site please enable cookies on your browser."
  5. Set browser options to prompt whenever cookie is being stored / saved in your system. Navigate or use that part of web site which use cookies. It will prompt and ask if you want to accept or reject the cookie. Application under test should display an appropriate message if you reject the cookies. Also, check that if pages are getting crashed or data is getting corrupted.
  6. Close all browsers windows and manually delete all cookies. Navigate various web pages and check and see if these web pages show unexpected behavior.
  7. Edit few cookies manually in notepad or some other editor. Make modifications like alter the cookie content, name of the cookie, change expiry date etc. Now, test the site functionality. Corrupted cookies should not allow to read the data inside it.
  8. Cookies written by one web site should not be accessible by other website.
  9. If you are testing an online shopping portal, Check if reaching to your final order summary page deletes the cookie of previous page of shopping cart properly and no invalid action or purchase got executed from same logged in user.
  10. Check if the application under test is writing the cookies properly on different browsers as intended and site works properly using these cookies. This test can be done on browsers like different versions of internet explorer, Mozilla Firefox, Netscape, Opera etc.
  11. If the application under test is using cookies to maintain the logging state for users. Check if some id is being displayed in the address bar. Now, change the id & press enter. It should display an access denied message and and you should not be able to see other user's account.

Testing the software system or software application as a whole is referred to as System Testing of the software. System testing of the application is done on complete application software to evaluate software's overall compliance with the business / functional / end-user requirements. The system testing comes under black box software testing. So, the knowledge of internal design or structure or code is not required for this type of software testing.
In system testing a software test professional aims to detect defects or bugs both within the interfaces and also within the software as a whole. However, the during integration testing of the application or software, the software test professional aims to detect the bugs / defects between the individual units that are integrated together.

During system testing, the focus is on the software design, behavior and even the believed expectations of the customer. So, we can also refer the system testing phase of software testing as investigatory testing phase of the software development life cycle.

At what stage of SDLC the System Testing comes into picture:
After the integration of all components of the software being developed, the whole software system is rigorously tested to ensure that it meets the specified business, functional & non-functional requirements. System Testing is build on the unit testing and integration testing levels. Generally, a separate and dedicated team is responsible for system testing. And, system testing is performed on stagging server.

Why system testing is required:
  • It is the first level of software testing where the software / application is tested as a whole.
  • It is done to verify and validate the technical, business, functional and non-functional requirements of the software. It also includes the verification & validation of software application architecture.
  • System testing is done on stagging environment that closely resembles the production environment where the final software will be deployed.
Entry Criteria for System Testing:
  • Unit Testing must be completed
  • Integration Testing must be completed
  • Complete software system should be developed
  • A software testing environment that closely resembling the production environment must be available (stagging environment).
System Testing in seven steps:
  1. Creation of System Test Plan
  2. Creation of system test cases
  3. Selection / creation of test data for system testing
  4. Software Test Automation of execution of automated test cases (if required)
  5. Execution of test cases
  6. Bug fixing and regression testing
  7. Repeat the software test cycle (if required on multiple environments)  
Contents of a system test plan: The contents of a software system test plan may vary from organization to organization or project to project. It depends how we have created the software test strategy, project plan and master test plan of the project. However, the basic contents of a software system test plan should be:

- Scope
- Goals & Objective
- Area of focus (Critical areas)
- Deliverables
- System testing strategy
- Schedule
- Entry and exit criteria
- Suspension & resumption criteria for software testing
- Test Environment
- Assumptions
- Staffing and Training Plan
- Roles and Responsibilities
- Glossary

How to write system test cases: The system test cases are written in a similar way as we write functional test cases. However, while creating system test cases following two points needs to be kept in mind:

- System test cases must cover the use cases and scenarios
- They must validate the all types of requirements - technical, UI, functional, non-functional, performance etc.

As per Wikipedia, there are total of 24 types of testings that needs to be considered during system testing. These are:

GUI software testing, Usability testing, Performance testing, Compatibility testing, Error handling testing, Load testing, Volume testing, Stress testing, User help testing, Security testing, Scalability testing, Capacity testing, Sanity testing, Smoke testing, Exploratory testing, Ad hoc testing, Regression testing, Reliability testing, Recovery testing, Installation testing, Idem potency testing, Maintenance testing, Recovery testing and failover testing, Accessibility testing

The format of system test cases contains:
  • Test Case ID - a unique number
  • Test Suite Name
  • Tester - name of tester who execute of write test cases
  • Requirement - Requirement Id or brief description of the functionality / requirement
  • How to Test - Steps to follow for execution of the test case
  • Test Data - Input Data
  • Expected Result
  • Actual Result
  • Pass / Fail
  • Test Iteration

In LoadRunner, you can add C Vuser functions to any Vuser script in order to enhance the script. VuGen generates only a few of the general Vuser functions while you record. If required, the remaining functions can be manually programmed into a script.
Below is a list of general API functions for ANSI C scripts. It includes all protocols except for Java, VB, and GUI:

Transaction Functions:
1. lr_end_sub_transaction --> Marks the end of a sub-transaction for performance analysis.

2. lr_end_transaction --> Marks the end of a transaction.

3. lr_end_transaction_instance --> Marks the end of a transaction instance for performance analysis.

4. lr_fail_trans_with_error --> Sets the status of open transactions to LR_FAIL and sends an error message.

5. lr_get_trans_instance_duration --> Gets the duration of a transaction instance specified by its handle.

6. lr_get_trans_instance_wasted_time --> Gets the wasted time of a transaction instance by its handle.

7. lr_get_transaction_duration --> Gets the duration of a transaction by its name.

8. lr_get_transaction_think_time --> Gets the think time of a transaction by its name.

9. lr_get_transaction_wasted_time --> Gets the wasted time of a transaction by its name.

10. lr_resume_transaction --> Resumes collecting transaction data for performance analysis.

11. lr_resume_transaction_instance --> Resumes collecting transaction instance data for performance analysis.

12. lr_set_transaction_instance_status --> Sets the status of a transaction instance.

13. lr_set_transaction_status --> Sets the status of open transactions.

14. lr_set_transaction_status_by_name --> Sets the status of a transaction.

15. lr_start_sub_transaction --> Marks the beginning of a subtransaction.

16. lr_start_transaction --> Marks the beginning of a transaction.

17. lr_start_transaction_instance --> Starts a nested transaction specified by its parent’s handle.

18. lr_stop_transaction --> Stops the collection of transaction data.

19. lr_stop_transaction_instance --> Stops collecting data for a transaction specified by its handle.

20. lr_wasted_time --> Removes wasted time from all open transactions.

Command Line Parsing Functions:
1. lr_get_attrib_double --> Retrieves a double type variable used on the script command line.

2. lr_get_attrib_long --> Retrieves a long type variable used on the script command line.

3. lr_get_attrib_string --> Retrieves a string used on the script command line.

Informational Functions:
1. lr_user_data_point --> Records a user-defined data sample.

2. lr_whoami --> Returns information about a Vuser to the Vuser script. Not applicable for Application Management.

3. lr_get_host_name --> Returns the name of the host executing the Vuser script.

4. lr_get_master_host_name --> Returns the name of the machine running the LoadRunner Controller or Tuning Console. Not applicable for Application Management.

String Functions:
1. lr_eval_string --> Replaces a parameter with its current value.

2. lr_save_string --> Saves a null-terminated string to a parameter.

3. lr_save_var --> Saves a variable length string to a parameter.

4. lr_save_datetime --> Saves the current date and time to a parameter.

5. lr _advance_param --> Advances to the next available parameter.

6. lr _decrypt --> Decrypts an encoded string.

7. lr_eval_string_ext --> Retrieves a pointer to a buffer containing parameter data.

8. lr_eval_string_ext_free --> Frees the pointer allocated by lr_eval_string_ext.

9. lr_save_searched_string --> Searches for an occurrence of string in a buffer and saves a portion of the buffer, relative to the string occurrence, to a parameter.

Message Functions:
1. lr_debug_message --> Sends a debug message to the Output window or the Business Process Monitor log files.

2. lr_error_message --> Sends an error message to the Output window or the Business Process Monitor log files.

3. lr_get_debug_message --> Retrieves the current message class.

4. lr_log_message --> Sends a message to a log file.

5. lr_output_message --> Sends a message to the Output window or the Business Process Monitor log files.

6. lr_set_debug_message --> Sets a debug message class.

7. lr_vuser_status_message --> Generates and prints formatted output to the Controller or Console Vuser status area. Not applicable for Application Management.

8. lr_message --> Sends a message to the Vuser log and Output window or the Business Process Monitor log files.

Run-Time Functions
1. lr_load_dll --> Loads an external DLL.

2. lr_peek_events --> Indicates where a Vuser script can be paused.

3. lr_think_time --> Pauses script execution to emulate think time—the time a real user pauses to think between actions.

4. lr_continue_on_error --> Specifies an error handling method.

5. lr_rendezvous --> Sets a rendezvous point in a Vuser script. Not applicable for Application Management.

Working with different stake holders in a project, teams would be facing difficulty in keeping transparency on bugs because of following common problems:
  • Lack of process for bug logging: Typical scenario like testing & development teams are not well educated on severities & priorities to be used and their importance.
  • No clear communication to testing team on required fields as part of bug logging. Testers may skip to mention required data like reproducible steps or may skip to attached screen shots.
  • Lack of a standard bug tracking / logging template. If all team members will follow their own template to describe defects, it may lead to discrepancy at a later stage.
  • Team will not have a dedicated SPOC communicate defects to all the stake holders
  • Team will follow their own communication channel to communicate defects using phone/email. Sometimes they won’t even log defect after communicating issue to Dev and getting fix on the fly.
  • Team will not maintain appropriate statuses for defects. Even after they retest and close some times defect still shows as ‘Ready for Test’.
  • Improper Defect Triage/Communication Process: Triage process allows all stake holders to gather at one place (Physically or virtually) to discuss on all open defects and decide on action items. Without this call/meeting in regular intervals it will be difficult to have a common understanding on issues/defects or reasons for blocking of test execution.
  • Test team some time will not have control on Test environments and they would not know when the fix is deployed in to test environment. Sometimes Dev team adhocly performs certain actions on test environment and fixes the issue. Not having complete control on Test Environment would cause so many issues in ensuring quality of defect retest.
  • In today’s market conditions, we have so many Freeware tools available for Test/Defect management tools. Some projects also afford to have cost assigned to Defect Management tools and buy required amount of licenses. Even after having a tool in place, if the process is not defined about how to utilize the tool then we will have many challenges to be faced in handling Defects.
    The below are the common blind spots identified in the poor or No process scenarios.
  • No Training on tool(s) to the team
  • No clear guidelines on the process to the team
  • No availability of tool till the execution starts
  • No planning about how many licenses required for the team
  • No Communication process defined
  • No Triage process defined
  • All the above will lead to poor reporting of the Defect status and eventually Test Execution status.

Unit testing is a software development process in which the smallest testable parts of an application, called units, are individually and independently scrutinized for proper operation. The primary goal of unit testing is to take the smallest piece of testable software in the application, isolate it from the remainder of the code, and determine whether it behaves exactly as expected. Each unit is tested separately before integrating them into modules to test the interfaces between modules.By means of effective Unit testing large percentage of defects are identified. Unit testing is performed by developers.
Each module that is developed by designers need to be tested individually to verify proper operation so that any faulty module can be fixed immediately rather than let it exist and then cause some major issue in the integration phase. Once all of the units in a program have been found to be working efficiently and without any bugs, larger components of the program can be evaluated by means of integration testing. Though Unit testing may be time consuming, tedious and requires thoroughness on the part of the development team, but in the long run it can avoid major pitfalls in the software.

Benefits of unit testing:
  • The modular approach during Unit testing eliminates the dependency on other modules during testing. 
  • We can test parts of a project with out waiting for the other parts to be available.
  • Designers can identify and fix problem immediately, as the modules are best known to them. This helps in fixing multiple problems simultaneously.
  • Cost of fixing a defect identified during the early stages is less compared to that during later stage.
  • Debugging is simplified. 
  • Structural coverage of code is higher.
  • Unit testing is more cost effective compared to the other stages of testing
Misconceptions about Unit Testing:
  • Integration Tests will Catch all the Bugs Anyway: This is one of the common misconceptions of designers. Complexity of the issue rises while it passes through various testing cycles and then when the bug is raised during the later stages, the resolution time will be high as the scope of the bug widens. It is better to weed off the crop before it poisons the whole farm.
  • Programmers Dilemma: Most designers believe Unit testing is not actually required as it is time consuming. They feel they are too good programmers and their software doesn’t need Unit tests. But in the real world, everyone makes mistakes. Real software systems are much more complex. Software behavior various in different environment and with different scenarios. Coding is not a one pass process. Enhancements to the code can be made only when we know the existing module is functioning as expected.
  • It Consumes Too Much Time: Developers are often in a hurry to complete their code and integrate it. Unit Testing is most often considered a useless activity, as they feel anyways the code will be tested by QA. There is no point in having a system which works but not exactly as it is supposed to function and is  to be full of bugs. Practically, such an approach to development will often result in software which will not even run. The net result is that a lot of time will be spent tracking down relatively simple bugs which are wholly contained within particular units. Individually, such bugs may be trivial, but collectively they result in an excessive period of time integrating the software to produce a system which is unlikely to be reliable. This can also lead to failure to meet the required deadlines.
Unit Testing Best Practices:
  • Ensure each Unit Test case is independent of each other. As the software is prone to changes during the Unit Testing due to enhancements/changes to the requirements. Hence any given behavior should be specified in one and only one test. Otherwise if you later change that behavior, you’ll have to change multiple tests.
  • Test only one code at a time. It is always recommended to test each of the modules independently and not while all are chained together. Otherwise you will have lots of overlap between tests and changes to one unit may effect all other modules and cause the software to fail.
  • Name your unit tests clearly and consistently. Ensure that your test cases are easily readable so that anyone picking up Unit test cases can execute them without any issues. Ensure the test case nomenclature is consistent throughout.
  • Before changing a module interface or implementation, make sure that the module has test cases and that it passes its tests before changing the implementation. This way you can know that your changes didn't break anything.
  • Always ensure the bug identified during Unit Testing is fixed before moving it to the next phase.
Unit Testing  Techniques: Structural, Functional & Error based Techniques

Structural Techniques: It is a White box testing technique that uses an internal perspective of the system to design test cases based on internal structure. It requires programming skills to identify all paths through the software. The tester chooses test case inputs to exercise paths through the code and determines the appropriate outputs. Major Structural techniques are:
  • Statement Testing: A test strategy in which each statement of a program is executed at least once. 
  • Branch Testing: Testing in which all branches in the program source code are tested at least once.
  • Path Testing: Testing in which all paths in the program source code are tested at least once.
  • Condition Testing: Condition testing allows the programmer to determine the path through a program by selectively executing code based on the comparison of a value  
  • Expression Testing: Testing in which the application is tested for different values of Regular Expression.
Functional testing techniques: These are Black box testing techniques which tests the functionality of the application. Some functionality testing techniques are:
  • Input domain testing: This testing technique concentrates on size and type of every input object in terms of boundary value analysis and Equivalence class.  
  • Boundary Value: Boundary value analysis is a  software testing design technique in which tests are designed to include representatives of boundary values.  
  • Syntax checking: This is a technique which is used to check the Syntax of the application. 
  • Equivalence Partitioning: This is a software testing technique that divides the input data of a software unit into partition of data from which test cases can be derived
Error based Techniques: The best person to know the defects in his code is the person who has designed it.
Few of the Error based techniques are:
  • Fault seeding techniques can be used so that known defects can be put into the code and tested until they are all found.
  • Mutation Testing: This is done by mutating certain statements in your source code and checking if your test code is able to find the errors. Mutation testing is very expensive to run, especially on very large applications.
  • Historical Test data: This technique calculates the priority of each test case using historical information from the previous executions of the test case. 
Careful approach to Unit testing helps detecting many bugs at a stage of the software development where they can be corrected economically. It is a tedious process when bugs are detected and corrected at later stages of software development as fixing the bugs is difficult, time consuming and costly. Efficiency and quality are best served by testing software as early in the life cycle. Whenever any changes are made to the software we need to ensure regression testing is performed. Testing strategies like thorough unit testing, good management of the testing process, and appropriate use of tools helps in maximizing the effectiveness of testing effort. Effective unit testing is all part of developing a very high quality software product which can benefit the organization on a whole.
Sometimes, testing on various browsers becomes a challenge for software test professionals & project teams. Running the test cases on all browsers makes the testing cost very high. Specially, it becomes a challenge when we do not have expert designers in the team or when we don’t have verification/validation phase at the time of screen design. This is the bad part. Now, let’s see what is good.
Cross Browser Testing Tools–Reduce Browser Compatibility Testing EffortThe best thing is that there are many FREE as well as paid cross browser compatible testing tools available in the market. On top of it, you can do your job with most of the FREE tools. If you have very specific requirements, then you may need to have a paid cross browser compatible testing tool. Lets have quick look on some of the best tools:

1. IE Tab: This is one of my favourite & best tools available for free. This is basically an add-on of Firefox & Chrome. With a single mouse click from within Firefox & Chrome, you can see how the webpage will view in Internet Explorer. It is very light.

2. Microsoft Super Preview: This is a free tool offered by Microsoft. It can help you to check the webpage on various versions of Internet Explorer. you can use it to test and debug the issues in layout. You can download it for free from Microsoft website.

3. Spoon Browser Sandbox: You can use this testing tool to test the web application on almost all major browsers like Firefox, Chrome & Opera. Initially, it supports IE as well, but for the last few months, its support for IE has been reduced.

4. Browsershots: Using this free browser compatibility testing tool, you can test the application on any platform & browser combinations. So, it is most widely used tool. Due to large combination of browsers & platforms, it take long time to display results.

5. IE Tester: Using this tool, you can test the web pages on various versions of IE on various Windows platforms like Windows Vista, Windows 7 & XP.

6. BrowserCam: This is a paid browser compatibility online testing tool. It’s trial usage allows you to test for 24 hours only with the screen limit of 200.

7. Cross Browser Testing: This is a perfect tool for testing the website for JavaScript, Ajax and Flash features on various browsers. It offers 1 week free trial. It is available @ http://crossbrowsertesting.com/

8. Cloud Testing: If you want to test your application’s browser compatibility on various browsers like IE, Firefox, Chrome, Opera, then this tool is for you.

Apart from these tools, there are few other tools like IE NetRenderer, Browsera, Adobe Browser Lab etc. By investing some time on RnD on these tools, you can save your huge effort with excellent Quality.

 Performance testing - It is performed to evaluate the performance of components of a particular system in a specific situation. It very wide term. It includes: Load Testing, Stress Testing, capacity testing, volume testing, endurance testing, spike testing, scalability testing and reliability testing etc. This type of testing generally does not give pass or fail. It is basically done to set the benchmark & standard of the application against Concurrency / Throughput, Server response time, Latency, Render response time etc. In other words, you can say it is technical & formal evaluation for responsiveness, speed, scalability and stability characteristics.
Load Testing is subset of performance testing. It is done by constantly increasing the load on the application under test till the time it reaches the threshold limit. The main goal of load testing is to identify the upper limit of the system in terms of database, hardware and network etc. The common goal of doing the load testing is to set the SLAs for the application. Example of load testing can be:
Running multiple applications on a computer simultaneously - starting with one application, then start second application, then third and so on....Now see the performance of your computer.
Endurance test is also a part of load testing which used to calculate metrics like Mean Time Between Failure and Mean Time to Failure.
Load Testing helps to determine:
  • Throughput
  • Peak Production Load
  • Adequacy of H/W environment
  • Load balancing requirements
  • How many users application can handle with optimal performance results
  • How many users hardware can handle with optimal performance results
Stress testing - It is done to evaluate the application's behaviour beyond normal or peak load conditions. It is basically testing the functionality of the application under high loads. Normally these are related to synchronization issues, memory leaks or race conditions etc. Some testing experts also call it as fatigue testing. Sometimes, it becomes difficult to set up a controlled environment before running the test. Example of Stress testing is:

A banking application can take a maximum user load of 20000 concurrent users. Increase the load to 21000 and do some transaction like deposit or withdraw. As soon as you did the transaction, banking application server database will sync with ATM database server. Now check with the user load of 21000 does this sync happened successfully. Now repeat the same test with 22000 thousand concurrent users and so on.
Spike test is also a part of stress testing which is performed when application is loaded with heavy loads repeatedly and increase beyond production operations for short duration.
Stress Testing helps to determine:
  • Errors in slowness & at peak user loads
  • Any security loop holes with over loads
  • How the hardware reacts with over loads
  • Data corruption issues at over loads