Experienced Testing Interview Questions: As an experienced QA, when you attend any interview, you may expect some of the QA tester interview questions below.
Experienced Testing Interview Questions
Tell me something about yourself.
I started my career as a QA in the year ____. Since then, I have worked on several operating systems, such as Windows XP,2007, and Windows 8. Testing applications come in very handy to me. I have taken care of applications in a domain such as Healthcare, CRM, ERP, etc.
Being a QA, I also have experience in the field of writing. Test Plans Test Cases are a few examples. I have also attended several meetings with project managers and business analysts.
When different kinds of testing come into question, I have also explored that field. Whether it is Smoke Testing, Integration Testing, Regression Testing, Blackbox, or UAT Testing, I have given all of them a shot. Writing defects is something I laid special emphasis on. I would always assess, reassess, and test them thoroughly before passing them on. If the defects were not fixed, I would make an effort to reopen them again.
You can Check this Video Also:
Have you written a Test Plan? What is a Test Plan? What does it include?
Yes, I have written/contributed to the test plan. A test plan is a document describing a software testing effort’s scope, approach, objectives, resources, and schedule. It identifies the items to be tested, items not to be tested, Who will do the testing, the test approach followed, what will be the pass/fail criteria, training needs for the team, the testing schedule, etc.
A typical Test Plan, as per IEEE-829, contains the following:
What is a TestCase? What does it include?
A test case is a document that has a set of test data, preconditions, and expected results developed for a particular test scenario to verify compliance against a specific requirement.- Typical Test Case Parameters consists of:
Check In Details: What Is Test Case?
What is the Software Development Life Cycle?
The systems (or software) development life cycle (SDLC) is a conceptual model used in project management that describes the stages involved in an information system development project, from an initial feasibility study through maintenance of the completed application. It includes the following different stages:
Check: Software Testing Life Cycle (STLC) In Detail
Why not use exhaustive testing? How do you prioritize test cases?
Exhaustive testing is a test approach in which all possible data combinations are used for testing. It takes a lot of time. That’s why we need to use some testing techniques. In another way, we can prioritize test cases so that testing efforts can be reduced and tester/QA can focus on more important functionalities.
We can prioritize test cases according to perceived risks and customer expectations towards features, and the tester can reduce the number of test cases. Below are some factors to consider in prioritizing test cases:
How many Test Cases did you write in your last project?
Wrote about 1,000 Test Cases in my last project. (The reasonable number of Test Cases varies from 500 to thousands. The number of 1100 test cases can be completed in an 8-month project duration).
What document did you refer to when writing the Test Cases?
NOTE: It can also be Use Cases or Design Documents and purely depends on the company.
Did you have a situation where you did not have any documents (no requirement document, no Use Cases, or no Design Document), and you had to write the Test Cases? How did you write the Test Cases?
Yes. I have been in that kind of scenario in some companies. There were companies that had no documents at all (As requirement docs become obsolete sometimes for new or maintenance projects)In that case, I had to discuss the application scenario and functionality with the Business Analysts or developer. Sometimes, I prepared a document indicating the main workflow of the application.
Can you tell me what a Use Case is?
A use case is a document that describes the user action and system response for a particular functionality. For example, a Use Case for Banking System can have the following user interactions:
What is Build? What is meant by Patch?
- Build: When each of the different modules of software is prepared, they are put in a single folder by the Configuration Management Team, and it is called the ‘Build’ In other words, the developers put their code in the shared location (folder), and all those codes (modules) are combined so that it is a complete application that works.
- Patch: A patch (sometimes called a “fix”) is a quick repair job for a piece of programming. During a software product’s beta test distribution or try-out period and later after the product is formally released, problems/bugs will almost be found. A patch is an immediate solution that is provided to users. For example, Check that HP UFT releases patches to support new browser versions or fix any bugs found after release.
What is meant by the Build Deployment?
When the Build prepared by the Configuration Management Team is sent to different Test Environments, it is called the Build Deployment.
What is the Requirement Traceability Matrix?
The Tractability matrix is used to cross-check the test cases as per the requirement of the test cases. In other words, it checks whether each functionality is covered in the Test Cases as per the requirement document.
What is Exploratory Testing, and when should it be performed?
The definition of Exploratory Testing is “simultaneous test design and execution” against an application. This means that the tester uses his domain knowledge and testing experience to predict where and under what conditions the system might behave unexpectedly. As the tester starts exploring the system, new test design ideas are thought of on the fly and executed against the software under test.
In an exploratory testing session, the tester executes a chain of actions against the system, and each action depends on the result of the previous action. Hence, the outcome of the actions could influence what the tester does next. Therefore, the test sessions are not identical.
This is in contrast to Scripted Testing, where tests are designed beforehand using the requirements or design documents, usually before the system is ready, and execute those same steps against the system at another time.
Exploratory Testing is usually performed as the product is evolving (agile) or as a final check before the software is released. It is a complementary activity to automated regression testing.
How do You Verify the Results of Your Search on the Search Results Page?
In the first instance, we need to know where the data is coming from. Are they coming from a database? Or some XML files from 3rd party websites?
Once we have this information, we can start comparing the results we see on the result page with the results from the source, e.g., the database.
Another option is to use mocks to generate the data we need to fully control the data we see on the search results page.
How is Web Application Testing different from Desktop Application Testing?
Web Applications are typically hosted on a server that we can access via a web browser, whereas desktop applications are installed on the client’s machine.
This setup opens a whole new testing challenge: Performance and Security testing become important as the application is open to a wide audience. Good design and usability are also important.
Other important factors that come into play are testing on multiple browsers, multiple devices, redirection, and responsiveness.
What are the HTTP response code blocks, and what do they mean?
After a request is sent to a server, there are different possible response codes which the server can return:
The blocks are:
- 2xx for Success, the most common one is 200, which means “OK.”
- 3xx for Redirection, the most common ones are 301 and 303, meaning “Permanent Redirect” and “Redirect for Undefined Reason”, respectively.
- 4xx for Application Error, the most common ones are 403 and 404, meaning “Forbidden” and “Not Found”, respectively.
- 5xx for Server Error, the most common one is 500, meaning “Server Error.”
How would you Test a Service Oriented Architecture (SOA) Web Application?
The testing of web applications that communicate with a web service can be broken down into two parts:
Testing of the Web Service in isolation. Each web service has one or more functions that can be tested by sending appropriate requests, analyzing the response, and verifying correct data is returned in the response. We can use tools such as SoapUI to test a Soap Service or Rest Client to test a RESTful web service.
Integration Testing of Web Service with the Front End is also important as it can highlight issues with data in the request and display of the response. The reason for this separation is to be able to identify issues in the web service much quicker and easier to debug.
Suppose you have a Login form that is connected to an Authentication Web Service. What tests would you perform at which layer?
All the input/output validation should be tested at the API layer, calling the Authentication Web Service tests such as valid/invalid username/password combinations and verifying correct error messages.
There are many ways to test a website and many test cases to execute; how can you ensure the web application is fit for release?
We can Automate the majority of test cases, but most importantly, we can use test techniques such as Pair-wise testing to reduce combinations and/or model-based testing to plan user journeys to ensure major functionality of web application works.
We can also use Paralytics to gain insight into what users do on the website, which page is most popular, and which feature is most used by users.
What is a Web Service?
A Web Service is a program that can be accessed by other programs over the web (HTTP). For example, let’s assume that you have a function that prints text in HTML format. The application’s target is the web browser, which renders the output, and a human being can easily read the text on the page.
On the other hand, a web service’s target audience is other programs or other web services that consume the data served by the web service. The output is normally in a standard language that other programs can understand. Take the above example: if the web service outputs the text in, say, XML format, then other web services that can read or understand XML can use the output.
The main advantage of a Web Service is that applications can be written in any language, but they can communicate and exchange data with each other through a Web Service. Software applications written in various programming languages and running on multiple platforms can use web services to transfer data over the Internet (HTTP). This interoperability (e.g., between Java and Python or Windows and Linux applications) is due to the use of open standards (XML, SOAP, HTTP).
- SOAP (Simple Object Access Protocol)
- UDDI (Universal Description, Discovery, and Integration)
- WSDL (Web Services Description Language)
- Experienced Testing Interview Q&A
What do you think is a test plan? Have you written one before? What does it usually consist of?
A test plan is a sort of document that analyzes the resource, scope, approach, and schedule of several testing activities. It will help you find items that need to be tested, its features that need further testing, the risks that come with some, and the solutions.
Yes, I have written a test plan before. It consists of history, contents, introduction, scope, overview, and approach. The risks and assumptions are not left out either.
Define a Test Case and a Use Case. What do they consist of?
A test case is a document that gives you a step-by-step detailed idea of how to test an application. It usually comprises results (pass or fail), remarks, steps, outputs, and descriptions.
A use case, on the other, is a document of another kind. It helps you understand the user’s actions and the system’s response found in a particular functionality.
What is a test strategy?
A test strategy helps you understand the process of testing in every software development cycle. It has been made so that all project managers and developers will be informed about some of the most important testing issues. All objectives, methods, total time, and the resources which are needed for the project are explained.
A few components you will always find in a test strategy are test level and test schedules, test groups and test priorities, test summary, requirements of the environment, responsibilities, etc.
What is SQL?
SQL stands for Structured Query Language. It is an American National Standards Institute computer language used to analyze and assess database systems. The statements of SQL are used to get hold of data and retrieve it. They only work with database programs such as MS Access, Informix, Oracle, and Sybase.
However, there are also different kinds of SQL languages found today. They have to be in compliance with the standards of the ANSI. The keywords should be supported in the same way.
Describe Change Control.
Change Control is also popularly known as Change Request. It tells us in detail about the additional functionalities that are included once the Business Requirement Document has been signed off.
What is the build?
A build is a component or folder containing one of the software’s modules. The Configuration Management Team usually prepares this.
Describe the bug life cycle.
The bug life cycle Or Defect Life Cycle comprises various statuses of an error during its life cycle. A few examples are open, deferred, solved, reopened, fixed, solved, and closed. You may also speak about this process and how you monitor and determine the status with the help of several points.
Tell us about the biggest bug you have ever found.
In my testing experience, I have found several defects. Some of them were small, whereas some of them were huge. The biggest one I have encountered so far is in the previous project on a page where I found a button called “More Information”.
Once the person using the computer pressed that button, a new window would automatically pop up. I would then close the window by using three ways. First, I would click on ‘X’ in the page’s top right corner. I would then click on a Close button and finally the combination keys on the keyboard.
How do you plan on dealing with your team members?
There are higher possibilities that I won’t be the only one on the team. Dealing with the team members can get very difficult and frustrating. There will be quarrelsome dispositions and misunderstandings, and some will also try to ignore the other.
But my purpose is to look beyond all of this. We are a team and should work together to reach a common goal. I will be friendly and invite them over for coffee. As a human, it is very important to share feelings and have important discussions; that is exactly what I intend to do. This is something that not only me but everyone else in a working environment should apply.
Have you used automation tools before?
For Automation Tools, we are considering Functional Automation Testing Tools. In some projects, I used Selenium Web-driver for building Smoke and Critical Test Cases. We have also used JMeter for performance testing to check some performance parameters.
Do you like the QA job? If yes, tell us why.
Yes, I do like the QA job. The only reason behind this is because the job is process-oriented. This means that here, I have the opportunity to try several things at a time. I can analyze the needed documents, test the application, write test plans and test cases, prepare reports, and retest them once again if the need arises. My favorite task would be reducing defects. The more defects I find while working, the happier I will be.
Consider if there is no Test lead, No Test Manager, and QA Manager. If you are the senior test engineer, you are getting pressure from the client to give the build. But you see that there are five high and 5 low severity bugs. So, what you will do, and how will you interact with the client?
As you said, 5 bugs are high, and 5 bugs are low severity. If no test lead or manager is unavailable as a Senior Testing Engineer, I will concentrate on 5 high severity bugs. First, I will understand them and send them to the particular development team with the help of the project manager. If required, I will explain to them the situation and the bug severity.
Also, I will interact with the client on behalf of my test team, and I will make them understand the current status of the application.
Suppose a website contains 20 pages & has a similar type of error on most pages. The tester checked one page & posted the bug in a bug-tracking system, including that this bug remains on most pages, but the developer only debugged one page (the location the Tester had written). Now, who is responsible for checking other pages, Developer or Tester?
Yes, it is the responsibility of the tester to identify the bug. While Posting bugs, we have to specify that this bug is repeated on another screen.
By mistake, you have posted a bug saying that the error is displayed on a single page. Then there is a thing called Defect discussion, where the nature of the bug is discussed with the development team at the end of the day, where the development may come to know the nature of the bug.
You have completed a project, and the release date is the next day; you have one big problem, but that problem can’t be resolved in a short time, and the estimate is 10 days. What are your options?
We could think of any workaround that would be suitable at that point in time for the problem and make a note in the Release notes.
If there is no workaround, a note should be mentioned in the release notes stating it is a known issue.
You have tested the application, and it is released. The user asks for some changes in the project and gives one week’s time to complete it. Out of the one week, 6 days are taken by the developer to make the changes. So you have only one day to test it. What will you do in the case in case of manual testing?
In that case, we can test the main part of the application and find 80% of errors in that main functionality only; for that, we can mainly concentrate on the main functionality.
High priority, then why is a priority given by project managers and severity given by testers?
High-severity bugs affect the end-users. Testers test an application from the user’s point of view hence, it is given a high severity. High priority is given to the bugs which affect the development. Project managers assign a high priority based on the development/deployment point of view.
If you have executed 100 test cases and every test case passed, but apart from these test cases, you found some defect for which the test case is not prepared, then how you will report the bug?
While reporting this bug to a bug tracking tool, first, you will generate the test case and write the steps to reproduce the bug. The bug will be reported.
How would you test software applications without any formal documents like Requirement Document?
Have a meeting with Project Stakeholders who were part of project initiation(Business Analyst, Project Manager). They can elaborate on functionalities present, Expected Results, and Business rules that drive the application Have a session with developers as they are part of developing software and have considered some requirements. They know the major functionality of the software and can elaborate more.
Do some exploratory testing and learn application functionalities. Exploratory testing is an excellent way to learn applications from a tester’s point of view; usually, self-learning boosts confidence. Most of the small-scale companies don’t have documentation. The tester must rely on his previous experience testing similar applications in this testing.
What is the Quality Gates? Why should it be used?
Quality Gate is an activity that is present between stages of a project life cycle. This activity must be completed before moving to the next phase of the project lifecycle. It’s a general criterion that must be satisfied before moving to the next stage in the project life cycle. e.g., Software Requirement Specification(SRS) may have Peer Review.
A Requirement Traceability Matrix (From BRS to SRS) Signed Off by Client, Project Manager. After completing the above Quality Gate, the only project moves to the next stage, i.e., the High-Level Design Phase in the Software Development Life cycle.
As per definition, it can be used to improve the visibility of quality in SDLC Stages. It is used to reduce project risk through phase-by-phase quality gates. (You can compare Quality Gates with Entry and Exit Criteria used in the Testing Phase. Both are on the same lines.)
If you have ‘n’ requirements and you have less time, how do you prioritize the requirements?
In such a scenario, the most critical requirements need to be finalized with discussion from the client and stakeholders. In testing, requirements aren’t really ‘finalized’ by the testing team.
How do you find the regression scenarios if a defect is fixed?
Regression scenarios would be run on all the test cases that failed during manual testing because of the bug in the software. Checking the history of the bug may help to identify the regression scenarios. Also, we have to decide by observing bugs and what could be affected by functionalities due to such bugs.
How is load testing performed on a website? How does it work?
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/page you want to access. To load test a website, QA and Automation Engineers must multiply the number of requests sent to the server to simulate different traffic loads. The web server’s response to the number of virtual users can then be measured by using a performance tool. This is used to determine performance issues and server capacity.
What is defect measurement?
Defect Measurement is a process for analyzing the developer and tester’s efficiency and the process based on the bug details collected from one project.
Through Defect Measurement below, all the factors are measured:
- Efficiency of developer
- Efficiency of tester
- Is the progress in gear?
What Test Techniques are there, and what is their purpose?
Test Techniques are primarily used for two purposes:
- To help identify defects.
- To reduce the number of test cases.
- Equivalence partitioning is used to reduce the number of test cases by identifying different sets of data that are not the same and only executing one test from each set of data.
- Boundary Value Analysis is used to check the behavior of the system at the boundaries of allowed data.
State Transition Testing is used to validate allowed and disallowed states and transitions from one state to another by various input data.
- Pair-wise or All-Pairs Testing is a very powerful test technique and is mainly used to reduce the number of test cases while increasing the coverage of feature combinations.
How do you test the login feature of a web application?
The Possible answer to these questions:
- Sign in with a valid login, Close the browser, reopen it, and see whether you are still logged in or not.
- Session management is important – how do we keep track of logged-in users? Is it via cookies or web sessions?
- Sign in, then log out, and then go back to the login page to see if you are truly logged out.
- Log in, then go back to the same page. Do you see the login screen again?
- Sign in from one browser, then open another browser to see if you need to sign in again.
- Log in, change the password, log out, and see if you can log in again with the old password.
Difference Between HTTP and HTTPS
|Port for Communication||Port 80||Port 443|
|SSL Digital Certificate||Not required||Required|
|OSI Layer||Application Layer||Transport Layer|
Difference Between getting and POST
|Aspect||GET Request||POST Request|
|How Request is Sent||Sent via URL string (appended to the URI with a question mark as a separator)||Encapsulated in the body of the HTTP request|
|Visibility of Request||Visible||Not visible|
|Request Length Limitation||Limited by URL length||No length limitation|
|Speed Comparison||Faster than POST request||Slower than GET request|
|Data Types||Can carry only text data||Can carry both text and binary data|
|Caching and Bookmarking||Can be cached and bookmarked||Not cacheable or bookmarkable|
|HTML Form Method||Default method for HTML FORM element||Requires the method attribute set to “POST.”|
|Character Encoding||Restricted to use ASCII characters||Can use “enctype” attribute for UCS (Universal Multiple-Octet Coded Character Set) with “multipart/form-data” value|
Difference Between Usability Testing and GUI Testing.
|Aspect||GUI Testing||Usability Testing|
|Purpose||Check the appearance of the application||Checks the easiness/user-friendliness of the application|
|Focus||Look and feel of the application||User-friendliness of the application|
|Elements Tested||Colors, fonts, font sizes, buttons, links, icons, etc.||Mandatory fields, cursor positioning, tab button functionality, etc.|
|Scope||Front end of the application||Overall, working from a non-technical user’s perspective|
|Key Evaluation||Visual elements conformity to design, display as specified||Interaction and ease of use for non-technical users|
Difference between Ad-hoc Testing and Exploratory Testing.
|Aspect||Adhoc Testing||Exploratory Testing|
|Approach||Begins with learning the application first and then starts testing||Tests the application while learning it|
|Tester’s Familiarity||Tester knows the application in advance||The tester doesn’t know the functionality of the application initially|
|Documentation||Documentation is not mandatory||Documentation is mandatory|
|Tester’s Expertise||An Expert tester is not necessarily needed||An Expert tester is needed|
|Formality||Generally informal and unplanned||A systematic approach with simultaneous learning, design, and execution.|
|Example||Testing WhatsApp without a specific plan breaks the application.||Defining a scope (e.g., testing the Attach Document functionality) and exploring that specific area|
Explain Version, Revision, and Releases.
- Version: An initial release or re-release of a configuration item associated with a complete compilation or recompilation of the item. Different versions have different functionality.
- Revision: Change to a version that corrects only errors in the design/code but does not affect the documented functionality.
- Release: The formal distribution of an approved version.
When do you start testing the application?
Criteria to start testing may include the following points:
- The definition of all test scenarios and test cases are completed.
- Functional and Business requirements should be cleared, confirmed, and approved.
- Test Environment is ready(Availability of hardware and software for initiating testing is ensured)
- The bug-tracking system is in place and accessible.
- Test Data is available.
- Unit Testing is done successfully by developers.
- The tester has significant knowledge of the application under test.
If there are two defects in the Application, One is with High Severity and the Other with High Priority. Which one must be fixed first?
- Severity is related to testing/QA Terms and the impact of a defect on the Application.
- Priority is related to Business Terms, and it is the impact of a defect on the Overall Business or End Users.
So defects with High Priority must be fixed first as they affect end-users or businesses.
How do you define software product quality?
Software Product Quality can be defined in terms of the following quality attributes.
- Reliability: Software products should be reliable in terms of Availability, Fault tolerance, and consistency. Consistent means it should give correct results at any time and under any conditions.
- Maintainability: Maintainability is the ability of the system to change with a degree of ease. These changes could impact components, services, features, and interfaces when adding or changing the functionality, fixing errors, and meeting new business requirements.
- Re-usability: Reusability defines the capability for components and subsystems to be suitable for use in other applications and other scenarios. Reusability minimizes the duplication of components and also the implementation time.
- Usability: Usability defines how well the application meets the requirements of the user and consumer. It defined how the application is easy to use.
- Testability: Testability measures how easy it is to create test criteria for the system and its components and execute these tests to determine if the criteria are met.
- Security: Security is the capability of a system to prevent malicious or accidental actions outside of the designed usage and to prevent disclosure or loss of information. A secure system aims to protect assets and prevent unauthorized modification of information.
- Scalability: Scalability is the ability of a system to handle increases in load without impacting the performance of the system or the ability to be readily enlarged.
- Performance: Performance indicates a system’s responsiveness to execute any action within a given time interval. It can be measured in terms of latency or throughput. Latency is the time taken to respond to any event. Throughput is the number of events that take place within a given amount of time.
- Interoperability: Interoperability is the ability of a system or different systems to operate successfully by communicating and exchanging information with other external systems written and run by external parties. An interoperable system makes it easier to exchange and reuse information internally as well as externally.
Let’s say you have a test plan with over 200 test cases. How do you decide what should be automated and what should still be done manually?
In such a case, we need to consider two points
- Priorities of Test Cases.
- Feasibility of automation for Test Cases listed.
- Some of the questions that the candidate should raise to evaluate: Now, using the following criteria, we have to divide test cases in an automated and Manual way.
- Test cases take a lot of time to execute manually and are tedious.
- Parts of the application that need regular regression(We can check defect history to get the most error-prone areas)
- Test cases can be done manually and easily.
- The test cases are not easy for manual testing. (If the Selenium tool is being used and the test case is more involved with Windows controls, i.e., non-browser)
- Areas of the software application that could be changed in the next weeks. This will prevent us from developing automated test cases for the same.
What to do when we are out of time, the application is not bug-free, and tomorrow it’s going for production?
Make a list of all open defects and share across all key stakeholders like Requirement Owner (PO, Business Analyst), Dev Lead, Dev Manager, Test Lead, Test Manager, and Delivery Manager (stakeholders may vary depending on your project)
Schedule a defect triage meeting to prioritize all defects in the following categories
- Category A: Issues that must be fixed. Software can’t be released without that.
- Category B: high-priority Issues that should be included in the solution if it is possible
- Category C: Issues which is considered desirable but not necessary
- Category D: Defects that will not be fixed (issues that do not generate any value addition to the software)
- All stakeholders should decide to go/no-go based on the following:
- Can we accommodate Category A issues within the deadlines?
If Yes – Can we accommodate category B issues within the deadlines?
If No – Can we accommodate category B issues post the release?
- If No – Which all issues from category A can be accommodated? Can the release date be postponed? If Yes, are there any contractual obligations from the customer?
- Note – “accommodate” means that issues should be fixed, code reviewed, and tested with impact areas. Remember that last-minute major fixes are usually dangerous. So make a wise decision. Key stakeholders (not just the test team) must take this decision. Make sure that the team gives their input on impact and testing efforts based on the experience.
- Also, remember that – the Testing team has “some” control over quality. The entire team (dev/test / PMS, etc.) is responsible for the quality.
What are the different types of environments used in software releases?
Generally, companies have four environments. Dev, QA/Testing, Staging, and Production
- Dev Environment: It’s generally used by developers to commit the working copy of the code. It contains the most recent version of the application. Many developers merge their code into this environment.
- QA Environment: This environment is solely used by Testers/QA to test applications.
- Staging Environment: This environment is a copy or mirror of the production environment. It looks the same as the production environment, as it may contain very recent data from productions. We can call this a release candidate. The staging area contains the “next” version of the application, and the tester tests the application for the final release. The tester may find issues here as data is the same as in the production environment.
- Production Environment: It is nothing but the live site.
What is meant by a test log?
Test log creates an integrated management environment where you can create and manage your entire test plan, other than your test cases.
- It helps in managing the development life cycle.
- It also helps in promoting the reusability of the test cases.
- It helps in improving efficiency.
- It also helps in managing the xml database.
- It helps in documenting both automated and manual test cases.
What is the difference between latent defects and masked defects?
- Latent Defects: These are the defects that are present in the system. These defects remain for a long time and can also be detected in different versions of the software. It may be detected after the release. The main reason for this defect is that the exact set of conditions hasn’t been met.
For Example, February has 28 days. The system will not recognize the leap year and shows an error for the leap year. This defect remains in the system and will be recognized as latent.
- Masked Defects: The main functionality of these defects is that they will hide the other defects in the system. These defects can be observed by in-page navigation.
Example: If a defect on the current page causes a problem in moving to another page, then the defects on the next page can’t be seen.