Software Testing

Fundamentals of Manual software testing


SKP Tutorial

6/14/20236 min read

grayscale photo of person using MacBook
grayscale photo of person using MacBook

Software Testing

Software testing is a crucial step in software development. It involves the evaluation of software products or applications to ensure they meet the desired quality and performance standards. The process involves the identification of defects or bugs in the software, and the identification of potential areas of improvement. Software testing can be done manually or by automated tools and techniques. Manual testing requires human intervention to test the software, while automated testing uses software tools to run tests automatically. Testing is done at different stages of software development, from the initial stage of requirements gathering to the final stage of deployment. Effective software testing ensures that software products are reliable, secure, and efficient, and ultimately helps to deliver a high-quality end product to the end-user.

Manual Software Testing:

Manual software testing is a fundamental approach to verify and validate the functionality, usability, and quality of a software application. It involves the use of human testers who perform various tests and checks to identify defects and ensure the software meets the desired requirements. Manual testing is a critical part of the overall software testing process and is typically performed before automation testing.

Here are some key aspects of manual software testing:

Test Planning: Manual testing begins with test planning, where testers analyse the software requirements and design test cases and scenarios. Test planning involves understanding the application's purpose, identifying the target audience, and defining the scope of testing.

  1. Test Case Design: Test cases are created based on the test plan. Testers outline specific steps to be followed, input data to be used, and expected results. These test cases cover different aspects of the software, including functional testing, usability testing, performance testing, and more.

  2. Test Execution: Testers execute the test cases manually by following the predefined steps. They input data, interact with the software's user interface, and compare the actual results with the expected results. Any deviations or defects are documented for further analysis and resolution.

  3. Defect Reporting: During test execution, when defects are identified, they are reported in a defect tracking system or a bug tracking tool. Testers provide detailed information about the defect, including steps to reproduce, screenshots, and logs, to help developers understand and fix the issues.

  4. Regression Testing: As the software evolves, new features are added, and existing features are modified. Manual testing includes regression testing, which ensures that the changes made to the software do not introduce new defects or break existing functionalities. Testers rerun the previously executed test cases to ensure the software's overall stability.

  5. Ad-Hoc Testing: Apart from following the predefined test cases, manual testers often perform ad-hoc testing. This involves exploring the software without a specific script to uncover unexpected defects or usability issues. Ad-hoc testing allows testers to mimic real-world user behavior and discover edge cases that may have been missed in the test planning phase.

  6. Usability Testing: Manual testers also focus on evaluating the user-friendliness and intuitiveness of the software. They assess factors such as ease of navigation, clarity of instructions, responsiveness, and overall user experience. Usability testing helps identify areas of improvement to enhance the software's user satisfaction.

Manual software testing has several advantages, including:

  • Early bug detection: Manual testing helps detect defects at an early stage of the software development life cycle, allowing for prompt bug fixes and reducing the overall cost of development.

  • Flexibility and adaptability: Manual testing is suitable for both simple and complex applications, making it flexible and adaptable to various testing scenarios.

  • Exploratory testing: Manual testers can employ their domain knowledge and intuition to explore the software thoroughly, identifying potential defects and risks.

  • Cost-effectiveness: Manual testing requires fewer initial investments compared to automation testing tools, making it a cost-effective option for smaller projects or tight budgets.

However, manual testing also has limitations, including:

  • Time-consuming: Manual testing can be time-consuming, especially when executing a large number of test cases or performing regression testing with every software change.

  • Human error: Manual testing relies on human testers, who may inadvertently overlook defects or make mistakes during test execution.

  • Limited scalability: Manual testing becomes challenging to scale when dealing with large and complex software systems. As the application grows, automation testing becomes more efficient and effective.

In conclusion, manual software testing plays a crucial role in ensuring the quality and reliability of software applications. It helps detect defects, assess usability, and provide valuable feedback to improve the overall user experience. While automation testing is gaining popularity, manual testing remains an essential part of the testing process, particularly during the early stages of software development and for certain types of testing.

To start manual testing, you can follow these steps:

Understand the Requirements: Begin by thoroughly reviewing the project requirements, specifications, and any relevant documentation. Gain a clear understanding of what is expected from the software or system being tested.

Create a Test Plan: Develop a test plan that outlines the objectives, scope, test scenarios, and test cases to be executed. Determine the testing approach, testing techniques, and any test data or tools required.

  • Identify Test Scenarios: Identify the different scenarios or situations that need to be tested. These could include positive and negative scenarios, boundary conditions, error handling, and various user interactions.

  • Design Test Cases: Create detailed test cases based on the identified test scenarios. Each test case should have clear steps to be executed, expected results, and any preconditions or prerequisites.

  • Set up Test Environment: Prepare the necessary test environment, including the software, hardware, network configurations, and any other dependencies required for testing.

  • Execute Test Cases: Start executing the test cases based on the test plan. Follow the defined steps and record the actual results.

  • Log Defects: If you encounter any issues or discrepancies during testing, document them as defects in a defect tracking system. Include relevant information like steps to reproduce, observed behavior, and expected behavior.

  • Retest and Regression Testing: After defects are fixed, retest the affected areas to ensure the fixes were successful and no new issues were introduced. Additionally, perform regression testing to verify that the existing functionality is not affected by recent changes.

  • Report Test Results: Prepare a test summary report that includes the test coverage, executed test cases, defects found, and any other relevant metrics. Communicate the test results to stakeholders, including project managers, developers, and other team members.

  • Repeat the Cycle: Continue the process of executing test cases, logging defects, and retesting until the software meets the required quality standards.

Remember, manual testing is an iterative process, and it requires careful attention to detail, effective communication, and an understanding of the software under test

Manual testing is often considered an iterative process because it involves repeating testing activities in cycles or iterations. Here are a few reasons why manual testing is iterative:

Continuous refinement: Manual testing is an ongoing process of identifying and fixing defects or issues in software. Testers execute test cases, observe the system's behavior, and document any bugs or problems they encounter. Based on the findings, they refine the test cases, update test scripts, and retest the software. This iterative cycle continues until the desired level of quality is achieved.

Feedback-driven: Manual testing relies on the tester's judgment and expertise. Testers provide valuable feedback on the software's behavior, usability, and overall quality. This feedback influences subsequent testing cycles, allowing testers to focus on specific areas or features that require further attention or improvement.

Progressive exploration: Manual testers often employ exploratory testing techniques where they investigate the software's behavior without predefined test cases. They explore different scenarios, functionalities, and inputs to uncover defects and gain a deeper understanding of the system. This exploratory approach is iterative in nature, as testers refine their exploration based on earlier findings and adjust their focus as they gain more insights

Regression testing: Manual testing involves performing regression testing to ensure that changes or fixes in one part of the software do not introduce new defects or break existing functionality in other areas. Whenever a change is made, testers repeat relevant test cases or execute a subset of tests to validate that the system still behaves as expected. This repetition of tests after each change is an iterative process that ensures the overall stability of the software.

Test case enhancement: Manual testers continuously enhance their test cases by incorporating new scenarios, edge cases, and user feedback. As they gain more knowledge about the system, they identify additional test scenarios that were not initially considered. This iterative enhancement of test cases helps in improving the overall test coverage and ensuring the software's robustness.

By embracing an iterative approach, manual testing allows for continuous improvement and the identification of defects and issues throughout the software development lifecycle. It enables testers to adapt, refine, and optimize their testing efforts based on the changing requirements, user feedback, and evolving understanding of the system under test.

Write your text here...