DEV Community: gokila selvaraj

Python Selenium Architecture

gokila selvaraj — Sun, 05 Oct 2025 15:51:30 +0000

*Python Selenium Architecture *

The Selenium architecture defines how your Python test script interacts with the browser using Selenium WebDriver.

It consists of four main components:

Components of Selenium Architecture

*Selenium Client Library *
• Selenium provides libraries for multiple languages: Python, Java, C#, Ruby, JavaScript, etc.
• Testers write test scripts using the Python Selenium library (selenium package).
• Example:
• from selenium import webdriver
• driver = webdriver.Chrome()
• driver.get("https://www.google.com")
This script is written in Python, but Selenium converts it into a form the browser understands.
JSON Wire Protocol / W3C WebDriver Protocol

• Acts as a communication bridge between your Python script and the browser driver.
• Your Python commands are converted into JSON (JavaScript Object Notation) format and sent to the browser driver via HTTP.
• Example:
o Python command: driver.get("https://www.google.com")
o Is converted to a JSON request, sent to the ChromeDriver, telling it to open the page.

Browser Drivers

• Each browser has its own driver that communicates between Selenium and the actual browser:
o Chrome → ChromeDriver
o Firefox → GeckoDriver
o Edge → EdgeDriver
o Safari → SafariDriver
• The driver receives commands in JSON format from Selenium and translates them into native browser actions.
• Communication happens through HTTP requests on a specific port.

Real Browsers

• Finally, the browser executes those actions:
o Open a URL
o Click a button
o Enter text
o Capture screenshots
• The browser performs the operation and sends the response (status or error message)
back through the same route:

• Browser → Browser Driver → JSON Response → Selenium Client Library → Python Script
Selenium Architecture Flow Diagram
Python Test Script
↓
Selenium Client Library (Python Bindings)
↓
JSON Wire / W3C WebDriver Protocol
↓
Browser Driver (e.g., ChromeDriver)
↓
Web Browser (e.g., Chrome)

Response Path (Back):

Web Browser → Browser Driver → JSON Response → Selenium Library → Python Script

driver.find_element("id", "loginBtn").click()

step-by-step:

The Python Selenium library sends a command: click element with ID 'loginBtn'.
It is converted into JSON format and sent via HTTP to the browser driver.
ChromeDriver receives it and tells the Chrome browser to perform a click.
The browser performs the click and sends a success response back to Selenium.

Significance of the Python Virtual Environment

A Python virtual environment is an isolated workspace that allows you to install and manage Python packages independently for each project — without affecting your system-wide (global) Python installation.

It helps developers and testers maintain different versions of Python libraries for multiple projects on the same system.

Example:

Project A (OrangeHRM Automation): needs selenium==4.10.0

Project B (Banking Automation): needs selenium==4.5.0

If both use the same global Python, there’ll be a version conflict.
With virtual environments, both can coexist peacefully:

Component-Role
Selenium Client Library-Converts Python commands into JSON
JSON Wire/W3C Protocol-Defines the communication standard
Browser Driver-Translates JSON commands into browser actions
Browser-Executes user actions (click, type, etc.)

Benefit:

Benefit-Description
Isolation-Keeps dependencies separate per project
Reproducibility-Ensures same package versions across systems
Stability-Prevents conflicts with global Python packages
Portability-Easy to share via requirements.txt

Manual Testing Techniques

gokila selvaraj — Sun, 05 Oct 2025 15:21:59 +0000

1️⃣ Common Manual Testing Techniques:
Manual testing techniques help testers create effective test cases to find defects without using automation tools.
A. Equivalence Partitioning (EP)
• Definition: Divide input data into valid and invalid groups so that testing one value from each group is enough.
• Example:
Suppose a form accepts ages 18 to 60.
o Valid partition: 18–60 → test with 25
o Invalid partitions: <18 and >60 → test with 17 and 61
This reduces test cases while maintaining coverage.

B. Boundary Value Analysis (BVA)
• Definition: Test values at the edges of valid and invalid input ranges since most errors occur at boundaries.
• Example:
For input range 1–100:
Test with 0, 1, 2, 99, 100, and 101
→ Ensures correct handling at lower and upper limits.

C. Decision Table Testing
• Definition: Test all possible combinations of inputs and conditions using a table.
• Example:
A loan system grants approval only if both conditions are true:

o Salary > ₹50,000
o Experience > 5 years

Rule Salary > 50k Experience > 5 Loan Approved

1 No No No
2 Yes No No
3 No Yes No
4 Yes Yes ✅ Yes

• → This ensures you don’t miss any logical combinations.

D. State Transition Testing

• Definition: Test how the system behaves when it moves between different states.
• Example:
ATM System:

o State 1: Card Inserted → Enter PIN → Withdraw → Card Ejected.

You test transitions like:

o Enter wrong PIN 3 times → Card Blocked (Invalid transition)
o Enter correct PIN → Proceed (Valid transition)

E. Error Guessing

• Definition: Based on the tester’s experience and intuition to find common errors.
• Example:
o Entering blank username/password fields
o Typing special characters in numeric fields
o Uploading invalid file formats

2️⃣ Boundary Value Analysis (BVA)

A black-box testing technique where testers focus on values at boundaries of input domains.

Example:
An online exam system accepts marks between 0 and 100.
• Test inputs: -1, 0, 1, 99, 100, 101
• Expected results:
o -1 → Invalid (below range)
o 0 → Valid (minimum)
o 1 → Valid
o 99 → Valid
o 100 → Valid (maximum)
o 101 → Invalid (above range)
Why use it?

Because developers often make off-by-one errors, and these are caught only by testing boundary conditions.

3️⃣ Decision Table Testing

Definition:
A systematic way to test all combinations of conditions and actions in business logic using a decision matrix.

Example:
For an online discount rule:
• Condition 1: Customer is a member
• Condition 2: Purchase amount > ₹5000

Rule Member Amount > 5000 Discount (%)
1 No No 0
2 Yes No 5
3 No Yes 10
4 Yes Yes 15

→ Ensures all logical rules are verified.
When to Use:
When multiple conditions determine the outcome (e.g., banking, insurance, or e-commerce systems).

4️⃣ The Future of Manual Testing in the Age of AI
Current Trend:

AI and automation are revolutionizing testing, but manual testing is still important for human judgment, creativity, and usability validation.
Automation vs Manual Testing:
Area Automation/AI Strength Manual Testing Strength
Repetitive Regression Tests Fast and consistent Not efficient
Exploratory Testing Limited context Deep insight & creativity
UI/UX Feedback Detects layout issues Understands user emotions
Complex Business Scenarios Needs rules to learn Humans adapt easily

Example:
• AI Testing: Can detect if a button is missing.
• Manual Tester: Can say “The button placement confuses users.”

selenium

gokila selvaraj — Sun, 05 Oct 2025 15:09:16 +0000

What is selenium?
Selenium is a widely used tool for testing web-based applications that checks if they are working as expected. It is a primary preference amongst testers for cross-browser testing and is viewed as one of the most reliable systems for web application automation evaluation.
Selenium has four Components of Selenium components, which are
1) Selenium IDE
2) Selenium RC
3) Selenium Web-Driver
4) Selenium GRID
Selenium is an open-source tool for automating web browsers. It helps to test the website functionality easily and check the regular performance across different browsers and systems through cross-browser testing .
•Automated Web Application Testing: Selenium is mainly used for the automation testing of web applications across different browsers and platforms.
•Cross-Browser Testing: It checks the compatibility of web applications across various web browsers like Chrome, Firefox, Safari, and Edge.
•Web Scraping: Automates the filter of the data from websites for purposes such as data analysis and monitoring with easy automation.
•Continuous Integration/Continuous Deployment (CI/CD): Integrates with CI/CD tools like Jenkins to enable continuous testing as part of the development pipeline and automation.
•Functional Testing: It checks the functionality of a web application against the specified requirements of the browser.

Why we use selenium Testing in Automation?

Language and Framework Support
Open Source Availability
Multi-Browser Support
Support Across Various Operating Systems
Ease Of Implementation
Reusability and Integrations
Flexibility
Parallel Test Execution and Faster Go-to-Market
Less Hardware Usage
Easy to Learn and Use
Constant Updates

What is relevance the selenium automation testing using python?

prefer Python for writing Selenium test scripts because of its simplicity, readability, and ease of use. Python’s clear and concise syntax allows for faster script development and easier maintenance, which is crucial in testing scenarios.

Additionally, Python has a rich set of libraries and frameworks that complement Selenium, making it easier to handle complex tasks such as data manipulation, reporting, and integration with other tools.

Python’s extensive community support and documentation also provide valuable resources for troubleshooting and improving test scripts. These factors make Python a popular choice for Selenium automation.

SELENIUM ARCHITECTURE/PYTHON VIRTUAL ENVIRONMENT

gokila selvaraj — Sun, 13 Oct 2024 11:00:47 +0000

**What is Selenium WebDriver?
Selenium WebDriver is a powerful automation tool used for testing web applications across different browsers and platforms. It provides a programming interface to interact with web elements and perform various actions such as clicking buttons, entering text, navigating pages, and validating elements. Unlike Selenium RC, WebDriver directly communicates with the browser using native methods, making it faster and more reliable. WebDriver supports multiple programming languages like Java, Python, C#, etc., making it versatile for developers and testers.

It also enables parallel testing, allowing multiple test cases to run simultaneously across different browsers, improving efficiency and reducing testing time.
WebDriver’s architecture includes a client library, WebDriver API, browser drivers, and the actual browsers, ensuring seamless automation and accurate testing results.

Architecture of Selenium WebDriver (Selenium 3):

The architecture of Selenium WebDriver in Selenium 3 follows a client-server model. Selenium provides client libraries for different programming languages like java, Python, Ruby, etc. These libraries’ aim is to allow Selenium WebDriver to interact with the control browser. JSON Protocol acts as a communication bridge between the client libraries and browser drivers. Client libraries send commands in JSON format over HTTP requests. Browser drivers understand the JSON wire Protocol and translate the commands into action within the browser.

Components of Selenium 3 WebDriver

Selenium Client Library: This component provides language-specific bindings or APIs (java, Python, Ruby, etc. ) that allow users to write test scripts and interact with the WebDriver.
JSON Wire Protocol over HTTP: The JSON Wire Protocol is a standardized protocol used for communication between the Selenium Client Library and the Browser Drivers. It defines a set of commands and responses in JSON format exchanged over HTTP requests.

Browser Drivers: These are executable files that establish a communication channel between the WebDriver and the actual web browsers such as Chrome, Firefox, Safari, etc. Each browser requires its specific driver (e.g., ChromeDriver, GeckoDriver, etc.) to enable WebDriver to control and automate browser actions.

Real Browsers: These are web browsers like Google Chrome, Mozilla Firefox, Microsoft Edge, etc., where the actual testing and automation take place. The WebDriver interacts with these browsers through their respective browser drivers to perform actions like clicking elements, filling forms, navigating pages, and validating content.

Working of Selenium 3 WebDriver:

1)Write a test script using the Selenium client library in your preferred language.
2)The test script sends commands through the client library to interact with the browser.
3)The client library converts commands into JSON format and sends them via HTTP request.
4)The browser driver decodes JSON commands and interacts with the real web browser.
5)Browser performs actions (e.g., clicking buttons, entering text) on the web page based on the received commands.

Architecture of Selenium 4 WebDriver:

Selenium four brings significant improvements to the architecture, often with the introduction of the W3C WebDriver Protocol. This protocol standardizes interactions between the purchaser and server, selling higher compatibility and consistency across one-of-a-kind implementations. Moreover, Selenium 4 affords a better guide for present-day net technology and progressed overall performance.

The architecture of Selenium 4 WebDriver has made a key change compared to Selenium 3 which is a communication protocol. Like Selenium 3, Selenium 4 offers client libraries for various programming languages, which help WebDriver interact with the browser.

WebDriver W3C protocol is the major change in Selenium 4 as it completely replaces JSON Protocol which was in Selenium 3.

The WebDriver W3C Protocol is defined by the World Wide Web Consortium (W3C) that ensure better compatibility and stability on different browsers and client libraries.

Components of Selenium 4 WebDriver:

Selenium Client Library: This component provides language-specific bindings or APIs (e.g., Java, Python, Ruby) that allow users to write test scripts and interact with the WebDriver.
WebDriver W3C Protocol: WebDriver is a protocol that provides a standard way for web browsers to communicate with an automation script. In Selenium 4, it focuses on W3C WebDriver Protocol, for better consistency and compatibility across different browsers.

Working of Selenium 3 WebDriver:

1)Write your test script using the Selenium client library in your comfortable language.
2)The test script sends commands through the client library to interact with the browser.
3)Client library converts commands into WebDriver W3C Protocol format.
4)The browser driver receives commands via WebDriver W3C Protocol.
5)Browser drivers understand commands and interact with real web browsers.

Difference between Architecture of Selenium 3 & Selenium 4
**
**Selenium 3 :

1)JSON wire web driver protocol
2)client-server model communication
3)Limited browser Compatibility
4)Moderate performance
5)Limited Support for Modern Web Tech
6)Interactions with Browser(e.g., Gecko Driver, Chrome driver)
7)Limited future-proofing with reliance on browser-specific implementations.

**Selenium 4:**

1)W3C WebDriver Protocol
2)client-server model communication
3)improved browser Compatibility
4)improved performance
5)Better Support for Modern Web Tech
6)Interactions with Browser(e.g., Gecko Driver, Chrome driver)
7)Improved future-proofing with reliance on browser-specific implementations.

***Python Virtual Environment:*

1)It is sandboxing of the Python projects
2)It is a module which helps us to keep the required dependencies of a particular project separated by creating an isolated environment.

For that you need to install Python “virtualenv” module system wide

Install Python Virtual Environment:

Pip install virtualenv

Verify Python Virtual Environment

Virtualenv --version

Create Virtual Environment

It will create a project folder

_virtualenv

Activate Virtual Environment

Scripts\activate

Deactivate Virtual Environment

Scripts\deactivate

Install Python Selenium Module

_pip install seleniu_m

Install Python WebDriver Manager Module

pip install webdriver-manager

What is selenium ? why do we use in Automation?

gokila selvaraj — Sun, 13 Oct 2024 07:14:39 +0000

Selenium is a popular open-source tool used for automating web browser interactions. It allows developers and testers to write scripts that simulate user actions like clicking buttons, entering text, navigating between web pages, and interacting with various web elements. Selenium supports multiple programming languages (such as Python, Java, C#, and JavaScript) and can be integrated with various testing frameworks for seamless automation.

Key Reasons for Using Selenium in Automation:

Cross-Browser Testing:

Selenium supports multiple browsers like Chrome, Firefox,
Safari, and Edge. This allows you to automate web testing across
different browsers to ensure consistent behavior.

Supports Multiple Operating Systems:

Selenium runs on various operating systems, including Windows,
Linux, and macOS, which makes it versatile for cross-platform
testing.

Integration with Test Frameworks:

Selenium can be integrated with various test frameworks like
TestNG, JUnit, and PyTest, allowing developers to organize and
manage test cases efficiently.

Parallel Execution:

Selenium Grid allows you to run tests in parallel on different
machines and browsers, significantly reducing testing time.

Easy to Use for Web Testing:

Selenium interacts directly with the browser's DOM, which means it can handle complex web applications, including dynamic content and AJAX.

Supports Multiple Languages:

Selenium provides bindings for several languages, which means you can write tests in your preferred programming language (Python, Java, C#, etc.).

Handles Dynamic Elements:

Selenium can handle dynamic web elements that change without page reloads (e.g., AJAX-based elements).

Free and Open Source:

Selenium is completely free and supported by a large community, making it a cost-effective option for automation testing.

Browser Compatibility:

Selenium ensures that web applications function consistently across different browsers, versions, and platforms, helping in identifying browser-specific bugs.

By automating repetitive and time-consuming manual tasks (such as regression tests), Selenium helps increase productivity, improve testing accuracy, and enable continuous integration/continuous deployment (CI/CD) workflows.

*Advantages of Selenium Testing *
Selenium automated testing comes with several benefits, such as:

1)Selenium has proven to be accurate with results thus making it extremely reliable.

2)Since selenium is open-source, anybody willing to learn testing can begin at no cost.

3)Selenium supports a broad spectrum of programming languages like Python, PHP, Perl, and Ruby.

4)Selenium supports various browsers like Chrome, Firefox, and Opera, among others.

5)Selenium is easy to implement and doesn’t require the engineer to have in-depth knowledge of the tool.

6)Selenium has plenty of re-usability and add-ons

limitations of Selenium testing.

1)Since Selenium is open-source, it doesn’t have a developer community and hence doesn’t have a reliable tech support.

2)Selenium cannot test mobile or desktop applications.

3)Selenium offers limited support for image testing.

4)Selenium has limited support for test management. Selenium is often integrated with tools like JUnit and TestNG for this purpose.

TESTING TECHNIQUES

gokila selvaraj — Tue, 04 Jun 2024 08:03:23 +0000

1)BOUNDARY VALUE ANALYSIS:

Boundary Value Analysis is based on testing the boundary values of valid and invalid partitions. The behavior at the edge of the equivalence partition is more likely to be incorrect than the behavior within the partition, so boundaries are an area where testing is likely to yield defects.

It checks for the input values near the boundary that have a higher chance of error. Every partition has its maximum and minimum values and these maximum and minimum values are the boundary values of a partition.

1.A boundary value for a valid partition is a valid boundary value.
2.A boundary value for an invalid partition is an invalid boundary value.

For each variable we check-

1.Minimum value.
2.Just above the minimum.
3.Nominal Value.
4.Just below Max value.
5.Max value.

Example: Consider a system that accepts ages from 18 to 56.
Boundary Value Analysis(Age accepts 18 to 56)

Invalid

(min-1)
17

Valid

(min, min + 1, nominal, max – 1, max)

18, 19, 37, 55, 56

Invalid

(max + 1)

Valid Test Cases: Valid test cases for the above can be any value entered greater than 17 and less than 57.

Enter the value- 18.
Enter the value- 19.
Enter the value- 37.
Enter the value- 55.
Enter the value- 56.
Invalid Cases: When any value less than 18 and greater than 56 is entered.

Enter the value- 17.
Enter the value- 57.

2)Decision table technique in Black box testing:

The decision table technique is one of the widely used case design techniques for black box testing. This is a systematic approach where various input combinations and their respective system behavior are captured in a tabular form.

That's why it is also known as a cause-effect table. This technique is used to pick the test cases systematically; it saves testing time and gives good coverage to the testing area of the software application.

Decision table technique is appropriate for the functions that have a logical relationship between two and more than two inputs.

This technique is related to the correct combination of inputs and determines the result of various combinations of input. To design the test cases by decision table technique, we need to consider conditions as input and actions as output.

EXAMPLE:
Most of us use an email account, and when you want to use an email account, for this you need to enter the email and its associated password.

If both email and password are correctly matched, the user will be directed to the email account's homepage; otherwise, it will come back to the login page with an error message specified with "Incorrect Email" or "Incorrect Password."

Now, let's see how a decision table is created for the login function in which we can log in by using email and password. Both the email and the password are the conditions, and the expected result is action.

EMAIL (1) T T F F

PASSWORD (2) T F T F

EXPECTED RESULT ACCOUNT PAGE INCORRECT INCORRECT INCORRECT
(ACTION ) PASSWORD EMAIL EMAIL

In the table, there are four conditions or test cases to test the login function. In the first condition if both email and password are correct, then the user should be directed to the account's Homepage.

In the second condition if the email is correct, but the password is incorrect then the function should display Incorrect Password. In the third condition if the email is incorrect, but the password is correct, then it should display Incorrect Email.

Now, in fourth and last condition both email and password are incorrect then the function should display Incorrect Email.

In this example, all possible conditions or test cases have been included, and in the same way, the testing team also includes all possible test cases so that upcoming bugs can be cured at testing level.

To find the number of all possible conditions, the tester uses 2n formula where n denotes the number of inputs; in the example, there is the number of inputs is 2 (one is true and the second is false).

Number of possible conditions = 2^ Number of Values of the second condition
Number of possible conditions =2^2 = 4

While using the decision table technique, a tester determines the expected output, if the function produces expected output, then it is passed in testing, and if not then it is failed. Failed software is sent back to the development team to fix the defect.

3)USE CASE TESTING:

Use case testing is a type of black box testing technique that helps you to identify test cases that form part of the entire system on a transaction basis from start to finish. It is used for functional testing to find defects in a developed system.

It is important in identifying gaps related to your software application that could have been missed during component testing. With use case testing, you can determine the software quality through end to end testing methodology.

Below are a few characteristics of use case testing.

It helps to organize the functional requirements so that requirements can be referred to when required.
Describes the main flow and alternate flow of events.
Captures the goals and behavior requirements of different actors.
Capture the paths or scenarios for better system understanding.

One example of a use case in software testing is conducting regression testing. This involves retesting previously implemented features to ensure that recent changes or bug fixes haven't introduced new issues. It helps maintain the overall quality and stability of the software during development and updates.

4)LCSAJ TESTING:

LCSAJ stands for Linear Code Sequence and Jump. LCSAJ testing is a white-box testing methodology 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 software.

White-box testing is a software testing technique in which we test the internal structure and the software code under test.

A single LCSAJ has the following three components:

Start of the segment, which can be a branch or the start of the program
The end of the segment, which can be the end of a branch or the end of the program.
A specific target line

The code executes sequentially from the start of the segment until the end of the segment, and then the control flow breaks the sequential execution and jumps to the target line.

                     #START#
                       .
                       .
                       .
                       . (SEQUENTIAL EXECUTION)
                       .

                      #END#
                       .
                       .
                       . (CONTROL FLOW JUMPS)
                       .

                    #TARGET
                     LINE#

what is manual testing, Benefits and drawbacks of manual testing?

gokila selvaraj — Tue, 04 Jun 2024 06:55:54 +0000

MANUAL TESTING:

Manual testing is a software testing process in which test cases are executed manually without using any automated tool. All test cases are executed by the tester manually according to the end user's perspective. It ensures whether the application is working, as mentioned in the requirement document or not. Test cases are planned and implemented to complete almost 100 percent of the software application. Test case reports are also generated manually.
Manual Testing is one of the most fundamental testing processes as it can find both visible and hidden defects of the software. The difference between the expected output and the output, given by the software, is defined as a defect. The developer fixed the defects and handed it to the tester for retesting.
Manual testing is mandatory for every newly developed software before automated testing. This testing requires great effort and time, but it gives the surety of bug-free software. Manual Testing requires knowledge of manual testing techniques but not of any automated testing tool.

WHY WE NEED MANUAL TESTING:

Whenever an application comes into the market, and it is unstable or has a bug or issues or creates a problem while end-users are using it.

If we don't want to face these kinds of problems, we need to perform one round of testing to make the application bug-free and stable and deliver a quality product to the client, because if the application is bug-free, the end-user will use the application more conveniently.

If the test engineer does manual testing, he/she can test the application from an end-user perspective and get more familiar with the product, which helps them to write the correct test cases of the application and give quick feedback on the application.

TYPES OF MANUAL TESTING:

White Box Testing
Black Box Testing
Gray Box Testing

WHITE BOX TESTING:

The white box testing is done by the Developer, who checks every line of code before giving it to the Test Engineer. Since the code is visible to the Developer during the testing, that's why it is also known as White box testing.

BLACK BOX TESTING:

The black box testing is done by the Test Engineer, who can check the functionality of an application or the software according to the customer /client's needs. In this, the code is not visible while performing the testing; that's why it is known as black-box testing.

GRAY BOX TESTING:

Gray box testing is a combination of white box and Black box testing. It can be performed by a person who knew both coding and testing. And if a single person performs white box, as well as black-box testing for the application, is known as Gray box testing.

ADVANTAGE OF MANUAL TESTING:

It does not require programming knowledge while using the Black box method.
It is used to test dynamically changing GUI designs.
Tester interacts with software as a real user so that they can discover usability and user interface issues.
It ensures that the software is a hundred percent bug-free.
It is cost-effective.
Easy to learn for new testers.

DISADVANTAGE OF MANUAL TESTING:

It requires a large number of human resources.
It is very time-consuming.
Tester develops test cases based on their skills and experience. There is no evidence that they have covered all functions or not.
Test cases cannot be used again. Need to develop separate test cases for each new software.
It does not provide testing on all aspects of testing.
Since two teams work together, sometimes it is difficult to understand each other's motives, which can mislead the process.

EXAMPLES:

Jira
Bugzilla
Mantis
ZapNUnit
Tessy
LoadRunner
Citrus
SonarQube

functional testing and Non functional testing with examples

gokila selvaraj — Sat, 01 Jun 2024 16:32:44 +0000

functional testing

It checks the application's activities and actions.
It is based on the needs of the consumer.
It aids in improving the application's functionality.
Manual testing can be used to carry out functional testing.

Example:

unit testing
component testing
Integration Testing

Non Functional testing

It checks the application functionality.
It is based on the customer's expectations.
It aids in enhancing the application's performance.
Manually performing non-functional testing is difficult.

Example:

performance testing
load testing
stress testing

software testing?need to about software testing?Relevance of software testing?

gokila selvaraj — Sat, 01 Jun 2024 11:00:25 +0000

software testing is the process of assessing the functionality of a software program. the process checks for errors and bugs in the outcome of the application.

Testing helps identify the failures early in the development process.