Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/software-testing/software-testing-manual-testing/ below:

Manual Testing - Software Testing

Manual testing is an important part of software development. Unlike automated testing, it involves a person actively using the software to find bugs and issues. This hands-on approach helps ensure the software works as intended and meets user needs.

Manual testing is a technique to test the software that is carried out using the functions and features of an application. In manual software testing, a tester tests the software by following predefined test cases. In this testing, testers make test cases for the codes, test the software, and give the final report about that software. Manual testing is time-consuming because it is done by humans, and there is a chance of human errors.

Every new application must be manually tested before its testing can be automated. Manual Testing requires more effort than automation testing but is necessary to check automation feasibility. There is no requirement for knowledge of any testing tool in manual testing.

Unlike automated testing, manual testing relies on predefined test cases and can be time-consuming and prone to human error. To master the nuances of manual testing and enhance your software testing skills, consider exploring the Complete Guide to Software Testing & Automation by GeeksforGeeks . This course provides comprehensive insights into manual testing techniques, helping you deliver more reliable and high-quality software.

There are different methods to implement manual testing, but it is broadly classified into three types of manual testing:

In Black Box Testing technique, the tester or the QA analyst will only check the functionality of the particular module or particular method or sometimes the entire application by providing the different test cases manually. Here, the tester will give the input for the application and test it manually.

If it returns the expected output, then the tester will proceed with another set of inputs and report all the results to the team. If the input given by the user manually is failed during the testing, then he/she will report this issue to the development team.

These techniques encompass both functional and non-functional testing.

• Functional testing: In this testing Test engineer checks whether the features of the application work according to the specified requirements. The tester verifies that the system does what it is supposed to do with proper requirement completion, based on the test cases. Functional testing can be done manually or automated, depending on the project needs.
• Non-functional testing: It will focuses on the software all start to end performance, usability, and other quality aspects that do not directly relate to specific functions. This includes testing the application speed, reliability, and user experience to re-sure it meets to the expected requirements.
• Regression testing: This testing is done after any code changes, updates, or bug fixes to verify that the new code does not have negatively impact the existing features of the software which are already working fine. Since new code might be having bugs or conflict with old code, regression testing involves re-running previous test cases to check that everything still works as expected. This type of testing is crucial for maintaining the stability of the software after updates.

In White Box Testing technique, the person will check the internal structure of the system like designs, coding, etc., manually. Here, the development team will review the entire coding part line by line to ensure the correctness of the code. If he/she finds any dissimilarities or errors in the code, they will correct or fix the errors in the coding or designs. Here, the process is entirely carried out manually and the process is efficient since the checking code or design is manually checked by humans.

Here are some key types of tests commonly used in white box testing:

• Path Testing: White box testing will be checks all possible execution paths in the program to sure about the each one of the function behaves as expected. It helps verify that all logical conditions in the code are functioning correctly and efficiently with as properly manner, avoiding unnecessary steps with better code reusability.
• Input and Output Validation: By providing different inputs to a function, white box testing check the the function gives the correct output each of the time. This helps to confirm that the software consistently produces the required results under various conditions.
• Security Testing: this will focuses on finding security issues in the code. Tools like static code analysis are used to check the code for potential security flaws, for checking the application for the best practices for secure development.
• Loop testing: It will be check that loops (for or while loops) in the program operate correctly and efficiently. It checks that the loop handles variables correctly and doesn’t cause errors like infinite loops or logic flaws.
• Data Flow Testing: This involves tracking the flow of variables through the program. It ensures that variables are properly declared, initialized, and used in the right places, preventing errors related to incorrect data handling.

In Gray Box Testing this technique is the combination of both white-box testing and black-box testing. Here, the internal structure of the application is partially known by the tester. The tester will check both the internal structure and the functionality of the application manually. The tester will check the coding part as well as test the application by providing different test cases manually. If the input fails at some stage, the tester will then make the changes in the coding part.

Below is the representational diagram of the steps in the manual testing process in detailed manner:

Manual testing starts with an understanding of what the software is supposed to do.

• Functional Requirements: Understand the software’s features, like a login page verifying user credentials correctly.
• Non-Functional Requirements: Check performance, usability, or security, such as ensuring the login page loads in under 2 seconds.
• User Stories & Design Documents: Study how users will interact with the software to meet their expectations.
• Stakeholder Input: Work with clients, product managers, or designers to resolve any unclear details.

Creating a test plan is the next step in manual testing. A well-crafted test plan guides manual testing to ensure clear goals.

• Scope: Defines what to test, like flight search and booking features, and what’s excluded, such as a third-party payment gateway.
• Objectives: Setting goals, like confirming core functionality or ensuring a user-friendly experience.
• Resources: Lists team members, tools (e.g., browsers or mobile devices), and testing timelines.
• Testing Techniques: Includes methods like functional testing, usability checks, or exploratory testing to uncover issues.
• Environments: Specifies setups like staging or production-like environments for accurate testing.

Test cases are clear, step-by-step scripts that ensure thorough manual testing. Test cases act as detailed guides for testers, ensuring every scenario is checked. Each test case includes:

• Test ID: A unique code, like TC_001, for easy tracking.
• Description: The goal, such as verifying with valid inputs.
• Preconditions: What’s needed before starting, like being on the search page.
• Steps: Actions to take, like pick tomorrow’s date, and click “Search.”
• Expected Result: The desired outcome, like a list of flights sorted by price.
• Postconditions: The system show the results page.

Read More: How to Write Test Cases?

The test environment copy the production setup where the software will run. This step involves:

• Installing the applications which is need for the testing purpose.
• Configuring settings according to your project.
• Ensuring access to test data which is need for the project verification.
• Verifying hardware/software requirements.

Execute test cases by steps and interacting with the application as a user.

• Actual Results: What happens during execution.
• Pass/Fail Status: Whether the actual result matches the expected result.
• Observations: Any unexpected behavior or usability issues.

When a test fails or unexpected behavior occurs, log defects with:

• Defect ID: Unique identifier.
• Summary: Brief description about the what the actual defect it is.
• Steps to Reproduce: Detailed steps to trigger the issue.
• Actual vs. Expected Results: What happened vs. what should have happened.
• Severity: Impact check it is critical, major or minor?
• Attachments: Screenshots, logs, or videos for proof of the defect.

After logging defects, developers fix them, and testers verify the fixes which they did:

• Track Status: Monitor defect status in the tracking tool its in-process or its done.
• Retest Fixes: Re-run the failed test case to confirm the defect is resolved.
• Update Defect: Mark as “Closed” if fixed or “Reopened” if the issue persists.

Regression testing ensures that defect fixes or new changes haven’t broken existing functionality.

• Affected areas check after resolving bugs.
• Critical features checks.
• Integration points checks where they are working as before.

Once testing is complete, calculate the results against the test plan’s objectives and create a test closure report for the same:

• Summary: Overview of testing activities.
• Test Results: Number of test cases executed, passed, and failed.
• Defects Found: Total defects, their severity, and resolution status.
• Outstanding Issues: Any unresolved defects or risks.
• Lessons Learned: Insights for future testing.

Analyze testing outcomes to provide actionable feedback to stakeholders, such as:

• Software quality.
• Process improvements.
• Future testing strategies.
• User experience insights.

Manual Testing Process is known as a process of verifying the working on a software/application is expected or not with the help of creating test-cases. It re-check that the software functions are meets the requirements without errors, bugs, or any other issues and provides the expected output to the user.

Here are the Differences between Manual Testing and Automation Testing in the proper descriptive form.

Read More: Differences between Manual Testing and Automation Testing

Here are the Tools Used for Manual Testing in the proper descriptive form.

1. Test Link: It is a web-based test management system that facilitates software quality assurance, and it is one of the most user-friendly programs. It is available through a browser connected to the internet. This manual software testing tool support various programming language.

• Support cross-browser testing across different platform.
• Facility to record and playback functionality for test automation.

2. Bugzilla: It is a web-based bug-tracking tool that is developed by Mozilla. It has a simple bug search that searches the complete text of the bug. It supports various OS like Mac, Windows, and Linux.

• Facility to list the software bug in different format.
• Bugzilla has advance searching facility.

3. Jira: It is a manual testing tool that helps teams assign, track, report, and manage work and bring teams together. This tool is compatible with agile software projects also. It have an option to track and manage bugs and defects and prioritize and assign tasks.

• Collaborate with team members.
• Easily generate reports and track progress.

4. LoadRunner: It is one of the most widely used performance testing tools. The primary purpose of this tool is to categorize the most prevalent causes of performance problems. It simulates real-world user behavior and load and identifies bottlenecks and performance issues.

• Scalable architecture for large-scale testing.
• Provides detailed reports and analysis.

5. Apache JMeter: It is an open-source load testing tool for analyzing and measuring the performance of a variety of services. It has an easy-to-use user interface. It simulates various types of load (web, database, etc.). It have Highly configurable and extensible and integrates with various plugins for additional features.

• Provides comprehensive performance reports and graphs.
• Manual Testing vs. Automation Testing

6. Perfecto: It is a software which is used to do manual testing specifically for mobile user interface. It consists of various mobile devices screen resolutions which allows us to test the user interface of mobile view with various screen virtual devices and Provides real device user interface experiences. Developers can also use this to pre-validate their developed code to test for all versions.

• For example, it provides the exact screen resolution of iPhone, Samsung, iPad, Pixel and so on depends on requirements needed.
• Provides good test environment to find the defects.
• It allows supports some tablet screen resolutions like iPad.

• Human Performance: Human testers who use the product the same way as end users conduct manual testing. Manually carrying out test cases, testers provide input and watch the result to find errors.
• Investigative Testing: Exploratory testing, in which testers examine the application without using pre-defined test cases, is a common component of manual testing. This method aids in locating unforeseen problems and evaluating the user experience.
• Flexibility: Throughout the testing process, testers can adjust to changing conditions and requirements. Based on their observations, they can adapt test cases or investigate new ideas.
• Initial Testing: Early in the software development life cycle, even before the program is fully developed, manual testing can be started. By doing exploratory testing, testers can find problems early in the development process.
• Examining Complex Situations: When testing complex scenarios that could be difficult to automate, manual testing works well. Testers can evaluate the interactions between various components and through complex workflows.
• Testing User Interfaces (UI): Manual testing is a good way to assess an application's user interface. From a user's point of view, testers can evaluate the general design, responsiveness appearance, and feel.

Below are some reasons why manual testing is required:

• Bug-free and Stability: The main goal of manual testing is to ensure that the application is bug-free, stable, in conformance with the requirements, and delivers a stable product to the customers.
• Familiarity with the product: Manual testing helps the test engineers get more familiar with the product and get an end-user perspective. This helps them to write correct test cases for the software.
• Fixing the defects: Manual testing helps to ensure that the defects are fixed by the developer and that retesting has been done on the fixed defects.

• Fast and accurate visual feedback: It detects almost every bug in the software application and is used to test the dynamically changing GUI designs like layout, text, etc.
• Less expensive: It is less expensive as it does not require any high-level skill or a specific type of tool.
• No coding is required: No programming knowledge is required while using the black box testing method. It is easy to learn for the new testers.
• Efficient for unplanned changes: Manual testing is suitable in case of unplanned changes to the application, as it can be adopted easily.

• Less reliable: Manual testing is less reliable as it does not provide testing on all aspects of testing.
• Can not be reused: There is a need to develop separate test cases for each new software.
• Large human resources required: Manual testing requires numerous human resources, and there are some tasks that can't be performed manually.
• Needs experience: The tester needs to know the application well. They develop test cases based on their experience, there is no proof that all the functions are covered or not.
• Time-consuming: If the project is large, then the testing process is time-consuming.

In this article, we have discussed detailed information about manual testing as well as automated testing. You will also find the key difference between manual and automated software testing along with the popular tool that is used for manual testing.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4