“Software Testing”

 

   Software testing is an activity to check whether the actual results and the expected results are matched and it should work as per the client requirements to ensure that the software is defect free software.

  Software testing is the process of finding errors in the developed product. It also checks whether the actual results can match expected results, as well as aids in the identification of defects, missing requirements, or gaps.

  Software testing is the process of checking the quality of software before launching to ensure that all requirements are fulfilled.

             Importance of Software Testing

 

  Identifies defects early: Developing complex applications can leave room for errors. Software testing is imperative, as it identifies any issues and defects with the written code so they can be fixed before the software product is delivered.

 

  Improves product quality: When it comes to customer appeal, delivering a quality product is an important metric to consider. An exceptional product can only be delivered if it's tested effectively before launch. Software testing helps the product pass quality assurance (QA) and meet the criteria and specifications defined by the users.

 

  Increases customer trust and satisfaction: Testing a product throughout its development lifecycle builds customer trust and satisfaction, as it provides visibility into the product's strong and weak points. By the time customers receive the product, it has been tried and tested multiple times and delivers on quality.

 

  Detects security vulnerabilities: Insecure application code can leave vulnerabilities that attackers can exploit. Since most applications are online today, they can be a leading vector for cyber attacks and should be tested thoroughly during various stages of application development. For example, a web application published without proper software testing can easily fall victim to a cross-site scripting attack where the attackers try to inject malicious code into the user's web browser by gaining access through the vulnerable web application. The nontested application thus becomes the vehicle for delivering the malicious code, which could have been prevented with proper software testing.

 

  Saves money: Software development issues that go unnoticed due to a lack of software testing can haunt organizations later with a bigger price tag. After the application launches, it can be more difficult to trace and resolve the issues, as software patching is generally more expensive than testing during the development stages.

                               

  Career as a Software Tester

 

  Software Testing is a critical field that ensures the quality and functionality of software before it reaches end-users. With a variety of job titles reflecting different specializations and levels of expertise, the career path for software testers is rich with opportunities for growth and development. From executing test cases to strategizing and leading quality assurance processes, these roles are essential in delivering reliable and efficient software products.

 

·       Junior Software Tester: An entry-level position, perfect for individuals starting their career in software testing. Junior Software Testers are typically responsible for executing basic test cases, reporting bugs, and learning the fundamentals of software quality assurance under the guidance of more experienced testers.

 

·       Software Tester: A foundational role in the software testing team, tasked with the hands-on work of identifying issues in software through manual testing or automated test scripts. Software Testers write detailed test cases, report defects, and work closely with developers to ensure software quality.

 

·       Senior Software Tester / Sr Test Engineer: With more experience, Senior Software Testers handle complex testing scenarios and often take on additional responsibilities such as test planning, mentoring junior testers, and contributing to the development of test strategies.

 

·       QA Lead / Test Lead: A leadership position within the testing team, QA Leads or Test Leads coordinate testing activities, manage a team of testers, and ensure that testing processes align with the project requirements and deadlines.

 

·       QA Manager / Test Manager: Responsible for overseeing the entire testing process, QA Managers or Test Managers strategize test plans, manage resources, and maintain the quality standards of software products. They also play a key role in interfacing with other departments and stakeholders.

 

·       Automation Test Engineer: Specializing in writing and maintaining automated test scripts, Automation Test Engineers focus on improving testing efficiency through automation tools and frameworks. They are instrumental in continuous integration and continuous delivery (CI/CD) pipelines.

 

·       Performance Test Engineer: Experts in assessing software performance, Performance Test Engineers design and execute performance tests to ensure software can handle expected load and stress conditions, providing insights into scalability and reliability.

 

·       Software Test Architect: A high-level role, Software Test Architects design and implement testing strategies and frameworks that guide the testing processes. They are responsible for the overall test infrastructure and ensuring that testing is effective and integrates well with development practices.

Each role within the software testing field brings its own set of challenges and requires a unique skill set. As technology evolves, so do these roles, offering a dynamic career path for professionals in the industry.

             

Types of software testing:-

 

Funtional Testing: Functional testing is a type of software testing that verifies the functionality of a software system or application. It focuses on ensuring that the system behaves according to the specified functional requirements and meets the intended business needs.

- The goal of functional testing is to validate the system’s features, capabilities, and interactions with different components. It involves testing the software’s input and output, data manipulation, user interactions, and the system’s response to various scenarios and conditions. Functional testing is only concerned with validating if a system works as intended.

 

Types: - Unit Testing, Integration testing, Smoke testing, UAT (User acceptance testing)

 

Non Functional testing: Non-Functional Testing is a type of testing used to evaluate a software application’s performance, usability, dependability, and other non-functional characteristics. It is intended to test a system’s readiness according to non-functional criteria that functional testing never considers

 

Types: - Performance, Load, Volume, usability, reliability etc.

 

Manual Testing: Manual Testing is a type of software testing where software tester executes the test cases manually without using any automation tools. Manual Testing is the most primitive of all testing types and helps find bugs in the software system. Any new application must be manually tested before its testing can be automated. Manual Testing does not require knowledge of any testing tool.

 

Manual testing process

The process of manual testing typically follows these stages:

1. Understanding requirements

It begins with a thorough analysis of what the software is intended to do. For example, grasping functional requirements and user expectations sets the stage for targeted testing.

2. Developing a test plan

Crafting a test plan is next, where QA developers outline their testing strategy, objectives, and necessary resources. This plan acts as a roadmap for the entire testing process.

3. Writing test cases

Test cases are scenarios created to test different aspects of the software. These should be comprehensive, covering a wide range of possible user interactions, and are designed to ensure that all functionalities are thoroughly tested.

4. Setting up the test environment

This step involves creating a realistic testing environment to ensure relevant and valuable results.

5. Executing test cases

This is a hands-on part of the process. QA developers manually interact with the software, executing test cases and observing responses and behaviors.

6. Logging defects

Any issues you encounter should be methodically documented, including steps to recreate the problem, its impact, and any other relevant observations.

7. Analyzing results and reporting

After the tests, QA developers analyze the findings, synthesizing them into reports that offer insights into the software's performance and potential areas for improvement.

8. Retesting and Regression testing

After fixing bugs, retesting is crucial to ensure the issues are resolved. Additionally, regression testing is conducted to confirm that new changes have not adversely affected existing functionalities.

Advantages of manual testing

Manual testing, an essential component of the software quality assurance process, offers several key advantages:

1. Human insight and intuition

Manual testing has a significant advantage over automated testing regarding the human element it brings to the table. Testers can use their experience and intuition to explore and evaluate the software in ways automated tests cannot. This human touch is beneficial in comprehending the user experience, pinpointing UI/UX issues, and providing feedback on the subjective aspects of the software, such as its appearance and feel.

2. Flexibility and adaptability

Manual testing allows testers to make quick changes in their testing approach as and when the software evolves. This flexibility is advantageous in the early stages of development, where features and requirements frequently change. Testers can adapt their test cases and approaches on the fly without the need for reprogramming or restructuring that automated tests would require.

3. Cost-effectiveness for small-scale projects

Manual testing can be more cost-effective for smaller projects or those with limited budgets. It doesn't require investment in automated testing tools and infrastructure, making it a viable option for startups or smaller teams with constrained resources.

4. Real-world application

Manual testing proves advantageous in scenarios where the user experience is paramount, such as in mobile application testing, where the feel of the application, gesture controls, and device-specific features are best evaluated manually.

      Limitations of manual testing

However, manual testing has limitations:

1. Time consumption and resource intensity

Manual testing can be significantly more time-consuming than automated testing, especially for large and complex applications. It requires more human resources, and the time taken to execute test cases manually can lead to longer development cycles.

2. Limitations in handling complex or large-scale testing scenarios

When dealing with complex or large-scale applications, manual testing may not be effective as testing every possible scenario or combination is infeasible, leading to gaps in test coverage.

3. Potential for human error

Given the repetitive and sometimes monotonous nature of manual testing, there is a higher risk of human error. Testers might overlook bugs or inconsistencies, especially when dealing with extensive testing scenarios.

4. Less effective in regression or performance testing

There are better approaches than manual testing for situations requiring repetitive testing (like regression testing) or high precision (like performance testing). In these cases, automated testing is often more efficient and reliable.

Goal of Manual Testing:-

 

- The key concept of manual testing is to ensure that the application is error free and it is working as per the client requirement.

- Test Suites or cases, are designed during the testing phase and should have 100% test coverage.

- It also makes sure that reported defects are fixed by developers and re-testing has been performed by testers on the fixed defects.

- Basically, this testing checks the quality of the system and delivers bug-free product to the customer.

 

Types of Manual Testing:-

 

1.     Black-Box Testing: Evaluate the performance and behavior of software from an end user's point of view. The tester only has visibility into the inputs and outputs, not the internal code structure. Black box testing is a software testing method in which testers evaluate the functionality of the software under test without looking at the internal code structure.

A black box testing will not consider the specifications of the code, and it will test the valid username and password to login to the right account. This form of testing technique will check the input and output.

 

The techniques of Black Box testing:

 

Equivalence Class Partitioning: Equivalence partitioning or equivalence class partitioning is a software  testing technique that divides the input data of a software unit into partitions of equivalent data from which test cases can be derived. In principle, test cases are designed to cover each partition at least once. The idea behind the technique is to divide or partition a set of test conditions into groups or sets that can be considered the same or equivalent, hence ‘equivalence partitioning’.

 

Message Box: The message box will accept only from “1 – 500” inputs. 

It can be numbers 1, 2, 3,4,5,6 etc 

It can be alphabets: ABCDFRGTTGGHTHTTHYYYHJJ etc

 

  Invalid        |                Valid                           |   Invalid

0, -1, -5,-20   |    1, 20, 50, 40, 100, 150, 500    | 501, 502, 505 1000

 

2) Boundary Value Analysis: It is based on testing on and around the boundaries between partitions. If you have done “range checking”, you were probably using the boundary value analysis technique.

“Mobile No: “8237867723”

Testers can identify that a system has a special response around a specific boundary value.

 

3) Decision table: Decision table testing is a software testing technique used to test system behaviour for different input combinations. This is a systematic approach where the different input combinations and their corresponding system behaviour (Output) are captured in a tabular form.

 

Example 1: How to make decision base table for login screen

 

Let's create a decision table for a login screen.

 

                          

 

The condition is simple if the user provides correct username and password the user will be redirected to the homepage. If any of the input is wrong, an error message will be displayed.

 

           

 

T – Correct username/password

F – Wrong username/password

E – Error message is displayed

H – Home screen is displayed

 

Interpretation:

Case 1 – Username and password both were wrong. The user is shown an error message.

Case 2 – Username was correct, but the password was wrong. The user is shown an error message.

Case 3 – Username was wrong, but the password was correct. The user is shown an error message.

Case 4 – Username and password both were correct, and the user navigated to homepage

 

While converting this to test case, we can create 2 scenarios,

- Enter correct username and correct password and click on login, and the expected result will be the user should be navigated to homepage

And one from the below scenario

- Enter wrong username and wrong password and click on login, and the expected result will be the user should get an error message

- Enter correct username and wrong password and click on login, and the expected result will be the user should get an error message

- Enter wrong username and correct password and click on login, and the expected result will be the user should get an error message

 

Advantages of Decision Table Testing

 

- When the system behaviour is different for different input and not same for a range of inputs, both equivalent partitioning, and boundary value analysis won't help, but decision table can be used.

- The representation is simple so that it can be easily interpreted and is used for development and business as well.

- This table will help to make effective combinations and can ensure a better coverage for testing

- Any complex business conditions can be easily turned into decision tables

- In a case we are going for 100% coverage typically when the input combinations are low, this technique can ensure the coverage.

 

Disadvantages of Decision Table Testing

 

The main disadvantage is that when the number of input increases the table will become more complex.

 

4 - State transition: State Transition testing is defined as the software testing technique in which changes in input conditions cause's state changes in the Application under Test (AUT). It is a black box testing technique in which the tester analyzes the behaviour of an application under test for different input conditions in a sequence.

 

When to Use State Transition?

- This can be used when a tester is testing the application for a finite set of input values.

- When the tester is trying to test sequence of events that occur in the application under test. I.e., this will allow the tester to test the application behavior for a sequence of input values.

- When the system under test has a dependency on the events/values in the past.

- When to Not Rely On State Transition?

- When the testing is not done for sequential input combinations.

 

If the testing is to be done for different functionalities like exploratory testing

Four Parts of State Transition Diagram

 

There are 4 main components of the State Transition Model as below

 

1) States that the software might get

2) Transition from one state to another

3) Events that origin a transition like closing a file or withdrawing money

4) Actions that result from a transition (an error message or being given the cash.)

 

 

State Transition Diagram and State Transition Table

 

There are two main ways to represent or design state transition, State transition diagram, and state transition table.

In state transition diagram the states are shown in boxed texts, and the transition is represented by arrows. It is also called State Chart or Graph. It is useful in identifying valid transitions.

In state transition table all the states are listed on the left side, and the events are described on the top. Each cell in the table represents the state of the system after the event has occurred. It is also called State Table. It is useful in identifying invalid transitions.

 

How to Make a State Transition (Examples of a State Transition)

 

Example 1:

Let's consider an ATM system function where if the user enters the invalid password three times the account will be locked.

In this system, if the user enters a valid password in any of the first three attempts the user will be logged in successfully. If the user enters the invalid password in the first or second try, the user will be asked to re-enter the password. And finally, if the user enters incorrect password 3^rd time, the account will be blocked.

State transition diagram

In the diagram whenever the user enters the correct PIN he is moved to Access granted state, and if he enters the wrong password he is moved to next try and if he does the same for the 3^rd time the account blocked state is reached.

 

State Transition Table:

State Transition	Correct PIN	Incorrect PIN
S1) Start
S2) 1st attempt	S5	S3
S3) 2nd attempt	S5	S4
S4) 3rd attempt	S5	S6
S5) Access Granted	-	-
S6) Account blocked	-	-

 

In the table when the user enters the correct PIN, state is transitioned to S5 which is Access granted. And if the user enters a wrong password he is moved to next state. If he does the same 3^rd time, he will reach the account blocked state.

 

Myths of Manual Testing

 

Myth: Anyone can do manual testing

Fact: Testing requires many skill sets

 

Myth: Testing ensures 100% Defect free product

Fact: Testing attempts to find as many defects as possible. Identifying all possible defects is impossible.

 

Myth: Automated testing is more powerful than manual testing

Fact: 100% test automation cannot be done. Manual Testing is also essential.

 

Myth: Testing is easy

Fact: Testing can be extremely challenging. Testing an application for possible use cases with minimum test cases requires high analytical skills.

 

2.     White-Box Testing: Evaluate the security and functionality of the product in more detail. This testing is performed by a developer or QA professional with an understanding of the internal code behind the software.

 

White box Testing techniques:

-        Statement Coverage: This is like making sure you read every sentence in a book. In code, it means ensuring every line or statement of the code is executed at least once during testing.

-        Branch Coverage: This is like choosing every possible outcome in a “Choose Your Own Adventure” book. In code, it means testing every possible outcome of the code’s decision points (like if-else conditions).

-        Path Coverage: This is like reading a book’s possible combination of chapters. In code, it means testing every possible path through the code from start to finish.

-        Condition Coverage: This is like checking every possible answer to a question in a book. In code, it means testing every possible outcome of logical conditions in the code.

-        Decision/Condition Coverage: This is like checking every possible combination of answers to multiple questions in a book. In code, it means testing every possible combination of outcomes in logical decisions (like a condition with and logic) in the code.

 

Automation Testing: Automation Testing means with using any automation tool to test the application and execute your test cases. Using a test automation tool, it's possible to record this test suite and re-play it as required. Once the test suite is automated, no human intervention is required.

- The goal of Automation is to reduce the number of test cases to be run manually and not to eliminate

 

Automated software testing is important due to the following reasons:

 

- Manual Testing of all workflows, all fields, and all negative scenarios is time and money consuming

- Automation does not require Human intervention.

- Automation increases the speed of test execution

- Automation helps increase Test Coverage

- Manual Testing can become boring and hence error-prone.

 

Which Test Cases to Automate?

 

- High Risk - Business Critical test cases

- Test cases that are repeatedly executed.

- Test Cases that are very tedious or difficult to perform manually.

 

Note: One of the Software Testing Fundamental is "100% Automation is not possible".

 

The following category of test cases are not suitable for automation

 

- Test Cases for which the requirements are frequently changing

- Test cases which are executed on an ad-hoc basis.

 

Manual Testing vs Automation Testing

 

Manual Testing	Automated Testing
Manual testing requires human intervention for test execution.	Automation Testing is use of tools to execute test cases
Manual testing will require skilled labour, long time & will imply high costs.	Automation Testing saves time, cost and manpower. Once recorded, it's easier to run an automated test suite
Any type of application can be tested manually, certain testing types like ad-hoc and monkey testing are more suited for manual execution.	Automated testing is recommended only for stable systems and is mostly used for Regression Testing
Manual testing can become repetitive and boring.	The boring part of executing same test cases time and again is handled by automation software in Automation Testing.

 

Automation Testing Tools:

 

1- SELENIUM is a free (open-source) automated testing framework used to validate web applications across different browsers and platforms. You can use multiple programming languages like Java, etc. Testing done using the Selenium tool is usually referred to as Selenium Testing.

 

-        Selenium Integrated Development Environment (IDE)

-        Selenium Remote Control (RC)

-        Web Driver

-        Selenium Grid

 

2- QTP :  QTP (Quick test Professional) is an automated functional Testing tool that helps testers to execute automated tests in order to identify any errors, defects or gaps in contrary to the expected results of the application under test. It was designed by Mercury Interactive and later on acquired by HP and now Micro Focus.

 

3- Cypress: Cypress is a purely JavaScript-based front-end testing tool built for the modern web. It aims to address the pain point’s developers or QA engineers face while testing an application. Cypress is a more developer-friendly tool that uses a unique DOM manipulation technique and operates directly in the browser.

 

4- J-meter: The Apache JMeter™ application is open source software, a 100% pure Java application designed to load test functional behaviour and measure performance. It was originally designed for testing Web Applications but has since expanded to other test functions.

 

5- Loadrunner:  Loadrunner from Micro Focus is the most widely used Load Testing tool. Performance Test Results produced by Loadrunner are used as a benchmark against other tools.

 

 

3.     Gray Box Testing: Gray Box Testing is a software testing technique which is a combination of Black Box Testing technique and White Box Testing technique.

In Black Box Testing technique, tester is unknown to the internal structure of the item being tested and in White Box Testing the internal structure is known to tester.

The internal structure is partially known in Gray Box Testing. This includes access to internal data structures and algorithms for purpose of designing the test cases.

Gray Box Testing is named so because the software program is like a semi-transparent or grey box inside which tester can partially see. It commonly focuses on context-specific errors related to web systems.

 

Gray Box Testing is performed for the following reason,

 

- It provides combined benefits of both black box testing and white box testing both

- It combines the input of developers as well as testers and improves overall product quality

- It reduces the overhead of long process of testing functional and non-functional types

- It gives enough free time for a developer to fix defects

- Testing is done from the user point of view rather than a designer point of view

Objective of Gray Box Testing:

        The objective of Gray Box Testing is:

To provide combined advantages of both black box testing and white box testing.

To combine the input of developers as well as testers.

To improve overall product quality.

To reduce the overhead of long process of functional and non-functional testings.

To provide enough free time to developers to fix defects.

To test from the user point of view rather than a designer point of view.

 

Advantages of Gray Box Testing:-

 

- Users and developers have clear goals while doing testing.

- Gray box testing is mostly done by the user perspective.

- Testers are not required to have high programming skills for this testing.

- Gray box testing is non - Intrusive.

- Overall quality of the product is improved.

- In gray box testing, developers have more time for defect fixing.

- By doing gray box testing, benefits of both black box and white box testing is obtained.

- Gray box testing is unbiased. It avoids conflicts between a tester and a developer.

- Gray box testing is much more effective in integration testing.

 

Disadvantages of gray box testing:

 

- Defect association is difficult when gray testing is performed for distributed systems.

- Limited access to internal structure leads to limited access for code path traversal.

- Because source code cannot be accessed, doing complete white box testing is not possible.

- Gray box testing is not suitable for algorithm testing.

- Most of the test cases are difficult to design.

 

Black Box Testing	White Box Testing
It can be referred as outer or external software testing	It is the inner or the internal software testing.
It is functional test of the software.	It is structural test of the software.

 

Qualities to be a software tester:

 

1-     Tester should be open Minded.

2-     Tester should understand the Priorities.

3-     Asking Questions

4-     As a tester you should be a Quick Learner.

5-     Questions can be asked

6-     To understand requirement.

7-     To understand changes done

8-     To understand how requirement has been implemented

9-     To understand how the bug fixed.

10-  To understand bug fix effects.

11-  To understand the product from other perspectives like development, business, etc.

12-  You are good at Reporting.

13-  You are Flexible to Support whenever it’s required.

14-  You Are a Constant Learner.

15-  You Can Wear End User’s Shoes.

16-  You are a good tester only when you can understand your customers Positive Attitude.

17-  Good Communication.

18-  Multi-Tasking Abilities.

19-  Generate and execute test ideas.

20-  Design test cases.

21-  Quick Learner, Passion For Testing, Think and act as an End-user.

 

What is Error, Defect, Bug and failure?

 

Interview question:

A mistake in coding is called Error,

Error found by tester is called Defect,

Defect accepted by development team then it is called Bug,

Build does not meet the requirements then it Is Failure.”