case study examples manual testing

How to Write Test Cases for Manual Testing

What is a Test Case?

What are the manual test cases.

• 3.1 Step 1 – Test Case ID:
• 3.2 Step 2 – Test Case Description:
• 3.3 Step 3 – Pre-Conditions:
• 3.4 Step 4 – Test Steps:
• 3.5 Step 5 – Test Data:
• 3.6 Step 6 – Expected Result:
• 3.7 Step 7 – Post Condition:
• 3.8 Step 8 – Actual Result:
• 3.9 Step 9 – Status:

Best Practice for writing good Test Case.

Benefits of writing high-quality test cases, manual testing test case examples, test case execution and when to automate.

Manual testing is a way of testing software applications, products, and systems while using a minimum number of tools or sometimes without using any tools. This blog will provide an overview of the fundamentals of writing effective test cases in manual testing and key tips and strategies to consider. Creating good test cases requires:

• careful planning,
• attention to detail, and
• a deep understanding of the software to be tested.

But don’t worry, with a well-designed test case; you can save time and effort and make the testing process super efficient.

Table Of Contents

• 1 What is a Test Case?
• 2 What are the Manual Test Cases?
• 4 Best Practice for writing good Test Case.
• 5 Benefits of writing high-quality Test cases
• 6 Manual Testing Test Case Examples
• 7 Test Case Execution and When to Automate
• 8 Conclusion

A Test Case is a specific set of conditions or variables under which a tester will determine whether an application, software system, or one of its features is working correctly or not. A Test Case aims to validate software features’ accuracy, completeness, and reliability. A test case usually includes the following details:

• test case ID,
• test case description,
• steps to follow,
• expected results,
• pass/fail criteria, and
• status of the test case.

A successful test case should identify correct and incorrect results, and any unexpected results should be reported as a bug. Test cases provide the basis for exhaustively testing a system and thus help increase the reliability and quality of the system by uncovering mistakes or gaps in the system.

I can say,” Manual testing is a good old-fashioned human instinct and attention to detail.” Manual testing involves testing software manually, i.e., without using any automated tools. For executing this testing, you sometimes create test cases beforehand. These test cases are called manual test cases. A few examples of manual test cases include:

• validating that the login page is working properly,
• testing that the correct data is displayed on the search results page,
• ensuring the registration form is accurate before submission,
• testing the functioning of the shopping cart, and
• validating the order process.

Manual test cases are written in a clear and precise manner, which helps testers to understand and execute the tests accurately. Moreover, manual test cases can be used multiple times to execute tests, this helps to save time and money on software testing.

Read all about Manual Testing

How to write test cases: A step-by-step guide

If I explain to you in just a two-line summary of how to write a manual test case, it would be: 1. Identify the feature or functionality you wish to test. 2. Create a list of test cases that define specific actions to validate the functionality. Let’s see the detailed steps for writing test cases.

Step 1 – Test Case ID:

In this step, the tester will assign a unique identifier to the test case. This allows the tester to recall and identify the test case in the future easily.

Example: TC-01: Verify Login Functionality for a User

Step 2 – Test Case Description:

The tester will describe the test case, outlining what it is designed to do. The tester may also provide a brief overview of the expected behavior. An Example: Test Case Description: Test for Logging Into the application Given: A valid username and password for the web application When: User enters the username and password in the login page Then: the user should be able to log in to the application successfully. The Home page for the application should be displayed.

Step 3 – Pre-Conditions:

The tester will document any pre-conditions that need to be in place for the test case to run properly. It may include initial configuration settings or manually executing some previous tests. A Pre-Condition example in testing could be that the test environment must be set up, to be very similar to the production environment, including the same hardware, operating system, and software.

Step 4 – Test Steps:

The tester will document the detailed steps necessary to execute the test case. This includes deciding which actions should be taken to perform the test and also possible data inputs.

Example steps for our login test:

1. Launch the login application under test.

2. Enter a valid username and password in the appropriate fields.

3. Click the ‘Login’ button.

4. Verify that the user has been successfully logged in.

5. Log out and check if the user is logged out of the system.

Step 5 – Test Data:

The tester will define any necessary test data. For example, if the test case needs to test that login fails for incorrect credentials, then test data would be a set of incorrect usernames/passwords.

Step 6 – Expected Result:

The tester will provide the expected result of the test. This is the result the tester is looking to verify. Examples of how to define expected results:

1. A user should be able to enter a valid username and password and click the login button.

2. The application should authenticate the user’s credentials and grant access to the application.

3. The invalid user should not be able to enter the valid username and password; click the login button.

4. The application should reject the user’s credentials and display an appropriate error message.

Step 7 – Post Condition:

The tester will provide any cleanup that needs to be done after running the test case. This includes reverting settings or cleaning up files created during the test case. Example: 1. The user can successfully log in after providing valid credentials. 2. After providing invalid credentials, The user is shown the appropriate error message. 3. The user’s credentials are securely stored for future logins. 4. The user is taken to the correct page after successful login. 5. The user cannot access the page without logging in. 6. No unauthorized access to the user’s data.

Step 8 – Actual Result:

The tester will document the actual result of the test. This is the result the tester observed when running the test. Example : After entering the correct username and password, the user is successfully logged in and is presented with the welcome page.

Step 9 – Status:

The tester will report the status of the test. If the expected and actual results match, the test is said to have passed. If they do not match, the test is said to have failed.

Example : Tested the valid login functionality. Result: The user is able to log in with valid credentials. Overall Test Result: All the test steps were successfully executed, and the expected results were achieved. The login application is functioning as expected. Tested for Invalid Login functionality. Result: The user is unable to log in with invalid credentials. Overall Test Result: The invalid login functionality has been tested and verified to be working as expected

When it comes to writing good test cases, certain best practices should be followed.

• First, it is important to identify the purpose of the test case and what exactly needs to be tested.
• Next, the test case should be written clearly and concisely, with step-by-step instructions for each action that needs to be taken. Also, it is important to consider all possible scenarios and edge cases to ensure thorough testing.
• Another important factor is maintaining organization and structure within your testing process by creating a logical flow of tests covering different aspects of the tested system.
• At last, it is always recommended to review and refine your test cases occasionally to maintain their quality over time.

By sticking to these best practices for writing good test cases, you can improve your success rate in identifying defects early in the software development lifecycle. This ensures optimal performance for end users.

Hey, did you know that making good test cases is important? It helps make sure that software stuff is top-notch. And good test cases help in lots of ways!

Let me narrow down to some essential facts here:

1. Accurately Identify Issues : High-quality test cases ensure the application is thoroughly tested and any issues or bugs are identified accurately.

2. Enhances test coverage : Test cases can assess different aspects of a software product or service, providing comprehensive coverage of the product to evaluate it. This means any bugs or other issues in the software can be identified and addressed before it is released for public use.

3. Enriches software quality : The amount of money and time needed for repairs and updates can be greatly reduced by recognizing faults and enhancing the general dependability and quality of the software before its launch.

4. Improves collaboration between stakeholders : High-quality test cases help stakeholders work collaboratively, as they can understand the objectives of the tests and share information and resources more effectively. This encourages a cohesive approach to testing and developing better products throughout the software development life cycle.

5. Improves user experience: High-quality test cases can enhance end users’ experience by assessing the software’s user experience and usability components. This helps to ensure that users are happy and satisfied with the software, which is essential for its success.

H ere are some examples that you can easily understand about Manual Testing:

1. Login Page: We can assume a login application like Gmail.

• Test Case 1: Verify that the application allows users to input their username and password.
• Test Case 2: Verify that the application correctly validates the correct credentials.
• Test Case 3: Verify that the application displays an error message when the incorrect credentials are entered.

2. Search Functionality:

We can assume Google searches for this.

• Test Case 1: Verify that users can search for specific records in the database.
• Test Case 2: Verify that the application displays the query results correctly.
• Test Case 3: Verify that the application displays an error message when no matches are found.

3. File Uploads:

We can assume a resume upload in any job portal like LinkedIn or Monster

• Test Case 1: Verify that users are able to upload the correct type of file format.
• Test Case 2: Verify that the application does not allow users to upload malicious file formats.
• Test Case 3: Verify that the application displays an error message when the maximum file size is exceeded.

The types of manual testing test cases are functional test cases, regression test cases, integration test cases, system test cases, GUI test cases, security test cases, usability test cases, performance test cases, compatibility test cases, and acceptance test cases.

Talking about the test case execution part, the main objective is to verify whether the software behaves as intended, identify any defects or issues, and ensure that all requirements are met.

To answer the question, when to Automate?

The decision to use Automation Testing depends on the project and its specific requirements.

When you want to test something swiftly and without the need for a human tester to go through each step, automation testing is your best bet. Not only does it make the process quicker, but it also helps minimize errors. Automated tests can quickly cover larger areas of the application and surface any issues that need further investigation. Automated tests can also be used for repetitive processes such as checking user input fields for consistency, running queries, and verifying functionality over multiple scenarios. It can also help improve test coverage and maximize the return on investment.

Testsigma is a cloud-based AI-driven Test Automation Platform that brings automation capabilities to non-technical users. It is designed for Test Automation Engineers and Testers of any experience level and can automate end-to-end processes, including UI and API. You can write your test cases in NPL( Normal English) using this tool.

Testsigma can help automate the entire test lifecycle, including Test Case Execution, Test Results Analysis, Regression Tests Creation, and Reports Generation. It also helps automate cross-platform tests on multiple browsers, mobile phones, and operating systems. Testsigma also provides test report automation, enabling teams to use visualized reports and analytics to track progress, optimize test execution speed, and reduce rework.

So far, we have read in detail about manual testing. Writing effective and thorough test cases, and executing them helps ensure that a software product functions exactly as intended and that bugs are identified. Manual testing of test cases should include steps to replicate actions performed in the software and validate that results are accurate and consistent. A systematic approach to writing test cases with strong input and output validations will help uncover issues easily, giving the tester a thorough view of any software product.

Frequently Asked Questions

How do you write a test report for manual testing?

Does a manual tester write test cases?

What is the difference between Test Scenario and vs. Test Case?

Writing Test Cases: Examples, Best Practices & Test Case Templates

Test automation is on everyone's lips these days, which is why you might be wondering if writing manual test cases is still relevant. For many teams the answer is a resounding Yes . While test automation is vital, writing test cases for manual testing is still important for many reasons .

Often times tests are just too complex and expensive to automate – manual testing can sometimes be more efficient and is often leveraged to prevent critical bugs in software from reoccurring. Automation is also still not suited for more creative and empathetic test approaches. And many companies simply don't have the expertise to turn their backs on writing test cases.

That's why manual testing is still a standard approach for software developers and testers, requiring proficiency in writing test cases and a place to manage them. Many companies utilize dedicated test management solutions for this purpose, while smaller teams often take the old-school approach with Excel spreadsheets. Regardless of the tool your team chooses, even the most modern test management app doesn't automatically make you a good test case writer.

So if you're looking to improve your test case writing skills, keep reading to learn from some of our test case examples and from best practices we've learned over time.

Why Writing Good Test Cases Makes a Difference

Before we get into the "how," let's first examine why you should care about writing good test cases in the first place:

Good test cases are easier to maintain. Writing test cases takes time. Consequently, if the system under test changes, you don't want to spend too much extra time updating them. Maintaining existing test cases should be as simple as possible – especially if you're not the test case author.

Good test cases are versatile. Nobody wants to update the entire test suite for every new feature release. Try to write nonspecific test cases that remain relevant after the system's user interface changes to save time and minimize errors in test cases caused by hasty updates.

Good test cases make you flexible. Finally, you can use the time saved in writing and managing test cases for other test methods, such as exploratory testing. This allows you to identify edge cases that need testing and ultimately ensure that your product delivers a great user experience.

Test Case Examples & Templates

Most importantly, a good test case should enable you to do your job as well as possible – regardless of the system under test or your test management solution.

Since many test management tools encourage testers to write overly detailed test cases, our examples should demonstrate that the quality of a test case doesn't depend on the number of fields you fill out. We sadly can't provide you with instructions on how to write the ideal test case for your specific scenario, but the examples below follow some of the best practices discussed later in this article.

Suppose we're developing a to-do app and need to test whether the UI correctly displays the results for creating, updating, and deleting to-do lists. Here's what some of these manual test cases could look like:

Title Create to-do list

Description

• Navigate to the Create new to-do list form
• Fill in all fields with valid test data (see test data in attachment)
• Submit form

Expected: The newly created to-do list detail page is loaded and shows all the specified data.

Attachment test_data_new_todo_list.txt

Title Update to-do list

Description Context: The user has created a to-do list.

• Navigate to the to-do list
• Click Update

Expected: The updated to-do list detail page is loaded and shows the newly entered data.

Attachment test_data_update_todo_list.txt

Title Delete to-do list

Description Conext: The user has created a to-do list.

• Click delete
• Confirm delete popup

Expected: The to-do list overview page is loaded, and the deleted to-do list is not listed.

Of course, this is not a complete test suite and we can think of various additional test cases for each scenario. However, these are some examples of nonspecific test cases that are quick to write and easy to maintain .

Let's look at another example. Imagine our to-do app had a bug in the past where the CSV export of a to-do list didn't result in a valid CSV file which caused a lot of issues for users.

We decide to write another test case to ensure that this bug doesn't reoccur with new app versions. In contrast to before, we want it to be more specific and yet as flexible and maintainable as possible:

Title Verify CSV export RFC 4180 compliancy

Description Prerequisites: The user has created a to-do list.

• Navigate to the export page
• Pick CSV as export file format
• Submit export form
• Open CSV file in a text editor
• The CSV file is downloaded to the computer
• The CSV file is RFC 4180 compliant (see sample CSV in attachment)
• The file content matches the to-do list data in the app

Attachment RFC_4180_CSV.csv

5 Best Practices for Writing Manual Test Cases

Now, let's look at five best practices for writing test cases we've learned over time. Taking them to heart will help you write better test cases and improve collaboration between testers and developers.

1. Keep it simple and consistent

It's not only about what you write ; it's also about how you write it . Using simple language and a specific writing style will help you write tests faster and make them easier for others to understand.

But making sure the entire team's on the same page here can be tricky. We therefore recommend creating and enforcing a style guide for writing manual test cases. This guide could define best practices, writing dos and don'ts, terms and abbreviations to use, the formatting of specific sections, and so on. Check out this Test Writing Style Guide from W3C to get an idea. You ideally define your own style guide based on your team's needs.

2. Start with a good test scenario

Writing good test cases is more straightforward when you have a good test scenario to begin with. And as you can imagine, poorly written test scenarios can negatively impact your test cases for several reasons. Let's look at a quick example!

Badly-scoped test scenario: Check user authentication functionality.

The problem with this scenario is that it doesn't define the test scope well. Should you write test cases for login, registration, and password reset? Suppose your colleague is working on a test scenario, "Verify user password reset," simultaneously. Now you're both writing the same test cases, wasting a lot of time.

Better-scoped test scenarios could be:

• Verify user login functionality
• Verify user registration functionality
• Verify password reset functionality

If you properly scope your test scenarios, it'll be easier to differentiate between tests and work with several testers in parallel.

Test case details and results added during testing.

3. Only be as specific as needed

You've probably heard the saying that testing is about being precise. However, test cases that are too specific are often inflexible and difficult to maintain. Hence, we believe that test cases should only be as detailed as needed . They should adapt to system changes and allow testers a more flexible approach to their work.

Let's demonstrate this with an example. Suppose we have a chat app and are working on checking the Update username functionality. The test case below ensures that the username isn't updated if the input field is left blank:

Title Check username update with empty username

Description Prerequisites: Be logged in

• Open the "Settings" page via the main navigation
• Open the "My profile" settings page
• Scroll to the "Update Username" section
• Don't provide any input to the field "New username"
• Submit the form by clicking the "Update Username" button
• Get message "Error: Username can't be empty."
• Username does not update in Profile

But what happens if the UI changes in the future? What if the "Settings" page isn't linked in the main menu, pages and buttons are given a different label, or the "Update Username" section is moved somewhere else? Then we'd have to rewrite all of the steps to make sure they reflect the current state of the system under test. And we'd have to do that for many test cases, which takes a lot of time.

Opting for a more vague approach saves you this trouble:

Description Prerequisites: Be logged in and be in the profile settings

• Scroll to update username form
• Leave username field empty
• Submit the form

Expected: See an update failure message.

With this version, you wouldn't have to update the test case with every slight change in the UI, but testers can still understand what to do. As a result, you can concentrate on other, more pressing, or creative tests.

4. But know when to be precise

Do testers regularly run into problems with the vague description of a test case and end the test run with an incorrect result? Then you should try writing a more specific test case and see if the testers fare better. Depending on the test case's complexity, it may take a few iterations to find the suitable accuracy.

Test cases for delicate features that work with sensitive data like passwords or credit card information also often call for more preciseness – especially if you've served your users with bugs in these features before.

You may remember the uproar Apple's macOS caused in 2017 when anybody could unlock the system with the username 'root' and a blank password. To be sure that this error never happens again, the testers could write a test case that tries to reproduce this exact bug:

Title Check login with empty password

• Start macOS
• Click "other" on Login Screen
• Enter username (data: root)
• Enter password (data: empty)
• Click enter twice

Expected: The login does not work and access is denied.

Not only can writing more accurate test cases help prevent known bugs, but it can also reduce the pressure software teams deal with by worrying less about delivering faulty software.

5. Encourage exploration

When you write down a list of test cases for your scenario, you're likely missing out on a few. Often you'll only recognize a test case when you encounter the corresponding error in your system. To address this, good testers invest time to freely explore features to discover new test cases and issues.

Not just that, but exploration also helps you discover a feature through your users' eyes and understand their needs and wants. Ultimately, this approach helps to improve the overall customer experience with your software, making you a more valuable tester for your company.

Again, the key is not to write test cases that are too specific:

• "Navigate to the profile settings page." Instead of specifying the exact route, we let the tester decide how to get to the destination.
• "Submit the contact form." A creative tester may have more than one idea of submitting a form – press the submit button, hit Enter on the keyboard, or even click the submit button of another form, etc.

The more you understand the system under test, the better you are at exploring it. In other words, you'll know what to look for and which aspects are more prone to errors. If you have time to explore, make the most of it and be creative.

Test cases and results in a test management tool (here: Testmo).

The Key to Writing Good Test Cases

Often times the key to writing good test cases is to know when to be specific and when not to. By following best practices and learning from test case examples, you can improve your test case writing skills and become a more effective tester.

Many effective software testing teams achieve their goals by combining manual test cases with test automation and exploratory testing. Keeping track of the various testing efforts and methods require efficient modern test management – especially if you're currently working with simple Excel sheets that are hard to maintain or if you use an older legacy system.

If that's the case for your team, you might want to consider looking for a dedicated test management tool such as our app Testmo that you can leverage for your testing strategy – now and in the future. Or review a list of the best test management tools to choose a tool for your projects.

But regardless of the tools you use, investing into becoming a better test case author and improving your manual testing skills is time well spent.

Start Testing with Testmo Free

#1 Modern Test Case Management Software

PS: We regularly publish original software testing & QA research, including free guides, reports and news. To receive our next postings, you can layout--page#doShowSubscribeModal">subscribe to updates . You can also follow us on Twitter and Linkedin .

Start testing with Testmo for free today

• Test Management
• Terms of Service
• Privacy Policy
• About & Contact
• Feature Tour
• Pricing & Plans
• Unified QA Testing
• Test Case Management
• Exploratory Testing
• Test Automation
• Projects & Milestones
• Reporting & Metrics
• QA Team Productivity
• CI Pipelines & DevOps
• IT Enterprise Cloud
• Integrations & Jira
• Testmo Blog
• Testing Guides
• Support & Docs
• Testing Topics
• layout--page#doShowSubscribeModal">Newsletter
• Legal & Terms

Subscribe Subscribe to updates

What is Manual Testing? A Comprehensive Guide (With Examples)

What is Manual Testing?

Manual testing is a software testing approach where testers manually evaluate software or application quality without the help of automated testing tools or test scripts. Testers interact with the system like how an end user would to identify bugs, defects, and issues in the software that create friction in user experience.    

When a developer manually runs their application and tries out the features they have coded, they are doing manual testing. Its simplicity makes manual testing great for small-scale testing of personal projects. Even for large-scale testing where there are thousands and millions of items and features to test, manual testing is still needed to some degree.     

Types of Manual Testing

Any type of testing can be executed both manually and with the help of an automation tool. The final decision to choose which approach lies in the nature of that specific test case. Several testing types that are usually done manually include:

• Exploratory testing : testers explore the application or software without predefined test cases.
• Ad-hoc testing: Testers perform testing without following any specific test cases or scripts. Instead, they test the application based on their knowledge, experience, and intuition, targeting areas that seem likely to have defects
• Usability testing: Testers interact with the application, performing various tasks and providing feedback on the overall user experience.
• Functional Testing
• Non-functional Testing
• Unit Testing
• Integration Testing

Read More: Different Types of QA Testing

Manual Testing Example With Facebook

Let's see how manual testing is done at Facebook!

Now imagine that you are a manual tester whose task is to ensure that the Login page of Facebook works 24/7. What test cases will you carry out to achieve that goal?

Take your time and list down all of the test cases you want to execute. Make sure to include all of the possible scenarios.

Here is a non-exhaustive list for you:

Positive Test Cases:

• Login in with valid credentials
• Login with a new password after resetting the password.
• Login with a new password after changing it.
• Login with the "Remember Me" checkbox selected and verify that the session persists.
• Login with valid credentials on different browsers (e.g., Chrome, Firefox, Safari).
• Login with valid credentials on different devices (e.g., desktop, mobile, tablet).
• Login and verify session timeout after a period of inactivity.
• Login and verify redirection to the user's home page.

Negative Test Cases:

• Login with an invalid username and a valid password.
• Login with a valid username and an invalid password.
• Attempt to login with the username field empty and a valid password.
• Attempt to login with a valid username and the password field empty.
• Attempt to login with both username and password fields empty.
• Attempt to login with SQL injection code in the username or password field.
• Attempt to login with a username or password exceeding the maximum allowed length.
• Attempt to login with special characters only in the username or password field.
• Attempt to login with valid credentials for an account that is locked.
• Attempt to login multiple times with incorrect credentials leading to account lockout.

Performance Test Cases:

• Simulate 1000 users concurrently logging in.
• Stress test with 10,000 concurrent login attempts.
• Increase the load gradually until performance degradation.
• Test login performance under maximum load conditions.
• Continuous login attempts for several hours to test stability.
• Suddenly increase login attempts to test response to spikes.
• Measure CPU and memory usage during peak login times.
• Verify login functionality under failover conditions.
• Test login performance on different browsers (e.g., Chrome, Firefox, Safari).
• Test login performance under different network conditions (e.g., high latency, low bandwidth).
• Continuous login attempts over an extended period for memory leaks or issues.

For each of these test cases, you must manually perform every single test step it requires. For example, for the “Login in with valid credentials” test case, here are the test steps you need to take:

Navigate to Facebook Login Page

• Open a web browser.
• Go to the Facebook login page ( https://www.facebook.com ).

Enter Valid Credentials

• Enter a valid username (email or phone number) in the username field.
• Enter a valid password in the password field.

Click on Login Button

• Click on the "Log In" or "Sign In" button.

Verify Successful Login

• Wait for the page to load.
• Verify that you are successfully logged into your Facebook account.
• Ensure that the user profile or home page is displayed without errors.

While that may seem like simple and straightforward steps, when you factor in the number of test cases to do, and the number of times these test cases must be re-executed (known as regression tests), the amount of effort required becomes more than enormous.

It is highly likely that these test cases are all automated to increase efficiency. Manual testing is actually reserved for the more complex scenarios.

Manual Testing vs Automation Testing

Unlike manual testing, automation testing involves executing test cases automatically either through reusable test scripts or with the help automation testing tools . 

Read More: What is Automation Testing?

Both manual testing and automation testing have their strengths and weaknesses. The choice between them depends on factors such as project size, complexity, frequency of testing, available resources, and the specific goals of testing. 

In practice, a combination of both approaches often yields the best results, with manual testing for exploratory and usability aspects and automation testing for repetitive and resource-intensive tasks. You can have a look at the table below to better understand the differences between the 2 approaches:   

Read More: Manual Testing vs Automation Testing

In the long run, automation brings good ROI . According to the State of Quality Report 2024 , “the percentage of respondents reporting high to very high ROI increases from groups adopting automation for less than a year to those exceeding five years”. In other words, although initially automation testing requires a lot of investment and training as compared to manual testing, the benefit is totally worth it over time.

→ Check out the State of Software Quality Report 2024 to get the latest industry insights

How To Do Manual Testing?

No matter what approach testers choose, they all have to follow the Software Testing Life Cycle (STLC), with the major difference being the execution step: manually or automatically.

Manual testing begins with requirement analysis, which provides the QA team with a comprehensive understanding of the test objectives, serving as the foundation for the creation of a  test plan by the QA manager. This test plan includes detailed instructions for test execution (what area to cover in the test, how to test, what technology is required, resources to be allocated, timeline, roadmap, contingency plans, and expected outcomes). These 2 initial steps align stakeholders with the overall vision of the project and prepares them for the real test activities later.

Read More: Key Differences Between a Test Plan and a Test Strategy Document  

After the configuration of the test environment, testers proceed with manual execution of the test cases as outlined in the plan, then communicate bugs found to the development team for the troubleshooting process. Let’s take a simple test scenario: Form Validation. The goal is to verify that form fields display appropriate messages and behave as expected. A manual testers should follow these steps to execute that test:

• Open the form page
• Navigate to the form
• Type a random combination of characters in the email field
• Submit the form

Expected results: the form displays an error message indicating that the input characters are not in the correct format of an email

This test case can get more complex depending on the business requirements. For example, a B2B company only wants to collect business emails and not personal emails, so they want to make sure that users type in emails without the “gmail.com” ending. In this scenario, testers will perform the test above once again, but they’ll type in a personal email (for example:  [email protected] ) then a business email ( [email protected] ) to see how the form behaves.     

Another good example is manual  insurance application testing , where the tester examines the policy creation functionality, ensuring that a new policy can be successfully created with accurate information and stored in the correct system. The following steps should be followed:

• Log in to the insurance application with valid credentials.
• Navigate to the policy creation section.
• Enter the required policy details, such as policy type, insured party information, coverage details, and premium amount.
• Provide valid and appropriate inputs for each field, ensuring data accuracy.
• Save the policy.

Expected Result:

• The policy should be created successfully, and a confirmation message or notification should be displayed.
• The created policy should have accurate and consistent information as provided during the policy creation process.
• The new policy is stored and accessible in the insurance application for further processing and management.
• The right information is presented in the frontend and backend.

In this scenario, testers need to have a list of policy details to enter. Manually entering a long list of data is exhausting, and may introduce human errors, so although manual testing is possible, having some supporting tools for these scenarios truly helps. 

If you don't know which test cases to start with, here are the list of popular test cases for you. They should give you a good foundation of how to approach a system as a tester. 

• Test Cases For API Testing
• Test Cases For Login Page
• Test Cases For Registration Page
• Test Cases For Banking Application
• Test Cases For E-commerce website
• Test Cases For Search Functionality

Why Do We Need Manual Testing?

The recent decade has witnessed a tremendous shift in the Software Testing industry from manual testing to  automation testing . Many people claim that manual testing belongs to the past, and manual testers will be replaced by  automation testing tools , especially now that AI, Machine Learning, and many other disruptive technologies are on the rise.

Read More: AI Testing: The Future of Software Testing    

In reality, that will not happen, at least not in many years to come. Manual testing plays an essential role in the software development life cycle, and will continue to do so, for several reasons:

1. Manual testing allows for more human input

To be human is to be creative and intuitive, and in certain types of testing those 2 factors are a must-have. For example, in exploratory testing, testers have to actively explore and interact with the software to “get to know” the application before deep-diving into the details. It is proven that this approach allows testers to uncover bugs that they don't even know of in the first place. You can read more on the research here .

It is a free-style approach with no rules, no specifications, no documentation, only the tester simultaneously learning about the product and pinpointing potential areas for further testing. Manual testing allows us to ask questions like “What if I do it  this  way?” - and this liberty of experimentation is something automation testing just won’t be able to deliver.    

After that there is usability testing to evaluate how good the UX is, and machines can’t differentiate between “good” usability and “bad” usability. Automated test scripts don’t know that a text is illegible, a button is just visually unappealing or the placement of certain text next to certain images makes the instructions unclear. 

Only a human tester with adequate product knowledge and, most importantly, real-world perspective, can identify that. Skipping these types of testing is risky for the release quality, and there is no workaround as we know of for now that doesn’t involve a manual tester.

2. Manual testing leaves room for changing requirements

Software development is a highly dynamic process with requirements constantly changing, and human testers can adapt to these changes quickly by adopting a new test approach.     

For example, previously the requirement was simply to test the login functionality if it accepts valid username and password, but now the requirement includes password strength verification. With manual testing, testers only have to type in several combinations of passwords that meet and do not meet the password strength criteria (include capitalization, special characters, and exceed a certain number of characters) to see how the system responds.

With automation testing, the process involves updating the test scripts, updating the test data, executing the scripts, then checking the results, which are more technical-intensive and time consuming, especially in teams with limited programming expertise.    

Moreover, the scenario above does not happen many times - it only needs to be tested once and for all - so automating such a test case is counterproductive. If the QA team decides that a changing requirement is a one-off event, it is better to just go with manual testing.

3. Manual testing has lower learning curve than automated testing

To do manual testing is to experience the application in the same way an end user would, and almost anyone can become an end user. Manual testers, of course, must have enough technical knowledge and experience to know how to best “break” the app, but other than that they don’t need programming skills or engineering expertise to create test scripts like an automation tester. The low learning curve of this approach allows teams to start testing quickly at limited resources.    

Even in large scale testing projects with established infrastructure for automation testing, there can be test scenarios that are too complicated to be automated. Admittedly, automation testing is more ROI-positive in the long run than manual testing, but in too complex cases, technical limitation is truly a roadblock.

4. Manual testing allows QA team to go beyond the happy path

The happy path is the expected and ideal journey through a system or application where everything goes smoothly without any errors or issues. It's like following a clear and direct route to reach your destination.    

Automation testing typically focuses on the happy path since its goal is to verify that the system or application functions correctly according to the intended design and requirements. To login and use all of the features correctly is staying on the happy path, but unexpected scenarios exist, and QA teams must account those scenarios into their test plan too. Manual testing allows them to venture into the “unhappy path” where error conditions are triggered and the system is put under the extremes.    

With manual testing, the QA team must be creative to think of and test scenarios where users can potentially cause errors, such as malformed data, empty mandatory fields, or database connection failures. They also need to simulate extreme cases that cause system overload to see how it responds. These scenarios don’t happen frequently, but when they do, the consequence is huge, and manual testing is the best way to test them. 

5. Manual testing is great for small projects

Automation testing requires upfront investment whether you choose to  build an automation testing framework from scratch  or  buy a prebuilt automation testing tool from a vendor. We have written quite an extensive post comparing  Katalon vs Selenium , a prebuilt tool vs a library to build automation framework. While the long-term savings and scalability is great, small projects, small businesses, and start-ups don’t want to add this to their already high short-term cost. Manual testing is a more reasonable choice here.

6. Low maintenance cost

A huge roadblock to many automation testing adopters is the maintenance cost and effort. Many companies cut automation out of their techstack to escape the need for constantly revising their automation test scripts when their code changes, or else their test scripts become obsolete and no longer reliable. On the other hand, manual testing does not require any test case maintenance : when a code update occurs, testers can adapt immediately.     

The more unstable the system is, the more important manual testing is. Humans can respond to unpredictability, but for automated test scripts, a slight change in the environment is enough to return false positives .

Challenges Of Manual Testing

Despite all of the benefits mentioned above, manual testing still presents its own challenges. It is simple to see how manual execution of tasks gets progressively more resource-intensive as the project scales.

1. Time-consuming

Manual testing involves executing test cases step-by-step, and the time it takes to perform each step depends on the speed of the human tester, who is greatly limited by their human physical capabilities. Humans can’t process billions of data points within a few seconds like a machine, and they are prone to error, fatigue, and distraction. When they make a mistake, they have to go back and correct it, further increasing the testing time.

The most time consuming activity is  regression testing , where testers have to execute a large number of tests to verify if anything goes wrong after a code update. Regression testing involves re-executing a lot of test cases, such as the Login feature test. It is a really simple test, but having to manually login over and over every time the code gets updated is exhausting and counterproductive.    

That’s not to account for the number of Operating Systems, browsers, and devices that testers have to run their tests on. The number of tests add up exponentially until it is humanly impossible. Over time, some QA teams even abandon some features to prioritize testing on more critical ones since they don’t have enough resources, leading to limited test coverage. which is a risky move. 

Read More: How To Switch From Manual Testing to Automation Testing?

2. Limited Test Reusability

Another major issue with manual testing is that tests can’t be reused like automation testing where tests are stored as automation scripts, ready to be executed whenever needed. Manual testing usually can’t be recorded in any form except for documentation on test results or test planning. In other words, every test execution is a new execution, which is why sometimes testers happen to discover a bug but can’t replicate it.     

Lack of test reusability results in 2 subsequent issues: 

• Lack of consistency: since manual testing relies on subjectivity and personal experience, and there may be an absence of well-defined and documented testing processes, QA professionals tend to approach the scenario in their own way, creating disparity in test results.
• Lack of scalability:   the more tests to be executed, the more manual testers required. Admittedly cost-effective for small projects, large testing projects benefit more from a hybrid approach with a strategic blend between manual testing and automation testing where repetitive tests are scripted to be reused across multiple runs.

3. Difficulty In Test Management

Without test management tools, manual testing efforts become a mess, since there is nowhere to document test cases or test scenarios and all test results are recorded by human testers with varying degrees of experience. 

Many testers advocate for using Google Sheets to manage test cases, which makes sense because Google Sheets can be considered as an all-purpose management tool. Each row is a test step, and the next column is a dropdown of whether the test passed, failed, or was unable to be tested, and the next column to that is the environment (browser + OS). You can customize the sheet to be as detailed as your team wants it to be. Google Sheet is also great for collaborative test plan development. 

In fact, Google Sheet has a  default template for test management that everyone can immediately gain access to.

It was good, at first, for basic needs. But once again, when the project scales, managing everything on a single spreadsheet gets unnecessarily complicated, and having dozens of testers simultaneously tampering with the spreadsheet is just a hassle, especially when a function gets modified and all cells return an error. By this point, you would wish you have a more dedicated system designed for test management.    

A good test management goes beyond what Google Sheet offers:

• Test case versioning
• Traceability 
• Text execution tracking
• Test report capabilities
• Lack of native integration with other testing tools and systems
• JIRA integration for advanced test management (Agile boards, issue history, issue dependencies, change tracking, comprehensive dashboard view, facilitated communication between stakeholders, etc.)
• Large test suite management
• Advanced access control (role-based access control, test suite or module-level permissions, workflow-based access control)

How To Improve Your Manual Testing With Katalon?

Katalon Platform is a comprehensive quality management platform supporting test management for  both manual testing and automation testing  on web, API, mobile across a wide variety of environments, all in 1 place, with minimal engineering and programming skill requirements. 

Katalon is a great addition to your manual testing techstack, helping you manage your day-to-day testing activities such as preparing test cases, executing them, storing results, robust report generation for analytics, bug tracking, import/export test cases, and even JIRA integration for project management. It gives you the capabilities of all of the tools you use everyday with specific customization for testing.    

For example, for test planning, once you have activated Katalon TestOps, you can create a test project and schedule a test release, with detailed information on test case status, start date, and release date. If you have a JIRA integration, you can click the “Populate JIRA release” button to import your existing JIRA test plan.

This integration allows for seamless synchronization of manual testing activities with bug tracking, project management, and other related tools, enabling better alignment between testing and development teams.

You can easily add your test cases in Katalon TestOps. The folders are displayed in a tree view in the left sidebar. Below is the  Project Dashboard  for the Web UI Tests Project for an eCommerce website, and in the Test Cases folder you can find the  Order and check out a single product  test case. 

You can click on the test case to edit its details.    

For reports on your manual testing efforts, Katalon highlights your testing activities with real-time data, which is categorized into 3 components: profile coverage (categorized by test profiles), execution trend (number of tests executed/passed/failed by day/week/month), and platform coverage (Mac, OS). These reports can all be shared automatically via email to the relevant stakeholders of your choice.

In addition to all of that, Katalon has a Slack - Microsoft Teams integration to allow you to send test reports to a Slack/Teams channel for enhanced collaboration and communication, resulting in a unified testing approach.    

If you want to experience the Katalon Platform, there is a Free Forever version and 30-day Free Trial that allows you to fully enjoy its capabilities.

Start Testing With Katalon Platform Free Trial    

1. How do you prioritize manual vs automation testing?

The decision to prioritize manual or automation testing is based on factors like:

• Project complexity
• Testing goals and objectives
• Repetitive testing tasks
• Available resources and expertise
• Time constraints

A general rule of thumb is that test cases with higher complexity and low repetitiveness should be conducted manually to ensure that there is human input to the test, while repetitive test cases are generally automated so that testers can focus on other value-generating activities   

2. Does manual testing require coding?

Manual testing does not require coding skills. Testers manually execute test cases and validate software functionality without writing code.

3. What is test scenarios in manual testing?

Test scenarios in manual testing are detailed descriptions of possible interactions, conditions, and actions that users might undertake with the software. They guide testers in conducting tests, ensuring various functionalities are adequately validated.

4. What is user story in manual testing?

A user story in manual testing is a concise, informal description of a feature's functionality from an end user's perspective. It helps testers understand the context and purpose of testing, enabling effective test case creation.

5. How to test a website using manual testing?

To test a website manually, testers navigate through its various pages, functionalities, and features. They validate links, forms, user interactions, responsiveness, and visual aspects. Additionally, they perform boundary tests, input validations, and compatibility checks across browsers and devices.

Read More: A Complete Web QA Checklist

6. What are the tools required for manual testing?

• Web browsers (Chrome, Firefox, etc.) for website testing. 
• Defect tracking tools (JIRA, Bugzilla) for issue management. 
• Document tools (Excel, Word) for test case documentation. 
• Collaboration tools for communication within testing teams.

Thanks for reaching out!

Article & Observations About Diverse Teams Working Better Together

Software Testing Client Project Case Study

Apr 21 • Case Studies

We are often asked what software testing is . The video below shares a solid definition of the term.

But we thought a software testing project case study might be helpful to better understand what software testers do on a typical day. This includes testing software, writing requirement documents for our clients, and creating user guides to ensure compliance for our clients to use for quality assurance and auditing purposes.

Iterators LLC was hired to complete accessibility testing for a few projects for the Library of Congress (LOC). Accessibility testing is required on all government websites, with Section 508 and WCAG 2.2 requirements used. To become a Trusted Tester an employee must complete the DHS Trusted Tester online training course requirements and pass the DHS Section 508 Trusted Tester Certification Exam of Homeland Security in Accessibility, and we are in a unique position to help on this project. We cross-train all our employees so that we can work on several projects at one time or several different aspects of a project to complete the work and reduce the cost to our clients.

Our first project assigned by LOC was testing their new braille feature on BARD Mobile for Android. We were tasked with testing the braille feature with several refreshable braille displays.

During our testing, we used the Orbit Reader 20 , and two different braille displays from Freedom Focus 14 and Freedom Focus 40 . There are plans to use other refreshable displays such as Humanware, but this testing has not occurred yet. We needed to test refreshable braille displays and their use in tandem with Google BrailleBack and Google TalkBack .

This work was to ensure that all hardware worked as expected with the apps we were testing. For this testing, we had to complete functional testing, smoke testing, exploratory testing and had a user panel to ensure we caught all issues that a visually impaired individual might experience while using the app.

Initially, our client was unsure if we would find any bugs and hesitant to have us enter bugs into Bugzilla as they stated the software was “complicated”. Bugzilla is a web-based general-purpose bug tracking system and not unlike other bug tracking systems we use every day such as Jira, TestRails, PractiTest, and Click-Up.

Testing was completed over several agile sprints with many significant software testing bugs found. Our testing had us test against the National Library Service requirements document. Next, we had to create an up-to-date user manual. While the manual had been updated several times, the testing had not been.

For example, when downloading a book or magazine from the Now Reading section of the mobile app, the download would end up at the bottom of the page. For years, the user guide had listed the download being at the top of the page once the document was downloaded.

Our testing team, on several occasions, said this was an error in the documentation and that the download ends up at the bottom of the page. This was corrected in the user document and sent to the development team to fix per the requirement document.

Over the next several months, we reported 30 high-priority bugs with about half fixed at this point. We have encouraged our client to test in an agile fashion because once the development team is finished, it’s harder to get these bugs fixed.

Our bugs were reported and based on the requirement document used to create the software. Lastly, the user guide had to be rewritten to reflect the app's behavior and general updates.

Once the app was tested and created, the user guide was sent to Communication Services to ensure the style used per other requirement documentation. This document had to be approved before being disseminated to the public. For example, how does the library determine what the Most Popular Books are, and over what period.

Once the document was returned from COS, this PDF document had to be remediated . The process of remediation is to make a PDF, create the heading for the document, alt text added to meaningful images, and decorative images either ignored or taken out of the digital document altogether.

Once the remediation process is complete and validated, the document becomes ADA-compliant. We then provide an accessible PDF that can be read with the use of a screen reader and create the HTML output so that the document can be added to the Library of Congress website.

You can find the current user guide we completed here: https://www.loc.gov/nls/braille-audio-reading-materials/bard-access/bard-mobile-android/#creatingfolders3.3

Case studies can be a great learning tool in software testing and project management. By looking at project case study examples, you can see how the project was planned and executed, as well as how certain tasks were managed. This can give a better understanding of what software testing involves on a daily basis. With the right software testing case studies example, software testers can hone their skills, improve project performance, and ultimately deliver better software testing results.

Related Resources:

• Crafting an Effective Test Plan: A Step-by-Step Guide
• Top Test Management Tools
• Mobile Application Functional and Performance Testing

About the Author

Jill Willcox has worked on accessibility issues for most of her professional career. Iterators is an inclusive women-owned small business (WOSB) certified by the Small Business Administration and WBENC. We provide software testing services for websites, mobile apps, enterprise software, and PDF remediation services, rendering PDFs ADA compliant.

Jill Willcox

Clutch names iterators llc as a top certified women-owned business for 2022.

Iterators LLC named Top Certified Women0owned Business Again 2022

Test Strategy vs Test Plan: What’s the Difference?

What is the difference between a test strategy and a test plan? Read this article to b...

May 05 • Reference

Manual Testing Tutorial – Complete Guide | Software Testing Tutorial

In this free online Software Testing Tutorial, we cover all manual testing concepts in detail with easy-to-understand examples. This Manual Testing Tutorial is helpful for beginners to advanced level users to learn software testing concepts with practical examples.

Why This Manual Testing Tutorial? This Software Testing Tutorial covers right from basics to advanced test concepts.

What are the prerequisites to learn Manual Testing Tutorials for beginners & advanced level?

• Basic computer knowledge
• Interest to learn Software Testing

Who is the targeted audience of this Software Testing Tutorial? Anyone who has an interest to learn Software Testing.

Software Testing Tutorial – Table of Content

Click on the links below to see the detailed content of each concept in this Manual Testing Tutorial.

Testing Fundamentals

• What Is Software Testing | Everything You Should Know
• 7 Principles of Software Testing
• Software Development Life Cycle
• Waterfall Model in SDLC
• Spiral Model in SDLC
• V Model in SDLC
• Agile Scrum Methodology
• Software Testing Life Cycle
• Types of Software Testing
• Levels of Testing

Types of Testing

• Automation Testing
• Static Testing
• Dynamic Testing
• Functional Testing
• Non-Functional Testing
• Smoke Testing
• Sanity Testing
• Unit Testing
• Integration Testing
• System Testing
• What is Regression Testing & When Do We Do?
• What is Retesting & When Do We Do?

Test Case Development

• What is Documentation Testing in Software Testing
• How To Create Test Scenarios (with Examples)
• Test Case Template With Explanation
• Test Scenarios of Login Page
• Test Scenarios of Registration Page
• Test Scenarios of GMail
• How To Write Test Cases for ATM
• Test Scenarios of Smart TV
• Test Scenarios of TV
• Requirements Traceability Matrix – RTM
• Do We Really Write Test Cases For All Testing Types

Testing Techniques

• Equivalence Partitioning Testing Technique
• Boundary Value Analysis Testing Technique
• Decision Table Test Design Technique
• State Transition Test Design Technique
• Use Case Testing

Test Management & Control

• Test Deliverables
• How To Create Test Strategy
• How To Create Test Plan
• Test Environment for Software Testing
• Bug Life Cycle (Defect Life Cycle)
• Bug Report Template (Defect Management Process)

Testing Different Domains

• Web Application Testing Tutorial
• eCommerce Testing Guide
• Payment Gateway Testing Guide
• How To Test Banking Application
• Database Testing

White Box Testing

• What is White Box Testing
• What is Static Testing? How To Perform It?

Performance Testing

• Performance Testing Types
• Performance Testing Tutorial
• Load Testing
• Stress Testing
• Reliability Testing
• Volume Testing Guide
• Benchmark Testing Guide
• Risk Based Testing
• Endurance Testing
• 12 Best Performance Testing Tools

Different Testing Types

• Acceptance Testing Guide
• User Acceptance Testing (UAT)
• Operational Acceptance Testing
• Confirmation Testing
• Configuration Testing
• Portability Testing
• Alpha Testing
• Beta Testing
• Positive Testing
• Negative Testing
• End-To-End Testing
• Maintenance Testing
• Manual Testing Methods
• Test Metrics
• Write Good Bug Report
• Software Architecture
• Black Box Test Design Techniques
• Grey Box Testing
• Adhoc Testing
• Mutation Testing Guide
• Localization Testing
• Bug Severity And Priority – Info-graphic
• Defect Triage Process in Software Testing
• What is Testing in Production
• Performance Testing – Complete Guide
• Penetration Testing – Complete Guide
• Security Testing – Complete Guide
• Product Testing
• Monkey Testing
• Fuzz Testing
• Cloud Testing Guide
• Automated Visual Regression Testing
• Usability Testing Guide
• Accessibility Testing Guide
• Cross Browser Testing
• Cross Browser Testing Checklist
• Parallel Testing
• ERP Application Testing
• Mobile App Testing Guide
• Salesforce Testing Guide
• A/B Testing Guide
• Pairwise Testing Guide
• Game Testing Guide
• Smart TV Testing Guide
• OTT Testing Guide
• Live Streaming Testing Guide
• AR/VR Testing Guide
• SaaS Testing Guide
• SOA Testing Guide
• Pilot Testing Guide
• API Testing – Complete Guide
• Website Cookie Testing Guide
• Geolocation Testing
• Shift-Left Testing
• Independent Testing
• Digital Experience Testing
• IoT Device Testing
• Choose Software Testing As A Career
• 7 Steps To Become A Pro At QA Testing
• Software Testing Interview Questions Free eBook
• Principles of Agile Software Development
• What are Quality Attributes in Software Architecture
• 20 Skills Of Highly Effective Software Tester
• A-Z Software Testing Terms That All New Software Testers Should Learn
• 100+ Software Testing Types
• A Day In The Life Of A Software Tester
• How To Hire A QA Engineer

Difference Between Software Testing Types

• SDLC Vs STLC
• Quality Assurance vs Quality Control (QA vs QC)
• Manual vs Automation Testing
• Black Box And White Box Testing
• Smoke Testing Vs Sanity Testing
• Static Testing Vs Dynamic Testing
• Test Strategy Vs Test Plan
• Test Case Vs Test Scenario
• Regression Vs Retesting
• Severity Vs Priority
• Functional Vs Non-Functional Testing
• Unit Testing Vs Integration Testing
• Integration Vs System Testing
• Verification And Validation
• Entry And Exit Criteria
• Performance Engineering Vs Performance Testing
• Performance Vs Load Testing
• Load Testing Vs Stress Testing
• Difference between Desktop, Client-Server And Web Application Testing
• Difference Between Defect Bug Error And Failure

Interview Preparation Topics:

• Manual Testing Interview Questions
• Real-Time Software QA Interview Questions And Answers
• Agile Testing Interview Questions
• JIRA Interview Questions
• Game Testing Interview Questions
• Automation Testing Interview Questions
• Selenium Interview Questions
• Performance Testing Interview Questions
• LoadRunner Testing Interview Questions
• JMeter Interview Questions
• Database Testing Interview Questions
• SQL Interview Questions

ISTQB Certification

ISTQB stands for I nternational S oftware T esting Q ualification B oard. I don’t say you will get a salary hike if you finish this certification but it’s always good to have certification in career development.

• How To Prepare for ISTQB Exam

Software Testing Tools

Manual testing does not mean that the software testers won’t use any tool in the process of testing. There are several tools available in the market which helps Software QA’s to test an application in an efficient manner.

• Best Test Management Tools
• Best Defect Tracking Tools
• Best Automation Testing Tools
• Best Regression Testing Tools
• Best Cross Browser Testing Tools
• Best Unit Testing Tools
• Best Functional Testing Tools
• Best Web Application Testing Tools
• Best API Testing Tools
• Best Performance Testing Tools
• Best Penetration Testing Tools
• Best Open Source Security Testing Tools
• Best Agile Testing Tools
• Best Service Virtualization Tools
• Best IT Automation Tools
• Best Data Warehousing Automation Tools
• Software Testing Trends 2022
• Mobile Testing Trends 2022

Download a sample resume using the below link and modify it as per your needs

• Sample Resume for Software Testers

Learn Through Videos

Check the below playlist to watch the complete Testing Tutorial.

If you want us to cover any other topic, please comment below. Finally, Happy Testing!

Can I learn software testing on my own?

Yes, you can learn software testing on your own. There is no need to enroll in any online courses by paying. There are many websites and YouTube channels dedicated to the topic. Here at SoftwareTestingMaterial, our software testing course covers nearly all topics a tester needs to get a Software Testing Job.

What should I learn for software testing?

If you want to become a software tester, you need to start by learning the basics. Once you understand manual testing, you can move on to automated testing using tools like Selenium. Our Selenium tutorial will help get you started with automating web applications.

Do Testers need programming skills?

It is beneficial for everyone to understand the process and try their hand at coding. For the most part, QA testers (manual testers) do not need to be concerned with learning how to code. If you want to become an SDET then you need to have coding knowledge.

Related posts:

• Selenium WebDriver.
• TestNG Tutorial
• VBScript Tutorial
• SQL Tutorial
• Java Tutorial

Like This Post?

Subscribe and get free access to subscriber-only guides, templates, and checklists. 

You are subscribing to email updates. Unsubscribe anytime. Your data is safe.

Rajkumar SM is a founder of SoftwareTestingMaterial. He is a certified Software Test Engineer by profession and a blogger & a YouTuber by a choice. He has extensive experience in the field of Software Testing. Furthermore, he loves to be with his wife and a cute little kid 'Freedom'.

Similar Posts

Integration Testing – Big Bang, Top Down, Bottom Up & Hybrid Integration

Beta Testing – A Detailed Guide

Decision Table Test Case Design Technique

Volume Testing Guide | What You Should Know

The Ultimate Automated Visual Testing Tutorial For 2024

What is FTP (File Transfer Protocol) 

23 comments.

Sir you are just fabulous I just read ur sdlc model what a expiation just superb ur too good yaar love you

Thanks Alok. I am glad you like it. Welcome to Software Testing Material

Testing spell is incorrect in the menu list

Hi Kulkarni, it’s not TestING its TestNG. It’s not typo. Anyway thanks. Keep visiting.

hi sir. i want to learn selenium.. and before that manual testing is optional or important..where i start bro…

You must learn manual testing concepts.

Sir could u upload video on complete day to day activities of QA tester.. Take (whatsapp, or fb)

Thanks a ton, u made my preparation easy by putting all concepts at one place. The way you presented each concept is crystal clear. Thanks again for such a great effort 🙂

Thanks Chaitri. I am glad you liked it.

I need below details about Manual Testing.

Manual Testing – Concepts, Methods, Types, Roles & responsibility for Test Engineer to Managers, Test Plan / Scenario / Case, Test Estimation.

End to end Manual testing details in Video & PDF Format

Check this post manual testing tutorial

Can you please add migration testing concepts

thanks and regards swetha

Sure swetha. We will post ASAP

Hi I’m Kalpana I saw your video on youtube its very nice explanation. now I want to learn QA manual testing from your video I’m new to this area. I want to start from the beginning to end where can I start which video it’s going to help me could you please guide me.

Thanks, Kalpana

Hi Kalpana, just follow this Manual Testing Tutorial . It will be helpful.

Please click on ‘Types of Testing” its taking to the page “Automation VS Manual”.

Thanks great effort. All topics are explained in easy way. Thanks, Purvi

Sir I got to much gap after completion of my btech now I want learn testing tools and I want to do the job on this basis am I get job after training the course . the gap is near around 6 years.

Hey Rajnkumar, can you add mobile testing details on this site then it will be very helpfull to all. Thanks

Hi. Its already there. We have published mobile testing guide, mobile testing tools etc.,

It is really a good information on manual testing it is really informative thanks for sharing with us

Hi Dipak, Thanks for your message.

Good day, Raj. For my preparation, I’m using your Testing Material, which is simple and straightforward. This week I have an interview, but I’m unable to access Agile interview questions. Could you please assist me with this problem? Thank you very much.

Hi Sudheer, Thanks for your message. Agile Interview Questions are listed under Interview Preperation in the guide and also you can navigate through menu – Interview Questions. Thanks.

Leave a Reply Cancel reply

Your email address will not be published. Required fields are marked *

Case Studies

• Test consulting & tools assessment partnership providing test assessment approach along with its in-house tools evaluation frameworks across various areas ❶
• Test advisory and managed testing of their new banking systems and integration testing for the complex touchpoints for multiple Fiserv products ❷
• Functional testing for MIFID II compliance across various systems including Charles River, Black Rock Alladin and Unavista. Set up a team of domain experts in quick time and help client complete the testing as per the regulatory deadline ❸
• Functional, usability and performance testing of new digital wallet services for quick financial transactions, and performed end-to-end testing of mobile app and APIs ❹

• Test partnership across all digital and backend applications for functional testing and tst automation. Setting up the QA processes, automation solution and framework from scratch and defined the automation roadmap ❶
• Functional and regression testing for existing ERP and web application. Development of automation framework and script to run regression suite. Refined overall testing process and implemented agile processes for both SDLC & STLC ❷
• Designed test strategy and performed functional and system integration tests across the application & UAT support was provided for supply chain, stores sales, and warehouses system ❸

Health Care

• Test partnership for automation, functional & performance testing services in a hybrid model across their information management system tested on both functionality and database end ❶
• End-to-end functional, security and performance testing of solution for defects in the application before going live. Setting up QA/ testing processes and creating re-usable test cases, etc. ❷
• Created performance test scenarios & automated critical test cases for strategy style maintenance & batch execution of automation scripts for desktop-based application ❸
• Performed VAPT on the web application, web services, AWS S3 buckets and medical device as per OWASP guidelines & SANS Top 25. Created HIPAA compliance policy manual for client & assisted with its readiness assessment ❹

• End-to-end functional testing partnership and provided agile coaching and streamlined their test processes. Supported system, data migration, and performance testing for ongoing sprints & support on regression, exploratory, integration, and automation testing ❶
• Test advisory, end-to-end functional testing, test automation, implement integrated automated testing framework, test optimization techniques & helped in setting up CI/CD pipeline. Streamlined IT processes and artifacts, optimized resource skills, tool metrics & provided well-defined quality management and monitoring mechanism ❷
• End-to-end validations on their IoT system. Performed component level and system-level tests using JMeter, Grafana, and Prometheus integration was implemented for component level and system-level performance, scalability, stress and endurance tests ❸

Media & Publishing

• End-to-end test testing function operating in an onsite/ offshore model. Services included test automation and performance testing. Reduced regression cycle time using automation first approach and helped identify the application bottleneck ❶
• Test automation partnership for their money control application based on web, desktop and mobile (both Android & iOS). Leveraged its in-house test automation framework Tx-Automate built on the BDD approach to help create an end to end CI/ CD testing framework integrated with client’s in-house DevOps tools ❷
• Performed integration, functional, usability & regression testing the application & customized QA process as per client needs to implement enforced standards and to build consistency across the teams ❸
• Conducted POC to identify a suitable performance testing tool for the application & recommended HP load runner, perform tool and using these testing was performed of a complex application ❹

ISV & Telecom

• Staffing & managing of QA testing team to support a host of different applications. Implemented matured agile transformation QA practice and extensive experience of test and lifecycle automation helping to build the right QA capabilities ❶
• Device testing for their mobile application based on iOS and android platforms over different physical devices. Determined the transparent data transmission in the devices connected via HFP ❷
• Test automation partnership for client’s software used for client lifecycle management processes. Leveraged Tx-Automate to enhance the solution and build a team to rapidly scale test automation for their key financial services clients ❸

• Test partnership for cloud transformation initiative including moving applications portfolio to Cloud. Created detailed cloud migration testing strategy, test planning & execution ❶
• Crafted a compelling solution with its comprehensive managed testing centre of excellence (TCoE) for QA partnership, provided in a global delivery model (GDM) ❷
• Managed testing services including test advisory, functional testing, automation & performance testing for a critical initiative to move 35+ applications to cloud. Set up automation framework using in-house automation framework ‘Tx-Automate’ ❸
• Examined the current QA processes, people and tools, and benchmark against the industry best practices like TMMi/ CMMi. Provided futuristic QA and automation roadmap & helped them in standardizing the QA /testing process at organization level ❹

Related Blog

Robotic Process Automation (RPA): A Revolution in the Software Testing Industry

The Critical Need for Automation Testing in the Software Ecosystem

Subscribe Our Newsletter

Lorem ipsum dolor sit amet, consectetur

Opt-In. Read T&C

Request For Download

Read more on our Privacy Policy .

During your visit on our website, we collect personal information including but not limited to name, email address, contact number, etc. TestingXperts will collect and use your personal information for marketing, discussing the service offerings and provisioning the services you request. By clicking on the check box you are providing your consent on the same. In the future, if you wish to unsubscribe to our emails, you may indicate your preference by clicking on the “Unsubscribe” link in the email. Read more on our Privacy Policy

Test Cases In Software Testing Examples

What We Are Learn:

Test Cases In Software Testing Examples: Test cases are essential to software testing, especially system testing. Simply put, the test cases are a set of preconditions, inputs, and expected outcomes that determine whether the software functions correctly. Also, following the test cases in software testing provides a systematic approach to verifying the software’s quality, performance, and functionality.

The test cases are typically developed based on the requirements and specifications of the software application, including test case design. Most organizations have their own test case template to prepare the TCs, and a well-written test case template with prerequisites is essential for effective software testing.

Because It provides a standardized format for organizing and documenting test cases, which makes it easier for testers to understand and execute them, test case templates typically include the test case ID, test case description, preconditions, steps, expected results, automation, and actual results. Writing effective test cases requires a deep understanding of the software application, its requirements, and its functionality.

Testers must be able to identify potential issues and edge cases and develop test cases that cover all possible scenarios, ensuring comprehensive test coverage. The testing team must work together to create test cases that are comprehensive, clear, and easy to understand so that other testers and stakeholders can review and execute them.

Testers can use boundary value analysis, equivalence partitioning, and decision table testing when writing TCs . These techniques help identify and prioritize the test cases most likely to identify defects and issues in the software application. Additionally, test data can be used to ensure that the software application’s user interface (UI) is functioning as expected under different scenarios.

Nowadays, many organizations use a test case template in Excel, a popular and effective way to manage and organize test cases in a test environment. Excel provides a range of features that make it easy to create, manage, and execute test cases, including test scripts.

Testers also use Excel to create TC templates, track testing progress, and generate reports. However, investing in test management tools may be beneficial for more complex testing needs.

Nowadays, many organizations use a test case template in Excel , a popular and effective way to manage and organize test cases. Because Excel provides a range of features that make it easy to create, manage, and execute test cases. Testers also use Excel to create test case templates, track testing progress, and generate reports.

However, those organizations are ready to afford some test case management tools, and they are using those online test case writing tools to accelerate test case preparation, including automation testing. Out of them, some are paid, and some are open source. Some TC management tools like JIRA, Bugzilla, and others exist, which offer compatibility with various testing frameworks and tools.

What are the Manual Test Cases in Software Engineering?

if we search in Google for the definition, according to Wikipedia

A test case specifies the inputs, execution conditions, testing procedure, and expected results that define a single test to achieve a particular software testing objective, such as to exercise a particular program path or verify compliance with a specific requirement.

What is a Test Case?

Test cases are software or application pieces that you can use to test the functionality of a real system. They can be used to evaluate the correctness and completeness of your code and can be used in conjunction with unit testing tools to ensure the quality of your applications.

Test cases can be created manually or using software testing tools. They are an essential part of software development and should be used wherever possible to ensure the quality and functionality of your applications, including end-user test execution.

How To Write Test Cases In Software Testing

Writing test cases is an essential part of software testing. Without them, it would not be easy to verify the results of your tests. Test cases are templates that help automate the testing process. They help specify the conditions under which a particular functionality should be tested, including the postcondition.

For example, a test case could include clicking the login button and verifying that the user is directed to the correct page.

Creating test cases ensures your software functions as expected and performs properly in all situations, including login functionality where the user enters their username and password. Additionally, TCs are necessary for manual testing – without them, it would be difficult to verify the results of your tests. So make sure to write test cases and test them frequently!

Best Practice for Writing Good Test Case For Tester

Writing good pre-test cases is essential for testing the functionality and usability of your software or application. If you follow best practices for software requirements, your TCs will be easy to follow and understand, and you’ll be able to run them frequently to ensure they’re accurate.

Include all the necessary details in your test cases to test the software under all possible conditions. Finally, ensure your test cases are easy to follow and run so that everyone involved in testing can get the most out of them. You can also provide a tutorial to help users understand how to run the test cases effectively.

Basic Format of Test Cases Excel Sheet

Creating test cases with a traceability matrix is essential to software testing, including regression testing. A test case is a scenario you use to test software or system. The statement of the problem, what you want to be tested, and the conditions under which the test will take place are all included in a test case.

A TC can be used to verify that your application works as expected or to find problems early in development. Writing test cases well makes it easier for you and other developers to work on your project.

Now, we will see how to create a basic test case format. First, we will create the test case template and then implement the test cases as required. So, to create a test case template, I will open an Excel sheet and add the required fields, including documentation.

So before start writing the test case template, let’s see what fields are necessary in a TCs template while writing test cases. Here is the fields list:

For details on how to write test cases in manual testing, we have already shared a detailed article on our SoftwareTestingo Blog . You can check by clicking How to Write Test Cases in Software Testing. Link.

Manual Testing Test Cases QA

We noticed that the interviewer mostly gave some real-time scenarios and expected test cases. If you have good knowledge of that application, you need to think as much as possible about test scenarios. If you are unaware of that application, you can ask for the details of the application, which is called Business Rules and Acceptance Criteria.

Different Types of Test Case Scenarios

Test cases are a set of specific instructions or criteria that are used to determine whether a piece of code is working correctly. These test cases can be designed to test different aspects of the code, such as its functionality, performance, or security. In some cases, test cases may be designed to intentionally cause the code to fail, for example, by providing incorrect input or attempting to access restricted areas.

This is done to verify that the code can handle such situations and respond appropriately rather than crashing or behaving unexpectedly. So, based on the behaviors, we can divide the test cases into the following:

Test Cases Examples ~ Test Cases Scenario Example

We Know if someone started his/her career as a manual tester, then the first assigned work for him may be writing test cases. In that time, you may be looking for Test Cases in Software Testing Examples PDF, which will help you to understand how to write test cases.

We will provide the manual testing projects with test cases in a PDF. So, if you have been searching for Test Cases in the Software Testing Examples PDF, we will gladly share the test cases below.

The manual testing projects below with test cases pdf can be used for software testing, performance testing, and penetration testing. The test case example for manual testing provided in the PDF is only an example to give you a better idea of how these tools work best in the software development environment (development/testing).

Functional Test Case Examples

When you see the headline, you may wonder: What is a functional test case example? So, let us try to explain what a functional test case example is.

A functional test case is a valuable tool for testers that helps ensure that a new function or feature works as expected. Creating and running a functional test case lets you quickly determine if the function or feature works as intended. This process helps prevent any unexpected side effects during the release process, which could lead to chaos and instability. 

Functional tests should be conducted throughout the development cycle – at the initial design stage, during development, and after release. They help to identify potential issues early on so that they can be fixed before users experience them.

Additionally, continuous testing allows for corrections to be made as soon as they’re identified – saving time and resources both now and in the future. So, why make sure your functions work as expected? It’s simple – without proper functionality verification, there’s no way of knowing whether your product is ready for release!

Mobile App Test Cases In Software Testing

Nowadays, mobile apps are common for almost every application. So, mobile app test cases are essential to validate the functionality of the various mobile applications. So, as per the request, we are developing some detailed mobile app test cases here.

Test Cases Example For Web Application

Validating a web application is a challenging task because web applications contain so many elements. So, validating each of those web elements needs detailed test cases. We have listed the positive and negative test cases of those elements on many websites.

Sample Functional Test Cases Example For Web Application In Manual Testing

We are getting many requests to update more test case examples for web applications. We guess one of the major reasons is as manual testers, we mostly validate web applications. This is one of the most time-consuming tasks for any QA or testers because, in a web application, you can find so many web elements, and you have to validate each.

So, as promised, we are trying to bring as many Web applications test scenarios or cases as possible. We hope these test case examples for web applications will help you understand how to validate a web page’s web elements.

We have shared some of the web page element’s functional test cases for web applications in manual testing. However, we may find new web page elements when validating different applications. So, if possible, can you share those elements’ details with us so we can share the sample functional test cases example for web applications in manual testing?

How do you write manual test cases in manual testing?

• You must remember some points when writing test cases, like writing the test case so that each step will test one thing at a time. Don’t complicate it by testing multiple things in a single test scenario.
• Try to cover positive and negative test cases to help provide a quality product to the users and help the organization.
• Try to write the test cases in a simple word that every word can easily understand.
• Write the test steps in a passive voice, like this. Do that, and it should be.
• When writing test steps, try to use the exact name for the fields.

Download Test Scenario Template | Manual Test Cases Template

Every business person wants to understand and use the software, but not all can make a full test plan. A Manual test scenario template helps create a complete test plan for testing the software at different stages of development. This test case example template helps developers test the software without writing any code by automating the entire process of building, executing, and monitoring the tests.

Manual test cases are one of the most important aspects of any testing process. They help you to define what needs to be tested and how it needs to be tested. Below, we will provide a test case example template for manual test cases that you can download and use in your testing process.

For Reference, You Can Take reference to the below manual test cases template, and we are working to add manual testing sample projects pdf:

Note: The template format may vary from organization to organization because every organization follows according to its requirements.

In conclusion, test cases are an essential component of software testing. They provide a systematic approach to verifying the quality and functionality of software applications. Writing effective test cases requires attention to detail, critical thinking, and a thorough understanding of the software application.

Test case templates provide a structured format for organizing and documenting test cases, making it easier for testers to execute them. Excel is a popular tool for managing and organizing test cases, allowing testers to create, track, and report on their progress.

Softwaretestingo Editorial Board

I love open-source technologies and am very passionate about software development. I like to share my knowledge with others, especially on technology that's why I have given all the examples as simple as possible to understand for beginners. All the code posted on my blog is developed, compiled, and tested in my development environment. If you find any mistakes or bugs, Please drop an email to [email protected] , or You can join me on Linkedin .

30 thoughts on “Test Cases In Software Testing Examples”

Need test case for WhatsApp web for my assignment

We try to add that in the list

Sir!! Please publish negative as well as positive test cases on food ordering app.

How to write a test case for an IVR application and call menu options which is related to telecommunication

Will try to update that too in the list

Please write test case on website

Please write thr test cases for Online Gold Shopping ???

How to write a test case for Rapido app and write test cases from “booking a ride” to “ending the trip”.

We will try to update the test scenario.

Hi please can you add a test cases for Recruitment project (For Job Portal project). Since I’m working on Job Portal project. Some where I’m missing some of the scenarios. It will be very much helpful if you include it.

Sure will try to add manual test cases for the job portal.

Sir!! How to write negative as well as positive test cases on food ordering app.

We Will Try to add

Hi, can you add some test cases for smart products or smart technologies? Thanks

Can you clarify the test strategy for manual tester

can u plz upload test scenarios for OLA,facebook app for different text fields

You Can Check these test cases:

1. https://www.softwaretestingo.com/ola-mobile-testing-test-cases/ 2. https://www.softwaretestingo.com/test-cases-for-facebook-in-excel-sheet/ 3. https://www.softwaretestingo.com/test-cases-for-facebook-chat-application/ 4. https://www.softwaretestingo.com/facebook-login-gmail-test-cases/ 5. https://www.softwaretestingo.com/text-field-test-case/

sir please add salesforce application Test cases

It seems that theres a few test cases on this list that dont have a link that redirects them to the test cases.

Change password Login functionality Mandatory field Search box

please add test cases for Ethernet module

Will try to add

Please add test cases for home automation project

plz help me out to write the testcases and scenario for toursim website

please add test cases for the bus,full positive and negative scenarios

Is there any article of positive and negative scenarios for Learning Management System Projects?

Is there any article related to Salesforce for writing test cases?

Hi Yadav, Currently there are no artticle related saleforce. But will try to add few soon

Please Write a test case for Face Recognization Application Thank You…!!!

Please write test cases for parabank demo website

For Such an Application, There are n Number of scenarios. So it’s better if you could mention a specific scenario then we will try to add those scenario test cases

Leave a Comment Cancel reply

Manual Test Case Scenarios

The Manual Test Scenario represents a series of associated actions or functions and helps set up a condition to test or even multiple conditions as they relate to a specific functional area.

Industry Awards

Global locations, certified qa professionals, happy clients, completed projects.

The Manual Test Scenario represents a series of associated actions or functions and helps set up a condition to test or even multiple conditions as they relate to a specific functional area. Where the test case tells you how to test something, the test scenario tells you what to test. Generally, a single test scenario is comprised of several test cases. The associated test cases try to test all possible inputs and outputs using that functional path or area. Each test case associated with a scenario have input values and expected results. They are step by step procedures to test the condition put forth by the overall test scenario.

A test scenario may also be a series of independent tests that, when completed, ensure the business process flow is functioning correctly from beginning to end. Some of these test cases may rely on the output of the previous test and as such, have to be executed sequentially. They always represent both typical, day-to-day operations as well as the unusual outlying situations.

An example scenario could be generalized to ‘Validate the Login Page’ and include multiple test cases to verify the behavior of invalid username and password combinations, ‘remember me’ functionality, or password resets. Or, the scenario could be more specific such as, “User Logs in with invalid credentials”. The test cases in the second scenario would be specific to invalid login situations. How generalized or specific a Test Scenario is depends on the QA Professional writing the scenario, the time allotted for scenario and test case creation, and the nature of the application under test.

QA Mentor utilizes the use cases, business requirements, and functional specifications to create each test scenario. We then map each one to its associated business requirements and associate them with functional specifications. This helps ensure and prove complete test coverage for the highest quality results.

Awards & Recognitions in Software Testing Services

GET IN TOUCH

Please complete the form and one of our QA Expert Specialists will be in contact within 24 hours. Alternatively, drop us an email at [email protected] or give us a call at 212-960-3812

Select your query Request Free Consulting Request a Call Back Request a Quote Request Online Presentation Request for Free Proof of Concept Request for Free Pilot Project Request for Functional Testing Request for Non-Functional Testing Request for QA Services Request for QA Packages

Software Testing Techniques with Test Case Design Examples

What is Software Testing Technique?

Software Testing Techniques help you design better test cases. Since exhaustive testing is not possible; Manual Testing Techniques help reduce the number of test cases to be executed while increasing test coverage. They help identify test conditions that are otherwise difficult to recognize.

Boundary Value Analysis (BVA)

Boundary value analysis is based on testing at the boundaries between partitions. It includes maximum, minimum, inside or outside boundaries, typical values and error values.

It is generally seen that a large number of errors occur at the boundaries of the defined input values rather than the center. It is also known as BVA and gives a selection of test cases which exercise bounding values.

This black box testing technique complements equivalence partitioning. This software testing technique base on the principle that, if a system works well for these particular values then it will work perfectly well for all values which comes between the two boundary values.

Guidelines for Boundary Value analysis

• If an input condition is restricted between values x and y, then the test cases should be designed with values x and y as well as values which are above and below x and y.
• If an input condition is a large number of values, the test case should be developed which need to exercise the minimum and maximum numbers. Here, values above and below the minimum and maximum values are also tested.
• Apply guidelines 1 and 2 to output conditions. It gives an output which reflects the minimum and the maximum values expected. It also tests the below or above values.

On Zoho Projects Website

On Jira Software Website

On Monday’s Website

Equivalence Class Partitioning

Equivalent Class Partitioning allows you to divide set of test condition into a partition which should be considered the same. This software testing method divides the input domain of a program into classes of data from which test cases should be designed.

The concept behind this Test Case Design Technique is that test case of a representative value of each class is equal to a test of any other value of the same class. It allows you to Identify valid as well as invalid equivalence classes.

Input conditions are valid between

Hence there are five equivalence classes

You select values from each class, i.e.,

Also read more about – Boundary Value Analysis and Equivalence Partitioning Testing

Decision Table Based Testing

A decision table is also known as to Cause-Effect table. This software testing technique is used for functions which respond to a combination of inputs or events. For example, a submit button should be enabled if the user has entered all required fields.

The first task is to identify functionalities where the output depends on a combination of inputs. If there are large input set of combinations, then divide it into smaller subsets which are helpful for managing a decision table.

For every function, you need to create a table and list down all types of combinations of inputs and its respective outputs. This helps to identify a condition that is overlooked by the tester.

• Enlist the inputs in rows
• Enter all the rules in the column
• Fill the table with the different combination of inputs
• In the last row, note down the output against the input combination.

Example : A submit button in a contact form is enabled only when all the inputs are entered by the end user.

State Transition

In State Transition technique changes in input conditions change the state of the Application Under Test (AUT). This testing technique allows the tester to test the behavior of an AUT. The tester can perform this action by entering various input conditions in a sequence. In State transition technique, the testing team provides positive as well as negative input test values for evaluating the system behavior.

Guideline for State Transition:

• State transition should be used when a testing team is testing the application for a limited set of input values.
• The Test Case Design Technique should be used when the testing team wants to test sequence of events which happen in the application under test.

In the following example, if the user enters a valid password in any of the first three attempts the user will be able to log in successfully. If the user enters the invalid password in the first or second try, the user will be prompted to re-enter the password. When the user enters password incorrectly 3 rd time, the action has taken, and the account will be blocked.

State Transition Diagram

In this diagram when the user gives the correct PIN number, he or she is moved to Access granted state. Following Table is created based on the diagram above-

State Transition Table

In the above-given table when the user enters the correct PIN, the state is transitioned to Access granted. And if the user enters an incorrect password, he or she is moved to next state. If he does the same 3 rd time, he will reach the account blocked state.

Error Guessing

Error Guessing is a software testing technique based on guessing the error which can prevail in the code. The technique is heavily based on the experience where the test analysts use their experience to guess the problematic part of the testing application. Hence, the test analysts must be skilled and experienced for better error guessing.

The technique counts a list of possible errors or error-prone situations. Then tester writes a test case to expose those errors. To design test cases based on this software testing technique, the analyst can use the past experiences to identify the conditions.

Guidelines for Error Guessing:

• The test should use the previous experience of testing similar applications
• Understanding of the system under test
• Knowledge of typical implementation errors
• Remember previously troubled areas
• Evaluate Historical data & Test results
• Test Case Design Technique allow you to design better cases. There are five primarily used techniques.
• Boundary value analysis is testing at the boundaries between partitions.
• Equivalent Class Partitioning allows you to divide set of test condition into a partition which should be considered the same.
• Decision Table software testing technique is used for functions which respond to a combination of inputs or events.
• In State Transition technique changes in input conditions change the state of the Application Under Test (AUT)
• Error guessing is a software testing technique which is based on guessing the error which can prevail in the code.
• What is Software Testing?
• 7 Principles of Software Testing with Examples
• V-Model in Software Testing
• STLC (Software Testing Life Cycle)
• Manual Testing Tutorial
• Automation Testing
• What is Unit Testing?
• What is Integration Testing? (Example)

• Trending Now
• Foundational Courses
• Data Science
• Practice Problem
• Machine Learning
• System Design
• DevOps Tutorial
• Software Testing Tutorial
• What is Software Testing?
• Principles of software testing - Software Testing
• Software Development Life Cycle (SDLC)
• Software Testing Life Cycle (STLC)
• Types of Software Testing
• Levels of Software Testing
• Test Maturity Model - Software Testing

SDLC MODELS

• Waterfall Model - Software Engineering
• What is Spiral Model in Software Engineering?
• What is a Hybrid Work Model?
• Prototyping Model - Software Engineering
• SDLC V-Model - Software Engineering

TYPES OF TESTING

• Manual Testing - Software Testing
• Automation Testing - Software Testing

TYPES OF MANUAL

• White box Testing - Software Engineering
• Black Box Testing - Software Engineering
• Gray Box Testing - Software Testing

White Box Techniques

• Data Flow Testing
• Control Flow Software Testing
• Branch Software Testing
• Statement Coverage Testing
• Code Coverage Testing in Software Testing

BLACK BOX Techniques

• Decision Table Based Testing in Software Testing
• Pairwise Software Testing
• Cause Effect Graphing in Software Engineering
• State Transition Testing
• Software Testing - Use Case Testing

TYPES OF BLACK BOX

• Functional Testing - Software Testing
• Non-Functional Testing

Types of Functional

• Unit Testing - Software Testing
• Integration Testing - Software Engineering
• System Testing - Software Engineering

Types of Non-functional

• Performance Testing - Software Testing
• Usability Testing - Software Engineering
• Compatibility Testing in Software Engineering

Test case development

• Testing Documentation - Software Testing
• How to write Test Cases - Software Testing

Testing Techniques

• Error Guessing in Software Testing
• Equivalence Partitioning Method
• Software Testing - Boundary Value Analysis

Test Management

• Test plan - Software Testing
• Software Testing - Test Case Review
• Requirements Traceability Matrix - RTM

Defect Tracking

• Bugs in Software Testing
• Bug Life Cycle in Software Development
• Severity in Testing vs Priority in Testing
• Test Environment: A Beginner's Guide
• Defect Management Process

Other types of Testing

• Regression Testing - Software Engineering
• Smoke Testing - Software Testing
• Sanity Testing - Software Testing
• Software Testing | Static Testing
• Dynamic Testing - Software Testing
• Load Testing - Software Testing
• What is Stress Testing in Software Testing?
• Recovery Testing in Software Testing
• Exploratory Testing
• Visual Testing - Software Testing
• Acceptance Testing - Software Testing
• Alpha Testing - Software Testing
• Beta Testing - Software Testing
• Database Testing - Software Testing
• Software Testing - Mainframe Testing
• Adhoc Testing in Software
• Globalization Testing - Software Testing
• Mutation Testing - Software Testing
• Security Testing - Software Testing
• Accessibility Testing - Software Testing
• Structural Software Testing
• Volume Testing
• Scalability Testing - Software Testing
• Stability Testing - Software Testing
• Spike Testing - Software Testing
• Negative Testing in Software Engineering
• Positive Testing - Software Testing
• Endurance Testing - Software Testing
• Reliability Testing - Software Testing
• Monkey Software Testing
• Agile Software Testing
• Component Software Testing
• Graphical User Interface Testing (GUI) Testing
• Test Strategy - Software Testing
• Software Testing Tools
• Top 20 Test Management Tools
• Defect Testing Tools - Software Testing
• 7 Best Automation Tools for Testing
• Top 10 Performance Testing Tools in Software Testing
• Cross-Browser Testing Tools - Software Testing
• Software Testing - Integration Testing Tool
• Software Testing - Unit Testing Tools
• Mobile Testing Tools - Software Testing
• GUI Testing Tool
• Security Testing Tools - Software Testing
• Penetration Testing - Software Engineering

DIFFERENCES

• Manual Testing vs Automated Testing
• Difference between Load Testing and Stress Testing
• Sanity Testing Vs Smoke Testing - Software Engineering
• Difference between System Testing and Acceptance Testing
• Quality Assurance (QA) vs Quality Control (QC)
• Difference between Static and Dynamic Testing
• Differences between Verification and Validation
• Difference between Alpha and Beta Testing
• Difference between Black Box and White and Grey Box Testing
• Difference between Globalization and Localization Testing

Test Case vs Test Scenario

• Test Strategy vs Test Plan
• Software Testing - Boundary Value Analysis vs Equivalence Partitioning
• Difference between SDLC and STLC
• Software Testing - Bug vs Defect vs Error vs Fault vs Failure
• Differences between Testing and Debugging
• Difference between Frontend Testing and Backend Testing
• Difference between High Level Design(HLD) and Low Level Design(LLD)
• Software Testing - BRS vs SRS
• Difference between Positive Testing and Negative Testing
• Difference between Top Down and Bottom Up Integration Testing
• Difference between Use Case and Test Case
• Difference between Monkey Testing and Gorilla Testing
• Difference between Stubs and Drivers
• Difference between Component and Unit Testing
• Difference between Software Testing and Embedded Testing
• Difference between GUI Testing and Usability Testing
• Difference between Tester and SDET
• Software Testing - Desktop vs Client-Server vs Web Application Testing
• Active Software Testing
• What is an API (Application Programming Interface)
• Difference between End-to-end Testing and Unit Testing
• Difference Between Object-Oriented Testing and Conventional Testing

How to write Test Cases – Software Testing

Software testing is known as a process for validating and verifying the working of a software/application. It makes sure that the software is working without any errors, bugs, or any other issues and gives the expected output to the user. The software testing process isn’t limited to finding faults in the present software but also finding measures to upgrade the software in various factors such as efficiency, usability, and accuracy. So, to test software the software testing provides a particular format called a Test Case . 

This article focuses on discussing the following topics in the Test Case:

Table of Content

What is a Test Case?

When do we write test cases , why write test cases   .

Test Case Template

Best Practice for Writing Test Case

Test case management tools, types of test cases, example test cases for a login page.

A test case is a defined format for software testing required to check if a particular application/software is working or not. A test case consists of a certain set of conditions that need to be checked to test an application or software i.e. in more simple terms when conditions are checked it checks if the resultant output meets with the expected output or not. A test case consists of various parameters such as ID, condition, steps, input, expected result, result, status, and remarks.

Parameters of a Test Case: 

• Module Name: Subject or title that defines the functionality of the test. 
• Test Case Id: A unique identifier assigned to every single condition in a test case. 
• Tester Name: The name of the person who would be carrying out the test. 
• Test scenario: The test scenario provides a brief description to the tester, as in providing a small overview to know about what needs to be performed and the small features, and components of the test.  
• Test Case Description: The condition required to be checked for a given software. for eg. Check if only numbers validation is working or not for an age input box. 
• Test Steps: Steps to be performed for the checking of the condition. 
• Prerequisite: The conditions required to be fulfilled before the start of the test process. 
• Test Priority: As the name suggests gives priority to the test cases that had to be performed first, or are more important and that could be performed later. 
• Test Data: The inputs to be taken while checking for the conditions. 
• Test Expected Result: The output which should be expected at the end of the test. 
• Test parameters: Parameters assigned to a particular test case. 
• Actual Result: The output that is displayed at the end. 
• Environment Information: The environment in which the test is being performed, such as the operating system, security information, the software name, software version, etc.  
• Status: The status of tests such as pass, fail, NA, etc. 
• Comments: Remarks on the test regarding the test for the betterment of the software. 

Below are some of the points of difference between a test case and a test scenario:

Test cases are written in different situations:

• Before development: Test cases could be written before the actual coding as that would help to identify the requirement of the product/software and carry out the test later when the product/software gets developed. 
• After development: Test cases are also written directly after coming up with a product/software or after developing the feature but before the launching of a product/software as needed to test the working of that particular feature. 
• During development: Test cases are sometimes written during the development time, parallelly. so whenever a part of the module/software gets developed it gets tested as well.   

So, test cases are written in such cases, as test cases help in further development and make sure that we are meeting all the needed requirements. 

Test cases are one of the most important aspects of software engineering, as they define how the testing would be carried out. Test cases are carried out for a very simple reason, to check if the software works or not. There are many advantages of writing test cases:

• To check whether the software meets customer expectations: Test cases help to check if a particular module/software is meeting the specified requirement or not. 
• To check software consistency with conditions: Test cases determine if a particular module/software works with a given set of conditions. 
• Narrow down software updates: Test cases help to narrow down the software needs and required updates.
• Better test coverage: Test cases help to make sure that all possible scenarios are covered and documented. 
• For consistency in test execution: Test cases help to maintain consistency in test execution. A well-documented test case helps the tester to just have a look at the test case and start testing the application. 
• Helpful during maintenance: Test cases are detailed which makes them helpful during the maintenance phase. 

Let’s look at a basic test case template for the login functionality. 

• The Test case template contains the header section which has a set of parameters that provide information about the test case such as the tester’s name, test case description, Prerequisite, etc. 
• The body section contains the actual test case content, such as test ID, test steps, test input, expected result, etc. 

Below is the table that shows the basic template of a test case:

In the given template below it’s identifiable that the section from module name to test scenario is the header section while the table that lies below the test scenario (from test case ID to comments) is the body of the test case template.     

Here a test case template for login functionality has been created with its parameters and values. 

There are certain practices that one could follow while writing the test cases that would be considered beneficial. 

• Simple and clear: Test cases need to be very concise, clear, and transparent. They should be easy and simple to understand not only for oneself but for others as well. 
• Maintaining the client/customer/end-user requirements must be unique : While writing the test cases, it’s necessary to make sure that they aren’t being written over and over again and that each case is different from the others. 
• Zero Assumptions: Test cases should not contain assumed data, and don’t come up with features/modules that don’t exist. 
• Traceability: Test cases should be traceable for future reference, so while writing it’s important to keep that in mind, 
• Different input data: While writing test cases, all types of data must be taken into consideration. 
• Strong module name: The module name should be self-explanatory while writing the test case.  
• Minimal Description: The description of a test case should be small, one or two lines are normally considered good practice, but it should give the basic overview properly. 
• Maximum conditions: All kinds of conditions should be taken into consideration while writing a test, increasing the effectiveness. 
• Meeting requirements: While writing the test case the client/customer/end-user requirements must be met.
• Repetitive Results: The test case must be written in such a way that it should provide the same result. 
• Different Techniques: Sometimes testing all conditions might not be possible but using different testing with different test cases could help to check every aspect of a software. 
• Create test cases with the end user’s perspective: Create test cases by keeping end-user in mind and the test cases must meet customer requirements.
• Use unique Test Case ID: It is considered a good practice to use a unique Test Case ID for the test cases following a naming convention for better understanding.
• Add proper preconditions and postconditions: Preconditions and postconditions for the test cases must be mentioned properly and clearly.
• Test cases should be reusable: There are times when the developer updates the code, then the testers need to update the test cases to meet the changing requirements.
• Specify the exact expected outcome: Include the exact expected result, which tells us what will be result of a particular test step.

Test management tools help to manage the test cases. These tools are automated tools that decrease the time and effort of a tester as compared to the traditional way. Some test case management tools include advanced dashboards, easier bug, and progress tracking as well as management, custom test case templates, integration of test cases, inviting guest testers, managing team requirements and plans, and much more.

Below are some of the test case management tools:

• Testpad: Testpad is a simple tool that makes test case management easier. The software’s main motto says that it aims to find a bug that matters. A few features of Testpad include manual testing, reports of the test cases and software, dragging and dropping to make testing easier, inviting guest testers by email, building custom templates, and much more. 
• TestCaseLab: TestCaseLab is easily manageable for the test cases and could swiftly integrate them with bug trackers. The features of TestCaseLab include Custom test cases, Test Runs, Integrations of test cases, Test Plans, tags and priority for test cases, search by name of test cases, description, tags, etc. 
• TestRail: TestRail is another platform that aims to make test case management easier, it streamlines the software testing processes and along with more visibility into QA. The basic features of TestRail include management for test cases, plans, and runs, more test coverage, real-time insights into the QA progress, etc. 
• TestLodge: TestLodge is a test case management tool that helps the entire team manage their requirements, test plans, test cases, and test runs all in one single place and with no user limit. The basic features of TestLodge include Test Plans, Test Runs, a Dashboard, a Test Suite, and many more.

Formal and Informal Test Case

• Formal Test Cases: Formal test cases are test cases that follow the basic test case format. It contains the test case parameters such as conditions, ID, Module name, etc. Formal Test cases have set input data and expected results, they are performed as per the given order of steps. 
• Informal Test Cases: Informal test cases are test cases that don’t follow the basic test case format. In these, as the tests are performed the test cases are written in real-time then pre-writing them, and the input and expected results are not predefined as well.
• Functionality Test Case: The functionality test case is to determine if the interface of the software works smoothly with the rest of the system and its users or not. Black box testing is used while checking for this test case, as we check everything externally and not internally for this test case. 
• Unit Test Case: In unit test case is where the individual part or a single unit of the software is tested. Here each unit/ individual part is tested, and we create a different test case for each unit.  
• User Interface Test Case: The UI test or user interface test is when every component of the UI that the user would come in contact with is tested. It is to test if the UI components requirement made by the user are fulfilled or not.  
• Integration Test Case: Integration testing is when all the units of the software are combined and then they are tested. It is to check that each component and its units work together without any issues. 
• Performance Test Case: The performance test case helps to determine response time as well as the overall effectiveness of the system/software. It’s to see if the application will handle real-world expectations. 
• Database Test Case: Also known as back-end testing or data testing checks that everything works fine concerning the database. Testing cases for tables, schema, triggers, etc. are done. 
• Security Test Case: The security test case helps to determine that the application restricts actions as well as permissions wherever necessary. Encryption and authentication are considered as main objectives of the security test case. The security test case is done to protect and safeguard the data of the software. 
• Usability Test Case: Also known as a user experience test case, it checks how user-friendly or easy to approach a software would be. Usability test cases are designed by the User experience team and performed by the testing team. 
• User Acceptance Test Case: The user acceptance case is prepared by the testing team but the user/client does the testing and review if they work in the real-world environment.   

Below is an example of preparing various test cases for a login page with a username and password.

Unit Test case: Here we are only checking if the username validates at least for the length of eight characters.

Here it is only checked whether the passing of input of thirteen characters is valid or not. So since the character word ‘geeksforgeeks’ is entered then the test is successful it would have failed for any other test case.  

  Functionality Test case: Here it is checked whether the username and password both work together on the login click.

Here it is being checked whether passing wrong and right inputs and if the login functionality is working or not, it’s showing login is successful for the right credentials and unsuccessful for the wrong ones, hence both tests have passed otherwise would have failed.

User Acceptance Test Case: Here the user feedback is taken if the login page is loading properly or not.

Here it is being checked in by clicking on the login button if the page is loaded and the ‘Welcome to login page’ message is displayed. The test has failed here as the page was not loaded due to a browser compatibility issue, it would have loaded if the test had passed. 

Please Login to comment...

Similar reads.

• Manual Testing
• Software Testing

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Case Study Research Method in Psychology

Saul Mcleod, PhD

Editor-in-Chief for Simply Psychology

BSc (Hons) Psychology, MRes, PhD, University of Manchester

Saul Mcleod, PhD., is a qualified psychology teacher with over 18 years of experience in further and higher education. He has been published in peer-reviewed journals, including the Journal of Clinical Psychology.

Learn about our Editorial Process

Olivia Guy-Evans, MSc

Associate Editor for Simply Psychology

BSc (Hons) Psychology, MSc Psychology of Education

Olivia Guy-Evans is a writer and associate editor for Simply Psychology. She has previously worked in healthcare and educational sectors.

On This Page:

Case studies are in-depth investigations of a person, group, event, or community. Typically, data is gathered from various sources using several methods (e.g., observations & interviews).

The case study research method originated in clinical medicine (the case history, i.e., the patient’s personal history). In psychology, case studies are often confined to the study of a particular individual.

The information is mainly biographical and relates to events in the individual’s past (i.e., retrospective), as well as to significant events that are currently occurring in his or her everyday life.

The case study is not a research method, but researchers select methods of data collection and analysis that will generate material suitable for case studies.

Freud (1909a, 1909b) conducted very detailed investigations into the private lives of his patients in an attempt to both understand and help them overcome their illnesses.

This makes it clear that the case study is a method that should only be used by a psychologist, therapist, or psychiatrist, i.e., someone with a professional qualification.

There is an ethical issue of competence. Only someone qualified to diagnose and treat a person can conduct a formal case study relating to atypical (i.e., abnormal) behavior or atypical development.

 Famous Case Studies

• Anna O – One of the most famous case studies, documenting psychoanalyst Josef Breuer’s treatment of “Anna O” (real name Bertha Pappenheim) for hysteria in the late 1800s using early psychoanalytic theory.
• Little Hans – A child psychoanalysis case study published by Sigmund Freud in 1909 analyzing his five-year-old patient Herbert Graf’s house phobia as related to the Oedipus complex.
• Bruce/Brenda – Gender identity case of the boy (Bruce) whose botched circumcision led psychologist John Money to advise gender reassignment and raise him as a girl (Brenda) in the 1960s.
• Genie Wiley – Linguistics/psychological development case of the victim of extreme isolation abuse who was studied in 1970s California for effects of early language deprivation on acquiring speech later in life.
• Phineas Gage – One of the most famous neuropsychology case studies analyzes personality changes in railroad worker Phineas Gage after an 1848 brain injury involving a tamping iron piercing his skull.

Clinical Case Studies

• Studying the effectiveness of psychotherapy approaches with an individual patient
• Assessing and treating mental illnesses like depression, anxiety disorders, PTSD
• Neuropsychological cases investigating brain injuries or disorders

Child Psychology Case Studies

• Studying psychological development from birth through adolescence
• Cases of learning disabilities, autism spectrum disorders, ADHD
• Effects of trauma, abuse, deprivation on development

Types of Case Studies

• Explanatory case studies : Used to explore causation in order to find underlying principles. Helpful for doing qualitative analysis to explain presumed causal links.
• Exploratory case studies : Used to explore situations where an intervention being evaluated has no clear set of outcomes. It helps define questions and hypotheses for future research.
• Descriptive case studies : Describe an intervention or phenomenon and the real-life context in which it occurred. It is helpful for illustrating certain topics within an evaluation.
• Multiple-case studies : Used to explore differences between cases and replicate findings across cases. Helpful for comparing and contrasting specific cases.
• Intrinsic : Used to gain a better understanding of a particular case. Helpful for capturing the complexity of a single case.
• Collective : Used to explore a general phenomenon using multiple case studies. Helpful for jointly studying a group of cases in order to inquire into the phenomenon.

Where Do You Find Data for a Case Study?

There are several places to find data for a case study. The key is to gather data from multiple sources to get a complete picture of the case and corroborate facts or findings through triangulation of evidence. Most of this information is likely qualitative (i.e., verbal description rather than measurement), but the psychologist might also collect numerical data.

1. Primary sources

• Interviews – Interviewing key people related to the case to get their perspectives and insights. The interview is an extremely effective procedure for obtaining information about an individual, and it may be used to collect comments from the person’s friends, parents, employer, workmates, and others who have a good knowledge of the person, as well as to obtain facts from the person him or herself.
• Observations – Observing behaviors, interactions, processes, etc., related to the case as they unfold in real-time.
• Documents & Records – Reviewing private documents, diaries, public records, correspondence, meeting minutes, etc., relevant to the case.

2. Secondary sources

• News/Media – News coverage of events related to the case study.
• Academic articles – Journal articles, dissertations etc. that discuss the case.
• Government reports – Official data and records related to the case context.
• Books/films – Books, documentaries or films discussing the case.

3. Archival records

Searching historical archives, museum collections and databases to find relevant documents, visual/audio records related to the case history and context.

Public archives like newspapers, organizational records, photographic collections could all include potentially relevant pieces of information to shed light on attitudes, cultural perspectives, common practices and historical contexts related to psychology.

4. Organizational records

Organizational records offer the advantage of often having large datasets collected over time that can reveal or confirm psychological insights.

Of course, privacy and ethical concerns regarding confidential data must be navigated carefully.

However, with proper protocols, organizational records can provide invaluable context and empirical depth to qualitative case studies exploring the intersection of psychology and organizations.

• Organizational/industrial psychology research : Organizational records like employee surveys, turnover/retention data, policies, incident reports etc. may provide insight into topics like job satisfaction, workplace culture and dynamics, leadership issues, employee behaviors etc.
• Clinical psychology : Therapists/hospitals may grant access to anonymized medical records to study aspects like assessments, diagnoses, treatment plans etc. This could shed light on clinical practices.
• School psychology : Studies could utilize anonymized student records like test scores, grades, disciplinary issues, and counseling referrals to study child development, learning barriers, effectiveness of support programs, and more.

How do I Write a Case Study in Psychology?

Follow specified case study guidelines provided by a journal or your psychology tutor. General components of clinical case studies include: background, symptoms, assessments, diagnosis, treatment, and outcomes. Interpreting the information means the researcher decides what to include or leave out. A good case study should always clarify which information is the factual description and which is an inference or the researcher’s opinion.

1. Introduction

• Provide background on the case context and why it is of interest, presenting background information like demographics, relevant history, and presenting problem.
• Compare briefly to similar published cases if applicable. Clearly state the focus/importance of the case.

2. Case Presentation

• Describe the presenting problem in detail, including symptoms, duration,and impact on daily life.
• Include client demographics like age and gender, information about social relationships, and mental health history.
• Describe all physical, emotional, and/or sensory symptoms reported by the client.
• Use patient quotes to describe the initial complaint verbatim. Follow with full-sentence summaries of relevant history details gathered, including key components that led to a working diagnosis.
• Summarize clinical exam results, namely orthopedic/neurological tests, imaging, lab tests, etc. Note actual results rather than subjective conclusions. Provide images if clearly reproducible/anonymized.
• Clearly state the working diagnosis or clinical impression before transitioning to management.

3. Management and Outcome

• Indicate the total duration of care and number of treatments given over what timeframe. Use specific names/descriptions for any therapies/interventions applied.
• Present the results of the intervention,including any quantitative or qualitative data collected.
• For outcomes, utilize visual analog scales for pain, medication usage logs, etc., if possible. Include patient self-reports of improvement/worsening of symptoms. Note the reason for discharge/end of care.

4. Discussion

• Analyze the case, exploring contributing factors, limitations of the study, and connections to existing research.
• Analyze the effectiveness of the intervention,considering factors like participant adherence, limitations of the study, and potential alternative explanations for the results.
• Identify any questions raised in the case analysis and relate insights to established theories and current research if applicable. Avoid definitive claims about physiological explanations.
• Offer clinical implications, and suggest future research directions.

5. Additional Items

• Thank specific assistants for writing support only. No patient acknowledgments.
• References should directly support any key claims or quotes included.
• Use tables/figures/images only if substantially informative. Include permissions and legends/explanatory notes.
• Provides detailed (rich qualitative) information.
• Provides insight for further research.
• Permitting investigation of otherwise impractical (or unethical) situations.

Case studies allow a researcher to investigate a topic in far more detail than might be possible if they were trying to deal with a large number of research participants (nomothetic approach) with the aim of ‘averaging’.

Because of their in-depth, multi-sided approach, case studies often shed light on aspects of human thinking and behavior that would be unethical or impractical to study in other ways.

Research that only looks into the measurable aspects of human behavior is not likely to give us insights into the subjective dimension of experience, which is important to psychoanalytic and humanistic psychologists.

Case studies are often used in exploratory research. They can help us generate new ideas (that might be tested by other methods). They are an important way of illustrating theories and can help show how different aspects of a person’s life are related to each other.

The method is, therefore, important for psychologists who adopt a holistic point of view (i.e., humanistic psychologists ).

Limitations

• Lacking scientific rigor and providing little basis for generalization of results to the wider population.
• Researchers’ own subjective feelings may influence the case study (researcher bias).
• Difficult to replicate.
• Time-consuming and expensive.
• The volume of data, together with the time restrictions in place, impacted the depth of analysis that was possible within the available resources.

Because a case study deals with only one person/event/group, we can never be sure if the case study investigated is representative of the wider body of “similar” instances. This means the conclusions drawn from a particular case may not be transferable to other settings.

Because case studies are based on the analysis of qualitative (i.e., descriptive) data , a lot depends on the psychologist’s interpretation of the information she has acquired.

This means that there is a lot of scope for Anna O , and it could be that the subjective opinions of the psychologist intrude in the assessment of what the data means.

For example, Freud has been criticized for producing case studies in which the information was sometimes distorted to fit particular behavioral theories (e.g., Little Hans ).

This is also true of Money’s interpretation of the Bruce/Brenda case study (Diamond, 1997) when he ignored evidence that went against his theory.

Breuer, J., & Freud, S. (1895).  Studies on hysteria . Standard Edition 2: London.

Curtiss, S. (1981). Genie: The case of a modern wild child .

Diamond, M., & Sigmundson, K. (1997). Sex Reassignment at Birth: Long-term Review and Clinical Implications. Archives of Pediatrics & Adolescent Medicine , 151(3), 298-304

Freud, S. (1909a). Analysis of a phobia of a five year old boy. In The Pelican Freud Library (1977), Vol 8, Case Histories 1, pages 169-306

Freud, S. (1909b). Bemerkungen über einen Fall von Zwangsneurose (Der “Rattenmann”). Jb. psychoanal. psychopathol. Forsch ., I, p. 357-421; GW, VII, p. 379-463; Notes upon a case of obsessional neurosis, SE , 10: 151-318.

Harlow J. M. (1848). Passage of an iron rod through the head.  Boston Medical and Surgical Journal, 39 , 389–393.

Harlow, J. M. (1868).  Recovery from the Passage of an Iron Bar through the Head .  Publications of the Massachusetts Medical Society. 2  (3), 327-347.

Money, J., & Ehrhardt, A. A. (1972).  Man & Woman, Boy & Girl : The Differentiation and Dimorphism of Gender Identity from Conception to Maturity. Baltimore, Maryland: Johns Hopkins University Press.

Money, J., & Tucker, P. (1975). Sexual signatures: On being a man or a woman.

Further Information

• Case Study Approach
• Case Study Method
• Enhancing the Quality of Case Studies in Health Services Research
• “We do things together” A case study of “couplehood” in dementia
• Using mixed methods for evaluating an integrative approach to cancer care: a case study

Related Articles

Research Methodology

Qualitative Data Coding

What Is a Focus Group?

Cross-Cultural Research Methodology In Psychology

What Is Internal Validity In Research?

Research Methodology , Statistics

What Is Face Validity In Research? Importance & How To Measure

Criterion Validity: Definition & Examples

AI on Trial: Legal Models Hallucinate in 1 out of 6 (or More) Benchmarking Queries

A new study reveals the need for benchmarking and public evaluations of AI tools in law.

Artificial intelligence (AI) tools are rapidly transforming the practice of law. Nearly  three quarters of lawyers plan on using generative AI for their work, from sifting through mountains of case law to drafting contracts to reviewing documents to writing legal memoranda. But are these tools reliable enough for real-world use?

Large language models have a documented tendency to “hallucinate,” or make up false information. In one highly-publicized case, a New York lawyer  faced sanctions for citing ChatGPT-invented fictional cases in a legal brief;  many similar cases have since been reported. And our  previous study of general-purpose chatbots found that they hallucinated between 58% and 82% of the time on legal queries, highlighting the risks of incorporating AI into legal practice. In his  2023 annual report on the judiciary , Chief Justice Roberts took note and warned lawyers of hallucinations. 

Across all areas of industry, retrieval-augmented generation (RAG) is seen and promoted as the solution for reducing hallucinations in domain-specific contexts. Relying on RAG, leading legal research services have released AI-powered legal research products that they claim  “avoid” hallucinations and guarantee  “hallucination-free” legal citations. RAG systems promise to deliver more accurate and trustworthy legal information by integrating a language model with a database of legal documents. Yet providers have not provided hard evidence for such claims or even precisely defined “hallucination,” making it difficult to assess their real-world reliability.

AI-Driven Legal Research Tools Still Hallucinate

In a new  preprint study by  Stanford RegLab and  HAI researchers, we put the claims of two providers, LexisNexis (creator of Lexis+ AI) and Thomson Reuters (creator of Westlaw AI-Assisted Research and Ask Practical Law AI)), to the test. We show that their tools do reduce errors compared to general-purpose AI models like GPT-4. That is a substantial improvement and we document instances where these tools provide sound and detailed legal research. But even these bespoke legal AI tools still hallucinate an alarming amount of the time: the Lexis+ AI and Ask Practical Law AI systems produced incorrect information more than 17% of the time, while Westlaw’s AI-Assisted Research hallucinated more than 34% of the time.

Read the full study, Hallucination-Free? Assessing the Reliability of Leading AI Legal Research Tools

To conduct our study, we manually constructed a pre-registered dataset of over 200 open-ended legal queries, which we designed to probe various aspects of these systems’ performance.

Broadly, we investigated (1) general research questions (questions about doctrine, case holdings, or the bar exam); (2) jurisdiction or time-specific questions (questions about circuit splits and recent changes in the law); (3) false premise questions (questions that mimic a user having a mistaken understanding of the law); and (4) factual recall questions (questions about simple, objective facts that require no legal interpretation). These questions are designed to reflect a wide range of query types and to constitute a challenging real-world dataset of exactly the kinds of queries where legal research may be needed the most.

Figure 1: Comparison of hallucinated (red) and incomplete (yellow) answers across generative legal research tools.

These systems can hallucinate in one of two ways. First, a response from an AI tool might just be  incorrect —it describes the law incorrectly or makes a factual error. Second, a response might be  misgrounded —the AI tool describes the law correctly, but cites a source which does not in fact support its claims.

Given the critical importance of authoritative sources in legal research and writing, the second type of hallucination may be even more pernicious than the outright invention of legal cases. A citation might be “hallucination-free” in the narrowest sense that the citation  exists , but that is not the only thing that matters. The core promise of legal AI is that it can streamline the time-consuming process of identifying relevant legal sources. If a tool provides sources that  seem authoritative but are in reality irrelevant or contradictory, users could be misled. They may place undue trust in the tool's output, potentially leading to erroneous legal judgments and conclusions.

Figure 2:  Top left: Example of a hallucinated response by Westlaw's AI-Assisted Research product. The system makes up a statement in the Federal Rules of Bankruptcy Procedure that does not exist (and Kontrick v. Ryan, 540 U.S. 443 (2004) held that a closely related bankruptcy deadline provision was not jurisdictional). Top right: Example of a hallucinated response by LexisNexis's Lexis+ AI. Casey and its undue burden standard were overruled by the Supreme Court in Dobbs v. Jackson Women's Health Organization, 597 U.S. 215 (2022); the correct answer is rational basis review. Bottom left: Example of a hallucinated response by Thomson Reuters's Ask Practical Law AI. The system fails to correct the user’s mistaken premise—in reality, Justice Ginsburg joined the Court's landmark decision legalizing same-sex marriage—and instead provides additional false information about the case. Bottom right: Example of a hallucinated response from GPT-4, which generates a statutory provision that has not been codified.

RAG Is Not a Panacea

Figure 3: An overview of the retrieval-augmentation generation (RAG) process. Given a user query (left), the typical process consists of two steps: (1) retrieval (middle), where the query is embedded with natural language processing and a retrieval system takes embeddings and retrieves the relevant documents (e.g., Supreme Court cases); and (2) generation (right), where the retrieved texts are fed to the language model to generate the response to the user query. Any of the subsidiary steps may introduce error and hallucinations into the generated response. (Icons are courtesy of FlatIcon.)

Under the hood, these new legal AI tools use retrieval-augmented generation (RAG) to produce their results, a method that many tout as a potential solution to the hallucination problem. In theory, RAG allows a system to first  retrieve the relevant source material and then use it to  generate the correct response. In practice, however, we show that even RAG systems are not hallucination-free. 

We identify several challenges that are particularly unique to RAG-based legal AI systems, causing hallucinations. 

First, legal retrieval is hard. As any lawyer knows, finding the appropriate (or best) authority can be no easy task. Unlike other domains, the law is not entirely composed of verifiable  facts —instead, law is built up over time by judges writing  opinions . This makes identifying the set of documents that definitively answer a query difficult, and sometimes hallucinations occur for the simple reason that the system’s retrieval mechanism fails.

Second, even when retrieval occurs, the document that is retrieved can be an inapplicable authority. In the American legal system, rules and precedents differ across jurisdictions and time periods; documents that might be relevant on their face due to semantic similarity to a query may actually be inapposite for idiosyncratic reasons that are unique to the law. Thus, we also observe hallucinations occurring when these RAG systems fail to identify the truly binding authority. This is particularly problematic as areas where the law is in flux is precisely where legal research matters the most. One system, for instance, incorrectly recited the “undue burden” standard for abortion restrictions as good law, which was overturned in  Dobbs (see Figure 2). 

Third, sycophancy—the tendency of AI to agree with the user's incorrect assumptions—also poses unique risks in legal settings. One system, for instance, naively agreed with the question’s premise that Justice Ginsburg dissented in  Obergefell , the case establishing a right to same-sex marriage, and answered that she did so based on her views on international copyright. (Justice Ginsburg did not dissent in  Obergefell and, no, the case had nothing to do with copyright.) Notwithstanding that answer, here there are optimistic results. Our tests showed that both systems generally navigated queries based on false premises effectively. But when these systems do agree with erroneous user assertions, the implications can be severe—particularly for those hoping to use these tools to increase access to justice among  pro se and under-resourced litigants.

Responsible Integration of AI Into Law Requires Transparency

Ultimately, our results highlight the need for rigorous and transparent benchmarking of legal AI tools. Unlike other domains, the use of AI in law remains alarmingly opaque: the tools we study provide no systematic access, publish few details about their models, and report no evaluation results at all.

This opacity makes it exceedingly challenging for lawyers to procure and acquire AI products. The large law firm  Paul Weiss spent nearly a year and a half testing a product, and did not develop “hard metrics” because checking the AI system was so involved that it “makes any efficiency gains difficult to measure.” The absence of rigorous evaluation metrics makes responsible adoption difficult, especially for practitioners that are less resourced than Paul Weiss. 

The lack of transparency also threatens lawyers’ ability to comply with ethical and professional responsibility requirements. The bar associations of  California ,  New York , and  Florida have all recently released guidance on lawyers’ duty of supervision over work products created with AI tools. And as of May 2024,  more than 25 federal judges have issued standing orders instructing attorneys to disclose or monitor the use of AI in their courtrooms.

Without access to evaluations of the specific tools and transparency around their design, lawyers may find it impossible to comply with these responsibilities. Alternatively, given the high rate of hallucinations, lawyers may find themselves having to verify each and every proposition and citation provided by these tools, undercutting the stated efficiency gains that legal AI tools are supposed to provide.

Our study is meant in no way to single out LexisNexis and Thomson Reuters. Their products are far from the only legal AI tools that stand in need of transparency—a slew of startups offer similar products and have  made   similar   claims , but they are available on even more restricted bases, making it even more difficult to assess how they function. 

Based on what we know, legal hallucinations have not been solved.The legal profession should turn to public benchmarking and rigorous evaluations of AI tools. 

This story was updated on Thursday, May 30, 2024, to include analysis of a third AI tool, Westlaw’s AI-Assisted Research.

Paper authors: Varun Magesh is a research fellow at Stanford RegLab. Faiz Surani is a research fellow at Stanford RegLab. Matthew Dahl is a joint JD/PhD student in political science at Yale University and graduate student affiliate of Stanford RegLab. Mirac Suzgun is a joint JD/PhD student in computer science at Stanford University and a graduate student fellow at Stanford RegLab. Christopher D. Manning is Thomas M. Siebel Professor of Machine Learning, Professor of Linguistics and Computer Science, and Senior Fellow at HAI. Daniel E. Ho is the William Benjamin Scott and Luna M. Scott Professor of Law, Professor of Political Science, Professor of Computer Science (by courtesy), Senior Fellow at HAI, Senior Fellow at SIEPR, and Director of the RegLab at Stanford University. 

More News Topics

Neuromarketing — Predicting Consumer Behavior to Drive Purchasing Decisions 

Buying decisions can be driven by unconscious choices. Learn about how neuromarketing uncovers what drives decisions to increase conversions and revenue.

Valerie Kirk

What drives a person to not only buy something, but to choose one product or service over the other? The usual answers that come to a marketer’s mind when asked that question include need, price, availability, and brand familiarity.

But what if it goes deeper than that? What if consumer decision-making is driven by biology — specifically neural activity in the brain?

This idea is the basis of neuromarketing — sometimes known as consumer neuroscience — a field of study that incorporates biology and brain activity to predict and even influence consumer behavior and purchase decisions.

The Science Behind Neuromarketing

While the term neuromarketing was first introduced in the early 2000s, consumer neuroscience began to emerge in the 1990s, when measuring brain activity using functional magnetic resonance imaging (fMRI) machines became more accessible. 

Consumer neuroscience examines fMRI scans and electroencephalogram measurements of people’s brain activity when they are given or shown stimuli, such as an advertisement, product packaging, or something to drink. It could also include verbal prompts to monitor reactions. The brain activity seen on the scans shows what a person is feeling in that moment. 

Consumer neuroscience also includes physiological tracking — measuring facial expressions, eye movements, pupil dilation, heart rate, or other physical reactions people experience when given the stimuli. With eye tracking software, marketers can use heat maps to see what consumers are most drawn to in ad campaigns or websites and the journey they take to ultimately purchase something or disengage with digital assets. 

Examples of neuromarketing research include: 

• Serving Coca-Cola and Pepsi to subjects in an fMRI machine. When the drinks weren’t identified, the researchers noted a consistent neural response. But when subjects could see the brand, the part of their brains associated with emotions, memories, and unconscious processing showed enhanced activity, demonstrating that knowledge of the brand altered how the brain perceived the beverage. 
• Scanning the brains of test subjects while they tasted three wines, each labeled with a different price. Their brains registered the wines differently, with neural signatures indicating a preference for the most expensive wine. In actuality, all three wines were the same. 

Why is Neuromarketing Important?

By understanding what people react to based on biology and not conscious choices, marketers can essentially predict consumer behavior. When marketers can predict behavior, they can take steps to market their products — from the price to packaging to product marketing campaigns — in ways that elicit emotional responses and compel consumers to buy, thus increasing sales and revenue. 

There is a truth to neuromarketing that can’t be replicated by traditional marketing research tactics like focus groups. People may not always tell the truth in focus groups, or they say things they think others want to hear. 

Neuromarketing techniques remove the human choice element in market research and expose a person’s real and unfiltered responses. This helps marketers gain a more complete understanding of consumer motivation and buying behavior, which drives marketing decisions and budget spending.

How is Neuromarketing Used in Business Today?

Businesses are turning to neuromarketing to guide critical marketing decisions. In many cases, neuromarketing techniques are replacing traditional marketing research tactics. 

Here are five ways businesses are using neuromarketing to improve their marketing efforts and drive sales. 

1. Testing Ads 

Marketers can get true, unbiased responses to ad campaigns by showing different ads to test subjects and scanning their brain activity or tracking their eye movement while they view the ads. Based on the scans and other physiological and emotional reactions, they can determine which campaign — or which campaign elements — resonate more with consumers.  

2. Improving Packaging Design

When test subjects are given early prototypes of a product packaging, brain scans can help marketing and design teams gain insights into which version people are more likely to pick up and buy. Package design includes color, images, and size and shape. 

3. Enhancing Website and App Design 

Neuromarketing can help guide website and app design. Brain scans can show which design elements are more likely to engage users and drive clicks and purchases. Facial coding can also show how people view websites and apps, which can inform where to put different pieces of content. 

4. Informing Rebranding

From start to finish, neuromarketing can guide decisions on rebranding. This includes whether a rebrand is needed, which visual elements and messages work better for the new brand, and how to use the new identity in marketing tools and other brand assets. 

5. Optimizing Conversion Rates 

It’s estimated that 95 percent of decision-making is made unconsciously. Neuromarketing can help marketers understand what drives a person to make those unconscious choices to buy or not buy a product. Brands can then adapt their marketing materials and tactics to enhance elements that inspire people to buy.

DCE Professional & Executive Development Consumer Behavior Course:

Using Neuromarketing to Predict and Influence Customers

Examples of Neuromarketing in Action

• Through neuromarketing techniques, Frito-Lay learned that matte bags with pictures of potatoes did not trigger a negative consumer response, whereas shiny bags with pictures did. Based on those insights, they changed their chip packaging design. 
• The National Cancer Institute used fMRI scans to test three anti-smoking commercials that included a telephone hotline. The subjects were heavy smokers who indicated they wanted to quit. The National Cancer Institute ran all three ads, but the ad to which the test group reacted favorably corresponded to an increased hotline call volume when it ran.
• IKEA has designed their stores in a way that showcases everything they sell before a consumer can actually leave the store, thus increasing the likelihood of a purchase. The layout was developed using neuromarketing research.
• Neuromarketing research has shown that people react favorably to movement and speed. This knowledge guided FedEx to include a hidden arrow in its logo that represents quickness, which garners favorable reactions — and subconscious brand trust — among consumers.
• People also react favorably to color. Through research on brain activity, businesses know that the color red signifies strength. It’s easy to see why red is the favored logo color of so many iconic brands, including Coca-Cola, Target, McDonald’s, and Netflix.  

The Ethics of Neuromarketing

In general, people like to think that they make purchasing decisions — and really any decision — consciously after considering all of the options and facts. Neuromarketing exposes the fact that people can be influenced on an unconscious level. This realization can lead not only to privacy concerns but also to people feeling like they are being manipulated by brands they trust, which could make them avoid those brands entirely. 

For example , in 2015, one of the main political parties in Mexico used neuromarketing to learn more about voters’ interests and reactions to campaign ads. When the information leaked, there was a backlash from Mexican citizens. The candidate apologized, but the revelation likely cost him votes. 

Since the very first advertisement, businesses have been trying to persuade people to buy products. Neuromarketing uses the technology of the time to help marketers understand their customers better and deliver a more favorable experience. Currently, brain scans and physiological responses are being performed on test subjects who all have likely signed an informed consent document.

While it may seem like a logical progression of the marketing and advertising discipline, companies that use neuromarketing techniques should have robust and ethical protocols and a crisis communication plan in place in case of public backlash.

How to Study Neuromarketing

People working across marketing disciplines could benefit from understanding what drives consumer behavior. Harvard Division of Continuing Education Professional & Executive Development offers a 2-day Consumer Behavior Course: Using Neuromarketing to Predict and Influence Customers.

The course covers a wide range of topics to help participants understand the psychology of consumer behavior and how to apply it. Participants will come away with a new set of tools for creating marketing campaigns that effectively resonate with the consumer base, capture market share, and ultimately drive profits and sales.

The program includes a discussion on corporate responsibility, marketing ethics, and specific guidelines for utilizing psychological techniques while safeguarding consumer and societal well-being.

Marketing Analytics Online Course: Strategies for Driving Business Results

Digital Marketing Strategy

Behavioral Decision Making

About the Author

Valerie Kirk is a freelance writer and corporate storyteller specializing in customer and community outreach and topics and trends in education, technology, and healthcare. Based in Maryland near the Chesapeake Bay, she spends her free time exploring nature by bike, paddle board, or on long hikes with her family.

How to Determine What My Leadership Style Is

Determining your leadership style is key to the success of your team, your organization, and your growth as a leader.

Harvard Division of Continuing Education

The Division of Continuing Education (DCE) at Harvard University is dedicated to bringing rigorous academics and innovative teaching capabilities to those seeking to improve their lives through education. We make Harvard education accessible to lifelong learners from high school to retirement.