Software Testing Techniques
Published: 2024-05-13 10:42:59

Boundary Value Analysis:

Boundary value analysis is a type of functional testing, when you have an input domain, you need to check that it accepts valid data and sends error messages when it receives invalid data. Boundary analysis testing helps verify that functionality in an efficient way by building only the test cases required for comprehensive testing.

Benefits:

- Better software quality
- Increased test coverage
- Early defect detection
- Efficiency

Drawbacks:

- Narrow scope, Simplistic
- Assumptions
- Error
- Test case explosion

Example:
We have a box where the user can enter their birth year.
Boundary values are:
Minimum year = 1930
Maximum year = 2024

There are a total of six test cases:

1929, 1930, and 1931, which are below minimum, minimum, and above minimum, respectively
2023, 2024, and 2025, which are below the maximum, maximum, and above the maximum, respectively.

Decision Table Testing:

Decision Table Testing is a behaviour-based technique, used where different combinations of test input conditions result in different outcomes. When a system has complex business rules, then the decision table testing technique helps in identifying the correct test cases. As a result, it helps us to validate if the application/system can handle all the possible combinations of input data. The Decision Tables consists of ‘Input’ and ‘Outputs’ of a system. 

Once a decision table is made with all the combinations of condition and actions, the table is shrunk by deleting the following columns, to ensure that the table does not become vast.

- Impossible combinations of actions and conditions
- Possible, but infeasible combinations
- Combinations that do not affect the outcome.
- The minimum coverage for a decision table is at least one test case per a decision rule.
- Coverage percentage = The number of decision rules tested by at least one test case.

Example:		
Consider a ‘Login’ Page Functionality.
Rules are:	

- If ID & Password is correct, user should be able to login successfully.
- If any or both of the ID & Password are incorrect /blank. In such cases, it should show ‘Invalid Credentials’ message.

Here there are:

- 2 Inputs – UserID, Password
- 2 Outputs – Login Successfully, Error showing ‘Invalid Credentials’ 
- 3 Options — Blank, Valid, Invalid.

So, the total number of test cases are as follows:

1. Combination 1: Blank and invalid, Blank and Valid, Blank and Blank vice versa.
2. Combination 2: Valid and Invalid, Invalid and Invalid vice versa.
3. Combination 3: Valid and Valid.

So, as part of Decision Table Testing from each combination we will consider one possible combination.

Advantages:				

- Helps to identify all the important combinations of conditions.
- Identification of any gaps in the requirements is possible.

Limitations:		

- It is challenging when there are no well-designed requirements.
- The tables become more complex as the number of input values increase.

Use Case Testing:

Use Case Testing is a software testing technique that helps to identify test cases that cover entire system on a transaction by transaction basis from start to end. Use cases are made on the basis of user actions and the response of the software application to those user actions. Use case testing helps to identify gaps in software application that might not be found by testing individual software components.

Example:
Login functionality (with email and password) of a Web Application:
Step 1: User enters email and password.
Step 2: System will validate the password.
Step 3: If password is correct, the access will be granted.

There can be an extension of this use case.

- If password is not valid, system will display a message and ask for re-try.
- If Password, not valid for n number of times system will ban the IP address.

LCSAJ Testing:

LCSAJ stands for Linear Code Sequence and Jump. LCSAJ testing is used to determine the code coverage, i.e., what percentage of the code is executed with the existing test cases. It helps in designing new test cases, which can increase the coverage of the code under test. Once the code coverage reaches a certain level, we can stop the testing. Hence, LCSAJ methodology also helps in determining when to stop the testing of a software.

A single LCSAJ has the following three components:

- Start of the segment
- End of the segment
- A specific target line