Testing Fundamentals interview questions and answers

The purpose of software testing is to validate and verify that the software meets the intended business requirements and functions as expected. Testing also helps to identify any issues and bugs in the software so they can be addressed and corrected before the software is released to the public.

Testing helps to ensure that the software is of high quality, free of bugs and can serve its intended purpose. It also helps to ensure that the software is secure, reliable and performs optimally.

Testing is typically done in several stages and can involve a range of approaches and techniques. Generally, it involves the following steps:

• Analyzing the requirements and specifications of the software.

• Designing test cases based on the requirements and specifications.

• Executing the test cases and recording the results.

• Analyzing the results to determine if any issues or bugs are present.

• Reporting the results to the developers.

• Fixing any identified issues.

• Re-testing the software to ensure that the issues have been addressed.

Testing can involve any combination of manual testing, automated testing and/or performance testing. It is typically done by a dedicated team of testers who have the skills and expertise to effectively test the software.

The most common type of testing is functional testing. Functional testing is a type of software testing that verifies that each function of the software application is performing correctly. This type of testing is usually done manually, but can also be automated.

Functional testing often involves verifying that the application can complete certain tasks and that the output is accurate. Some examples of functional testing tasks include:

• Verifying that a login page accepts valid credentials.

• Testing the functionality of a shopping cart.

• Ensuring that a search feature produces accurate results.

• Checking that the application can read and write data from a database.

• Verifying that a particular page is displayed correctly.

When conducting functional testing, testers must ensure that all features of the application are tested thoroughly. This includes testing for valid input, invalid input, boundary cases, error conditions, and performance.

Functional testing is a type of testing focused on verifying the functionality of a system. It verifies that the system works as intended and all the features are functioning correctly. It checks for correctness, completeness, accuracy, and conformance to specifications. Examples of functional testing include unit testing, integration testing, system testing, and acceptance testing.

Non-functional testing is a type of testing focused on verifying the non-functional aspects of a system. It checks how the system performs under certain conditions and how it responds to different types of input. Non-functional testing is usually done after the functional tests are complete. Examples of non-functional testing include performance testing, load testing, security testing, stress testing, and scalability testing.

The main difference between functional testing and non-functional testing is the scope of the tests. Functional testing is concerned with verifying system functionality and features, while non-functional testing is concerned with verifying how the system performs.

To give an example, let's say you are testing a web application. Functional testing would involve verifying that all the buttons and links on the page are working correctly and that the user is taken to the correct page when a button is clicked. Non-functional testing would involve testing the performance of the application, such as how long it takes for the page to load, how well the application responds to different types of input, and how secure the application is.

Regression testing is a type of software testing that verifies that software previously developed and tested still performs correctly even after it was changed or interfaced with other software. It is an important part of software development and maintenance because it helps to detect errors, bugs, and other issues that could be introduced into the software due to changes or additional features.

Regression testing is used to test changes to the software and make sure that the software still meets its requirements. It is usually done after the software has been released and new features or changes have been added. This type of testing helps to ensure that the changes or additional features do not break the existing code or introduce any new issues.

In order to perform regression testing, the test cases that were run during the initial software development phase must be run again. This will help to determine if the changes to the software have caused any new issues or if the existing code is still working properly.

In addition, regression testing can be used to verify that the software still meets its non-functional requirements such as performance and usability. This will help to ensure that the software is still usable and efficient even after changes have been made.

To summarize, regression testing is an important part of software development and maintenance, as it helps to ensure that changes or additional features have not broken the existing code or introduced any new issues. It is used to verify that the software still meets its functional and non-functional requirements, and that it is still usable and efficient.

Testing fundamentals typically involve four different levels of testing: unit testing, integration testing, system testing and acceptance testing.

Unit Testing: This is the most basic level of testing and is typically performed by the developer. It involves testing individual units or components of a software to ensure they are fit for use. It is also referred to as component or module testing.

Integration Testing: This level of testing occurs after unit testing and is used to test how different units of software interact with each other. Integration testing typically involves testing of interfaces between various subsystems.

System Testing: This type of testing is performed on a complete and fully integrated system to confirm it meets the specified requirements. System testing is conducted in a controlled environment and is designed to verify the system’s accuracy, completeness, security and quality.

Acceptance Testing: This is the final level of testing and is conducted by the customer or an independent testing team to determine whether or not the system meets the customer’s requirements. This type of testing typically involves user acceptance testing (UAT) to ensure the system meets the user’s expectations.

White box testing and black box testing are two different approaches to software testing:
Black box testing:

Black box testing is a technique in which the tester is not aware of the internal workings of the system under test. The tester is only concerned with the inputs and outputs of the system and how it behaves in response to different inputs. Black box testing is typically used to test the functionality of a system, and to ensure that it meets the requirements specified by the customer.
White box testing:

White box testing, on the other hand, is a technique in which the tester has access to the internal workings of the system under test, such as the source code. This allows the tester to test the system at a more granular level, such as testing individual functions or methods. White box testing is typically used to test the correctness of the code, and to ensure that it adheres to coding standards and best practices.
In summary, black box testing is concerned with testing the system from the perspective of the user, while white box testing is concerned with testing the system from the perspective of the developer.

The software development life cycle (SDLC) is a systematic approach to software development that helps ensure that quality software is produced. It encompasses the entire development process from the initial requirements gathering to the deployment of the finished product. The SDLC follows a series of steps that include:

1. Gathering requirements: This is the first step of the SDLC, where the requirements for the software are gathered from stakeholders and customers. This includes understanding the user’s needs, the purpose of the software, and any constraints or limitations.

2. Design: Next, the requirements are used to design the architecture of the software. This includes designing the functionality and features of the software, as well as how the software will be implemented.

3. Implementation: The software is then coded by developers. This step involves writing the code that will implement the functionality of the software.

4. Testing: Once the code has been written, it must be tested to ensure that it works properly. Testing includes unit testing, integration testing, system testing, and acceptance testing.

5. Deployment: After the software has passed all of the tests, it can be deployed and made available to users. This process typically involves configuring the software for the environment it will be running in and making sure that the software is compatible with existing systems.

6. Maintenance: Finally, after the software has been deployed, it must be maintained to ensure that it remains functional and secure. Maintenance includes making sure that the software is up-to-date, fixing any bugs or issues, and patching any security vulnerabilities.

Verification and validation are two important components of software testing. Verification is the process of evaluating a system or component to determine whether the products of a given development phase fulfill the requirements established during the previous phase. Validation is the process of evaluating a system or component during or at the end of the development process to determine whether it satisfies specified requirements.

In other words, verification is a process of evaluating the software to ensure that the software meets the requirements, while validation is the process of checking the software against the pre-defined specifications.

Example:
Let's say we are developing a software for an e-commerce website.

Verification: During the initial development phase, we evaluate the software to make sure it meets the customer requirements, such as the ability to add items to a cart, create an account, and make payments.

Validation: Once the development phase is complete, we validate the software by testing it against the specifications provided. We would check the software's performance, security, usability, etc. to make sure it meets the pre-defined specifications.

To sum up, verification is the process of ensuring that the software meets the customer requirements, while validation is the process of confirming that the software meets the pre-defined specifications.

There are many types of bugs that can be encountered during software testing, but some of the most common ones include:
1. Functional bugs: These are defects that occur when the software does not behave as expected or does not meet the functional requirements.
2. Performance bugs: These are issues related to the performance of the software, such as slow response times, excessive memory usage, or high CPU utilization.
3. Compatibility bugs: These are defects that occur when the software is not compatible with certain hardware or software configurations, or when it fails to work properly with other software applications.
4. Security bugs: These are defects that can be exploited by attackers to gain unauthorized access to the system or to compromise the confidentiality, integrity, or availability of the system.
5. Usability bugs: These are issues related to the usability or user experience of the software, such as confusing or unclear user interfaces, difficulty in navigating the application, or lack of user feedback.
6. Documentation bugs: These are defects that occur when the software documentation is incomplete, inaccurate, or outdated, leading to confusion or incorrect usage of the software.
It's important to note that bug types can overlap, and a single issue may manifest in multiple ways. Effective testing strategies should aim to identify and eliminate as many different types of bugs as possible.

Bug, defect, and error are terms that are commonly used interchangeably in the software testing world. However, they are technically different from each other.

A bug is an error, flaw, mistake, failure, or fault in a computer program that causes it to produce an incorrect or unexpected result, or to behave in unintended ways. A bug is usually a coding error in the program, but can be caused by incorrect hardware or an incorrect command or data.

A defect is a deviation from the expected or required behavior of a system. A defect is caused by a bug in the program code, or it can be caused by incorrect data or incorrect system design.

An error is an incorrect result produced by a system, typically due to a defect or bug in the system. An error is usually an unexpected result caused by a defect or bug in the program.

To illustrate the differences between a bug, defect, and error, let's consider the example of a calculator program. If the calculator program is written incorrectly and produces an incorrect result, then that is a bug. If the calculator program is written correctly but is given incorrect data, then that is a defect. And if the calculator program produces an incorrect result due to either a bug or defect, then that is an error.

In summary, a bug is an error in the program code, a defect is a deviation from the expected or required behavior of the system, and an error is an incorrect result produced by the system due to a bug or defect.