Software testing is an activity conducted in the software development life-cycle to verify that the software is accurate and works according to the requirements. Testing plays an integral part in any software development project.
In its essence, software testing aims to answer the question: How does one ensure that the software does what it is supposed to do and doesn’t do what it is not supposed to do? The primary goal behind software testing is to get enough confidence that the software under testing produces the correct output for a given input.
An important thing to keep in mind when learning about software testing is that testing does not improve software quality by itself. Or that a high amount of testing doesn’t mean that the software is high quality. Testing is an indicator of quality, providing crucial feedback to the developers who created the software to take necessary action to fix the problems found in testing.
This article provides the frequently asked interview questions by the interviewer for a Software Tester or Quality Assurance (QA) position. It’s divided into three sections based on the skill set of the applicant:
In the end, multiple-choice questions are provided to test your understanding of testing.
Software Testing Interview Questions
1. Explain the role of testing in software development?
Software testing comes into play at different times in different software development methodologies. There are two main methodologies in software development, namely Waterfall and Agile.
In a traditional waterfall software development model, requirements are gathered first. Then a specification document is created based on the document, which drives the design and development of the software. Finally, the testers conduct the testing at the end of the software development life cycle once the complete software system is built.
An agile software development model works in small iterations. You test the software in parallel as it is getting built. The developers build a small functionality according to the requirements. The testers test it and get customer feedback, which drives future development.
2. How much testing is sufficient? Or, is it possible to do exhaustive testing of the software?
It is impossible to exhaustively test software or prove the absence of errors, no matter how specific your test strategy is.
An extensive test that finds hundreds of errors doesn’t imply that it has discovered them all. There could be many more errors that the test might have missed. The absence of errors doesn’t mean there are no errors, and the software is perfect. It could easily mean ineffective or incomplete tests. To prove that a program works, you’d have to test all possible inputs and their combinations.
Consider a simple program that takes a string as an input that is ten characters long. To test it with each possible input, you’d have to enter 2610 names, which is impossible. Since exhaustive testing is not practical, your best strategy as a tester is to pick the test cases that are most likely to find errors. Testing is sufficient when you have enough confidence to release the software and assume it will work as expected.
3. What are the different types of testing?
You can test the software in many different ways. Some types of testing are conducted by software developers and some by specialized quality assurance staff. Here are a few different kinds of software testing, along with a brief description of each.
|Unit Testing||A programmatic test that tests the internal working of a unit of code, such as a method or a function.|
|Integration Testing||Ensures that multiple components of systems work as expected when they are combined to produce a result.|
|Regression Testing||Ensures that existing features/functionality that used to work are not broken due to new code changes.|
|System Testing||Complete end-to-end testing is done on the complete software to make sure the whole system works as expected.|
|Smoke Testing||A quick test performed to ensure that the software works at the most basic level and doesn’t crash when it’s started. Its name originates from the hardware testing where you just plug the device and see if smoke comes out.|
|Performance Testing||Ensures that the software performs according to the user’s expectations by checking the response time and throughput under specific load and environment.|
|User-Acceptance Testing||Ensures the software meets the requirements of the clients or users. This is typically the last step before the software is live, i.e. it goes to production.|
|Stress Testing||Ensures that the performance of the software doesn’t degrade when the load increases. In stress testing, the tester subjects the software under heavy loads, such as a high number of requests or stringent memory conditions to verify if it works well.|
|Usability Testing||Measures how usable the software is. This is typically performed with a sample set of end-users, who use the software and provide feedback on how easy or complicated it is to use the software.|
|Security Testing||Now more important than ever. Security testing tries to break a software’s security checks, to gain access to confidential data. Security testing is crucial for web-based applications or any applications that involve money.|
4. Why developers shouldn’t test the software they wrote?
Developers make poor testers. Here are some reasons why:
- They try to test the code to make sure that it works, rather than testing all the ways in which it doesn't work.
- Since they wrote it themselves, developers tend to be very optimistic about the software and don't have the correct attitude needed for testing: to break software.
- Developers skip the more sophisticated tests that an experienced tester would perform to break the software. They follow the happy path to execute the code from start to finish with proper inputs, often not enough to get the confidence to ship software in production.
However, it doesn't mean that developers shouldn't test the software before sending it to the tester. Developer testing helps find many bugs that are caused by programming errors. These are hard to find for a tester because they don't always have access to the source code.
5. What is the software testing life cycle?
Similar to software development, testing has its life cycle. During the testing, a tester goes through the following activities.
- Understand the requirements: Before testing software or a feature, the tester must first understand what it is supposed to do. If they don’t know how the software is supposed to work, they can’t test it effectively.
- Test Planning and Case Development: Once the tester has a clear understanding of the requirements, they can create a test plan. It includes the scope of testing, i.e., part of software under test and objectives for testing. Various activities are involved in planning the test, such as creating documentation, estimating the time and efforts involved, deciding the tools and platforms, and the individuals who will be conducting the tests.
- Prepare a test environment: The development happens in a development environment, i.e., on a developer’s computer that might not represent the actual environment that the software will run in production. A tester prepares an environment with the test data that mimics the end user’s environment. It assists with realistic testing of the software.
- Generate the test data: Though it is impossible to do exhaustive testing of the software, the tester tries to use realistic test data to give them the confidence that the software will survive the real world if it passes the tests.
- Test Execution: Once the tester has a complete understanding of the software and has a test environment set up with the test data, they execute the test. Here, execution means that the tester runs the software or the feature under test and verifies the output with the expected outcome.
- Test Closure: At the end of the test execution, there can be two possible outcomes. First, the tester finds a bug in the part of the software under test. In this case, they create a test record/bug report. Second, the software works as expected. Both these events indicate the end of the test cycle.
6. What qualities a software tester should have?
Any software tester's goal is to find out as many bugs and problems in the system so that the customers don't have to. Hence, a good software tester should have a keen eye for detail. They should know the ins and outs of the software they are testing and push every aspect of the software to its limits, to identify bugs that are hard to find with the software's regular use.
Having the domain knowledge of the application is essential. If a tester doesn't understand the specific problems the software is trying to solve, they won't be able to test it thoroughly.
A good tester should keep the end-user in mind when they are testing. Having empathy with the end-user helps the tester ensure that the software is accessible and usable. Simultaneously, the tester should possess basic programming skills to think from a developer's perspective, which allows them to notice common programming errors such as null-references, out-of-memory errors, etc.
Communication, both written and verbal, is an essential skill for a tester. A tester will frequently have to interact with both the developers and the management. They should be able to explain the bugs and problems found during testing to the developers. For each bug found, a good tester should provide a detailed bug report consisting of all the information a developer would need to fix that problem. They should be able to make a good case to the management if they are uncomfortable releasing the software if it contains unresolved issues.
7. What is functional testing?
Functional testing is a form of black-box testing. As the name suggests, it focuses on the software's functional requirements rather than its internal implementation. A functional requirement refers to required behavior in the system, in terms of its input and output.
It validates the software against the functional requirements or the specification, ignoring the non-functional attributes such as performance, usability, and reliability.
Functional testing aims to answer the following questions, in particular:
- Does the software fulfill its functional requirements?
- Does it solve its intended users' problems?
8. What is a bug report?
During testing, a tester records their observations, findings, and other information useful to the developers or the management. All this data belongs to a test record, also called a bug report.
A detailed bug report is an important artifact produced during testing. It helps the team members with:
- Understand the problem,
- Steps to reproduce the problem,
- The environment and the specific conditions under which it happens, and
- The resolution if/when the developers fix the problem.
Here are a few bits of information that a good bug report should contain. Image Source: Bugzilla
|Title||A short headline that summarizes the problem. It shouldn’t be too long but just to give just the right information to the reader. It should be specific and accurate.|
|Description||The description should answer all the questions that are not explained by the title. It contains a detailed summary of the bug, its severity, and impact, steps to reproduce, expected results vs. the actual output.|
|Version||A lot of time can be wasted in trying to reproduce a bug in the wrong version of the product. Knowing the exact product version or the build number on which this bug was found is very useful to the developer in reproducing the bug.|
|Status||At any point, a bug can be either ‘Active’, ‘Ready for Testing’, or ‘Closed’. A bug becomes active when it is found, is ready for testing once the developer fixes it. A tester can mark it closed if the developer fixed it, or active if not.|
|Steps to Reproduce||Though the steps to reproduce the problem can be provided in the description, sometimes having a distinct field force the tester to think about them. They include each step one must take to successfully reproduce the problem.|
|Assigned To||Name of the developer or the tester to whom this bug is assigned.|
|Resolution||When a developer fixes the bug, they should include the cause for the bug and its resolution. It helps the team in the future when a similar bug resurfaces.|
For example, here is a picture of a bug reported on Jira, a popular bug-tracking software.
9. What is non-functional testing?
Non-functional testing tests the system's non-functional requirements, which refer to an attribute or quality of the system explicitly requested by the client. These include performance, security, scalability, and usability.
Non-functional testing comes after functional testing. It tests the general characteristics unrelated to the functional requirements of the software. Non-functional testing ensures that the software is secure, scalable, high-performance, and won't crash under heavy load.
10. What are some important testing metrics?
Testing metrics provide a high-level overview to the management or the developers on how the project is going and the next action steps.
Here are some of the metrics derived from a record of the tests and failures:
- Total number of defects found, ordered by their severity
- Total number of bugs fixed
- Total number of problems caused by an error in the source code vs. configuration or external environmental factors
- Bug find and fix rate over time
- Bugs by produce/feature area
- The average time is taken by a bug since it’s found and fixed.
- Total time spent on new feature development vs. time spent on resolving bugs and failures
- Number of outstanding bugs before a release
- Bugs/failures reported by the customers vs. those found by the testers
11. What is Test-Driven-Development?
Test-Driven-Development (TDD) is a popular software development technique, first introduced by Kent Beck in his book with the same name, published in 1999.
In TDD, a developer working on a feature first writes a failing test, then writes just enough code to make that test pass. Once they have a passing test, they add another failing test and then write just enough code to pass the failing test. This cycle repeats until the developer has the fully working feature. If the code under the test has external dependencies such as database, files, or network, you can mock them to isolate the code.
Benefits of TDD:
- Writing tests first forces you to think about the feature you are trying to build, helping you produce better code.
- As you always have a working set of tests at hand, a failing test indicates that the problem is with the code you just added, reducing the time spent in debugging.
- Writing tests help the developer to clarify the requirements and specification. It’s challenging to write good tests for a poor set of requirements.
- It’s tough to produce high-quality software unless you can test the software after each new change. You can never be sure that your new code didn’t break the working software. TDD gives you the confidence to add new code, as you already have a test in place.
12. What is manual testing?
In manual testing, a tester manually verifies the functionality of the software. The tester has a comprehensive list of all the test cases they should test, along with the test data. They go through each case, one by one. They launch the software as an end-user would, enter the input, and manually verify the output.
It may seem that manual testing is inefficient when compared to automated testing. It is slow, not repeatable in a consistent manner, and prone to human misjudgment.
However, manual testing allows the tester to realistically test the software, using actual user data in a natural user environment, subject to similar external conditions. Only a human, not a computer, can evaluate the usability and accessibility of the application and how it looks and feels to the end-user. It also gives a broader perspective of the system. Finally, some test scenarios just can't be automated and need to be manually tested.
You should always test the software manually before trying to automate the testing.
13. What is cross-browser testing?
All web applications run in browsers such as Google Chrome, Mozilla Firefox, Internet Explorer, Safari, etc. Though they all work primarily the same in implementing the web standards, there are subtle differences in all of them. When building the software, it’s not always possible for the software developer to meticulously test the feature on multiple browsers, noticing the subtle inconsistencies.
In cross-browser testing, a software tester launches the web application in all the supported browsers and tries to test the same functionality on all of them. They note any unexpected behavior in a browser that doesn’t work as expected or looks different; note the behavior and the browser name and version in the test report. This helps the programmer to fix the behavior in all the browsers where it doesn't work as intended.
14. What is automated testing?
As the name suggests, automated testing, which is also called test automation, is the programmatic execution of the tests. The tester uses an automation tool or software like Selenium to write code that performs the following tasks.
- Automatically run the software.
- Feed the input data to the system.
- Examine the output with the expected outcome.
- Fail the test if the results don’t match. Otherwise, pass the test.
Once a test is automated, you can run it as often as you want, to check if any new code has broken it. It enables you to spend your time on other high-value tests, such as exploratory testing that help find bugs that an automated test would miss.
Automated testing is beneficial for repetitive testing with inputs that don’t change frequently. Humans get tired and bored from conducting the same tests repeatedly and seeing the same results. It’s easy to make mistakes when you are testing a feature for the twentieth time. Software is much better at doing repetitive tasks without getting tired or making mistakes than a human operator would.
15. What is the difference between Quality Control(QC) and Quality Assurance(QA)?
QA stands for Quality Assurance. In a software development team, a QA ensures that the software is thoroughly tested before releasing it to the end-users.
QA activities are generally performed while the product is being developed and focuses on improving the software development process.
In many software organizations, a tester and a QA can be the same person, but they can be different depending on the organization's size. The goal of the QA is to ensure quality in the shipped software.
Quality Control: QC stands for Quality Control. Its main aim is to ensure that the developed products meet the required standards or not.
QC is a process in software engineering that is used to ensure Software product quality by testing and reviewing its functional and non-functional requirements. QC activities are generally performed after the product is developed as it examines the quality of the end products and the final outcome.
16. What is a software bug?
A software bug is an error in the software that produces wrong results. A software tester tests the software to find bugs in it.
There are many causes for the bugs—for example, poor design, sloppy programming, lack of version control, or miscommunication. Throughout development, developers introduce hundreds or thousands of bugs in the system. The goal of the tester is to uncover those bugs.
You can find a bug in many different ways, regardless of your role. When building the software, the software developer might notice the bug in another module, written by another developer or by themselves. The tester actively tries to find the bugs as part of a routine testing process. Finally, the users could see the bugs when the software is in production.
All bugs, no matter how they are found, are recorded into a bug-tracking system. A triage team triages the bugs and assigns a priority to the bug, and assigns the bug to a software developer to fix it. Once the developer resolves the problem, they check in the code and mark that bug as ready for testing. Once a bug is ready for testing, it goes to the tester, who tests the software to verify if it’s indeed fixed. If it is, then it’s closed. If not, they assign it to the same developer with a description of the exact steps to reproduce the bug. Some examples of popular bug-tracking systems include BugZilla, FogBugz, etc.
The first software bug was discovered by Admiral Grace Hopper, on September 9, 1947. After they opened a malfunctioning piece of hardware, they found an insect stuck in the relay. Image Source: Link
17. Write some common mistakes that lead to major issues.
Some common mistakes include:
- Poor Scheduling
- Ignoring small issues
- Not following the exact process
- Improper resource allocation
18. What is a user story?
All software has a target user. A user story describes the user's motivations and what they are trying to accomplish by using the software. Finally, it shows how the user uses the application. It ignores the design and implementation details.
A user story aims to focus on the value provided to the end-user instead of the exact inputs they might enter and the expected output.
In a user story, the tester creates user personas with real names and characteristics and tries to simulate a real-life interaction with the software. A user story often helps fish out hidden problems that are often not revealed by more formal testing processes.
19. What is a test environment?
A test environment consists of a server/computer on which a tester runs their tests. It is different from a development machine and tries to represent the actual hardware on which the software will run; once it’s in production.
Whenever a new build of the software is released, the tester updates the test environment with the latest build and runs the regression tests suite. Once it passes, the tester moves on to testing new functionality.
20. List some of the popular testing tools/frameworks, providing a brief description of each.
- Selenium: a web browser automation tool that automates the test suites you need to run on a web browser.
- Protractor: An end-to-end test framework for Angular and AngularJS applications. Protractor runs tests against your application running in a real browser, interacting with it as a user would.
- Cypress: A modern front-end testing tool built for the modern web. Though it’s similar to Selenium and Protractor, it’s architecturally different from them.
- JUnit and NUnit: These are unit testing frameworks for Java and C# programming languages, respectively.
21. What are the different types of severity you can assign to a bug?
Though it varies depending on the size and structure of the software development teams, typically, a bug can be assigned the following types of severities, going from low to high:
- User Interface bugs
- Accessibility issues
- Leaky abstractions
- Software hangs
- Users unable to perform a specific action
- Boundary conditions
- Crashing under high load
- Business logic and/or calculation errors
- Any user action that causes the software to crash
- Exposing sensitive user data
- Security problems
- Loss of data
Manual Testing Interview Questions for Freshers
22. What is black-box testing?
In black-box testing, the tester views the software as a black box, ignoring all the internal structure and behavior. Their only concern is the input provided to the system and the generated output. Black-box testing verifies the program’s behavior against the specified requirements.
During black-box testing, the test conditions are created based upon the software’s functionality but are unaware of how the software works internally. The software is tested from the end user’s perspective and gives a broader picture of the whole system.
Given that the users are only concerned with whether the software works according to their needs and don’t care how it works, black-box testing helps test software usability and anticipate how the customer will use the product.
23. What is white-box testing?
White-box testing is an alternative strategy to black-box testing, in which a tester views the system as a transparent box. They are allowed to observe the internal implementation of the system, which guides the test. Typically, the software developers perform the white-box testing during the development phase.
In white-box testing, we assume that the tester has some programming knowledge. They try to test each possible branch a program could take in a running system. Knowing what’s inside the box, i.e., taking a look at the source code and the implementation details, it’s possible to test the system more thoroughly.
24. What are the differences between manual and automated testing?
|Manual Testing||Automated Testing|
|A human tester tests the software by manually running the test cases and observing and comparing the actual and expected outputs.||A tester or a programmer uses scripts and tools that execute the software and compares the actual and expected outputs.|
|Manual testing is not reproducible and repeatable.||Since it is programmed, automated testing is consistently reproducible and repeatable. It can be executed as many times as the tester wants.|
|For new features, a tester can quickly test the feature manually, without much configuration and setup.||To set up automated testing, there’s the initial investment required to write the tests and prepare an environment to run those tests on.|
|Manual testing is useful for finding bugs in the user interface or accessibility issues.||Automated testing is more suitable for catching bugs that a human tester would miss, such as programming bugs, business logic errors.|
|Manual testing is prone to human errors and is slow.||As there is no human participation involved (other than writing tests), automated testing is more reliable. It is much faster than manual testing.|
25. What is alpha testing?
Before you ship the software to the customers, the internal testing team performs alpha testing. Alpha testing is part of the user acceptance testing. Its goal is to identify bugs before the customers start using the software.
26. What is beta testing?
Once you ship the software to the customers after alpha testing, the software's actual users perform the beta testing in a real production environment. It is one of the final components of user acceptance testing. Beta testing is helpful to get feedback from real people using your software in real environments.
27. What is exploratory testing?
Imagine a tourist in a foreign city. There are two ways in which they can explore the city.
- Follow a map, itinerary, or a list of places they should visit
- Explore randomly, following the streets as they lead them to new places
With the first approach, the tourist follows a predetermined plan and executes it. Though they may visit famous spots, they might miss out on hidden, more exciting places in the city. With the second approach, the tourist wanders around the city and might encounter strange and exotic places that the itinerary would have missed.
Both approaches have their pros and cons.
A tester is similar to a tourist when they are testing software. They can follow a strict set of test cases and test the software according to them, with the provided inputs and outputs, or they can explore the software.
When a tester doesn't use the test scripts or a predefined test plan and randomly tests the software, it is called exploratory testing. As the name suggests, the tester is exploring the software as an end-user would. It's a form of black-box testing.
In exploratory testing, the tester interacts with the software in whatever manner they want and follows the software's instructions to navigate various paths and functionality. They don't have a strict plan at hand.
Exploratory testing primarily focuses on behavioral testing. It is effective for getting familiar with new software features. It also provides a high-level overview of the system that helps evaluate and quickly learn the software.
Though it seems random, exploratory testing can be powerful in an experienced and skilled tester's hands. As it's performed without any preconceived notions of what software should and shouldn't do, it allows greater flexibility to the tester to discover hidden paths and problems along those paths.
28. What is end-to-end testing?
End to End testing is the process of testing a software system from start to finish. The tester tests the software just like an end-user would. For example, to test a desktop software, the tester would install the software as the user would, open it, use the application as intended, and verify the behavior. Same for a web application.
There is an important difference between end-to-end testing vs. other forms of testing that are more isolated, such as unit testing. In end-to-end testing, the software is tested along with all its dependencies and integrations, such as databases, networks, file systems, and other external services.
29. What is static software testing?
Static testing is a technique in which you test the software without actually executing it. It involves doing code walkthroughs, code reviews, peer-reviews, or using sophisticated tools such as eslint, StyleCop to perform static analysis of the source code. Static testing is typically performed during software development.
30. What is dynamic software testing?
In contrast to static testing, dynamic software testing tests the software when it’s executing. The tester runs the software in a test environment and goes through all the steps involved, entering the inputs and verifying the actual output with the expected result.
31. What is API testing?
API testing ensures that the APIs that the software is using work as expected. The tester writes code that makes an API request to the server that provides the API, provides the required inputs, collects the output from the response, and matches the actual output with the expected output.
API testing primarily concerns the business logic of the software that’s exposing the API. It does not involve the look and feel, accessibility, or usability of the software. API testing can be automated to make it repeatable and reproducible each time they run.
32. What is meant by Code Coverage?
Code coverage is one of the important testing metrics. It indicates the ratio of the codebase under unit tests to the entire codebase. Code coverage of 50% means that the unit tests cover half of the codebase.
It is crucial to keep in mind that 100% code coverage doesn’t mean that the software is error-free or there are no bugs. It just means that the unit tests cover all the code. However, it’s still possible that the tests don’t test all branches that code could take or the problems with business logic execution.
33. What are the benefits of Manual Testing?
There are several advantages of manual testing as given below:
- Preferable for products with a short life cycle
- Saves time, money, and resources
- Ensure the error-free product
- Useful in ad-hoc testing, exploratory testing, and usability testing
- No need to change the entire code to make minor changes
- Get accurate user interface feedback
- Ability to handle difficult use case situations in a better way
- GUI testing can be done accurately
- Highly reliable
- Make user-friendliness better
- Easy to learn for new testers
34. What are the drawbacks of Manual Testing?
There are several drawbacks of manual testing as given below:
- Not suitable for time-bounded projects and large organizations
- More prone to human errors and mistakes
- Less efficient as the choice of recording the testing process is not available
- Less Reliable
- Regression testing is time-consuming
- Does not cover all the aspects of testing
- Load testing and performance testing can be performed manually
- More expensive in the long run process
35. What is the procedure for manual testing?
The process of manual testing includes the following:
- Planning and control
- Analysis and Design
- Implementation and Execution
- Evaluating exit criteria and Reporting
- Test closure activities
36. Write different types of Manual Testing?
Different types of manual testing include:
- Black Box Testing
- White Box Testing
- Unit Testing
- System Testing
- Integration Testing
- Acceptance Testing
- Performance Testing
- Load Testing
37. Name some of the manual testing tools.
Some of the top manual testing tools include:
- Message queue monitors
- DB tools, etc.
38. When will you choose automated testing over manual testing?
Benefits of automated testing over manual testing
- When test cases need to be run repeatedly for a long duration of time.
- When one needs to perform regression testing, performance testing, or load testing.
- When one wants to record the testing process
- When one has less time to complete the testing phase
- When tests are needed to be executed in a standard runtime environment
- When tests include repetitive steps
- When there are multiple and quick deployments for the product, manual becomes very time taking and redundant
39. When will you choose manual testing over automated testing?
Benefits of manual testing over automated testing:
- When test cases need to be run for a short duration of time (once or twice).
- When one needs to perform ad-hoc testing, exploratory testing, or usability testing
- When one wants to ensure the user-friendliness of an application
- When flexibility is required
- When one wants to better handle the complex scenarios
40. Name some methods that can be used in code coverage.
There are several methods that can be used in code coverage includes:
- Statement Coverage
- Decision Coverage
- Branch Coverage
- Toggle Coverage
41. Define Latent Defect.
Latent defect, as the name suggests, is a type of defect or bug which has been in the software system for a long time but is discovered now. A latent defect is an existing defect that can be found effectively with inspections. It usually remains hidden or dormant and is a low-priority defect.
42. Write difference between Validation and Verification?
Validation: It is defined as a process that involves dynamic testing of software products by running it. This process validates whether we are building the right software that meets that customer requirement or not. It involves various activities like system testing, integration testing, user acceptance testing, and unit testing.
Verification: It is defined as a process that involves analyzing the documents. This process verifies whether the software conforms to specifications or not. Its ultimate goal is to ensure the quality of software products, design, architecture, etc.
Verification Vs Validation:
|It checks whether the software meets the specification or not.||It checks whether the specification captures the customer’s needs or not.|
|It is a type of static testing.||It is a type of dynamic testing.|
|There is no requirement of executing the code.||There is a requirement for executing the code.|
|This process is performed by the QA team to make sure that the software is built as per the specifications in the SRS document.||This process is performed with the involvement of the testing team.|
|Reviews, walkthroughs, inspections, and desk-checking are some methods that can be used in verification.||Black box testing, white box testing, and non-functional testing are some methods that can be used during validation.|
|It identifies the bugs or errors early in the development process.||It can identify the bugs or errors that the verification process cannot catch.|
|It is performed before the validation process.||It is performed after the verification process.|
43. Explain the term testbed.
Testbed is generally referred to as a digital platform that is used for testing an application. It includes an operating system, hardware, network configuration, database, software application under test, and all other software-related issues.
44. What is the role of documentation in manual testing?
Some of the commonly applied documentation artifacts that are associated with software testing include:
- Test Plan
- Test Scenario
- Test Case
- Traceability Matrix
45. What do you mean by Test case?
Test case is basically a document that includes a set of test data, preconditions, expected results, and postconditions. This document is specially developed for a specific test scenario to ensure whether the software product meets the specific requirement or not. In manual testing, test cases are executed manually by a tester without using any of the automated tools. One can easily identify loopholes in the specifications while developing test cases.
46. Name some attributes of the test case.
There are various attributes of test cases that make them more reliable, clear, and concise, avoiding any sort of redundancy. Some of them are given below:
- Test Case Id: Unique identifier of test case
- Test Summary: One-liner summary of test case
- Description: Detailed description of test case
- Prerequisite or pre-condition: Set of conditions to be followed before implementing the test steps
- Test steps: Detailed steps for performing test case
- Test Data: Test data value used in test case
- Expected Result: Estimated result to pass the test
- Actual Result: Actual result after executing the test steps.
- Test Result: Status of the test execution (Pass or Fail)
- Automation Status: Identifier for automation
- Date: Test execution date
- Executed By: Person name executing the test case
47. What is a Test Plan? What does it include?
A test plan is basically a dynamic document monitored and controlled by the testing manager. The success of a testing project totally depends upon a well-written test plan document that describes software testing scope and activities. It basically serves as a blueprint that outlines the what, when, how, and more of the entire test process.
A test plan must include the following details:
- Test Strategy
- Test Objective
- Test Scope
- Reason for Testing
- Exit/Suspension Criteria
- Resource Planning
- Test Deliverables.
48. What is a Test Report? What does it include?
Test report is basically a document that includes a total summary of testing objectives, activities, and results. It is very much required to reflect testing results and gives an opportunity to estimate testing results quickly. It helps us to decide whether the product is ready for release or not. It also helps us determine the current status of the project and the quality of the product. A test report must include the following details:
- Test Objective
- Project Information
- Test Summary
49. What do you mean by Test Deliverables?
Test deliverables, also known as test artifacts, are basically a list of all of the documents, tools, and other components that are given to the stakeholders of a software project during the SDLC. Test deliverables are maintained and developed in support of the test. At every phase of SDLC, there are different deliverables as given below:
Before Testing Phase
- Test plans document.
- Test cases documents
- Test Design specifications.
During Testing Phase
- Test Scripts
- Test Data
- Test Traceability Matrix
- Error logs and execution logs
After testing Phase
- Test Results/reports
- Defect Report
- Installation/ Test procedures guidelines
- Release notes
50. Explain STLC.
STLC (Software Testing Life Cycle) is a fundamental part of SDLC which is used to test software and ensure that the quality standards are met. It generally involves both verification activities and validation activities. In this, different activities are executed in a specific order throughout the software testing process. There are basically six different phases in STLC Model as shown below:
- Requirement Analysis
- Test Planning
- Test Case Development
- Test Environment Setup
- Test Execution
- Test Cycle Closure
51. Write difference between bug, defect, and error.
Error: It is defined as a programming mistake in coding because of which we can't compile or run a program.
Defect: It is defined as the variation or difference between the actual result and the expected result founded by a tester or developer. The defect is basically detected after the product goes into production and is resolved in the development phase only.
Bug: It is defined as a fault or mismatch in a software system that is detected during the testing phase. It has an impact on software functionality and performance.
52. Explain use-case testing.
Use case testing is basically defined as a technique that helps developers and testers to identify test cases that exercise the whole system on each transaction basis right from start to finish. It is a part of black-box testing that is used widely in developing tests or systems for acceptable levels.
53. What do you mean by Test Matrix and Traceability Matrix?
Test Matrix: It is referred to as a testing tool that is used to capture actual quality, effort, resources, plan, and time required to capture all the phases of software testing. It only covers the testing phase of the life cycle.
Requirement Traceability Matrix (RTM): It is referred to as a document, usually present in the form table, that is used to trace and demonstrate the relationship between the requirements and other artifacts of the project right from start to end. In simple words, it maps between test cases and customer requirements.
54. What is Positive and Negative Testing?
Positive Testing: It is a type of testing process where the software application is validated against the valid data sets as an input. It is simply used to check whether the application does what it is supposed to do or not.
Negative Testing: It is a type of testing process where the software application is validated against invalid data sets as an input. It is simply used to check whether the system shows an error when it is supposed to do or not. In test case execution, negative testing is considered a very crucial factor.
Positive vs Negative Testing:
|Positive Testing||Negative Testing|
|It tests the application or system by giving valid data.||It tests the application or system by giving invalid data.|
|It accepts all the numeric and alphabetic values.||It does not accept any special character.|
|This type of testing is performed to identify a known set of test conditions.||This type of testing is performed to identify an unknown set of test conditions.|
|It is usually performed on each and every application.||It is usually performed where the chances of unexpected conditions or errors are more.|
|It requires less time and can be performed by people having less knowledge.||It requires more time and can only be performed by professionals.|
|It makes sure that the software application is normal.||It makes sure that the software applications are 100% detect-free.|
|It does not encompass all the possible cases.||It encompasses all the possible cases.|
|It is less significant or vital than negative testing.||It is more significant and vital than positive testing.|
55. What do you mean by Critical bug?
A critical bug is referred to as a bug that affects the majority of the functionality of the given application. It does not disturb or block the testing of other parts of the given application. A bug is only classified as critical when it halts the core operations of the software.
56. What is UAT (User Acceptance Testing)?
UAT, also known as end-user testing, is basically a testing methodology performed by the end-users or clients for the approval of the production release. It is one of the last stages of the SDLC and is only performed after the software has been tested thoroughly. Its main purpose is to validate end-to-end business flow. It makes sure that the developed software meets all the requirements to float into the market or not.
57. System testing can be done at any stage?
All the components of the software are generally tested as a whole to make sure that the overall product fulfills the requirements that are specified. So, no. system testing cannot be done at any stage instead system testing must start only when all modules or units work correctly and are in place, but it needs to be performed before UAT.
58. Explain Monkey Testing and Performance Testing.
Monkey Testing: Monkey testing, also known as Random Testing, is a type of software testing technique in which data is generated randomly using a tool or some automated mechanism. The system is tested using this randomly generated input, and results are analyzed accordingly. There are no such rules in this type of testing.
Performance Testing: It is a type of non-functional software testing technique that is used to determine the system parameters like speed, scalability, and stability under different workload conditions. Its main purpose is to eliminate performance bottlenecks, not to find bugs. Some of the key parameters of performance testing include:
- CPU Utilization
- Memory Utilization
- QPS/TPS (Transaction per second)
- Average load time
- System throughput, etc.
59. Write the difference between Test Stub and Test Driver.
Test driver and test stub, both are types of test harness that are used to provide a simulation environment for testing a module or component. They both are dummy modules specially created for test purposes.
Test stubs: Test stubs are used in a top-down testing approach and allow testing of the upper levels of the code when the lower levels of the code are not developed yet. It is used as ‘called programs’ when subprograms are under construction.
Test drivers: Test drivers are used in a bottom-up testing approach and allow testing of the lower levels of the code when the upper levels of the code are not developed yet. It is used as ‘called programs’ when main programs are under construction.
60. Explain Endurance Testing or Soak Testing?
Endurance testing, also known as Soak testing, is a type of performance testing usually performed to check the performance of the system that is under constant use. Its main purpose is to determine whether a system can sustain a continuous high load or not. Memory utilization is also monitored to identify potential leaks during this testing. Some of the endurance testing tools include:
- Apache JMeter, etc.
61. What is the importance of Localization Testing?
Localization testing is a type of testing that is performed to ensure whether the software product offers full functionality and usability in a particular locale or not. It is simply used to verify the accuracy and suitability of the content. It is not only about linguistics, but also about traditions, common herd behavior, and other similar factors. It generally deals with the functionality and GUI of the application.
62. Explain Path testing.
Path testing is a type of testing specially used to design test cases. In this type of testing, the control flow graph of a program is specially designed to identify a set of linearly independent paths of execution. Its main objective is to ensure that each path is covered and executed well. It also reduces or minimizes the occurrence of redundant tests.
63. What do you mean by Baseline Testing and Benchmark testing?
Baseline Testing: It is a type of non-functional testing in which a set of tests are run to capture performance information. Using this gathered information, we can make required changes in the application and ultimately improve the performance and capabilities of the application. In general, it refers to a benchmark that usually forms the base of any new creation. During this testing, many errors are discovered and resolved.
Benchmark Testing: It is a type of testing that involves both the developers and DBAs (Database Administrators) to determine current performance information. Using this information, one can improve the performance of the same by matching it with the benchmarks (industry standards). Its main objective is to compare the present and future software releases with their specific benchmark.
64. Explain Fuzz Testing and its importance.
Fuzz testing is a software testing technique in which a large amount of random data, called fuzz, is provided as input to the application simply to detect or discover security loopholes and coding errors in the software application. It is more useful for bigger projects but it only detects a serious fault or defect. It is simply used to check the vulnerability of software and gives more effective results when used with beta testing, black box testing, etc.
65. What do you mean by Data flow testing?
Data flow testing is a type of structural testing that is used to analyze the flow of data in the program. In this, a programmer can perform various tests on data values and variables. Using this testing, one can determine the variables that are used at every stage of the program’s control flow. It helps us in the following ways:
- Eliminate or remove variables that are never used after being declared
- Pinpoint variables that are used but never declared
- Deallocate variable before it is used
- Pinpoint variables that are defined multiple times before it is used
66. What is the importance of agile testing?
Agile testing is basically a software testing process that uses agile methodologies i.e., follow test-first design paradigm. It evaluates the software from the customer's point of view. It does not require any development team to complete coding for starting QA, instead of testing and coding can go hand in hand. Features are tested as they are developed. Some of its advantages include:
- Boosts the performance as it allows all the testers and developers to work together
- Features are tested as they are developed
- Ensure successful delivery of the high-grade product
- Saves time and money
- Flexible and highly adaptable to changes
- Improves product quality and allows developers to release software as early as possible
67. What are different categories of debugging?
Different categories of debugging include:
- Brute force debugging
- Cause elimination
- Program slicing
- Fault tree analysis
Manual Testing Interview Questions For Experienced
68. What is Selenium? What are its benefits?
Selenium is a web browser automation tool that automates the test suits you need to run on a web browser.
Some of the benefits of Selenium include:
- It is open-source software, eliminating licensing costs.
- It supports all the major languages, such as Java, C#, Python, Ruby, etc.
- It supports all the major web browsers, e.g., Google Chrome, Firefox, Safari, etc.
- You can integrate it with other testing frameworks and tools to build a comprehensive test suite for your software.
69. What is boundary value analysis?
In software, many errors occur near the edges of the range of the data values. For example, when the programmer uses the greater-than operator (>) instead of the greater-than-or-equal-to (>=) operator, it causes the off-by-one indexing error.
Typically, developers miss these boundary cases because they follow a happy path when developing and testing. Boundary value analysis helps to discover the errors caused by extreme values. The tester chooses the test data at and immediately above and below the boundaries of the input domain of the data.
For example, if an input field expects a string of 20 characters long, the tester tests it with strings of lengths 19, 20, and 21.
70. What is regression testing?
The dictionary definition of regression is the act of going back to a previous place or state. In software, regression implies that a feature that used to work suddenly stopped working after a developer added a new code or functionality to the software.
Regression problems are pervasive in the software industry, as new features are getting added all the time. Developers don't build these features in isolation, separate from the existing code. Instead, the new code interacts with the legacy code and modifies it in various ways, introducing side effects, whether intended or not.
As a result, there is always a chance that introducing new changes may negatively impact a working feature. It's important to keep in mind that even a small change has the potential to cause regression.
Regression testing helps ensure that the new code or modifications to the existing code don't break the present behavior. It allows the tester to verify that the new code plays well with the legacy code.
71. What is unit testing?
Unit testing is the process of testing a single unit of code in an isolated manner. The unit of code can be a method, a class, or a module. Unit testing aims to focus on the smallest building blocks of code to get confidence to combine them later to produce fully functioning software.
A unit test invokes the code and verifies the result with the expected result. If the expected and actual outcomes match, then the unit test passes. Otherwise, it fails.
A good unit test has the following characteristics:
- It should test a single piece of functionality.
- It is fully automated and repeatable.
- It should run quickly and provide immediate feedback.
- It should be isolated and shouldn’t interact with external dependencies such as network, database, or file system unless needed. You can use the mocking technique to simulate the external dependencies and isolate the code under test.
72. What is an API?
API stands for Application Programming Interface. It is a means of communication between two software components. An API abstracts the internal workings and complexity of a software program and allows the user of that API to solely focus on the inputs and outputs required to use it.
When building software, developers rarely write software from scratch and make use of other third-party libraries. An API allows two software components to talk to each other by providing an interface that they can understand.
Another use of an API is to provide data required by an application. Let's say you are building a weather application that displays the temperature. Instead of building the technology to collect the temperature yourself, you'd access the API provided by the meteorological institute.
73. What are the different HTTP status codes that a server can return?
An HTTP status code is a three-digit number that indicates the status of an incoming HTTP request, that is, if the request has been completed or not.
A server can send the following five types of responses for an HTTP request.
- Information (100 - 199): These status codes provide a temporary response. The response consists of the status line and optional headers and terminates by an empty line.
- Success (200 - 299): Indicate that the incoming HTTP request was successfully received, understood, and accepted.
- Redirect (300 - 399): These status codes indicate further actions the client should take to satisfy the HTTP request. It can mean that the requested resource may have moved temporarily or permanently. It can also redirect the client to another URL.
- A client error (400 - 499): Indicate a problem with the client who initiated the HTTP request.
- Server error (500 - 599): The 5XX status code indicates a problem on the server while processing the request.
74. What is test coverage?
Test coverage is a metric that indicates how much of the source code is covered by the tests, allowing the tester to verify the quality of their testing. It helps the tester figure out whether they are testing everything they're supposed to test.
Test coverage can mean different things to different people, depending on the particulars of their testing approaches.
- Product: It means looking at test coverage to answer the question: Which features or the areas of the software does your tests cover?
- Requirements: The software might work well, but it's not useful to the customer if it doesn't satisfy their needs. Requirements coverage indicates how many of the requirements are tested.
- Source Code: This is usually a developer's domain and is a white-box testing technique. The developer can check how much of their source code is covered by the unit tests.
75. What is meant by browser automation?
It’s a process of automatically testing a web application’s functionality in a browser, where a program launches the browser, navigates to the application, and interacts with the user interface by clicking buttons or links, just like an average user would.
The only difference is that the browser automation can test this very quickly and often, whereas the same test would take a human tester a long time. It’s part of automated testing. Some essential tools for browser testing include Selenium, protractor.js, and cypress.
76. What is A/B testing?
A/B testing is the process of testing two or more different versions of your software with users to assess which performs better. It is a low-risk way of testing variations of a new or existing functionality.
You can choose a part of your users to use feature A. The other group uses feature B. Then user feedback and response are evaluated using statistical testing to decide the final version of the feature.
Typically, A/B testing is used to test the user experience of different interfaces. This allows the team to quickly gather feedback and test their initial hypothesis.
77. What is the difference between Retesting and Regression Testing?
Regression Testing: Regression testing, also known as generic testing, revolves around re-running functional and non-functional tests. It is especially done to ensure whether previously developed and tested software still performs the same after a change or not. It can be performed either manually or using automated tests.
Re-testing: Re-testing, also known as planned testing, is used for specific bugs after it has been fixed by the developers. Re-testing is performed to check the scenario under the same environmental conditions after detection has been fixed.
Regression vs Retesting:
|It is performed to make sure that the changes haven't affected the unchanged part.||It is performed to make sure that the test cases that were filed in the last execution are passed after the detects are fixed by developers.|
|It is not carried out for specific detect fixes.||It is usually carried out based on defect fixes.|
|It is only the previous version functionality-centric.||It is current or previous version functionality-centric.|
|It can be performed parallel with retesting.||It is needed to perform before regression testing.|
|It does not include the verification of bugs.||It includes the verification of bugs.|
|In this type of testing, test cases can be automated and the testing style is generic.||In this type of testing, test cases cannot be automated and the testing is done in a planned manner.|
|It is only used for passed test cases.||It is only used for failed test cases.|
78. What is System testing and Unit Testing? Write the difference between them.
System Testing: It is a typical black box testing technique that is performed in a complete and fully integrated system to evaluate the system’s compliance with its specific requirements. It must investigate both functional requirements and non-functional requirements. Generally, it is performed by both testers and developers.
Unit Testing: In unit testing, each component of the software is individually tested. Generally, unit testing is performed by developers. Those systems that have a lot of interdependencies between their modules cannot be tested by unit testing.
System vs Unit Testing:
|System Testing||Unit Testing|
|The system testing method involves treating each module as a separate target for testing, and integrating the modules after each has been tested.||The purpose of unit testing is to test only one module at a time, rather than the integrated version of the application.|
|Generally, when it comes to unit testing, a single module testing approach is taken.||For System test cases, it includes both top-down approach testing and bottom-up approach testing with all modules in integrated mode.|
|It focuses on system validation.||It focuses on functional verification.|
|It usually follows the requirements specification.||It usually follows the specification of modules.|
|It is also known as black-box testing.||It is also known as white-box testing.|
|It is a low-level test as compared to unit testing.||It is a high-level test as compared to system testing.|
79. What are the types of Integration Testing?
- Big bang testing
- Bottom-Up Testing
- Top-Down Testing
80. Name some of the most popular integration testing tools.
Some of the most popular integration testing tools include:
- JUnit 5
- H2 Database, etc.
81. What is Test Harness and Test Closure?
Test Harness: Test harness, also known as the automated test framework, is a collection of software and test data required to unit test software modules during development. It is mostly used by the developers and helps in the automation and execution of unit test cases. It generally includes two main parts as given below:
- Test execution engine
- Test script repository
Test Closure: Test closure is basically a document that provides the summary of all the tests that are performed during SDLC. It gives full detailed analysis reports of the bugs that are discovered and removed. It is usually performed prior to the end of the testing process.
82. Explain Test Scenario.
Test scenario also called a scenario test, is defined as high-level detailed documentation of test cases or use cases. In this, the tester tests the software application from an end-user perspective. It usually can serve as the basis for lower-level test cases or use case creation. Test scenario is also known as test condition or test possibility. It gives you an idea of what we need to test.
83. What is the defect life cycle?
Defect life cycle, also known as a bug life cycle, is a life cycle of various stages through which a defect goes during its whole lifetime. This life cycle starts as soon as the defect is discovered or reported by the tester and ends when the tester ensures that the defect is resolved and it won't occur again. The defect life cycle includes the steps as shown below:
84. Explain Experienced-based testing techniques.
The experience-based testing technique is a type of testing that is based on the tester’s experience with testing to understand the essential areas of a system. This type of testing is generally used in a low-risk system. Individual’s information, abilities, and foundation knowledge are prime supporters of the test conditions and experiments in experienced-based techniques. There are four different experienced-based testing techniques as shown below:
85. Write the difference between smoke testing and sanity testing.
Smoke Testing: It is a type of testing performed to ensure that the acute functionalities of the program are working well. It acts as a confirmation of whether the quality assurance team can further proceed with testing or not.
Sanity Testing: It is an unscripted form of testing performed to ensure that the code changes that are made are working well. It is performed by the test team for some basic tests. This testing focuses on one or a few areas of functionality and is usually narrow and deep.
Smoke vs Sanity Testing:
|Smoke Testing||Sanity Testing|
|Its main objective is to measure the stability of the system so that the team can proceed with more rigorous testing.||Its main objective is to measure the rationality of the system so that the team can proceed with more rigorous testing.|
|It is usually performed by the developers or testers.||It is usually performed by testers.|
|It is a subset of regression testing.||It is a subset of acceptance testing.|
|It can be executed both manually or by using automation tools.||It can only be executed manually, not by using automation tools.|
|It is generally performed when a new product is developed.||It is generally performed after regression testing.|
|It is documented and is used to test the end-to-end functions of the application.||It is not documented and is used to test only modified or defect-fixed functions.|
|It is also considered as a subset of acceptance testing.||It is also considered a subset of regression testing.|
86. What do you mean by pesticide paradox?
Pesticide paradox is basically a phenomenon where the more one tests the software, the more it becomes immune to its tests. To overcome this, testers should always find new strategies, approaches, and test cases, so that they can identify bugs and resolve them.
87. Explain Configuration Testing.
Configuration testing is a software testing technique that is used to evaluate the configurational requirements of the software. It discovers the optimal configuration of the system under which the application performs at its best, therefore configuration testing is considered important. It also helps in identifying and resolving any compatibility issues.
88. Name two parameters that can be useful to check the quality of test execution.
Two parameters required to check the quality of test execution includes:
- Defect reject ratio: Ratio of total rejection to total production.
- Defect leakage ratio: Ratio of the total possibility of rejection occurrence to the total production.
Software testing is an important activity that ensures quality, giving the confidence to release the software to customers. This article explained the testing process and its importance in software development. It also covers important concepts on manual testing and will guide you to master the field of manual testing.
However, testing is only a single component of a good software development strategy. A development team should use high coding standards, best practices, and patterns to reduce the bug count. As a long-term strategy, the best way to improve the testing process is to test frequently, measure the results, gather feedback and use it to get better.
- Automation Testing
- Smoke vs Sanity Testing
- Difference Between Alpha and Beta Testing
- Test Plan vs Test Strategy
- Agile Vs Waterfall
- Agile Vs Scrum
- Automation Testing Tools
- Performance Testing Tools
- API Testing Tools
- Testing Tools
- Manual Testing Tools
Software Testing MCQ
White box technique is also known as-
___ testing is done by going thro’ the code.
Out of the following, which is non-functional software testing?
Verification and validation use which of the following?
Which of the following is performed with Planning and Documentation?
STLC is related to-
Which of the following is a tool used for browser automation testing?
What type of testing allows the tester to inspect the internal implementation of the software?
The software testing that checks if the new code has broken the existing functionality is known as:
Who performs the unit testing?
A bug report does not contain:
Which of the following is not a unit testing framework?
Smoke testing is conducted to make sure
Which step is not part of a software development life cycle (SDLC)?
Which of the following activities doesn’t represent static testing?
When should the tester stop testing the software?