Manual testing is process of evaluation of software with involvement of a person to find bugs and issue. This approach helps ensure the software works as intended and meets user needs.
Characteristics of Manual Testing:
• Human-Centric – Testers execute test cases like end users, providing input and checking results.
• Exploratory – Involves investigative testing without predefined cases to uncover unexpected issues.
• Flexible – Testers adapt test cases or explore new scenarios as requirements change.
• Early Start – Can be performed in the initial stages of development to catch issues early.
• Handles Complexity – Suitable for testing complex workflows and component interactions.
• UI Evaluation – Effective for assessing user interface design, usability, and responsiveness.
Advantages of Manual Testing:
Wherever human intervention is required, manual testing is the only way to handle it.
Complex testing can be handled
Negative Test cases work only in Manual testing
Disadvantage of Manual Testing:
Time consuming for repetitive test execution like regression testing.
Error may occur due to carelessness
Types of Manual Testing
White box testing:
In White Box Testing technique/glass box Testing, the person will check the internal structure of the system like designs, coding, etc., manually.
White Box Testing Example
Consider the following piece of code:
Here, the development team will review the entire coding part line by line to ensure the correctness of the code. It includes following methods or coverage
- Statement Coverage
- Branch Coverage
- Path Coverage
- Cyclomatic Coverage
Statement Coverage:
Statement Coverage includes each are every line of code is works as expected or not.
The goal of WhiteBox testing in software engineering is to verify all the decision branches, loops, and statements in the code.
To exercise the statements in the above white box testing example, WhiteBox test cases would be
• A = 1, B = 1
• A = -1, B = -3
Branch Coverage:
Branch Coverage includes each are every branch is performs as expected or not.
Path Testing:
White box testing will be checks all possible execution paths in the program to sure about the each one of the functions behaves as expected.
Cyclomatic Testing:
Cyclomatic complexity is a metric that measures the complexity of a program by counting its decision points. Decision points refer to various condition in which the code’s behavior is exhibited.
Black Box testing:
Black Box Testing (close box testing) is a software testing method in which the functionalities of software applications are tested without having knowledge of internal code structure, implementation details and internal paths. Black Box Testing mainly focuses on input and output of software applications, and it is entirely based on software requirements and specifications. It is also known as Behavioral Testing.
Key Features of Black Box Testing
• Functionality Focus: It validates whether the software meets its functional requirements by testing its behavior against expected outcomes.
• No Internal Knowledge Required: Testers do not need programming or implementation knowledge, making it accessible to non-technical testers.
• User-Centric Approach: Testing is performed from the perspective of an end-user, ensuring the application is intuitive and meets user expectations.
• Independent Testing: Testers are independent of the development team, ensuring unbiased
Gray box testing:
Gray Box Testing is a software testing technique that combines elements of the Black Box Testing technique and the White Box Testing technique.
Objectives of Gray Box Testing:
• To provide the 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 the long process of functional and non-functional testing.
• To provide enough free time to developers to fix defects.
• To test from the user's point of view rather than a designer's point of view.
Example of Gray Box testing:
- DB testing and API Testing.
Boundary Value Analysis:
Boundary Value Analysis (BVA) is a test design technique used to identify test cases that target the edges of input value ranges. The approach focuses on the assumption that most errors occur at the boundaries rather than within the range itself.
Here’s a concise breakdown of how BVA works in designing test cases:
Identify Boundaries: The first step is to determine the input ranges for the software being tested. This includes both minimum and maximum values.
Focus on Edge Cases: Instead of testing every single value, BVA emphasizes testing only the values at the boundaries. This typically includes:
-The minimum and maximum values.
-One value below the minimum and one above the maximum.
-Values just inside the boundaries.
Benefit from Common Errors: Programmers often make mistakes when implementing logic for boundary conditions, such as confusion between ‘greater than’ (>) and ‘greater than or equal to’ (≥). BVA can uncover these types of logical errors efficiently.
Test Case Generation: For each boundary identified, test cases are generated. For example, if a function accepts values from 1 to 10, the test cases would include:
-0 (below minimum)
-1 (minimum)
-5 (within range)
-10 (maximum)
-11 (above maximum)
Support for Comprehensive Testing: Boundary Value Analysis is particularly useful in cases where the input data heavily influences the system's behavior, such as financial applications. It allows for a focused test effort while ensuring that critical edge scenarios are confirmed.
o Complementary Techniques: BVA is often paired with other testing methods, such as Equivalence Partitioning, which broadens the coverage by ensuring that not only boundaries but also representative values within each partition are tested.
Implementation in Testing Lifecycle: Often used during the testing phase, BVA assists testers in defining precise test cases, thereby improving the efficiency of the testing process.
Test Coverage Improvement: Utilizing BVA helps ensure that critical conditions are verified, leading to higher test coverage and increasing confidence in the software's performance under various scenarios.
In summary, Boundary Value Analysis is invaluable in software testing for identifying critical test cases that focus on edge values, ultimately enhancing the quality and reliability of software products.
Equivalence Partitioning (EP) is a testing technique used to reduce the number of test cases while still maintaining a high level of test coverage. The fundamental premise of EP is that inputs can be grouped into partitions or classes that are expected to exhibit similar behavior. Testing one representative value from each partition is deemed sufficient.
Steps in Equivalence Partitioning:
Identify Input Domain: Analyze the input field to understand its valid and invalid states. For instance, consider an age input field that accepts values between 20 and 50.
Define Partitions: Divide the inputs into various classes, typically including:
Valid Partitions:
Input within the valid range (e.g., 20-50)
Invalid Partitions:
Values below the minimum (e.g., 19 or lower)
Values above the maximum (e.g., 51 or higher)
Any invalid data types (e.g., letters, special characters)
Select Test Cases: From each partition, select one representative value. Using the earlier example:
Valid: 20 (exact lower limit), 30 (mid-range), 50 (exact upper limit)
Invalid: 19 (just below minimum), 51 (just above maximum), and "string" (invalid data type)
Example Overview:
In the example of the age field accepting values between 20 and 50:
Valid Partitions:
Acceptable values: 20, 30, 40, 50
Invalid Partitions:
Below range: 19
Above range: 51
Invalid data type: "text"
By choosing representative values from these partitions (for instance, testing with 20, 30, 19, and "string"), you effectively cover the necessary scenarios without needing to test every single number between the boundaries.
Benefits of Equivalence Partitioning:
Efficiency: Reduces the total number of test cases necessary for comprehensive coverage.
Error Detection: Identifies potential errors in data handling at both edges of input ranges and various data types.
In summary, Equivalence Partitioning helps testers focus their efforts by identifying representative values from different classes, ensuring that a limited number of carefully selected test cases can adequately validate software behavior.
Artificial Intelligence
In General AI (Artificial Intelligence) is the ability of a computational system to perform task associated with human intelligence like problem solving, decision making.
For Example:
AI is like teaching a child. At first, you show the child many examples — like pictures of apples and banana. Over time, the child learns to tell them apart on their own. AI works the same way, but with computers learning from data instead of real-life experience.
In 2025 AI's presence is everywhere, in my situation I use AI as peer for asking doubts, sharing my feedback and correcting grammar mistake in email.
The Future of Manual Testing in the Age of AI:
Testing is a standard process in IT to ensure the delivery of high-quality software. Without testing, a software product cannot be released to the market with confidence. Manual testing forms the foundation of any testing process. Before an application is proposed for release, it must be well-understood, and impact analysis should be carried out. For this purpose, a manual testing team is essential to understand the requirements clearly.
Only when the requirements are well understood can AI models be trained effectively to support the testing process. Even in 2025, AI remains unreliable in certain cases. It will not completely replace manual testers but will serve as a powerful assistant. AI helps testers speed up their work, reduce repetitive tasks, and allow them to focus on more critical and exploratory aspects of testing.
In the future, AI can also play a role in training juniors, helping the testers grasp concepts faster, reducing time spent on repetitive activities, and allowing them to focus on self-development and advanced skills.
In conclusion, AI requires human supervision to be effective, while humans can benefit from AI’s assistance in handling complex systems. Rather than replacing each other, AI and humans will work in partnership to achieve efficiency and quality in software testing.
Reference:
-Input got from testing course training session.
https://www.geeksforgeeks.org/software-testing/software-testing-manual-testing
https://www.guru99.com/manual-testing.html
https://www.udemy.com/course/certified-tester-foundation-level-ctfl/learn
Images are drawn with the help of draw.io site
Feedbacks are welcome.
Top comments (0)