About manual testing....

what is manual testing?

Manual testing is a software testing process where testers manually execute test cases without the use of any automation tools. It involves the tester's active participation in the testing process, where they simulate end-user scenarios to ensure the software functions as intended.

stages of manual testing:

1.Unit Testing:

• it involves the verification of individual components or units of source code.
• It focuses on testing the functionality of individual components within the application.
• it is use to discover bugs in the early stages of the development cycle by developers.

1. Integration Testing:

   • Integration testing is the next step after unit testing. Multiple units are integrated to be tested as a whole.
   • For example, testing a series of webpages in a particular order to verify interoperability.
   • Performing integration testing in parallel with development allows developers to detect and locate bugs faster.

2. System Testing:

   • system testing involves testing all the integrated modules of the software as a whole.
   • It helps QAs verify whether the system meets the desired requirements. It includes multiple tests like validating output based on specific input, testing user experience.
   • cross browser testing must be essential to any UI testing strategy.

3. UI Testing:

   • it is used to testing visual elements to ensure they function according to functionality and performance requirements.
   • covers the gamut of visual indicators and graphic-based icons – toolbars, fonts, menus, text boxes, radio buttons, checkboxes, colour, and more.
   • Acceptance Testing:
     • acceptance testing is to verify whether the system as a whole is fit for use in the real world.
     • The members of the organization perform internal acceptance testing (also known as alpha testing).
     • A limited number of end-users perform external testing (beta testing).
     • This approach helps teams evaluate how well the product satisfies the user’s standards. It also identifies bugs in the last stage before releasing a product.

Types of Manual Testing:

 Black box testing: 

    - we focuses on testing the functionality of a software 
      system without any knowledge of its internal workings. 
    - it is used to test the system from a user’s perspective, 
      focusing on testing whether the system works as expected 
      and meets the user’s needs. 
    - The tester only knows the inputs and expected outputs of 
    the system and does not know how the system works internal

 White box testing: 
    - we focuses on testing the internal workings of a 
      software system. 
    - This technique is used to test the system from a 
      developer’s perspective, focusing on testing the 
      system’s internal logic, performance, and efficiency. 
    - The tester has complete knowledge of the system’s 
      internal details, including the code and its 
      implementation.

 Grey box testing: 
    - Grey box testing is a software test technique that 
      combines the approaches of both black box and white box 
      testing. 
    - This technique is used to test the system from a 
      developer’s perspective, where the focus is on testing 
      some of the system’s internal workings but not all. 
    - The tester has partial knowledge of the system’s 
      internal details, and this technique is often used in 
      system integration testing.

Benefits of Manual Testing:

Human Insight: Testers can apply their domain knowledge and intuition to identify issues that automated tools might overlook. They can also provide valuable feedback on the user experience.

Exploratory Testing: Manual testing allows for exploratory testing, where testers actively explore the software to find defects that were not anticipated during the test design phase.

Cost-Effective for Small Projects: For small projects with limited resources, manual testing may be more cost-effective initially, as setting up automation can require a significant upfront investment.

Adaptability: Manual testing is adaptable to changes in the software. Testers can quickly modify test cases based on changing requirements or newly discovered issues.

Example in Support:

Consider a web application that needs to be tested for different browsers and devices. In manual testing, a tester can interact with the application on various browsers like Chrome, Firefox, and Safari, as well as on different devices such as desktops, laptops, tablets, and mobile phones. The tester can manually verify that the application renders correctly, functions as expected, and provides a consistent user experience across different environments. This flexibility and adaptability in testing scenarios make manual testing beneficial in certain situations. However, for repetitive and time-consuming tasks, automated testing tools might offer a more efficient solution.

Example 1 - Usability Testing: Imagine a scenario where a website needs to be tested for its user-friendliness and overall user experience. Testers interact with the site, navigate through pages, and provide feedback on the intuitiveness of the design.

Example 2 - Exploratory Testing: In a mobile application, testers might perform exploratory testing by randomly interacting with the app to identify any unexpected behaviour, user interface issues, or functionality gaps that were not covered by predefined test cases.

Example 3 - Ad Hoc Testing: Testers might perform ad hoc testing by intentionally deviating from the test cases to simulate real-world usage scenarios and discover defects that might not have been considered during formal test case creation.

Drawbacks of Manual Testing:

Time-Consuming: Manual testing can be time-consuming, especially for repetitive and large-scale testing efforts. The time required increases with the growth of the application.

Human Error: Testers may introduce errors during the testing process, such as overlooking certain test scenarios or making mistakes in test execution.

Limited Reusability: Test cases in manual testing are less reusable compared to automated tests. For each new release or build, testers need to repeat the same set of test cases manually.

Non-Scalability: Manual testing becomes impractical for large and complex projects, as the number of test cases and the frequency of releases increase.

Less Accuracy: Human Users (Testers) may make mistakes, so we cannot expect more accuracy in Manual Testing.

Performance testing is impractical in manual testing:
Organizing Thousands of Machines / Computers and human Users is impractical, If it is Test Automation, we can create thousands of Virtual users and using 3 or 4 Computers we can apply the Load and test the performance of the Application

For every release you must rerun the same set of tests:
We need to execute Sanity Test Cases and Regression Test cases on every modified build, it takes more time. In Automated Testing / Test Automation once we can create Tests then Tool can execute Tests multiple times quickly.

Executing the same tests, again and again it takes more time and man power also:
Sometimes we need to execute the same tests using multiple sets of Test data, for each test iteration user interaction is mandatory, In Test Automation using Test Data data file (either Text file or Excel file, or Database file) we can easily conduct Data-driven Testing.