Task 2 - Resubmission
Published: 2024-02-05 18:56:08

**Testing Techniques**
1.Boundary value Analysis(BVA) & Equivalence partition testing
2.Decision table testing
3.Use case testing


**Boundary value Analysis(BVA):**
Boundary value analysis is one of the test case design  techniques type in black box testing. This technique is used to find whether the application is accepting the expected range of values and there by rejecting the values which falls out of range, rather than focusing on only at the center of input  values. 

**Ex:** User ID text box has to accept alphabet characters (a-z), with length of maximum 4 to  10 characters length.

BVA will be performed as below. 

Alphabet character Length : 10  (Max values) : Pass
Alphabet character Length : 9   (Max values - 1) : Pass
Alphabet character Length : 11  (Max values + 1) : Fail
Alphabet character Length : 4 (Min values) : Pass
Alphabet character Length : 5  (Min values + 1) : Pass
Alphabet character Length : 3   (Min values - 1) : Fail

**Equivalence partition testing** is used to check the type of the input. This test case design is based on evaluation of equivalence classes of input condition. Equivalence class  means set of valid and invalid state of inputs.

**Ex:** User ID text box has to accept alphabet characters (a-z), with length of maximum 4 to  10 characters length.

**Under positive scenario: ** Text box should accept only (a-z) characters only.
**Under negative scenario:** Text box should not accept the characters other that (a-z), ie A-Z, 0-9, Spaces, Special characters etc.

**Decision table testing:**
Decision table testing is a black box test case design,  in which test cases are designed to execute the combinations of inputs shown in a decision table. Decision table testing approach is a good to deal with combinations of input, which has logical relationship between inputs. 

**Ex:** Login page validation Allow use to login only when both “Username” & “Password” is entered correctly. And if the information does not matches the user’s actual credentials, output with error message to be displayed to user.



![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ixwkkj1mu6e8i7sor7ka.png)

**Use case testing:**
Use case  testing is one of the black box testing techniques used for functional testing.
This technique helps tester to identify the test cases that covers the entire developed software application on each transactions from start to end. use case testing helps to identify gaps in system, that might not have been found by testing individual  software components.

Each use cases describes a specific use of the system by the user. Its is mostly used in developing test at system or acceptance level.

**Key elements of use cases:**

- Actors who will use with the system
- Use case diagram shows relations of the actors and use cases
- Use case scenarios.

**Ex:** Withdrawing money from ATM machine. 

Below are the use cases. 

**Use case 1:** Valid PIN
Insert card -> Validates card and asks for a PIN -> Enters a PIN -> Validates a Pin, and Allows access to the account. 

**Use case 2:**Pin not valid 1st 2 trials
Insert card -> Validates card and asks for a PIN -> Enters a PIN ->  Validates a Pin, and Pin not valid (Display message and ask for re-try – twice)

**Use case 3:** Pin invalid 3 times 
 Insert card -> Validates card and asks for a PIN -> Enters a PIN ->  Validates a Pin, and Pin not valid (Display message and ask for re-try ) -> Pin invalid 3 times (eat card and exit).

**Use case 4:** Card not valid
Insert card -> Validates card -> Card not valid (Display message and reject card)

**LCSAJ Testing :**
LCSAJ means “**Linear Code Sequence and Jump**” testing. It is a white-box testing technique. It helps in designing test cases, which can increase the coverage of the code under test. LCSAJ testing focus on verifying all code sequences and jumps within the code.
100% LCSAJ coverage means100% decision coverage

A single LCSAJ has  following components:
- Start of the segment, which can be a branch
- End of the segment, which can be the end of a branch
- specific line of linear code.


**Eg:**

1. Input X
2. Input Y
3. if X > Y:
4.     Print (“X is Bigger”)
5. else:
6.     Print (“Y is Bigger”)
7. Z = X + 7
8. Print Z


**Sequence 1:** Line 1 to 2
**Sequence2 :** Line 3 - 4
**Sequence 3:** Line 5  - 6
**Sequence 4:**  Line 7
**Sequence: 5:** Line 8


**Test Case 1:** I/P:  X= 1, Y= 2 (X >Y is False )
Test sequence executed: Sequence 1, sequence 3, Sequence 4, Sequence: 5.


**Test Case 2:** I/P:  X= 2, Y= 1 (X >Y is True)
Test sequence executed: Sequence 1, sequence 2, Sequence 4, Sequence: 5.

**Test Case 3:** IP:  X= 1, Y= 1 (X >Y is False)
Test sequence executed: Sequence 1, Sequence 4, Sequence: 5.