In this Software Testing interview questions article, I have collected the most frequently asked questions by interviewers. These questions were collected after consulting with top industry experts in the field of Manual and Automation testing. If you want to brush up on the software testing basics, which I recommend you do before going ahead with these Software Testing Interview Questions, take a look at this article on Software Testing Tutorial.
If you come across some other questions during your interviews or have queries that might be helpful for others as well, please share them in the comment section of this article. Meanwhile, you can maximize the Automation testing career opportunities that are sure to come your way by taking Selenium Online Training with Edureka.
If you are tech-savvy and want to up-skill yourself with all the latest technologies, take a look at this list of Top Trending Technologies.
Top 50 Software Testing Interview Questions & Answers | Software Testing Training | Edureka
This Edureka video on Top 50 Software Testing Interview Question and Answers will help you to prepare yourself for Software Testing Interviews. It covers questions for beginners, intermediate and experienced professionals.
Software Testing Interview Questions:
- What are the phases involved in Software Testing Life Cycle?
- What are the different methods of testing?
- What are the different levels of testing?
- Explain Bug Life Cycle or Defect life cycle.
- What is a test case?
- What is the difference between functional and non-functional testing?
- What is Verification and Validation in Software Testing?
- What is usability testing?
- What are the categories of defects?
- On what basis the acceptance plan is prepared?
80+ Software Testing Interview Questions and Answers
This Software Testing Interview question is divided into the following parts:
Let’s begin this software testing interview questions with beginners level questions first.
Beginners Level Software Testing Interview Questions and Answers for Freshers
1. What is Software testing?
Basically, software testing is a process conducted to view the functionality, performance, and quality of a software application. To do so, run the software under controlled conditions, either trigger or expose defects/bugs hidden in the software and ensure that all its components conform to predefined requirements. Testing verifies the following: whether the software behaves as expected, performs with Btn effectiveness, and is reliable to the end-users.
2. What are the different types of testing?
Tests can be done at different levels to ensure that the software application is of high quality and working on par. Here are few different kinds of software testing along with a brief description of each:
- Unit Testing: Correctness of the individual units or components which make up the software.
- Integration Testing: How the different modules or components interact with one another in the software.
- System Testing: The whole system is tested as an integral whole against the specified requirements.
- Acceptance Testing: Testing to permit relevant stakeholders to decide whether use of a software-developed system shall proceed at a specific point.
- Regression Testing: Testing to ensure earlier developed and tested software still does its function correctly after change.
- Performance Testing: To test speed, scalability, and stability under workload.
- Security Testing: It checks for vulnerabilities so that the software is secure from unauthorized access and damage.
- Usability Testing measures what the software does when viewed from a final-user perspective—whether it’s friendly or instinctive.
- Load Testing: This kind of testing evaluates what the software does under special load conditions, such as processing a large amount of data or experiencing high user traffic.
- Smoke Testing: This is the first rudimentary testing to check if the software’s most critical functions work to specification before sophisticated testing can start in earnest.
3. Explain how a test coverage tool works.
A test coverage tool is a utility that monitors and quantifies the amount of code under test by a software program. Extra code is run to keep tabs on which lines or branches of code are executed. This gives insight into how far their tests exercise the code and points out whether some functionality of the software might not be fit enough for release to production.
4. Can you describe the different types of test coverage techniques?
Among the different types of test coverage techniques are:
- Statement Coverage: It allows ensuring that at least one test case has caused the execution of every line in the code.
- Branch Coverage: Ensures that the possible outcomes conditional for respective branches would likely be tested.
- Path Coverage: Ensures the execution paths for all potential sequences might have been tested.
- Function Coverage: A test should ensure that all the functions or subroutines have been called within them.
- Condition Coverage: All Boolean conditions in the code are exercised for true and false.
- Loop Coverage: Generates tests that exercise looping constructs with zero, one, and multiple passes.
5. Explain black-box testing, white-box testing and gray-box testing.
Black-box testing is testing that is focused on the logic behind a software application’s functionality. It is based on the requirement specifications, which identify how the inputs are handled and translated into outputs.
White-box Testing involves knowledge of the internal logic, structure, and code of the software to be tested to ensure all possible line/ branch executions have been exercised.
Gray-box testing: This is a kind of mixture that incorporates both the black- and white-box testing methods mentioned herein. The testers know the inner mechanisms only partially, but such knowledge can help them set up more complete test cases, which are usually oriented toward integration and system behavior.
6. What are the phases involved in Software Testing Life Cycle?
The different phases involved in the software testing life cycle are:
| Requirement Analysis | Here, the QA team understands the requirements and identify the testable requirements. |
| Requirement Analysis | Here, the QA team understands the requirements and identify the testable requirements. |
| Test Planning | In this phase, the test strategy is defined. |
| Test Case Development | Here, detailed test cases are defined and developed. |
| Environment Setup | It is a setup of software and hardware for the testing teams to execute test cases. |
| Test Execution | It is the process of executing the code and comparing the expected and actual results. |
| Test Cycle Closure | It involves calling out the testing team member meeting & evaluating cycle completion criteria based on test coverage, quality, cost, time, critical business objectives, and software. |
7. What are the different methods of testing?
There are three methods of software testing and they are as follows:
- Black-box testing: It is a testing strategy based solely on requirements and specifications. In this strategy, it requires no knowledge of internal paths, structures, or implementation of the software being tested.
- White box testing: It is a testing strategy based on internal paths, code structures, and implementation of the software being tested. White box testing generally requires detailed programming skills.
- Gray box testing: It is a strategy for software debugging in which the tester has limited knowledge of the internal details of the program.
8. What are the different levels of testing?
There are mainly four testing levels and they are:
Basically, it starts with the Unit Testing phase and ends with Acceptance Testing.
9. What are the principles of software testing?
Software testing is governed by seven principles:
- Absence of errors fallacy: Even if the software is 99% bug-free, it is unusable if it does not conform to the user’s requirements. Software needs to be bug-free 99% of the time, and it must also meet all customer requirements.
- Testing shows the presence of errors: Testing can verify the presence of defects in software, but it cannot guarantee that the software is defect-free. Testing can minimize the number of defects, but it can’t remove them all.
- Exhaustive testing is not possible: The software cannot be tested exhaustively, which means all possible test cases cannot be covered. Testing can only be done with a select few test cases, and it’s assumed that the software will produce the right output in all cases. Taking the software through every test case will cost more, take more effort, etc., which makes it impractical.
- Defect clustering: The majority of defects are typically found in a small number of modules in a project. According to the Pareto Principle, 80% of software defects arise from 20% of modules.
- Pesticide Paradox: It is impossible to find new bugs by re-running the same test cases over and over again. Thus, updating or adding new test cases is necessary in order to find new bugs.
- Early testing: Early testing is crucial to finding the defect in the software. In the early stages of SDLC, defects will be detected more easily and at a lower cost.
- Testing is context-dependent: The testing approach varies depending on the software development context. Software needs to be tested differently depending on its type. For instance, an ed-tech site is tested differently than an Android app.
10. Explain Bug Life Cycle or Defect life cycle.
A defect life cycle is a process in which a defect goes through various phases during its entire lifetime. It starts when a defect is found and ends when a defect is closed, after ensuring it’s not reproduced.
Bug or defect life cycle includes the steps as illustrated in the below figure. If you wish to learn in depth about Bug Life Cycle then you can refer my article on Software Testing Tutorial.
11. What is a test case?
A test case is nothing but a set of conditions or variables under which a tester will determine whether a system under test satisfies requirements or works correctly.
12. What is the difference between functional and non-functional testing?
| Functional Testing | Non Functional Testing |
Performed before non-functional testing | Performed after functional testing |
Based on customers expectations | |
Describes what the product does | Describes how the product works |
13. What is Verification and Validation in Software Testing?
Verification is a static analysis technique. Here, testing is done without executing the code. Examples include Reviews, Inspections, and walkthroughs.
Validation is a dynamic analysis technique in which testing is done by executing the code. Examples include functional and non-functional testing techniques.
In the V model, the development and QA activities are done simultaneously. There is no discrete testing phase; testing starts right from the requirement phase. The verification and validation activities go hand in hand.
14. What is exploratory testing?
Exploratory testing means testers explore a computer program like an adventurer. They don’t follow a strict plan but try different things, like a curious detective looking for problems. This helps find mistakes that regular testing might miss, especially in tricky or new parts of the program. Testers take notes while they explore to remember what they did and what they found. It’s like exploring a new place without a map to find interesting things you wouldn’t expect! It also provides a high-level overview of the system that helps evaluate and quickly learn the software.
15. 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 desktop software, the tester would install the software as the user would, open it, use the application as intended, and verify the behavior. The same is true 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.
16. 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 build confidence in combining 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.
17. 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 focus solely on the inputs and outputs required to use it.
18. What is a test environment?
A test environment consists of a server or computer on which testers run 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.
19. Explain test scenarios, test scripts, and test cases in software testing.
- Test Case: Test Cases are a series of actions executed during software development to verify a particular feature or function. They consist of test steps, test data, preconditions, and postconditions designed to verify a specific requirement.
- Test Scenario: Usually, a test scenario consists of a set of test cases covering the end-to-end functionality of a software application. It provides a high-level overview of what needs to be tested.
- Test Scripts: In software testing, a test script refers to the set of instructions that will be followed to verify that the system under test performs as expected. The document outlines each step to be taken and the expected results.
20. What is a bug in software testing?
A bug in software testing is like a mistake in a computer program. It’s something that the program does that it’s not supposed to do, or it doesn’t do something that it should do. Just like a spelling mistake in a book, bugs can cause the program to act weird or not work correctly. Testers find these bugs so that the programmers can fix them and make the program better.
21. State the difference between bugs and errors
Bugs and errors differ in the following ways:
| Bugs | Erors |
| A bug is a problem in a computer program that causes it to behave in an unintended way. | An error is a mistake made by a human, such as a programmer, while writing the code. |
| It’s a flaw or a mistake in the code that leads to incorrect behavior, unexpected results, or crashes. | It’s the root cause of a bug. If a programmer makes a mistake when writing code, it can lead to a bug in the software. |
| Bugs can be the result of coding mistakes, logic errors, or design flaws. | Errors can include syntax mistakes, logic errors, incorrect calculations, and more. |
22. 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
23. 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
- Defect
- Test Summary
24. 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
● Simulators.
● Test Data
● Test Traceability Matrix
● Error logs and execution logs
After testing Phase
● Test Results/reports
● Defect Report
● Installation/ Test procedures guidelines
● Release notes
25. What are different categories of debugging?
Different categories of debugging include:
● Brute force debugging
● Backtracking
● Cause elimination
● Program slicing
● Fault tree analysis
26. Write some common mistakes that lead to major issues.
Some common mistakes include:
● Poor Scheduling
● Underestimating
● Ignoring small issues
● Not following the exact process
● Improper resource allocation
27. What is a user story?
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.
28. List some of the popular software testing tools/frameworks, providing a brief description of each.
1. Selenium: a web browser automation tool that automates the test suites you need to run on a web browser.
2. 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.
3. 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.
4. Jasmine: This is an open-source JavaScript testing framework that allows you to write behaviour-driven tests.
5. JUnit and NUnit: These are unit testing frameworks for Java and C# programming languages, respectively.
29. What is usability testing?
It is a testing methodology where the end customer is asked to use the software to see if the product is easy to use, to see the customer’s perception and task time. An accurate way to finalize the customer point of view for usability is by using prototype or mock-up software during the initial stages.
30. What are the categories of defects?
There are three main categories of defects as shown in the below figure:
- Wrong: It implies that requirements have been implemented incorrectly. It is a variance from the given specification.
- Missing: This is a variance from the specifications, an indication that a specification was not implemented, or a requirement of the customer was not noted properly.
- Extra: It is a requirement incorporated into the product that the end customer did not give. It always differs from the specification but may be an attribute desired by the product user.
31. On what basis the acceptance plan is prepared?
Basically, the acceptance document is prepared using the following inputs.
- Requirement document: It specifies what exactly is needed in the project from the customers perspective.
- Input from the customer: This can be discussions, informal talks, emails, etc.
- Project plan: The project plan prepared by the project manager also serves as good input to finalize your acceptance test.
32. What is coverage and what are the different types of coverage techniques?
The parameter used in software testing to describe the extent to which the source code is tested is known as coverage. There are three basic types of coverage techniques and they are:
- Statement coverage: It ensures that each line of source code has been executed and tested.
- Decision coverage: It assures that every decision (true/false) in the source code has been executed and tested.
- Path coverage: Here we ensure that every possible route through a given part of the code is executed and tested.
33. What are the benefits of Automation testing?
Benefits of Automation testing are:
- Supports execution of repeated test cases
- Aids in testing a large test matrix
- Enables parallel execution
- Encourages unattended execution
- Improves accuracy thereby reducing human-generated errors
- Saves time and money
34. Why is Selenium a preferred tool for Automation testing?
Selenium is an open-source tool that automates the tests carried out on web browsers. Since Selenium is open-source, there is no licensing cost involved, which is a major advantage over other testing tools. Other reasons behind Selenium’s ever-growing popularity are:
- Test scripts can be written in any of these programming languages: Java, Python, C#, PHP, Ruby, Perl &.Net
- Tests can be carried out in any of these OS: Windows, Mac or Linux
- Tests can be carried out using any browser: Mozilla Firefox, Internet Explorer, Google Chrome, Safari or Opera
- It can be integrated with tools such as TestNG & JUnit for managing test cases and generating reports
- It can be integrated with Maven, Jenkins & Docker to achieve Continuous Testing
Related Article: Selenium Interview Questions
35. What are the various components of Selenium?
Different components of Selenium are:
- Selenium Integrated Development Environment (IDE)
- Selenium Remote Control (RC)
- Selenium WebDriver
- Selenium Grid
36. What are the different types of locators in Selenium?
The locator is nothing but an address that identifies a web element uniquely within the webpage. Thus, to identify web elements accurately and precisely we have different types of locators in Selenium as follows:
- ID
- ClassName
- Name
- TagName
- linkText
- PartialLinkText
- Xpath
- CSS Selector
- DOM
37. What is XPath?
XPath, also known as XML Path, is a language for querying XML documents. It is an important strategy for locating elements in Selenium. It consists of a path expression along with some conditions. Here, you can easily write an XPath script/query to locate any element in the webpage. It is designed to allow the navigation of XML documents, with the purpose of selecting individual elements, attributes, or some other part of an XML document for specific processing. It also produces reliable locators.
38. What is the difference between Absolute and Relative Path?
- Absolute XPath
It is the direct way to find the element, but the disadvantage of the absolute XPath is that if there are any changes made in the path of the element, then that XPath fails. For example: /html/body/div[1]/section/div[1]/div
- Relative XPath
For Relative XPath, the path starts from the middle of the HTML DOM structure. It begins with the double forward slash (//), which means it can search the element anywhere at the webpage. For example: //input[@id=‘ap_email’]
39. What are the different exceptions in Selenium WebDriver?
Exceptions in Selenium are similar to exceptions in other programming languages. The most common exceptions in Selenium are:
- TimeoutException
- NoSuchElementException
- ElementNotVisibleException
- StaleElementException
40. When should I use Selenium Grid?
Selenium Grid can be used to execute the same or different test scripts on multiple platforms and browsers concurrently, achieving distributed test execution, testing in different environments, and remarkable execution time savings.
41. How do I launch the browser using WebDriver?
The following syntax can be used to launch the Browser:
WebDriver driver = new FirefoxDriver();
WebDriver driver = new ChromeDriver();
WebDriver driver = new InternetExplorerDriver();
Intermediate Level Software Testing Interview Questions and Answers
42. What are some important testing metrics?
Testing metrics provide a high-level overview to management or developers of the project’s progress 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
43. 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 some of your users to use feature A, while the other group uses feature B. Then, user feedback and responses are evaluated using statistical testing to decide on 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 gather feedback and test their initial hypothesis quickly.
44. Can you explain sanity testing in software testing?
The term ‘sanity testing’ refers to a subset of regression testing. The sanity testing ensures that the changes made to the code do not adversely affect the system’s performance. After the software build is received, a sanity test is conducted to ensure that the changes made to the code are working correctly. As a checkpoint, this testing is used to determine whether the build can proceed with further testing. Sanity testing focuses on validating the functionality of the application rather than detailed testing.
Features
- It focuses on a smaller section of the application and is a subset of regression testing.
- The process is undocumented.
- Sanity testing is often unscripted.
- In this approach, limited functionalities are deeply tested.
- A tester is usually responsible for performing this task.
45. What do you mean by latent defect and masked defect?
- Latent Defect: Latent defects are defects that exist but have not yet been invoked because the conditions required to invoke them have not been met. As a systematic flaw, they encompass the entire software production process, including all pre-production testing and extended testing. When users perform a particular task in an unusual or rare situation or without the presence of usual scenarios, latent defects are revealed.
- Masked Defect: These are the defects that have not yet resulted in a failure since another defect hides that portion of the code from being executed. It can only be discovered when the defect hiding it is exposed by the user through a specific operation. Some defects are hidden or marked by another defect and remain hidden until the other defect is detected.
46. Should testing be done only after the build and execution phases are complete?
Testing is always done after the build and execution phases. The earlier we catch a defect, the more cost-effective it is. For example, fixing a defect in maintenance is ten times more costly than fixing it during execution.
47. What’s the relationship between environment reality and test phases?
As test phases start moving ahead environment reality becomes more important. For example, while unit testing, you need the environment to be partly real, but at the acceptance phase you should have a 100% real environment, or we can say it should be the actual real environment.
48. What are the valuable steps to resolve issues while testing?
The following steps can assist in resolving issues during testing:
● Record: Keep track of any problems that arise and resolve them.
● Report: Inform higher-level managers of the issues.
● Control: Establish a process for managing issues.
49. What is defects in software testing?
The term defect refers to a system error that prevents the intended action from being accomplished. Testing is most important when it comes to finding defects. Testing needs to begin early in the development process since defects can be found throughout. As shown in the following figure, defects are divided into three main categories:
- Wrong: It implies incorrect implementation of requirements. There is a variance between the specifications and what was expected, resulting in this defect.
- Missing: This indicates that a specification has not been implemented or that a customer requirement has not been properly noted.
- Extra: In this case, the defect is caused by a requirement incorporated into the product that was not provided by the end-user.
50. What is the spice in software testing?
SPICE stands for Software Process Improvement and Capability Determination. In the field of software development processes, SPICE is a standard framework for assessing the efficiency and effectiveness of the development process. IEC (International Electrotechnical Commission) and ISO (International Organization for Standardization) jointly developed SPICE.
51. A defect that could have been removed during the initial stage is removed in a later stage. How does this affect the cost?
If a defect is identified at the initial stage, it should be removed during that stage/phase rather than at some later stage. Delaying a defect for later phases becomes more costly. The following figure shows how a defect becomes costly as the phases move forward.
52. What do you mean by regression and confirmation testing?
Regression Testing is a type of software testing that confirms that a recent code change has not adversely affected existing features.
Confirmation Testing: When a test fails because of a defect, the defect is reported. Then, a new version of the software is submitted whose defect is fixed. This is called confirmation testing or re-testing.
53. What do you mean by boundary value analysis?
Boundary Value Analysis (BVA) is a black box test design technique used to determine whether there are any bugs at the boundary of the input domain.
54. 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, this doesn’t mean developers shouldn’t test the software before sending it to the tester. Developer testing helps find many bugs caused by programming errors, which are hard for testers to find because they don’t always have access to the source code.
55. How much testing is sufficient? Or is it possible to exhaustively test the software?
No matter how specific your test strategy is, it is impossible to exhaustively test software or prove the absence of errors.
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.
56. 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 consider the end user when testing. 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.
57. What is Random testing?
In Random testing, data is usually generated randomly, often using a tool. The following figure shows how randomly generated data is sent to the system.
58. On what basis you can arrive at an estimation for your project?
To estimate your project, you have to consider the following points:
- Divide the whole project into the smallest tasks
- Allocate each task to team members
- Estimate the effort required to complete each task
- Validate the estimation
59. Which test cases are written first: white boxes or black boxes?
Usually, black box test cases are written first and white box test cases later. To write black box test cases we need the requirement document and, design or project plan. These documents are easily available at the initial start of the project. White box test cases cannot be started in the initial phase of the project because they need more architectural clarity, which is not available at the start of the project. So, normally, white box test cases are written after black box test cases are written.
60. Mention the basic components of the defect report format.
The basic components of the defect report format include:
- Project Name
- Module Name
- Defect detected on
- Defect detected by
- Defect ID and Name
- Snapshot of the defect
- Priority and Severity status
- Defect resolved by
- Defect resolved on
61. Is Automation testing in agile methodology useful?
Automation testing is very useful in agile methodology. It helps achieve maximum test coverage in a shorter sprint.
62. Which test cases can be automated?
- Smoke test cases
- Regression test cases
- Complex calculation test cases
- Data-driven test cases
- Non-functional test cases
63. On what basis you can map the success of Automation testing?
By following criteria, the success of Automation testing can be mapped:
- Defect Detection Ratio
- Automation execution time and time savings to release the product
- Reduction in Labour & other costs
64. Explain Load Testing on websites?
To access a website, a user sends a “request” to that website’s server, and the server sends back a response in the form of the website you want to access. To load test a website, quality assurance engineers and automation engineers just need to multiply the number of responses sent to simulate different traffic loads. The web server’s response to the influx of virtual users can then be measured. This is used to determine performance issues and server capacity.
65. What is the difference between Selenium and Sikuli?
| Selenium | Sikuli |
| It cannot automate flash objects like video players, audio players, etc. | It provides extensive support to automate flash objects |
| It has a complicated API | It has a simple API |
| It can automate only web applications | It can automate the web as well as a Windows application. |
66. How to click on a hyperlink using linkText()?
driver.findElement(By.linkText(“Google”)).click();
This command finds the element using link text and then clicks on it. Thus, the user is redirected to the corresponding page.
67. What is TestNG?
It is an advanced framework that is designed to leverage the benefits of both the developers and testers. It also has an inbuilt exception handling mechanism, which lets the program run without terminating unexpectedly.
68. How do you set test case priority in TestNG?
The below code helps you to understand how to set test case priority in TestNG.
package TestNG;
import org.testng.annotations.*;
public class SettingPriority {
@Test(priority=0)
public void method1() {
}
@Test(priority=1)
public void method2() {
}
@Test(priority=2)
public void method3() {
}
}
Test Execution Sequence:
Method1 Method2 Method3
69. What is the difference between Selenium and QTP?
| Selenium | Quick Test Professional |
| Selenium supports almost all the popular browsers like Firefox, Chrome, Safari, Internet Explorer, Opera etc | QTP supports Internet Explorer, Firefox and Chrome. QTP only supports Windows Operating System |
| Selenium is distributed as an open source tool and is freely available | QTP is distributed as a licensed tool and is commercialized |
| Selenium supports testing of only web-based applications | QTP supports testing of both the web-based application and windows based application |
70. What is an Object Repository, and how to create it in Selenium?
Object Repository refers to the collection of web elements belonging to Application Under Test (AUT) along with their locator values. With respect to Selenium, objects can be stored in an excel sheet which can be populated inside the script whenever required.
71. How to input text in the text box using Selenium WebDriver?
By using the sendKeys()method, we can input the text in the text box using Selenium WebDriver.
Advanced Level Software Testing Interview Questions for Experienced Professionals
This section helps you practice with the advanced level and scenario-based interview questions
72. What is Test-Driven-Development?
Test-driven development (TDD) is a popular software development technique. Kent Beck first introduced it in his 1999 book of the same name.
In TDD, a developer working on a feature first writes a failing test and then 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 a 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 specifications. 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.
Related Learning: Manual Testing Interview Questions
73. 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.
74. 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:
Low
- User Interface bugs.
- Accessibility issues.
Medium
- Leaky abstractions.
- Software hangs.
- Users unable to perform a specific action.
- Boundary conditions.
High
- 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.
75. What is alpha testing?
Before you ship the software to the customers, the internal testing team performs alpha testing. Alpha testing is part of user acceptance testing and aims to identify bugs before the customers start using the software.
76. What is beta testing?
Once you ship the software to the customers after alpha testing, the software’s actual users perform beta testing in a real production environment. Beta testing is one of the final components of user acceptance testing. It is helpful to get feedback from real people using your software in real environments.
77. What is meant by browser automation?
It’s a process of automatically testing a web application’s functionality in a browser. 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 browser automation can test this very quickly and often, whereas a human tester would take a long time. This is part of automated testing. Some essential tools for browser testing include Selenium, protractor.js, and Cypress.
Related Learning: Cypress vs Selenium
78. What do you mean by Test Matrix and Traceability Matrix?
Test Matrix: This is a testing tool used to capture the actual quality, effort, resources, plan, and time required to cover all the phases of software testing. It only covers the testing phase of the life cycle.
Requirement Traceability Matrix (RTM): This is a document, usually present in the form of a table, that is used to trace and demonstrate the relationship between the requirements and other artifacts of the project from start to end. In simple words, it maps between test cases and customer requirements.
79. What is static software testing?
Static testing is a technique in which software is tested without actually executing it. It involves code walkthroughs, code reviews, peer reviews, or using sophisticated tools such as Eslint and StyleCop to perform static analysis of the source code. Static testing is typically performed during software development.
80. 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.
81. What kind of input do we need from the end user to begin proper testing?
The end user is the most important person because he is the one who has to use the product and is more interested in the project than anyone else.
82. What is meant by workbench concept?
A workbench, at its core, is a way of documenting how a specific activity has to be performed. It is often referred to as phases, steps, and tasks, as shown in the following figure.
- Input
- Execute
- Check
- Production output
- Rework
83. What is meant by Defect Cascading?
Defect cascading is a defect caused by another defect. One defect triggers the other. When a defect is present in any stage but is not identified, it hides in other phases without getting noticed. This will increase the number of defects.
Let us understand this by an example.
You are designing the Login Module of a web page:
In phase 1, you are designing the Register User Module for Login. The mobile number is mandatory, but you can leave it blank due to a bug that goes unnoticed.
In Phase 2, you will design the login form with a username and password. The password is OTP, which will be sent to the User’s registered mobile number.
Now, the Register module has a bug that the mobile number can be left blank, so this may lead to Login failure or maybe some system error or crash if a null mobile number is not handled. This is known as defect cascading.
84. What are the different strategies for rollout to end users?
The strategies to be followed for rollout are as follows:
- Pilot
- Gradual Implementation
- Phased Implementation
- Parallel Implementation
85. Explain how you can find broken links in a page using Selenium WebDriver.
This is a tricky question that the interviewer might present to you. He can provide a situation wherein there are 20 links in a web page, and we have to verify which of those 20 links are working and how many are not working (broken).
As you have to verify the working of every link, the workaround is to send HTTP requests to all of the links on the web page and analyze the response. Whenever you use the driver.get() method to navigate to a URL, it will respond with a status of 200 – OK. This indicates that the link is working and has been obtained, whereas any other status indicates that the link is broken.
Let’s now understand how to do that.
First, we have to use the anchor tags <a> to determine the different hyperlinks on the web page. For every <a> tag, we can use the attribute ‘href’ value to obtain the hyperlinks and then analyze the response received when used in driver.get() method.
86. Which technique should be considered in the script “if there is neither frame id nor frame name”?
If frame name and frame ID are not available, we can use frame by index. For example, if there are 3 frames in a web page and none of them have a frame name and frame ID, we can still select those frames by using the frame (zero-based) index attribute. All frames will have an index number, like the first frame at index “0,” the second at index “1,” and the third at index “2.”
driver.switchTo().frame(int arg0);
87. How to take screenshots in Selenium WebDriver?
You can take a screenshot using the TakeScreenshot function. With the help of getScreenshotAs() method, you can simply save that screenshot. Example: File scrFile = ((TakeScreenshot)driver).getScreenshotAs(outputType.FILE);
88. Explain how you will log in to any site if it shows an authentication popup for username and password.
If a pop-up for logging in appears, we need to use the explicit command and verify if the alert is actually present. The code below helps you understand the use of the explicit wait command.
WebDriverWait wait = new WebDriverWait(driver, 10); Alert alert = wait.until(ExpectedConditions.alertIsPresent()); alert.authenticateUsing(new UserAndPassword(**username**, **password**));
89. How to skip a method or a code block in TestNG?
To skip a particular test method or code, you can set the ‘enabled’ parameter in the test annotation to false.
@Test(enabled = false)
90. Briefly explain what the below code snippet indicates.
WebElement sample = driver.findElement(By.xpath("//*[contains(text(), 'data')]"));
It defines a variable sample of type WebElement and uses an XPath search to initialize it with reference to an element that contains the text value “data.”
This brings us to the end of this article on the Top 50 Software Testing Interview Questions. I hope it helped to expand your knowledge. I wish you all the best for your interview. You can also check our blog on QA automation interview questions. Happy learning.
FAQs
1. How to prepare for a software testing interview?
Prepare for a software testing interview by immersing yourself in fundamental concepts of Software Testing and relevant tools, practicing problem-solving through test scenarios, understanding SDLC/STLC processes, domain knowledge if required, resume polishing, practicing behavioral questions, researching the company, asking worthy questions, and mock interviews.
2. What are the 7 steps of software testing?
The seven steps of software testing are mentioned below:
- Requirement Analysis
- Test Planning
- Development of Test Cases
- Environment Setup
- Test Execution
- Defect Tracking and Management
- Test Reporting
3. What is SDLC and STLC?
SDLC stands for Software Development Life Cycle and is the framework that helps development teams effectively plan, design, develop, test, and deploy software applications for maintenance.
STLC stands for Software Test Life Cycle, and it is a defined process outlining the approach used and activities for testing within SDLC. This allows appropriate testing to be run to find defects and change them prior to rolling them out to end-users.
4. What are the four types of software tests?
The following are the four kinds of software tests common in reference:
- Unit Testing
- Integration Testing
- System Testing
- Acceptance Testing
5. What is the basics of testing?
Software testing is a process or act of running or executing software in a normally systematic way to validate the quality of the software at levels such as unit, integration, and system testing, using various techniques that can be referred to as black-box and white-box testing. It is meant to verify functionality and integrity of the code in such an activity, whose objective is to find problems early, reduce cost, and improve the quality of software before release.
If you found this “Software Testing Interview Questions” article relevant, check out the Software Testing Course by Edureka, a trusted online learning company with a network of more than 250,000 satisfied learners spread across the globe.
Do you have a question for us? Please mention it in the comments section on this Software Testing Interview Questions, and we will respond to you.