Software testing is the process of evaluating a software application to verify that it behaves according to its requirements and to identify defects, unexpected behavior, usability problems, performance issues, security weaknesses, and other quality-related risks.
Software testing can be classified in different ways based on the testing objective, execution method, level of testing, scope, and whether the testing is performed manually or with automation tools. Understanding these testing types is an important foundation for learning Selenium and professional software testing.
In Selenium-based automation, testers commonly automate suitable web application scenarios such as functional testing, regression testing, smoke testing, cross-browser testing, data-driven testing, and end-to-end workflows. Other testing activities, such as exploratory, usability, and certain visual evaluations, may continue to require significant human involvement.
Learners can explore the JustAcademy Selenium Automation Testing Course to continue learning software testing and Selenium automation.
Software testing is the systematic process of checking an application or software system to determine whether it satisfies specified requirements and behaves as expected.
Testing involves designing test scenarios, preparing test data, executing tests, comparing actual results with expected results, identifying defects, and communicating test results to the development and project teams.
Software testing means evaluating software to find defects and verify that the application works according to its expected requirements.
Suppose an application has a login page. A tester may verify:
A software application contains many different components and quality requirements. A single testing approach cannot effectively evaluate every aspect of an application.
For example, functional testing checks whether features work correctly, while performance testing evaluates system behavior under different workloads. Security testing focuses on security risks, usability testing evaluates user experience, and compatibility testing checks behavior across different environments.
Software Testing
|
+-------------------------+
| |
Testing Approach Testing Objective
| |
+---- Manual +---- Functional
+---- Automation +---- Non-Functional
|
|
Testing Level
|
+---- Unit
+---- Integration
+---- System
+---- AcceptanceSoftware testing can be broadly organized into several categories.
| Category | Examples |
|---|---|
| Testing by Execution | Manual Testing, Automation Testing |
| Testing by Objective | Functional Testing, Non-Functional Testing |
| Functional Testing Types | Unit, Integration, System, Acceptance, Regression, Smoke, Sanity |
| Non-Functional Testing Types | Performance, Load, Stress, Security, Usability, Compatibility, Accessibility |
| Testing Based on Change | Regression Testing, Retesting |
| Testing Based on Knowledge | Black Box, White Box, Grey Box |
| Testing Based on Execution Style | Exploratory, Ad-Hoc, Scripted Testing |
Manual testing is testing performed by a human tester without using automation scripts to execute the complete test scenario.
The tester interacts directly with the application, enters test data, performs actions, observes results, compares actual results with expected results, and records the outcome.
Automation testing uses software tools, frameworks, and scripts to execute predefined test scenarios.
Automation can perform actions such as opening a browser, entering data, clicking elements, navigating through pages, validating results, and generating test reports.
WebDriver driver = new ChromeDriver();
driver.get("https://example.com/login");
driver.findElement(By.id("username"))
.sendKeys("[email protected]");
driver.findElement(By.id("password"))
.sendKeys("Test@123");
driver.findElement(By.id("loginButton"))
.click();
driver.quit();Selenium WebDriver can be used to automate browser-based test scenarios like the example above.
Functional testing verifies whether the application's features and functions behave according to specified requirements.
Requirement
↓
Test Scenario
↓
Test Case
↓
Execute Test
↓
Compare Actual vs Expected
↓
Pass / FailNon-functional testing evaluates quality characteristics of a system rather than only checking whether a specific business function works.
Unit testing tests small individual components of an application, such as functions, methods, or classes.
The purpose is to verify that a small unit of code behaves correctly in isolation or within a controlled environment.
public int add(int a, int b) {
return a + b;
}A unit test can verify that calling add(10, 20) returns 30.
Integration testing verifies whether multiple modules or components work correctly when they interact with each other.
Consider an e-commerce application:
Product Module
↓
Cart Module
↓
Payment Module
↓
Order ModuleIntegration testing verifies whether these components exchange information correctly.
A product is added to the cart. The cart sends the correct product and price information to checkout. The payment module processes the transaction, and the order module creates the expected order.
System testing evaluates the complete integrated application as a whole.
The objective is to verify whether the complete system behaves according to its specified requirements.
For an e-commerce application, system testing may cover:
Acceptance testing verifies whether the software satisfies business and user requirements and is suitable for its intended use.
Acceptance testing is often associated with business stakeholders, customers, product owners, or designated acceptance testers.
A business may specify that a customer must be able to search for a product, add it to the cart, complete checkout, and receive an order confirmation.
Acceptance testing checks whether the application satisfies these expected business workflows.
User Acceptance Testing (UAT) is performed to determine whether the system meets the needs of its intended users and business processes.
Before launching a banking application feature, selected business users may validate important workflows such as account access, transaction history, and fund-transfer processes.
Business Requirement
↓
Business Scenario
↓
User Acceptance Test
↓
Execute Workflow
↓
Validate Business Result
↓
Acceptance DecisionSmoke testing is a relatively broad but shallow set of checks used to determine whether a build is stable enough for more detailed testing.
For an e-commerce application, smoke tests may check:
If critical functionality is completely unavailable, the build may not be suitable for deeper testing.
Sanity testing is focused testing performed after specific changes or fixes to verify that the affected functionality works as expected and that the change has not introduced obvious related problems.
Suppose a login defect was fixed. A sanity test may focus on:
| Parameter | Smoke Testing | Sanity Testing |
|---|---|---|
| Purpose | Check whether the build is broadly stable for further testing | Verify specific changed or affected functionality |
| Scope | Broad and relatively shallow | Narrow and focused |
| Execution | Often performed on a new build | Often performed after a specific change or fix |
| Focus | Critical application functionality | Specific functionality and related areas |
Regression testing verifies that existing functionality continues to work after application changes.
Changes may include new features, bug fixes, configuration changes, dependency updates, or other modifications.
Suppose a developer changes the checkout module. Regression testing may verify:
Regression suites can contain many repetitive test cases. Suitable regression tests can therefore be automated and executed repeatedly.
Retesting means executing a failed test again after the reported defect has been fixed to determine whether the specific issue has been resolved.
Test Case
↓
Test Fails
↓
Defect Reported
↓
Developer Fixes Defect
↓
Retest
↓
Pass / Fail| Retesting | Regression Testing |
|---|---|
| Focuses on verifying a specific defect fix. | Checks whether existing functionality remains unaffected by changes. |
| Usually targets previously failed scenarios. | Can cover a broader existing test suite. |
| Confirms whether the reported defect has been fixed. | Checks for unintended side effects. |
Exploratory testing involves learning about the application, designing tests, executing actions, and investigating results dynamically.
Unlike strictly scripted testing, exploratory testing allows the tester to adapt based on observations.
A tester opens a shopping application and explores different combinations of:
The tester may discover unexpected behavior that was not explicitly described in predefined test cases.
Ad-hoc testing is informal testing performed without a detailed predefined test plan or structured test case set.
The tester uses experience and understanding of the application to investigate potential problems.
A tester intentionally enters unusual combinations of characters, rapidly clicks buttons, navigates between pages, or changes input values to investigate unexpected behavior.
Black box testing tests software from the perspective of its external behavior without requiring knowledge of the internal implementation.
A tester enters valid and invalid login credentials and checks the resulting behavior without needing to inspect the application's source code.
White box testing involves testing with knowledge of the application's internal code, logic, structure, or implementation.
White box testing is commonly associated with development-level testing and requires knowledge of the implementation.
Grey box testing combines aspects of black box and white box testing. The tester has some knowledge of the internal system while primarily evaluating externally observable behavior.
A tester may understand database structures or API behavior while testing the application through its user interface.
Performance testing evaluates how an application behaves in terms of response time, throughput, resource utilization, stability, and other performance characteristics.
Load testing evaluates application behavior under an expected or specified workload.
An application normally expects thousands of concurrent users. Load testing can be performed to evaluate how the application behaves under a representative workload.
Expected User Load
↓
Generate Requests
↓
Monitor System
↓
Measure Response Time
↓
Analyze Throughput
↓
Identify BottlenecksStress testing evaluates application behavior beyond normal or expected operating conditions to understand how the system behaves under extreme load.
A system designed for a certain number of concurrent users may be tested with progressively increasing traffic to identify performance limits, degradation, or failure behavior.
Volume testing evaluates how an application behaves when processing large amounts of data.
A reporting system may be tested using a database containing millions of records to evaluate query response times and system behavior.
Security testing evaluates an application's ability to protect data and functionality against unauthorized access and other security risks.
A tester verifies that a normal user cannot access administrative functionality without the required permissions.
Usability testing evaluates how easily and effectively users can interact with an application.
Usability testing generally benefits from human observation and feedback.
Compatibility testing verifies whether an application behaves correctly across different environments.
A web application may be tested across Chrome, Firefox, Edge, and other supported browsers.
Cross-browser testing verifies that a web application behaves correctly across supported browsers and browser configurations.
Web Application
|
+---- Chrome
|
+---- Firefox
|
+---- Edge
|
+---- Safari
|
+---- Other Supported BrowsersSelenium WebDriver is commonly used to automate suitable cross-browser web application scenarios.
Accessibility testing evaluates whether software can be used effectively by people with different accessibility needs.
Accessibility testing may combine automated checks with manual evaluation.
End-to-end testing verifies a complete business workflow from beginning to end.
Open Website
↓
Register / Login
↓
Search Product
↓
Open Product
↓
Add to Cart
↓
Checkout
↓
Payment
↓
Order ConfirmationAn end-to-end test validates that the complete workflow functions correctly across the involved components.
Positive testing verifies that the application behaves correctly when valid and expected inputs are provided.
For a login form:
Negative testing verifies how an application behaves when invalid, unexpected, incomplete, or incorrect inputs are provided.
The objective is to verify that the application handles invalid conditions appropriately.
Data-driven testing executes the same test logic with multiple sets of test data.
Test Data
Username Password
---------------------------------------
[email protected] Test@123
[email protected] Test@456
[email protected] Test@789The same login test can be executed using multiple data sets.
Keyword-driven testing uses predefined keywords to represent test actions.
| Keyword | Action |
|---|---|
| OPEN | Open browser or application |
| INPUT | Enter data |
| CLICK | Click an element |
| VERIFY | Validate expected result |
| CLOSE | Close browser |
Scripted testing follows predefined test cases and instructions.
The tester executes documented steps and compares actual results with expected results.
1. Open login page.
2. Enter valid username.
3. Enter valid password.
4. Click Login.
5. Verify dashboard.
6. Record result.Static testing evaluates software artifacts without executing the application.
The objective is to identify issues early in the development lifecycle.
Dynamic testing involves executing the software and evaluating its behavior.
Opening a web application, entering login credentials, clicking buttons, and validating the resulting page are examples of dynamic testing.
Alpha testing is testing performed in a controlled environment before the software is released to a broader external user group.
It is generally performed near the end of development and before beta testing or broader release activities.
Beta testing involves releasing software to a selected group of external users so that the software can be evaluated in realistic usage environments.
A company may provide a pre-release version of an application to selected customers and collect feedback about defects, usability, and real-world behavior.
Installation testing verifies whether software can be installed, configured, upgraded, and removed correctly in supported environments.
Recovery testing evaluates whether a system can recover correctly after failures or unexpected interruptions.
The objective is to determine whether the application can restore functionality and data appropriately.
Reliability testing evaluates whether software can perform consistently over a specified period and under expected conditions.
An application may be operated continuously for an extended period while monitoring failures, errors, and system behavior.
Scalability testing evaluates how effectively an application handles increasing workload, users, transactions, or data.
1,000 Users
↓
5,000 Users
↓
10,000 Users
↓
50,000 Users
↓
Measure System BehaviorThe objective is to understand how the application behaves as demand increases.
Localization testing verifies that an application works correctly for a particular language, region, or locale.
Internationalization testing evaluates whether an application is designed to support multiple languages, regions, character sets, and cultural conventions without requiring major code changes for each locale.
Localization focuses on adapting the application to a particular locale, while internationalization focuses on preparing the software to support multiple locales.
Configuration testing verifies application behavior under different supported configurations.
Compliance testing evaluates whether an application follows applicable requirements, standards, policies, regulations, or organizational rules.
API testing validates application programming interfaces directly rather than testing only through the user interface.
Client
↓
API Request
↓
Server
↓
API Response
↓
Validate Status / Data
↓
Pass / FailDatabase testing verifies that data is stored, retrieved, updated, and maintained correctly.
UI testing evaluates the application's user interface and verifies that interface elements behave as expected.
Selenium WebDriver is commonly used to automate suitable web UI testing scenarios.
| Parameter | Regression Testing | Retesting |
|---|---|---|
| Purpose | Check existing functionality after changes | Verify a specific defect fix |
| Scope | Can be broad | Usually focused |
| Target | Existing functionality potentially affected by changes | Previously failed test case |
| Automation | Frequently suitable for automation | Can also be automated where appropriate |
| Functional Testing | Non-Functional Testing |
|---|---|
| Checks what the system does. | Checks how well the system performs. |
| Focuses on business functionality. | Focuses on quality characteristics. |
| Examples include login and checkout. | Examples include performance and usability. |
| Validates functional requirements. | Validates non-functional quality requirements. |
Testing can also be classified according to the level at which the software is tested.
Testing Levels
Unit Testing
↓
Integration Testing
↓
System Testing
↓
Acceptance TestingTests individual units or components.
Tests interactions between components.
Tests the complete integrated system.
Tests whether the system satisfies business and user requirements.
The testing pyramid is a conceptual model for organizing different levels of automated tests.
/\
/ \
/ UI \
/------\
/Service \
/----------\
/ Unit \
/--------------\A typical testing strategy contains many lower-level tests and fewer expensive end-to-end UI tests, although the exact balance depends on the application and project requirements.
Selenium is primarily relevant to browser-based web application automation.
Test Scenario
↓
Test Case
↓
Selenium WebDriver
↓
Browser
↓
Web Application
↓
Web Element Interaction
↓
Assertion
↓
Test Result| Testing Type | Selenium Usage |
|---|---|
| Functional Testing | Automate web application functionality |
| Regression Testing | Repeatedly execute stable web test cases |
| Smoke Testing | Automate critical application checks |
| Sanity Testing | Automate focused checks where appropriate |
| End-to-End Testing | Automate complete browser workflows |
| Cross-Browser Testing | Execute tests across supported browsers |
| Data-Driven Testing | Execute the same workflow with multiple data sets |
Automation can assist many testing activities, but certain areas depend heavily on human observation, interpretation, or judgment.
Consider an e-commerce website containing registration, login, search, product pages, cart, checkout, payment, and order management.
| Feature | Possible Testing Types |
|---|---|
| Login | Functional, Negative, Regression, Security |
| Search | Functional, UI, Performance, Regression |
| Cart | Functional, Integration, Regression |
| Checkout | Functional, Integration, End-to-End, Regression |
| Payment | Functional, Security, Integration, End-to-End |
| Website UI | UI, Usability, Compatibility, Accessibility |
A banking application requires multiple testing approaches because it contains authentication, financial transactions, sensitive data, integrations, and business-critical workflows.
The appropriate testing type depends on the objective of the test.
| Testing Requirement | Relevant Testing Type |
|---|---|
| Verify a feature | Functional Testing |
| Verify individual code unit | Unit Testing |
| Verify module interaction | Integration Testing |
| Verify complete application | System Testing |
| Verify business acceptance | Acceptance Testing |
| Verify changes did not break existing functionality | Regression Testing |
| Verify a specific defect fix | Retesting |
| Check basic build stability | Smoke Testing |
| Check specific changed functionality | Sanity Testing |
| Check response under load | Performance / Load Testing |
| Check security controls | Security Testing |
| Check user experience | Usability Testing |
| Check multiple browsers | Compatibility / Cross-Browser Testing |
Choose a demo web application and create a testing plan covering different testing types.
Application
↓
Identify Features
↓
Create Test Scenarios
↓
Select Testing Types
↓
Manual Execution
↓
Identify Automation Candidates
↓
Selenium Automation
↓
Regression Execution
↓
Analyze ResultsSoftware testing is the process of evaluating software to verify that it meets requirements and behaves as expected.
Common categories include functional testing, non-functional testing, manual testing, automation testing, unit testing, integration testing, system testing, acceptance testing, regression testing, smoke testing, sanity testing, performance testing, security testing, usability testing, and compatibility testing.
Functional testing verifies whether application features behave according to specified requirements.
Non-functional testing evaluates quality characteristics such as performance, usability, security, compatibility, reliability, and scalability.
Regression testing verifies that existing functionality continues to work after application changes.
Retesting verifies whether a previously reported defect has been fixed successfully.
Smoke testing performs a broad but relatively shallow set of checks to determine whether a build is stable enough for further testing.
Sanity testing performs focused checks on specific functionality after relevant changes or fixes.
Black box testing evaluates external application behavior without requiring knowledge of the internal implementation.
White box testing involves testing with knowledge of internal code, logic, or structure.
Exploratory testing allows testers to dynamically investigate an application while learning about its behavior and adapting their tests based on observations.
Performance testing evaluates characteristics such as response time, throughput, resource utilization, and system behavior under workload.
Load testing evaluates application behavior under an expected or specified workload.
Stress testing evaluates system behavior under extreme or beyond-normal workload conditions.
Selenium is primarily used to automate interactions with web applications through supported browsers.
Selenium can be used for suitable web-based functional, regression, smoke, sanity, end-to-end, cross-browser, and data-driven testing scenarios.
Selenium is primarily a browser automation tool rather than a dedicated performance-testing tool. Performance testing generally requires specialized tools and approaches.
No. Selenium can automate suitable browser interactions, but exploratory testing, usability evaluation, visual judgment, test design, analysis, and other activities may still require human involvement.
Software testing includes many different testing types because applications must be evaluated from multiple perspectives. Functional testing verifies what the application does, while non-functional testing evaluates characteristics such as performance, security, usability, compatibility, reliability, and scalability.
Testing can also be classified according to testing level, such as unit testing, integration testing, system testing, and acceptance testing. Other important approaches include smoke testing, sanity testing, regression testing, retesting, exploratory testing, black box testing, white box testing, positive testing, negative testing, and end-to-end testing.
Selenium is primarily useful for automating web application testing. It can be used for suitable functional, regression, smoke, sanity, end-to-end, cross-browser, and data-driven web testing scenarios. Human testers continue to play an important role in exploratory testing, usability testing, test design, analysis, and other activities requiring judgment.
Learners who want to continue learning Selenium and software testing can explore the JustAcademy Selenium Automation Testing Course.
JustAcademy Selenium Training Course
Register for Selenium Course Demo
After completing this topic, a learner should be able to explain the major types of software testing, differentiate functional and non-functional testing, understand testing levels, explain smoke and sanity testing, distinguish regression testing from retesting, understand black box and white box testing, identify performance and security testing concepts, explain exploratory and usability testing, and identify which web testing scenarios can be automated using Selenium.
