Tybcs Software Testing
Tybcs Software Testing
The software stubs are used in the top down integration testin. They are implemented by
the developers as alternatives to specific units of the software which are missed or have not
been developed completely. They have the capability to simulate all the features of the
unavailable modules of the software. They are mainly used when certain lower level
components are required for testing but inaccessible at that moment.d) Write methods of
white box testing.
e) Define regression testing.
Regression Testing is the process of testing the modified parts of the code and the parts that
might get affected due to the modifications to ensure that no new errors have been
introduced in the software after the modifications have been made. Regression means
return of something and in the software field, it refers to the return of a bug. f) What is Agile
Methodology?
g) List dimensions of quality
In software testing, key quality dimensions include functionality, reliability, usability,
performance, security, maintainability, portability, and compatibility
h) Define strategy for web applications.
A web application testing strategy outlines how you'll ensure a web application functions
correctly, performs well, and is secure, encompassing various testing types, tools, and
approaches to achieve quality and reliability.
i) Define acceptance testing.
Acceptance Testing: To obtain customer sign-off so that software can be delivered and
payments received. Types of Acceptance Testing are Alpha, Beta & Gamma Testing
Justification:
o The Drivers establish the test environments and takes care of the communication,
estimates results, and also sends the reports.
o These are just like stubs and used by software test engineers in order to accomplish
the missing or incomplete modules/ components requirements.
o The drivers are mainly developed in the Bottom-up approach of incremental
integration testing.
Code Coverage: To verify that every path, branch, and condition within the code is tested
and exercised.
Identifying Bugs: To detect errors, bugs, or vulnerabilities in the internal structure or logic
of the software.
Ensuring Functionality: To verify that the internal operations of the software (such as
loops, functions, and data handling) are correct.
Customer Collaboration Over Contract Negotiation: Agile prioritizes working closely with
customers throughout the development process rather than focusing on rigid contracts or
documentation. In terms of testing, this principle encourages frequent feedback from the
customer or end-users to ensure that the software meets their needs and expectations. It
helps ensure the product is aligned with customer requirements, leading to better-quality
software.
R) WHAT IS DEBUGGING ?
In the context of software engineering, debugging is the process of fixing a bug in the
software. In other words, it refers to identifying, analyzing and removing errors. This activity
begins after the software fails to execute properly and concludes by solving the problem
and successfully testing the software. It is considered to be an extremely complex and
tedious task because errors need to be resolved at all stages of debugging.
S) WRITE ADVANTAGES OF LOAD TESTING IN SOFTWARE TESTING ?
1. Ensures Performance Under Load: Load testing helps verify how the software
behaves when multiple users access it simultaneously. It ensures that the application
performs well under expected user loads, preventing slowdowns or crashes.
2. Identifies Performance Bottlenecks: By simulating real-world user traffic, load
testing helps identify areas in the application (e.g., database, server, network) that
could become bottlenecks under high usage. This allows teams to address
performance issues before they impact real users.
3. Optimizes System Capacity: Load testing helps determine the system's capacity
limits—how many users, requests, or transactions the system can handle without
performance degradation. This information is vital for scaling infrastructure and
planning future capacity needs.
4. Improves User Experience: Ensuring that the application can handle peak traffic
without slowing down enhances the user experience. Load testing helps maintain
fast response times even during high demand, which is critical for user retention and
satisfaction.
1. Approach to Development:
• Agile Testing: Agile follows an iterative and incremental approach where testing is
integrated throughout the development lifecycle. Testing is continuous, with
frequent releases and updates in short cycles (sprints).
• Traditional Testing: Traditional testing follows a sequential, waterfall model where
testing typically happens after the development phase is completed. It is often
treated as a distinct phase at the end of the project.
2. Flexibility:
• Agile Testing: Agile is highly flexible, accommodating changes in requirements,
design, and code even late in the development process. Testers and developers
collaborate continuously to adjust to changing needs.
• Traditional Testing: Traditional testing is less flexible. Once the project requirements
and design are defined, changes to these are typically costly and difficult to
accommodate, especially after the testing phase begins.
3. Team Collaboration:
4. Test Planning:
• Agile Testing: In Agile, test planning is ongoing, with each sprint having its own set of
requirements and testing plans. Test cases evolve with the development process.
• Traditional Testing: Test planning in traditional testing is usually done upfront, with
a detailed test plan created before development begins. The test cases are often
fixed and follow a set structure.
5. Test Execution:
• Agile Testing: Testing is done throughout the development process, often with each
iteration or sprint delivering a tested version of the software. Automated testing is
frequently used to speed up test cycles.
• Traditional Testing: Testing is often done at the end of the development phase, once
the software has been fully built. It may involve manual testing and longer testing
cycles.
1. Evaluate System Behavior Under Sudden Load Changes: Spike testing helps assess
how well the application can handle sudden, unexpected surges in traffic or load.
This helps identify potential system failures or performance degradation when the
load increases abruptly.
2. Assess System Stability and Performance: The goal is to check if the system can
maintain its stability, performance, and response time when subjected to a spike in
traffic or load. It helps to determine whether the application can continue to
function properly during such spikes.
3. Identify Resource Bottlenecks: Spike testing helps to identify system bottlenecks or
performance issues related to resources such as CPU, memory, or network
bandwidth. These bottlenecks could cause the system to fail or slow down under
heavy load.
4. Understand System Recovery: One of the primary objectives of spike testing is to
determine how quickly and effectively the system can recover from a sudden spike in
load. This is important for systems that need to resume normal operations swiftly
after peak load periods.
5. Verify Load Handling Beyond Normal Capacity: By simulating extreme load
conditions, spike testing helps verify if the system can handle unexpected traffic
spikes beyond its usual capacity without crashing or failing.
6. Ensure High Availability: For mission-critical applications, spike testing ensures that
the system remains highly available and responsive, even when there are sudden
surges in usage, avoiding any downtime or failures.
Ensure Software Quality: The primary objective of software testing is to ensure that the
software meets the specified requirements and is of high quality. It aims to identify defects,
errors, or discrepancies between the expected and actual results, ensuring the software
works as intended and fulfills the user's needs.
Verify and Validate Functionality: Testing ensures that the software functions as
expected, performs all intended tasks correctly, and meets the requirements. It validates
that the application behaves as expected in various scenarios and verifies that it satisfies
both functional and non-functional requirements (e.g., performance, security).
Cyclomatic complexity is defined as the number of decision points (e.g., loops, if statements,
case statements) plus one. More formally, it can be calculated using the formula:
V(G)=E−N+2PV(G) = E - N + 2PV(G)=E−N+2P
Where:
1. Unit Testing:
5. Path Testing:
6. Loop Testing:
7. Mutation Testing:
8. Branch Testing:
9. Interprocedural Testing:
Agile software testing is a testing approach that aligns with the agile software development
methodology, emphasizing iterative development, frequent feedback, and continuous
integration of testing throughout the development lifecycle, rather than at the end.
It is testing that is performed, to determine how fast some aspect of a system performs
under a particular workload.
A core agile principle in software testing is continuous and early testing throughout
the development lifecycle, focusing on delivering value to the customer early and
often.
In detail:
Agile testing doesn't wait until the end of the development cycle; instead, it's
integrated into every stage, allowing for faster feedback and defect detection.
❖ Whole Team Approach:
Testing isn't the sole responsibility of a dedicated QA team; developers, business
analysts, and other stakeholders are involved in testing to ensure a comprehensive
approach.
❖ Frequent Deliveries:
Agile emphasizes delivering working software frequently, which necessitates a robust
testing process to ensure quality at each iteration.