UNIT V SOFTWARE TESTING AND SOFTWARE CONFIGURATION MANAGEMENT

Software Testing Strategy – Unit Testing – Integration Testing – Validation Testing – System
Testing – Debugging – White-Box Testing – Basis Path Testing – Control Structure Testing –
Black-Box Testing – Software Configuration Management (SCM) – SCM Repository – SCM
Process – Configuration Management for Web and Mobile Apps

1. Software Testing Strategy:

Software Testing is a type of investigation to find out if there is any default or error present
in the software so that the errors can be reduced or removed to increase the quality of the
software and to check whether it fulfills the specifies requirements or not.
The overall strategy for testing software includes:

1. Before testing starts, it’s necessary to identify and specify the requirements
of the product in a quantifiable manner. Different characteristics quality of the
software is there such as maintainability that means the ability to update and
modify, the probability that means to find and estimate any risk, and usability that
means how it can easily be used by the customers or end-users. All these
characteristic qualities should be specified in a particular order to obtain clear test
results without any error.
2. Specifying the objectives of testing in a clear and detailed manner. Several
objectives of testing are there such as effectiveness that means how effectively the
software can achieve the target, any failure that means inability to fulfill the
 requirements and perform functions, and the cost of defects or errors that mean
the cost required to fix the error. All these objectives should be clearly mentioned
in the test plan.
3. For the software, identifying the user’s category and developing a profile
for each user. Use cases describe the interactions and communication among
different classes of users and the system to achieve the target. So as to identify the
actual requirement of the users and then testing the actual use of the product.
4. Developing a test plan to give value and focus on rapid-cycle testing. Rapid
Cycle Testing is a type of test that improves quality by identifying and measuring
the any changes that need to be required for improving the process of software.
Therefore, a test plan is an important and effective document that helps the tester
to perform rapid cycle testing.
5. Robust software is developed that is designed to test itself. The software
should be capable of detecting or identifying different classes of errors. Moreover,
software design should allow automated and regression testing which tests the
software to find out if there is any adverse or side effect on the features of software
due to any change in code or program.
6. Before testing, using effective formal reviews as a filter. Formal technical
reviews is technique to identify the errors that are not discovered yet. The effective
technical reviews conducted before testing reduces a significant amount of testing
efforts and time duration required for testing software so that the overall
development time of software is reduced.
7. Conduct formal technical reviews to evaluate the nature, quality or ability
of the test strategy and test cases. The formal technical review helps in detecting
any unfilled gap in the testing approach. Hence, it is necessary to evaluate the
ability and quality of the test strategy and test cases by technical reviewers to
improve the quality of software.
8. For the testing process, developing a approach for the continuous
development. As a part of a statistical process control approach, a test strategy
that is already measured should be used for software testing to measure and
control the quality during the development of software.

Advantages of software testing:

1. Improves software quality and reliability

2. Enhances user experience
3. Increases confidence
Disadvantages of software testing:
1. Time-consuming
2. Limited coverage
3. Delays in delivery

2. Unit Testing:
Unit Testing is a software testing technique by means of which individual units of software
i.e. group of computer program modules, usage procedures, and operating procedures are
tested to determine whether they are suitable for use or not.
Types of Unit Testing:

There are 2 types of Unit Testing: Manual, and Automated.

Workflow of Unit Testing:

Unit Testing Techniques:

There are 3 types of Unit Testing Techniques. They are
1. Black Box Testing: This testing technique is used in covering the unit tests for
input, user interface, and output parts.
2. White Box Testing: This technique is used in testing the functional behavior of
the system by giving the input and checking the functionality output including the
internal design structure and code of the modules.
3. Gray Box Testing: This technique is used in executing the relevant test cases, test
methods, test functions, and analyzing the code performance for the modules.

Unit Testing Tools:

Here are some commonly used Unit Testing tools:

1. Jtest
2. Junit
3. NUnit
4. EMMA
5. PHPUnit

Advantages of Unit Testing:

1. Early Detection of Issues

2. Improved Code Quality
3. Increased Confidence
4. Faster Development
Disadvantages of Unit Testing:
1. The process is time-consuming
2. Unit Testing will not cover all the errors
3. It requires more time for maintenance
4. Time and Effort

3.Integration Testing:
Integration testing is the process of testing the interface between two software units or
modules. It focuses on determining the correctness of the interface.

Integration test approaches – There are four types of integration testing approaches. Those
approaches are the following:

1. Big-Bang Integration Testing – It is the simplest integration testing approach, where all
the modules are combined and the functionality is verified after the completion of individual
module testing. In simple words, all the modules of the system are simply put together and
tested. This approach is practicable only for very small systems. If an error is found during
the integration testing, it is very difficult to localize the error as the error may potentially
belong to any of the modules being integrated. So, debugging errors reported during big bang
integration testing is very expensive to fix.
Big-Bang integration testing is a software testing approach in which all components or
modules of a software application are combined and tested at once
Advantages:
1. It is convenient for small systems.
2. Simple and straightforward approach.
Disadvantages:
1. Not Good for long projects.
2. This can lead to system failure and decreased user satisfaction.
2. Bottom-Up Integration Testing – In bottom-up testing, each module at lower levels are
tested with higher modules until all modules are tested. The primary purpose of this
integration testing is that each subsystem tests the interfaces among various modules making
up the subsystem. This integration testing uses test drivers to drive and pass appropriate data
to the lower-level modules.
Advantages:
• It is easy to create the test conditions.
• It is Easy to observe the test results.
Disadvantages:
• Driver modules must be produced.
• As Far modules have been created, there is no working model can be represented.
3. Top-Down Integration Testing – Top-down integration testing technique is used in order
to simulate the behaviour of the lower-level modules that are not yet integrated. In this
integration testing, testing takes place from top to bottom. First, high-level modules are tested
and then low-level modules and finally integrating the low-level modules to a high level to
ensure the system is working as intended.
Advantages:
• Easier isolation of interface errors.
• In this, design defects can be found in the early stages.
Disadvantages:
• Modules at lower level are tested inadequately.
• It is difficult to observe the test output.
4. Mixed Integration Testing – A mixed integration testing is also called sandwiched
integration testing. A mixed integration testing follows a combination of top down and
bottom-up testing approaches. In top-down approach, testing can start only after the top-level
module have been coded and unit tested. In bottom-up approach, testing can start only after
the bottom level modules are ready. This sandwich or mixed approach overcomes this
shortcoming of the top-down and bottom-up approaches. It is also called the hybrid
integration testing. also, stubs and drivers are used in mixed integration testing.
Advantages:
• Mixed approach is useful for very large projects having several sub projects.
• Parallel test can be performed in top and bottom layer tests.
Disadvantages:
• For mixed integration testing, it requires very high cost because one part has a
Top-down approach while another part has a bottom-up approach.
• This integration testing cannot be used for smaller systems with huge
interdependence between different modules.

4. Validation Testing:
The process of evaluating software during the development process or at the end of the
development process to determine whether it satisfies specified business requirements.
Validation Testing ensures that the product actually meets the client's needs. It can also be
defined as to demonstrate that the product fulfills its intended use when deployed on
appropriate environment.
It answers to the question, Are we building the right product?
Validation Testing - Workflow:
Validation testing can be best demonstrated using V-Model. The Software/product under test
is evaluated during this type of testing.

Activities:
• Unit Testing
• Integration Testing
• System Testing
• User Acceptance Testing

5.System Testing: System Testing is a type of software testing that is performed on a

complete integrated system to evaluate the compliance of the system with the corresponding
requirements. In system testing, integration testing passed components are taken as input.
System Testing Process: System Testing is performed in the following steps:
• Test Environment Setup: Create testing environment for the better quality
testing.
• Create Test Case: Generate test case for the testing process.
• Create Test Data: Generate the data that is to be tested.
• Execute Test Case: After the generation of the test case and the test data, test
cases are executed.
• Defect Reporting: Defects in the system are detected.
• Regression Testing: It is carried out to test the side effects of the testing process.
• Log Defects: Defects are fixed in this step.
• Retest: If the test is not successful then again test is performed.

Types of System Testing:

• Performance Testing: Performance Testing is a type of software testing that is
carried out to test the speed, scalability, stability and reliability of the software
product or application.
• Load Testing: Load Testing is a type of software Testing which is carried out to
determine the behavior of a system or software product under extreme load.
• Stress Testing: Stress Testing is a type of software testing performed to check
the robustness of the system under the varying loads.
• Scalability Testing: Scalability Testing is a type of software testing which is
carried out to check the performance of a software application or system in terms
of its capability to scale up or scale down the number of user request load.

Advantages of System Testing :

• The testers do not require more knowledge of programming
• It will test the entire product or software
• It checks the entire functionality of the system with different test scripts
Disadvantages of System Testing :
• This testing is time consuming process
• The cost for the testing will be high since it covers the testing of entire software.
• It needs good debugging tool otherwise the hidden errors will not be found.

6. Debugging:
Debugging is the process of identifying and resolving errors, or bugs, in a software system.
It is an important aspect of software engineering because bugs can cause a software system
to malfunction, and can lead to poor performance or incorrect results.
There are several common methods and techniques used in debugging, including:
1. Code Inspection: This involves manually reviewing the source code of a
software system to identify potential bugs or errors.
2. Debugging Tools: There are various tools available for debugging such as
debuggers, trace tools, and profilers that can be used to identify and resolve bugs.
3. Unit Testing: This involves testing individual units or components of a software
system to identify bugs or errors.
4. Integration Testing: This involves testing the interactions between different
components of a software system to identify bugs or errors.
5. System Testing: This involves testing the entire software system to identify
bugs or errors.
6. Monitoring: This involves monitoring a software system for unusual behavior
or performance issues that can indicate the presence of bugs or errors.
7. Logging: This involves recording events and messages related to the software
system, which can be used to identify bugs or errors.

Debugging Process: Steps involved in debugging are:

• Problem identification and report preparation.
• Assigning the report to the software engineer defect to verify that it is genuine.
• Defect Analysis using modeling, documentation, finding and testing candidate
flaws, etc.
• Defect Resolution by making required changes to the system.
• Validation of corrections.
The debugging process will always have one of two outcomes :
1. The cause will be found and corrected.
2. The cause will not be found.

Debugging Approaches/Strategies:
1. Brute Force: Study the system for a larger duration in order to understand the
system. It helps the debugger to construct different representations of systems to
be debugged depending on the need. A study of the system is also done actively
to find recent changes made to the software.
2. Backtracking: Backward analysis of the problem which involves tracing the
program backward from the location of the failure message in order to identify
the region of faulty code. A detailed study of the region is conducted to find the
cause of defects.
3. Forward analysis of the program involves tracing the program forwards using
breakpoints or print statements at different points in the program and studying the
results. The region where the wrong outputs are obtained is the region that needs
to be focused on to find the defect.
4. Using past experience with the software debug the software with similar
problems in nature. The success of this approach depends on the expertise of the
debugger.
5. Cause elimination: it introduces the concept of binary partitioning. Data
related to the error occurrence are organized to isolate potential causes.
6. Static analysis: Analyzing the code without executing it to identify potential
bugs or errors. This approach involves analyzing code syntax, data flow, and
control flow.
 7. Dynamic analysis: Executing the code and analyzing its behavior at runtime to
identify errors or bugs. This approach involves techniques like runtime debugging
and profiling.
8. Collaborative debugging: Involves multiple developers working together to
debug a system. This approach is helpful in situations where multiple modules or
components are involved, and the root cause of the error is not clear.
9. Logging and Tracing: Using logging and tracing tools to identify the sequence
of events leading up to the error. This approach involves collecting and analyzing
logs and traces generated by the system during its execution.
10. Automated Debugging: The use of automated tools and techniques to assist in
the debugging process. These tools can include static and dynamic analysis tools,
as well as tools that use machine learning and artificial intelligence to identify
errors and suggest fixes.

Advantages of Debugging:

1. Improved system quality

2. Reduced system downtime.
3. Increased user satisfaction

Disadvantages of Debugging:

1. Time-consuming
2. Can be difficult to fix
3. Can be expensive

7. White-Box Testing:
White box testing techniques analyze the internal structures the used data structures, internal
design, code structure, and the working of the software rather than just the functionality as
in black box testing. It is also called glass box testing or clear box testing or structural testing.
White Box Testing is also known as transparent testing or open box testing.
Working process of white box testing:
• Input: Requirements, Functional specifications, design documents, source code.
• Processing: Performing risk analysis to guide through the entire process.
• Proper test planning: Designing test cases so as to cover the entire code.
Execute rinse-repeat until error-free software is reached. Also, the results are
communicated.
• Output: Preparing final report of the entire testing process.
Testing techniques:
• Statement coverage: In this technique, the aim is to traverse all statements at
least once. Hence, each line of code is tested. In the case of a flowchart, every
node must be traversed at least once. Since all lines of code are covered, helps in
pointing out faulty code.
• Branch Coverage: In this technique, test cases are designed so that each branch
from all decision points is traversed at least once. In a flowchart, all edges must
be traversed at least once.
• Condition Coverage: In this technique, all individual conditions must be
covered as shown in the following example:
1. READ X, Y
2. IF(X == 0 || Y == 0)
3. PRINT ‘0’
4. #TC1 – X = 0, Y = 55
5. #TC2 – X = 5, Y = 0
• Multiple Condition Coverage: In this technique, all the possible combinations
of the possible outcomes of conditions are tested at least once. Let’s consider the
following example:
1. READ X, Y
2. IF(X == 0 || Y == 0)
3. PRINT ‘0’
4. #TC1: X = 0, Y = 0
 5. #TC2: X = 0, Y = 5
6. #TC3: X = 55, Y = 0
7. #TC4: X = 55, Y = 5
• Basis Path Testing: In this technique, control flow graphs are made from code
or flowchart and then Cyclomatic complexity is calculated which defines the
number of independent paths so that the minimal number of test cases can be
designed for each independent path.
• Steps:
1. Make the corresponding control flow graph
2. Calculate the cyclomatic complexity
3. Find the independent paths
4. Design test cases corresponding to each independent path
• Loop Testing: Loops are widely used and these are fundamental to many
algorithms hence, their testing is very important. Errors often occur at the
beginnings and ends of loops.
1. Simple loops: For simple loops of size n, test cases are designed that:
• Skip the loop entirely
• Only one pass through the loop
• 2 passes
• m passes, where m < n
• n-1 ans n+1 passes
2. Nested loops: For nested loops, all the loops are set to their minimum
count and we start from the innermost loop. Simple loop tests are
conducted for the innermost loop and this is worked outwards till all
the loops have been tested.
3. Concatenated loops: Independent loops, one after another. Simple
loop tests are applied for each. If they’re not independent, treat them
like nesting.
White Testing is Performed in 2 Steps:
1. Tester should understand the code well
2. Tester should write some code for test cases and execute them

Features of white box testing:

1. Code coverage analysis

2. Access to the source code
3. Knowledge of programming languages
4. Identifying logical errors
5. Integration testing
6. Unit testing
Advantages:
1. Easy to automate.
2. White box testing can be easily started in Software Development Life Cycle.
3. Easy Code Optimization.
Disadvantage:
1. It is very expensive.
2. Very complex and at times not realistic.
3. Much more chances of Errors in production
9. Control Structure Testing:
Control structure testing is used to increase the coverage area by testing various control
structures present in the program. The different types of testing performed under control
structure testing are as follows-
1. Condition Testing : Condition testing is a test cased design method, which ensures that
the logical condition and decision statements are free from errors. The errors present in
logical conditions can be incorrect boolean operators, missing parenthesis in a booleans
expression, error in relational operators, arithmetic expressions, and so on.
2. Data Flow Testing : The data flow test method chooses the test path of a program based
on the locations of the definitions and uses all the variables in the program. The data flow
test approach is depicted as follows suppose each statement in a program is assigned a
unique statement number and that theme function cannot modify its parameters or global
variables.
3. Loop Testing : Loop testing is actually a white box testing technique. It specifically
focuses on the validity of loop construction. Following are the types of loops.
1. Simple Loop – The following set of test can be applied to simple loops, where
the maximum allowable number through the loop is n.
1. Skip the entire loop.
2. Traverse the loop only once.
3. Traverse the loop two times.
4. Make p passes through the loop where p<n.
5. Traverse the loop n-1, n, n+1 times.
2. Concatenated Loops – If loops are not dependent on each other, contact loops
can be tested using the approach used in simple loops. if the loops are
interdependent, the steps are

3. Nested Loops – Loops within loops are called as nested loops. when testing
nested loops, the number of tested increases as level nesting increases. The
following steps for testing nested loops are as follows-
1. Start with inner loop. set all other loops to minimum values.
2. Conduct simple loop testing on inner loop.
3. Work outwards.
4. Continue until all loops tested.
4. Unstructured loops – This type of loops should be redesigned, whenever
possible, to reflect the use of unstructured the structured programming
constructs.
10. Software Configuration Management (SCM):
System Configuration Management (SCM) is an arrangement of exercises which controls
change by recognizing the items for change, setting up connections between those things,
making/characterizing instruments for overseeing diverse variants, controlling the changes
being executed in the current framework, inspecting and revealing/reporting on the changes
made.
Processes involved in SCM – Configuration management provides a disciplined
environment for smooth control of work products. It involves the following activities:
1. Identification and Establishment – Identifying the configuration items from
products that compose baselines at given points in time. Establishing relationship
among items, creating a mechanism to manage multiple level of control and
procedure for change management system.
2. Version control – Creating versions/specifications of the existing product to
build new products from the help of SCM system. A description of version is
given below:

3. Change control – Controlling changes to Configuration items (CI). The change

control process is explained in Figure
below:
 4. Configuration auditing – A software configuration audit complements the
formal technical review of the process and product. It focuses on the technical
correctness of the configuration object that has been modified. The audit confirms
the completeness, correctness and consistency of items in the SCM system and
track action items from the audit to closure.
5. Reporting – Providing accurate status and current configuration data to
developers, tester, end users, customers and stakeholders through admin guides,
user guides, FAQs, Release notes, Memos, Installation Guide, Configuration
guide etc .

The key objectives of SCM are to:

1. Control the evolution of software systems

2. Enable collaboration and coordination
3. Provide version control
4. Facilitate replication and distribution.

The main advantages of SCM are:

1. Improved productivity and efficiency
2. Increased collaboration and communication
3. Improved quality and stability
The main disadvantages of SCM are:
1. Increased complexity and overhead
2. Difficulty in managing dependencies
3. Potential for conflicts and delays
11. Configuration Management for Web and Mobile Apps.
Supporting cloud, mobile, and database development sounds like a remarkably technical endeavor. In
practice, personality issues between team members can impact just how effectively you handle these
complex technical efforts.
Taming Complexity
[1, specifying practices to handle mainline, bugfixes, and other variants seemed to be fairly
straightforward. But version control in the cloud, on your Android, and also databases adds some unique
challenges that are not always so straightforward to tame. For example, technology experts are highly
specialized and may not have a firm grasp on all of the technical details requirement to produce a
complete complex system. Much of this complexity revolves around managing ambiguity.
Dealing with Ambiguity
The cloud brings with it the risk of having to manage resources, over which you have little actual
control. There is ample ambiguity in having to rely upon the service provided by a vendor that may or
may not be in alignment with your own goals and priorities. Mobile devices have their own set of
requirements and industry standards that are rapidly emerging as smart phones become as ubiquitous
as less dynamic cell phones.
Trying to version control your database also carries its own set of complexities. For example, handling
SQL scripts and stored procedures to managing low DBA level performance tuning takes creative and
flexible strategies. Although, there are emerging tools in this space, there also remain considerable
challenges. Some people are better at accepting and dealing with ambiguity than others. One effective
way to tame complexity is to reduce it into simple constructs that are easier to handle.
Reducing Cognitive Complexity
Taking complex problems and reducing them into one or more, less complicated challenges, reduces
work and eliminates many protential sources of error. Many technology professionals can tackle
complex tasks but are very challenged when it comes to reducing cognitive complexity. When you feel
challenged and uncertain as to how to handle complexity, start by defining the requirements for the
situation at hand. Many agile practices are very effective at managing requirements and provide a good
starting point for gaining a clear understanding of the system that you need to develop.
Requirements Management
Requirements may be specified in big documents with formal requirements specifications. Many agile
enthusiasts prefer to define requirements in lighter terms using what are called epics and stories. [2]
Still others use test-driven development to manage and reduce cognitive complexity. [3] From a
personality perspective, a critical determinant is whether you are an innovative leader or will be mired
and rendered immobile by the challenge of handling platforms that may be a little bit out of the ordinary.
Innovative leaders help the team tackle tough challenges and set the direction for the entire development
effort. This can be especially important when there is a lack of control.
Teamwork When There Is a Lack of Control
You will find that some members of your team are better than others at demonstrating leadership in the
face of complexity. Make sure that you balance your teams with not only regard to technical competence
but also sensitivity to personalities. You need to have some people who will help provide the synergy
for effective teamwork even when there is a lack of control.
Leadership for Managing Complexity
Some technology leaders truly shine in the face of challenge. When managing development in the cloud
or newly emerging platforms such as mobile devices, management complexity must be your primary
task. True leaders thrive on this type of challenge. They also create environments where learning can
impact the entire lifecycle development effort.
Retrospectives for Learning and Improving
Agile retrospectives are a very effective process improvement methodology in which the team meets to
discuss what went well and what needs to be improved.