Click on Subject/Paper under Semester to enter.

Environmental Sciences
Professional English and Sustainability -
Professional English - - II - HS3252 Discrete Mathematics GE3451
I - HS3152 - MA3354
Statistics and Theory of Computation
Matrices and Calculus Numerical Methods - Digital Principles and - CS3452
3rd Semester

4th Semester
- MA3151 MA3251 Computer Organization
1st Semester

2nd Semester

- CS3351 Artificial Intelligence

Engineering Graphics and Machine Learning
Engineering Physics - - CS3491
- GE3251 Foundation of Data
PH3151
Science - CS3352
Database Management
Physics for
Engineering Chemistry System - CS3492
Information Science Data Structure -
- CY3151 - PH3256 CS3301

Basic Electrical and

Algorithms - CS3401
Problem Solving and Electronics Engineering Object Oriented
Python Programming - - BE3251 Programming - CS3391 Introduction to
GE3151 Operating Systems -
Programming in C -
CS3451
CS3251

Computer Networks - Object Oriented

CS3591 Software Engineering
- CCS356
Compiler Design - Human Values and
5th Semester

CS3501 Embedded Systems Ethics - GE3791

7th Semester

8th Semester
6th Semester

and IoT - CS3691

Cryptography and Open Elective 2
Cyber Security - Open Elective-1 Project Work /
CB3491
Open Elective 3 Intership
Distributed Computing Elective-3
- CS3551 Open Elective 4
Elective-4
Elective 1
Management Elective
Elective-5
Elective 2
Elective-6
 All Computer Engg Subjects - [ B.E., M.E., ] (Click on Subjects to
enter)
Programming in C Computer Networks Operating Systems
Programming and Data Programming and Data Problem Solving and Python
Structures I Structure II Programming
Database Management Systems Computer Architecture Analog and Digital
Communication
Design and Analysis of Microprocessors and Object Oriented Analysis
Algorithms Microcontrollers and Design
Software Engineering Discrete Mathematics Internet Programming
Theory of Computation Computer Graphics Distributed Systems
Mobile Computing Compiler Design Digital Signal Processing
Artificial Intelligence Software Testing Grid and Cloud Computing
Data Ware Housing and Data Cryptography and Resource Management
Mining Network Security Techniques
Service Oriented Architecture Embedded and Real Time Multi - Core Architectures
Systems and Programming
Probability and Queueing Theory Physics for Information Transforms and Partial
Science Differential Equations
Technical English Engineering Physics Engineering Chemistry
Engineering Graphics Total Quality Professional Ethics in
Management Engineering
Basic Electrical and Electronics Problem Solving and Environmental Science and
and Measurement Engineering Python Programming Engineering
 lOMoARcPSD|45374298

www.BrainKart.com

UNIT IV SOFTWARE TESTING AND MAINTENANCE

Testing –Unit testing –Black box testing–White box testing –Integration and System testing–
Regression testing –Debugging-Program analysis –Symbolic execution –Model Checking-Case
Study.

Testing
Software testing is a crucial phase in the software development life cycle that involves evaluating a
system or application to ensure it meets specified requirements, functions as expected, and is free of
defects. Testing helps identify and rectify issues early in the development process, improving the
quality and reliability of the software. Here are key aspects and types of software testing:
Types of Software Testing:
1. Unit Testing:
 Focuses on testing individual units or components of the software in isolation.
 Ensures that each unit functions as intended.
2. Integration Testing:
 Tests the interaction between integrated components or systems.
 Detects issues related to the interface and communication between components.
3. System Testing:
 Evaluates the entire system as a whole to ensure it meets specified requirements.
 Verifies the overall functionality, performance, and security.
4. Acceptance Testing:
 Validates whether the software meets the user's acceptance criteria.
 Includes User Acceptance Testing (UAT) performed by end-users.
5. Regression Testing:
 Verifies that new changes or features do not negatively impact existing functionalities.
 Re-runs previously executed tests to catch unintended side effects.
6. Performance Testing:
 Assesses the system's performance under different conditions (e.g., load, stress, and
scalability testing).
 Identifies bottlenecks and measures response times.

https://play.google.com/store/apps/details?id=info.therithal.brainkart.annauniversitynotes
 lOMoARcPSD|45374298

www.BrainKart.com

7. Security Testing:
 Identifies vulnerabilities and weaknesses in the software to ensure data protection.
 Includes penetration testing, vulnerability scanning, and security audits.
8. Usability Testing:
 Evaluates the user-friendliness and overall user experience of the software.
 Assesses navigation, clarity, and ease of use.
9. Compatibility Testing:
 Ensures the software functions correctly across various devices, browsers, and operating
systems.
10. Automated Testing:
 Utilizes automated testing tools to execute test scripts, comparing actual outcomes with
expected results.
 Efficient for repetitive and regression testing.
Testing Life Cycle:
1. Test Planning:
 Defines the scope, objectives, resources, and schedule for testing.
 Outlines the testing strategy and identifies test cases.
2. Test Design:
 Develops test cases and test scripts based on requirements and design specifications.
 Includes positive and negative scenarios.
3. Test Execution:
 Executes test cases using manual or automated methods.
 Records and analyzes results, identifies defects.
4. Defect Reporting and Tracking:
 Documents and reports defects found during testing.
 Tracks defect status, from discovery to resolution.
5. Regression Testing:
 Re-executes selected test cases to ensure new changes do not introduce new defects.
6. Test Closure:
 Assesses whether testing objectives have been achieved.
 Documents test results, lessons learned, and finalizes testing activities.

https://play.google.com/store/apps/details?id=info.therithal.brainkart.annauniversitynotes
 lOMoARcPSD|45374298

www.BrainKart.com

Best Practices for Testing:

1. Early Testing:
 Start testing activities as early as possible in the development life cycle.
2. Clear Requirements:
 Ensure clear, complete, and testable requirements before testing begins.
3. Test Data Management:
 Manage test data effectively to cover a variety of scenarios.
4. Traceability:
 Establish traceability between requirements, test cases, and defects.
5. Communication:
 Foster open communication between developers, testers, and other stakeholders.
6. Automation Strategy:
 Implement test automation judiciously, focusing on repetitive and critical test scenarios.
7. Test Environment:

https://play.google.com/store/apps/details?id=info.therithal.brainkart.annauniversitynotes
 lOMoARcPSD|45374298

www.BrainKart.com

 Ensure a stable and representative test environment that mirrors the production
environment.
8. Continuous Learning:
 Continuously learn and adapt testing practices based on project experiences.
9. Documentation:
 Document test cases, test plans, and test results for future reference.
10. Performance Monitoring:
 Monitor and analyze test execution and performance regularly.
Effective testing is crucial for delivering high-quality software. By employing a combination of testing
types and adhering to best practices, development teams can detect and address issues early, ensuring a
more robust and reliable software product.
Unit testing
Unit testing is a software testing technique that involves testing individual units or components of a
software application in isolation. The goal of unit testing is to ensure that each unit of the software
functions as intended, producing correct results for a given set of inputs. A "unit" in this context
typically refers to the smallest testable part of an application, such as a function, method, or procedure.

Key Aspects of Unit Testing:

1. Isolation:
 Units are tested in isolation, independently of the rest of the application.

https://play.google.com/store/apps/details?id=info.therithal.brainkart.annauniversitynotes
 lOMoARcPSD|45374298

www.BrainKart.com

 External dependencies are often replaced with mock objects or stubs to control the unit's
behavior.
2. Automated Testing:
 Unit tests are usually automated to enable quick and frequent execution.
 Automated testing frameworks (e.g., JUnit for Java, pytest for Python) are commonly
used.
3. Repeatable:
 Unit tests should be repeatable and produce consistent results.
 Running the same unit test multiple times should yield the same outcome.
4. Fast Execution:
 Unit tests should execute quickly, allowing developers to run them frequently during
development.
 Fast feedback helps identify issues early in the development process.
5. Focused:
 Each unit test focuses on a specific aspect of a unit's behavior.
 Tests should be designed to cover various scenarios, including edge cases and error
conditions.
6. Independent:
 Unit tests should not depend on the order of execution or the results of other tests.
 Tests should be able to run in any order.
Benefits of Unit Testing:
1. Early Detection of Defects:
 Identifies and addresses defects at an early stage of development.
2. Documentation:
 Serves as documentation for the expected behavior of units, aiding in understanding and
maintenance.
3. Facilitates Refactoring:
 Enables developers to confidently make changes (refactoring) to the code while ensuring
that existing functionality remains intact.
4. Improved Code Quality:
 Encourages modular and well-structured code, leading to higher overall code quality.

https://play.google.com/store/apps/details?id=info.therithal.brainkart.annauniversitynotes
 lOMoARcPSD|45374298

www.BrainKart.com

5. Regression Testing:
 Acts as a form of regression testing, helping catch regressions when new code is added.
6. Supports Continuous Integration:
 Integrates well with continuous integration processes, allowing for automated testing in
a build pipeline.
Unit Testing Process:
1. Write Test Cases:
 Develop test cases that cover different aspects of a unit's functionality.
 Consider edge cases, boundary conditions, and possible error scenarios.
2. Implement Code:
 Write or modify code to implement the functionality being tested.
3. Run Tests:
 Execute the unit tests to verify that the code behaves as expected.
 Tests should pass before moving to the next development stage.
4. Refactor and Iterate:
 Refactor the code as needed to improve design or performance.
 Re-run tests to ensure that changes did not introduce defects.
5. Automate Testing:
 Integrate unit tests into an automated testing framework for continuous testing.
Example (using Python and pytest):
# Code to be tested (module.py)
def add_numbers(a, b):
return a + b

# Unit Test (test_module.py)

import pytest
from module import add_numbers

def test_add_numbers():
assert add_numbers(2, 3) == 5
assert add_numbers(-1, 1) == 0

https://play.google.com/store/apps/details?id=info.therithal.brainkart.annauniversitynotes
 lOMoARcPSD|45374298

www.BrainKart.com

assert add_numbers(0, 0) == 0
In this example, the add_numbers function is a simple unit of code. The corresponding unit test in
test_module.py checks various scenarios to ensure that the function produces the correct results.
Unit testing is a fundamental practice in modern software development, contributing to the reliability,
maintainability, and agility of software applications. It is often integrated into a broader testing strategy
that includes other testing levels and techniques.
Black box testing
Black box testing is a software testing method where the internal structure, design, or implementation
details of the system being tested are not known to the tester. The focus of black box testing is on
validating the external behavior of the software based on its specifications, requirements, and
functionality. Testers assess whether the software produces the expected outputs for a given set of
inputs, without having knowledge of the internal code or logic.
Key Characteristics of Black Box Testing:
1. No Knowledge of Internal Implementation:
 Testers do not have access to the source code, algorithms, or the internal workings of the
software.
 The testing process is based solely on the externally visible behavior.
2. Test Design Based on Requirements:
 Test cases are designed based on the documented specifications, functional
requirements, and system behavior described in the project documentation.
3. Tester's Perspective:
 Black box testing is performed from an end-user perspective, focusing on what the
system is supposed to do rather than how it achieves it.
4. Various Testing Levels:
 Applicable at different testing levels, including unit testing, integration testing, system
testing, and acceptance testing.
5. Inputs and Expected Outputs:
 Testers provide inputs to the system and examine the outputs to ensure they match the
expected results as specified in the requirements.
6. Functional and Non-functional Testing:

https://play.google.com/store/apps/details?id=info.therithal.brainkart.annauniversitynotes
 lOMoARcPSD|45374298

www.BrainKart.com

 Covers both functional aspects (e.g., features, operations) and non-functional aspects
(e.g., performance, usability).
Types of Black Box Testing:
1. Functional Testing:
 Verifies that the software functions according to specified requirements.
 Includes test cases for input validation, functional correctness, and system behavior.
2. Non-functional Testing:
 Focuses on non-functional aspects such as performance, usability, reliability, and
security.
 Examples include performance testing, usability testing, and security testing.
3. Acceptance Testing:
 Assesses whether the system meets the acceptance criteria defined by the end-users or
stakeholders.
 Includes User Acceptance Testing (UAT) and Operational Acceptance Testing (OAT).
4. Regression Testing:
 Ensures that new changes or updates do not negatively impact existing functionalities.
 Detects unintended side effects caused by modifications.
5. Boundary Value Analysis:
 Tests values at the boundary or extreme values of valid input ranges.
 Helps identify potential issues related to boundary conditions.
6. Equivalence Partitioning:
 Divides the input domain into classes or partitions, treating each class as equivalent.
 Aims to reduce the number of test cases while ensuring thorough coverage.
7. State Transition Testing:
 Focuses on testing the system's behavior as it transitions between different states.
 Particularly applicable to systems with finite state machines.
Advantages of Black Box Testing:
1. Independence:
 Testers do not need knowledge of the internal code, allowing for independence between
development and testing teams.
2. Client-Centric:

https://play.google.com/store/apps/details?id=info.therithal.brainkart.annauniversitynotes
 lOMoARcPSD|45374298

www.BrainKart.com

 Aligns with client or user expectations, as testing is based on specified requirements and
functionality.
3. Effective for Validation:
 Effectively verifies whether the software meets its intended purpose and requirements.
4. Encourages System Thinking:
 Promotes a holistic view of the system, encouraging testers to consider the overall
system behavior.
5. Test Case Reusability:
 Test cases designed based on requirements can be reused for regression testing.
Disadvantages of Black Box Testing:
1. Limited Coverage:
 May not explore all possible paths or combinations within the system.
 Test coverage is based on available specifications.
2. Redundancy:
 Some test cases may duplicate efforts, especially if multiple testers independently design
similar test cases.
3. Inefficient for Complex Algorithms:
 Inefficient for thoroughly testing complex algorithms or intricate internal logic.
Black box testing is an essential testing approach that complements white box testing, where the tester
has knowledge of the internal code. Both testing methods contribute to a comprehensive testing
strategy, ensuring the robustness and reliability of software systems.
White box testing
White box testing, also known as structural testing or glass-box testing, is a software testing method
that examines the internal structure, design, and implementation of the software being tested. Unlike
black box testing, where the tester is unaware of the internal workings of the system, white box testing
requires knowledge of the internal code and logic. The primary focus of white box testing is to ensure
that the code functions as expected, adheres to coding standards, and is free of errors.
Key Characteristics of White Box Testing:
1. Internal Code Knowledge:
 Testers have access to the source code, algorithms, and the internal structure of the
software.

https://play.google.com/store/apps/details?id=info.therithal.brainkart.annauniversitynotes
 lOMoARcPSD|45374298

www.BrainKart.com

 Testing is based on an understanding of how the code is written and how it should
behave.
2. Code Coverage:
 Aims to achieve high code coverage by testing various paths, branches, and statements
within the code.
 Different levels of code coverage include statement coverage, branch coverage, and path
coverage.
3. Test Design Based on Code Structure:
 Test cases are designed based on the internal structure of the code, often considering
branches, loops, and logical conditions.
4. Testing Levels:
 Applicable at various testing levels, including unit testing, integration testing, and
system testing.
5. Code Modification for Testing:
 In some cases, the code may be modified to facilitate testing, such as inserting
debugging statements or additional instrumentation.
6. Error Guessing:
 Testers may use their knowledge of the code to predict potential errors and design test
cases to uncover those issues.
Types of White Box Testing:
1. Unit Testing:
 Focuses on testing individual units or components in isolation.
 Verifies that each unit functions correctly according to its specifications.
2. Integration Testing:
 Tests the interaction and interfaces between integrated components or modules.
 Ensures proper communication and data flow between components.
3. System Testing:
 Assesses the overall system behavior, including interactions between different modules
and external dependencies.
4. Acceptance Testing:

https://play.google.com/store/apps/details?id=info.therithal.brainkart.annauniversitynotes
 lOMoARcPSD|45374298

www.BrainKart.com

 May involve white box testing at the acceptance testing level to ensure that the entire
system meets specified requirements.
5. Path Testing:
 Tests various paths through the code, including different decision points and loops.
 Aims to achieve complete path coverage.
6. Branch Testing:
 Focuses on testing different branches or decision points within the code.
 Aims to cover all possible branches.
7. Statement Testing:
 Ensures that each statement in the code is executed at least once during testing.
 Aims for complete statement coverage.
Advantages of White Box Testing:
1. Early Detection of Defects:
 Identifies and addresses defects at an early stage of development.
2. Code Optimization:
 Can help optimize code for better performance and efficiency.
3. Thorough Coverage:
 Aims for thorough coverage of different paths, branches, and statements within the code.
4. Effective for Complex Algorithms:
 Efficient for testing complex algorithms and intricate internal logic.
5. Facilitates Debugging:
 Helps identify the root causes of issues, making debugging more effective.
Disadvantages of White Box Testing:
1. Dependency on Code Knowledge:
 Requires testers with a deep understanding of the code, which may not be feasible in all
situations.
2. Limited User Perspective:
 Focuses on internal structure, potentially overlooking aspects that are critical from a
user's perspective.
3. Maintenance Overhead:
 Testing may need to be updated if code changes occur, leading to maintenance overhead.

https://play.google.com/store/apps/details?id=info.therithal.brainkart.annauniversitynotes
 lOMoARcPSD|45374298

www.BrainKart.com

4. Code Modification for Testing:

 In some cases, code modifications may be needed to facilitate testing, which can
introduce additional complexity.
White box testing is an integral part of a comprehensive testing strategy, working in conjunction with
black box testing to ensure the overall quality and reliability of software applications. Both testing
methods provide different perspectives and contribute to a more robust testing approach.
Integration and System testing
Integration testing and system testing are two critical phases in the software testing life cycle, occurring
after unit testing. They focus on evaluating the interactions between different components and assessing
the overall functionality of the entire system. Let's explore each in more detail:
Integration Testing:
Objective: Integration testing aims to validate the proper interaction and cooperation between
individual components or modules when integrated to form larger parts of the software.
Key Aspects:
1. Integration Strategy:
 Different integration strategies can be employed, such as top-down, bottom-up, or a
combination (sandwich or hybrid integration).
 Top-down integration starts with high-level modules, gradually incorporating lower-
level modules.
 Bottom-up integration begins with lower-level modules, gradually incorporating higher-
level modules.
2. Interfaces and Interactions:
 Focuses on testing interfaces and interactions between integrated components.
 Ensures that data flows correctly, functions are invoked as expected, and dependencies
are handled properly.
3. Stubs and Drivers:
 Stubs (for bottom-up integration) and drivers (for top-down integration) are used to
simulate the behavior of components not yet integrated.
 Facilitate the testing of incomplete parts of the system.
4. Data Flow and Control Flow:
 Verifies the correct flow of data and control between integrated components.

https://play.google.com/store/apps/details?id=info.therithal.brainkart.annauniversitynotes
 lOMoARcPSD|45374298

www.BrainKart.com

 Identifies and addresses issues related to data inconsistency or control flow disruptions.
5. Testing Levels:
 Can be performed at various levels, including unit integration, module integration, and
system integration.
6. Defect Isolation:
 Helps isolate and identify defects arising from the interactions between components.
System Testing:
Objective: System testing focuses on assessing the complete, integrated software system to ensure that
it meets specified requirements and behaves as intended in its intended environment.
Key Aspects:
1. End-to-End Testing:
 Evaluates the system as a whole, considering all integrated components and their
interactions.
 Tests the system from the user's perspective, including user interfaces, data flow, and
overall functionality.
2. Functional and Non-functional Testing:
 Validates both functional aspects (features, operations) and non-functional aspects
(performance, security, usability, reliability).
3. Test Environment:
 Requires a stable and representative test environment that closely resembles the
production environment.
 Ensures that testing conditions align with real-world scenarios.
4. User Scenarios:
 Includes testing user scenarios, ensuring that the system performs as expected in various
usage situations.
5. Acceptance Criteria:
 Verifies whether the system meets the acceptance criteria defined by end-users and
stakeholders.
 May include User Acceptance Testing (UAT) for final validation.
6. Regression Testing:
 Validates that new changes or updates do not adversely affect existing functionalities.

https://play.google.com/store/apps/details?id=info.therithal.brainkart.annauniversitynotes
 lOMoARcPSD|45374298

www.BrainKart.com

 Ensures that the system remains stable and consistent.

7. Performance Testing:
 Assesses the system's performance under different conditions, including load testing,
stress testing, and scalability testing.
8. Security Testing:
 Identifies vulnerabilities and weaknesses in the system's security measures.
 Ensures that sensitive data is adequately protected.
9. Usability Testing:
 Evaluates the overall user experience, including navigation, clarity, and ease of use.
 Addresses aspects that contribute to user satisfaction.
10. Recovery and Reliability:
 Tests the system's ability to recover from failures and assesses its overall reliability.
Relationship between Integration Testing and System Testing:
 Sequence:
 Integration testing precedes system testing. Before evaluating the system as a whole, it is
essential to validate the interactions between integrated components.
 Scope:
 Integration testing focuses on the connections between modules or components. In
contrast, system testing encompasses the entire software system, considering all
integrated components and their interactions.
 Level of Detail:
 Integration testing may involve detailed testing of specific components and their
connections. System testing takes a broader perspective, considering the overall system
behavior.
 Purpose:
 Integration testing identifies and addresses issues related to the integration of
components. System testing validates the system's compliance with specified
requirements and its readiness for deployment.
Both integration testing and system testing play critical roles in ensuring the quality and reliability of a
software system. They provide different levels of assurance, allowing for the detection and resolution
of defects at various stages of the testing process.

https://play.google.com/store/apps/details?id=info.therithal.brainkart.annauniversitynotes
 lOMoARcPSD|45374298

www.BrainKart.com

Regression testing
Regression testing is a type of software testing that aims to ensure that new code changes or
modifications to an existing system do not negatively impact the existing functionality. The primary
goal is to detect and fix defects introduced as a result of code changes, enhancements, or bug fixes.
Regression testing helps maintain the integrity of the software and ensures that previously working
features remain functional throughout the development life cycle.
Key Aspects of Regression Testing:
1. Scope:
 Regression testing involves re-executing a subset or all of the previously executed test
cases to validate that existing functionalities are not affected by recent changes.
2. Reasons for Regression Testing:
 Code changes: After modifying or adding code to fix a bug, implement a new feature, or
enhance existing functionality.
 Configuration changes: Changes in configuration settings, environments, or
dependencies.
 Bug fixes: After resolving defects to ensure that the fixes do not introduce new issues.
 Updates: Applying updates to third-party libraries or components.
3. Automation:
 Automated regression testing is common to ensure quick and consistent execution of a
large number of test cases.
 Automation tools help run test scripts and compare results against expected outcomes.
4. Test Suite Maintenance:
 The regression test suite needs to be maintained and updated as the application evolves.
 New test cases may be added, and obsolete ones may be removed or updated.
5. Frequency:
 The frequency of regression testing depends on the development cycle, the rate of code
changes, and the criticality of the application.
 It is often performed as part of the continuous integration/continuous deployment
(CI/CD) process.
6. Selection of Test Cases:

https://play.google.com/store/apps/details?id=info.therithal.brainkart.annauniversitynotes
 lOMoARcPSD|45374298

www.BrainKart.com

 Selecting an effective subset of test cases from the entire test suite is crucial to strike a
balance between coverage and execution time.
 Focus on test cases that cover critical functionalities and areas impacted by recent
changes.
7. Regression Test Selection Techniques:
 Re-test all: Execute all test cases in the regression suite.
 Selective testing: Choose a subset of test cases based on impact analysis or risk
assessment.
 Prioritization: Prioritize test cases based on critical functionalities or areas of the
application.
8. Integration with Continuous Integration:
 Regression testing is often integrated into the CI/CD pipeline to automatically trigger
tests when new code is committed.
 Enables early detection of issues and facilitates rapid feedback to developers.
9. Traceability:
 Maintain traceability between code changes, test cases, and defects.
 Helps identify the origin of defects and ensures comprehensive test coverage.
Benefits of Regression Testing:
1. Early Detection of Defects:
 Identifies and addresses defects early in the development process, preventing the
accumulation of issues.
2. Ensures Stability:
 Ensures that existing features remain stable and functional as the software evolves.
3. Supports Continuous Integration:
 Integrates well with CI/CD pipelines, facilitating automated testing in the development
workflow.
4. Reduces Manual Effort:
 Automation of regression testing reduces the manual effort required to re-run test cases.
5. Preserves Quality:
 Preserves the quality of the software by preventing regression issues from reaching
production.

https://play.google.com/store/apps/details?id=info.therithal.brainkart.annauniversitynotes
 lOMoARcPSD|45374298

www.BrainKart.com

6. Enhances Confidence:
 Boosts confidence in making changes to the codebase, knowing that existing
functionalities are protected by regression tests.
Challenges of Regression Testing:
1. Time and Resource Constraints:
 Executing a comprehensive regression test suite may be time-consuming, especially for
large applications.
 Resource constraints may limit the ability to run extensive tests frequently.
2. Test Data Management:
 Maintaining and managing test data, especially in complex scenarios, can be
challenging.
3. Test Suite Maintenance:
 Keeping the regression test suite up-to-date requires ongoing effort, especially when the
application undergoes frequent changes.
4. Dependency on Automation:
 Over-reliance on automated regression tests may lead to neglect of manual exploratory
testing, missing certain types of issues.
Regression testing is a crucial practice in software development, ensuring that changes to the codebase
do not inadvertently introduce defects or compromise existing functionalities. Its integration with
continuous integration practices is fundamental for delivering reliable and high-quality software
continuously.
Debugging
Debugging is the process of identifying, analyzing, and fixing errors, defects, or unexpected behaviors
in software code. It is a critical skill for software developers, as it helps ensure the correctness and
reliability of a program. Debugging involves isolating and resolving issues to restore the intended
functionality of the software. Here are key concepts and techniques related to debugging:
Key Concepts:
1. Bug:
 A bug is an error, flaw, or unintended behavior in a software program that causes it to
behave in a way different from its intended design.
2. Debugging Tools:

https://play.google.com/store/apps/details?id=info.therithal.brainkart.annauniversitynotes
 lOMoARcPSD|45374298

www.BrainKart.com

 Debugging tools are software utilities or features that assist developers in identifying
and resolving issues in their code. Common debugging tools include integrated
development environment (IDE) debuggers, profilers, and logging frameworks.
3. Breakpoints:
 Breakpoints are markers set in the code where program execution stops, allowing
developers to inspect the state of the program and analyze its behavior step by step.
4. Stepping Through Code:
 Developers can step through code execution one line or one function at a time to
understand the flow and identify the point where an issue occurs.
5. Variable Inspection:
 Debuggers enable developers to inspect the values of variables at different points in the
code, helping identify incorrect or unexpected values.
6. Console Output and Logging:
 Outputting information to the console or using logging frameworks helps developers
trace the execution flow and identify issues by examining log messages.
7. Exception Handling:
 Exception handling mechanisms allow developers to catch and handle runtime errors,
preventing them from crashing the entire program.
8. Code Profiling:
 Profilers help identify performance bottlenecks and areas of code that consume
excessive resources, leading to suboptimal performance.
Debugging Techniques:
1. Print Statements:
 Inserting print statements or logging statements at different points in the code to output
values or messages for diagnostic purposes.
2. Binary Search Method:
 Narrowing down the location of an issue by using a binary search approach,
systematically disabling or isolating sections of code until the problematic area is
identified.
3. Rubber Duck Debugging:

https://play.google.com/store/apps/details?id=info.therithal.brainkart.annauniversitynotes
 lOMoARcPSD|45374298

www.BrainKart.com

 Explaining the code or the problem to someone else or an inanimate object (like a rubber
duck) can help the developer gain new insights and identify issues.
4. Code Review:
 Having another developer review the code can bring fresh perspectives and help identify
issues that the original developer may have overlooked.
5. Reproducing the Issue:
 Creating a minimal, isolated test case that reproduces the issue helps in understanding
the problem and testing potential solutions.
6. Using Assertions:
 Adding assertions to the code to check the validity of certain conditions during runtime
can help catch issues early.
7. Static Code Analysis:
 Using tools that perform static code analysis to identify potential issues before runtime.
8. Memory Profiling:
 Analyzing memory usage and identifying memory leaks or inefficient memory
management.
Steps in the Debugging Process:
1. Reproduce the Issue:
 Understand the conditions that trigger the problem and try to reproduce the issue
consistently.
2. Isolate the Issue:
 Narrow down the scope of the problem to identify the specific section of code or module
where the issue occurs.
3. Use Debugging Tools:
 Employ debugging tools to set breakpoints, inspect variables, and step through the code
to understand its execution flow.
4. Analyze Code and Data:
 Carefully analyze the code and data to identify logical errors, incorrect assumptions, or
unexpected behavior.
5. Apply Fixes:
 Implement necessary code changes or fixes to address the identified issues.

https://play.google.com/store/apps/details?id=info.therithal.brainkart.annauniversitynotes
 lOMoARcPSD|45374298

www.BrainKart.com

6. Verify and Test:

 Verify that the implemented fixes resolve the problem and conduct thorough testing to
ensure that the changes do not introduce new issues.
7. Documentation:
 Document the debugging process, including the identified issues, root causes, and
applied solutions. This documentation can be valuable for future reference and
knowledge sharing.

https://play.google.com/store/apps/details?id=info.therithal.brainkart.annauniversitynotes
 lOMoARcPSD|45374298

www.BrainKart.com

Debugging is an iterative and often collaborative process, and effective debugging skills are essential
for software developers to produce reliable and high-quality code.
Program analysis
Program analysis refers to the techniques and methods used to systematically examine and understand
the behavior, properties, and characteristics of computer programs. It involves various static and
dynamic approaches to analyze source code, binaries, or the runtime behavior of programs. Program

https://play.google.com/store/apps/details?id=info.therithal.brainkart.annauniversitynotes
 lOMoARcPSD|45374298

www.BrainKart.com

analysis techniques are employed for a variety of purposes, including identifying errors, ensuring
security, optimizing performance, and enhancing software reliability. Here are some key aspects and
techniques of program analysis:
Static Program Analysis:
Static program analysis is performed without executing the program. It involves examining the source
code, bytecode, or binary code to gain insights into the program's properties. Common techniques
include:
1. Syntax Analysis:
 Examining the program's source code to ensure it adheres to the language's syntax rules.
This is often a part of the compilation process.
2. Semantic Analysis:
 Analyzing the meaning of program statements to identify semantic errors or
inconsistencies.
3. Control Flow Analysis:
 Studying the possible paths of program execution to understand the flow of control
through the code.
4. Data Flow Analysis:
 Analyzing the movement of data throughout the program to identify how variables are
defined, used, and modified.
5. Dependency Analysis:
 Identifying dependencies between different program elements, such as functions,
modules, or variables.
6. Type Analysis:
 Inferring or verifying the types of variables and expressions in the program.
7. Abstract Interpretation:
 Approximating the program's behavior using abstract representations to analyze possible
runtime states.
8. Symbolic Execution:
 Symbolically executing the program to explore different execution paths and identify
potential issues.
Dynamic Program Analysis:

https://play.google.com/store/apps/details?id=info.therithal.brainkart.annauniversitynotes
 lOMoARcPSD|45374298

www.BrainKart.com

Dynamic program analysis involves observing the behavior of a program during its execution. It
requires running the program with specific inputs and monitoring its runtime characteristics. Common
techniques include:
1. Profiling:
 Collecting data on the program's runtime performance, such as execution time, memory
usage, and resource consumption.
2. Tracing:
 Capturing the sequence of function calls and events during program execution.
3. Debugging:
 Using debugging tools to inspect the program's state, set breakpoints, and step through
the code during runtime.
4. Memory Analysis:
 Monitoring memory usage to detect memory leaks, buffer overflows, or other memory-
related issues.
5. Concurrency Analysis:
 Analyzing the behavior of concurrent programs to identify race conditions, deadlocks, or
other concurrency-related problems.
Program Verification:
Program verification aims to formally prove or establish the correctness of a program with respect to its
specifications or requirements. It involves mathematical methods and formal techniques to ensure that a
program behaves as intended. Common approaches include:
1. Model Checking:
 Automatically checking whether a model of the program satisfies a set of specified
properties.
2. Theorem Proving:
 Using mathematical logic to formally prove the correctness of a program or specific
properties.
3. Static Analysis for Safety and Security:
 Analyzing the program statically to ensure it adheres to safety and security guidelines,
such as identifying vulnerabilities or potential security threats.
4. Hoare Logic:

https://play.google.com/store/apps/details?id=info.therithal.brainkart.annauniversitynotes
 lOMoARcPSD|45374298

www.BrainKart.com

 A formal system for reasoning about the correctness of computer programs, particularly
in terms of preconditions and postconditions.
Program analysis techniques are crucial for software development, testing, and maintenance. They play
a vital role in ensuring the reliability, security, and performance of software systems. However,
program analysis is a challenging and evolving field, and the effectiveness of different techniques
depends on the specific goals and characteristics of the analyzed programs.
Symbolic execution
Symbolic execution is a program analysis technique used in software testing and verification. It
involves executing a program with symbolic values instead of concrete input values, allowing the
exploration of multiple execution paths and the generation of symbolic expressions that represent the
program's behavior. Symbolic execution is particularly useful for identifying inputs that lead to specific
program outcomes, exploring code paths, and detecting potential errors or vulnerabilities.
Key Concepts of Symbolic Execution:
1. Symbolic Variables:
 Instead of using concrete input values, symbolic execution works with symbolic
variables that represent unknown values. These variables are used to track the state of
the program during execution.
2. Path Constraints:
 As the program executes symbolically, path constraints are generated based on the
conditions encountered. Path constraints capture the conditions that must be satisfied for
a specific path to be taken during execution.
3. Path Exploration:
 Symbolic execution explores multiple paths through a program by considering different
branches, loops, and conditions. Each path is associated with a set of path constraints.
4. Symbolic Expressions:
 Symbolic execution produces symbolic expressions that represent computations and
relationships between variables along each path. These expressions are parametrized by
the symbolic variables.
5. Constraint Solving:

https://play.google.com/store/apps/details?id=info.therithal.brainkart.annauniversitynotes
 lOMoARcPSD|45374298

www.BrainKart.com

 Constraint solving is used to find concrete values for the symbolic variables that satisfy
the path constraints. Solving the constraints reveals concrete inputs that lead to specific
program outcomes.
6. Coverage Analysis:
 Symbolic execution can be used to analyze code coverage by systematically exploring
various paths through the program.
Steps in Symbolic Execution:
1. Initialization:
 Start with symbolic input values as the initial state of the program.
2. Execution:
 Execute the program symbolically, keeping track of the symbolic state, including
symbolic variables and expressions.
3. Path Conditions:
 Record the path conditions encountered during execution, representing the conditions
that must be satisfied to follow a specific path.
4. Branching:
 At branches (e.g., if statements), create new symbolic states corresponding to each
branch. Update path conditions accordingly.
5. Loop Handling:
 Handle loops by unrolling them symbolically, exploring multiple iterations based on
symbolic constraints.
6. Constraint Solving:
 Use a constraint solver to find concrete values for symbolic variables that satisfy the
accumulated path conditions.
7. Path Exploration:
 Continue exploring different paths through the program until desired coverage is
achieved or a specific goal is reached.
Use Cases of Symbolic Execution:
1. Automated Test Generation:
 Symbolic execution can be used to automatically generate test cases that explore
different paths in a program, helping achieve higher code coverage.

https://play.google.com/store/apps/details?id=info.therithal.brainkart.annauniversitynotes
 lOMoARcPSD|45374298

www.BrainKart.com

2. Bug Detection:
 Symbolic execution is effective in detecting bugs, vulnerabilities, or unexpected
behaviors by exploring paths that lead to undesired outcomes.
3. Program Verification:
 Symbolic execution is employed in formal methods to verify program correctness
against specifications, identifying conditions that violate desired properties.
4. Security Analysis:
 It can be applied to identify security vulnerabilities such as input validation issues,
buffer overflows, or injection attacks.
5. Constraint-Based Debugging:
 Symbolic execution can aid in debugging by providing information about the conditions
that lead to specific issues.
6. Program Understanding:
 It can be used for program comprehension, revealing the possible execution paths and
conditions within a program.
Challenges and Considerations:
1. Path Explosion:
 The number of paths explored can grow exponentially, leading to the "path explosion"
problem. Strategies such as path pruning and heuristics are used to manage this issue.
2. Complexity:
 Symbolic execution may face challenges with complex language features, external
dependencies, or dynamic behaviors.
3. Constraint Solving:
 The efficiency of constraint solvers can impact the overall effectiveness of symbolic
execution.
4. Path Merging:
 When paths merge during execution, handling the merging of symbolic states can be
complex.
Symbolic execution is a powerful technique with applications in various domains, including software
testing, security analysis, and program verification. Advances in tools and techniques have contributed
to its increasing adoption for improving the quality and security of software systems.

https://play.google.com/store/apps/details?id=info.therithal.brainkart.annauniversitynotes
 lOMoARcPSD|45374298

www.BrainKart.com

Model Checking
Model checking is a formal verification technique used to systematically check whether a system or
software model satisfies a given specification. It involves systematically exploring all possible states of
a model and verifying whether certain properties or conditions hold in each state. Model checking is
commonly used in the development of safety-critical systems, hardware verification, protocol
validation, and concurrent systems to ensure the correctness and reliability of systems.
Key Concepts of Model Checking:
1. Model Representation:
 The system or software under consideration is represented as a formal model. This
model typically captures the relevant aspects of the system, such as states, transitions,
and behaviors.
2. Specification Properties:
 Properties or specifications that the system should satisfy are formalized using temporal
logic or other formal languages. These properties specify the desired behavior of the
system.
3. State Space Exploration:
 Model checking systematically explores the entire state space of the model. The state
space includes all possible states the system can reach from its initial state, considering
different inputs and transitions.
4. Temporal Logic:
 Temporal logic, such as Linear Temporal Logic (LTL) or Computation Tree Logic
(CTL), is commonly used to express temporal properties and requirements in a formal
way. Temporal logic allows the specification of properties over sequences of states.
5. Automata-Based Representation:
 The model is often represented using automata or state transition systems, facilitating
the exploration of different states and transitions.
6. Property Verification:
 Model checking verifies whether the specified properties hold for all states of the
system. It checks whether the model satisfies or violates the given specifications.
Steps in Model Checking:
1. Model Specification:

https://play.google.com/store/apps/details?id=info.therithal.brainkart.annauniversitynotes
 lOMoARcPSD|45374298

www.BrainKart.com

 Formalize the system or software under consideration as a model, defining its states,
transitions, and relevant properties.
2. Property Formulation:
 Specify the desired properties or requirements of the system using temporal logic or
another formal language.
3. State Space Exploration:
 Systematically explore the entire state space of the model, considering all possible states
and transitions.
4. Property Verification:
 Verify whether the specified properties hold for all states of the model. Model checking
tools use algorithms to determine the satisfiability of properties.
5. Counterexample Analysis:
 If a property is found to be violated, model checking tools can provide a
counterexample, demonstrating a scenario where the property is not satisfied.
6. Refinement and Iteration:
 Refine the model or properties based on the analysis results. Iteratively perform model
checking until the desired level of correctness is achieved.
Applications of Model Checking:
1. Hardware Verification:
 Model checking is extensively used in the verification of digital circuits and hardware
designs to ensure correctness and eliminate design flaws.
2. Software Systems:
 It is applied to verify software systems, including embedded software and concurrent
systems, to ensure they meet specified requirements.
3. Communication Protocols:
 Model checking is used to validate the correctness of communication protocols, ensuring
reliable and secure communication between components.
4. Cyber-Physical Systems:
 Model checking is applied in the verification of cyber-physical systems, where software
interacts with physical processes.
5. Security Protocols:

https://play.google.com/store/apps/details?id=info.therithal.brainkart.annauniversitynotes
 lOMoARcPSD|45374298

www.BrainKart.com

 Model checking is used to verify the security properties of cryptographic protocols and
systems, ensuring they are resistant to attacks.
6. Distributed Systems:
 It is employed to verify the correctness and reliability of distributed systems, where
multiple components interact to achieve a common goal.
Challenges and Considerations:
1. State Space Explosion:
 Model checking faces the challenge of state space explosion, especially in large and
complex systems. Techniques such as abstraction and partial order reduction are used to
mitigate this challenge.
2. Expressiveness of Specifications:
 The ability to express complex system properties using formal languages and logics is
crucial for effective model checking.
3. Tool Scalability:
 The scalability of model checking tools is important, especially when dealing with large
systems or extensive state spaces.
4. Property Formulation:
 Formulating properties that accurately capture the desired system behavior is a critical
aspect of successful model checking.
Model checking is a powerful formal verification technique that provides a systematic and exhaustive
approach to ensuring the correctness of systems. It complements other verification methods and plays a
crucial role in enhancing the reliability and safety of complex systems.

https://play.google.com/store/apps/details?id=info.therithal.brainkart.annauniversitynotes
 Click on Subject/Paper under Semester to enter.
Environmental Sciences
Professional English and Sustainability -
Professional English - - II - HS3252 Discrete Mathematics GE3451
I - HS3152 - MA3354
Statistics and Theory of Computation
Matrices and Calculus Numerical Methods - Digital Principles and - CS3452
3rd Semester

4th Semester
- MA3151 MA3251 Computer Organization
1st Semester

2nd Semester

- CS3351 Artificial Intelligence

Engineering Graphics and Machine Learning
Engineering Physics - - CS3491
- GE3251 Foundation of Data
PH3151
Science - CS3352
Database Management
Physics for
Engineering Chemistry System - CS3492
Information Science Data Structure -
- CY3151 - PH3256 CS3301

Basic Electrical and

Algorithms - CS3401
Problem Solving and Electronics Engineering Object Oriented
Python Programming - - BE3251 Programming - CS3391 Introduction to
GE3151 Operating Systems -
Programming in C -
CS3451
CS3251

Computer Networks - Object Oriented

CS3591 Software Engineering
- CCS356
Compiler Design - Human Values and
5th Semester

CS3501 Embedded Systems Ethics - GE3791

7th Semester

8th Semester
6th Semester

and IoT - CS3691

Cryptography and Open Elective 2
Cyber Security - Open Elective-1 Project Work /
CB3491
Open Elective 3 Intership
Distributed Computing Elective-3
- CS3551 Open Elective 4
Elective-4
Elective 1
Management Elective
Elective-5
Elective 2
Elective-6
 All Computer Engg Subjects - [ B.E., M.E., ] (Click on Subjects to
enter)
Programming in C Computer Networks Operating Systems
Programming and Data Programming and Data Problem Solving and Python
Structures I Structure II Programming
Database Management Systems Computer Architecture Analog and Digital
Communication
Design and Analysis of Microprocessors and Object Oriented Analysis
Algorithms Microcontrollers and Design
Software Engineering Discrete Mathematics Internet Programming
Theory of Computation Computer Graphics Distributed Systems
Mobile Computing Compiler Design Digital Signal Processing
Artificial Intelligence Software Testing Grid and Cloud Computing
Data Ware Housing and Data Cryptography and Resource Management
Mining Network Security Techniques
Service Oriented Architecture Embedded and Real Time Multi - Core Architectures
Systems and Programming
Probability and Queueing Theory Physics for Information Transforms and Partial
Science Differential Equations
Technical English Engineering Physics Engineering Chemistry
Engineering Graphics Total Quality Professional Ethics in
Management Engineering
Basic Electrical and Electronics Problem Solving and Environmental Science and
and Measurement Engineering Python Programming Engineering