JNTUA Software Engineering Lab Manual R20
JNTUA Software Engineering Lab Manual R20
me/jntua
Name:___________________________________________
H.TNo: ___________________________________________
Year/Semester: ____________________________________
INSTITUTE VISION
To be a premier institute for professional education producing dynamic and vibrant force of
technocrats with competent skills, innovative ideas and leadership qualities to serve the society
with ethical and benevolent approach.
INSTITUTE MISSION
To create a learning environment with state-of-the art infrastructure, well equipped laboratories,
research facilities and qualified senior faculty to impart high quality technical education.
To facilitate the learners to foster innovative ideas, inculcate competent research and consultancy
skills through Industry-Institute Interaction.
To develop hard work, honesty, leadership qualities and sense of direction in rural youth by
providing value based education.
QUALITY
Vemu Institute of Technology is committed and strives to maintain the quality education through
superior teaching, rigorous training, continuous evaluation and monitoring.
OBJECTIVES
Course Objectives:
CO2: Understand the phases of software projects and practice the activities of each phase
CO4:Adopt skills such as distributed version control, unit testing, integration testing, build man
Agement, and deployment
PO-2: Problem analysis: Identify, formulate, review research literature, and analyze complex
PO-3: Design/development of solutions: Design solutions for complex engineering problems and
design system components or processes that meet the specified needs with appropriate
consideration for the public health and safety, and the cultural, societal, and environmental
considerations.
PO-4: Conduct investigations of complex problems: Use research-based knowledge and research
methods including design of experiments, analysis and interpretation of data, and synthesis of the
information to provide valid conclusions.
PO-5: Modern tool usage: Create, select, and apply appropriate techniques, resources, and modern
engineering and IT tools including prediction and modeling to complex engineering activities
with an understanding of the limitations.
PO-6: The engineer and society: Apply reasoning informed by the contextual knowledge to
assess societal, health, safety, legal and cultural issues and the consequent responsibilities
relevant to the professional engineering practice.
PO-7: Environment and sustainability: Understand the impact of the professional engineering
solutions in societal and environmental contexts, and demonstrate the knowledge of, and need
for sustainable development.
PO-8: Ethics: Apply ethical principles and commit to professional ethics and responsibilities
and norms of the engineering practice.
PO-9: Individual and team work: Function effectively as an individual, and as a member
or leader in diverse teams, and in multidisciplinary settings.
PO-11: Project management and finance: Demonstrate knowledge and understanding of the
engineering and management principles and apply these to one’s own work, as a member and
leader in a team, to manage projects and in multidisciplinary environments.
PO-12: Life-long learning: Recognize the need for, and have the preparation and ability
to engage in independent and life-long learning in the broadest context of technological change.
PSO-2: Domain Knowledge: Get qualified in competitive exams to Pursue Higher Education
through the knowledge attained in advanced programming languages like Java,
Machine Learning, PHP, Python, Android Studio, Hadoop Framework, AWS, R and Weka etc.
17 Define the design activities along with necessary artifacts using Design Document. .
Reverse Engineer any object-oriented code to an appropriate class and object diagrams.
18
Test a piece of code which executes a specific functionality in the code to be tested and
19 asserts a certain behavior or state using Junit.
20 Test the percentage of code to be tested by unit test using any code coverage tools
Define an appropriate metrics for at least 3 quality attributes for any software application
21
of your interest.
Define a complete call graph for any C/C++ code. (Note: The student may use any tool that
22
generates call graph for source code)
17 Define the design activities along with necessary artifacts using Design Document. . 37
Reverse Engineer any object-oriented code to an appropriate class and object diagrams. 40
18
Test a piece of code which executes a specific functionality in the code to be tested and 43
19 asserts a certain behavior or state using Junit.
Test the percentage of code to be tested by unit test using any code coverage tools 45
20
Define an appropriate metrics for at least 3 quality attributes for any software 48
21
application of your interest.
Define a complete call graph for any C/C++ code. (Note: The student may use any tool 51
22
that generates call graph for source code)
Additional Experiments
23 Library Management system 53
24 Hospital Management System 54
DO‘S
2. While entering into the LAB students should wear their ID cards.
4. Students should sign in the LOGIN REGISTER before entering into the laboratory.
5. Students should come with observation and record note book to the laboratory.
7. After completing the laboratory exercise, make sure to shutdown the system properly
DONT‘S
SCHEME OF EVALUATION
Write C/C++/Java/Python
12 program for classifying the
various types of coupling.
Write a C/C++/Java/Python
13 program for classifying the
various types of cohesion.
Write a C/C++/Java/Python
program for object oriented
metrics for design proposed
14
Chidamber and kremer .
(Popularly called as CK
metrics)
Convert the DFD into
15 appropriate architecture
styles.
Draw complete class
diagram and object
16
diagrams using Rational
tools
Define the design activities
along with necessary
17
artifacts using Design
Document.
Reverse Engineer any
object-oriented code to an
18
appropriate class and object
diagrams.
Test a piece of code which
executes a specific
functionality in the code to
19
be tested and asserts a
certain behavior or state
using Junit.
Test the percentage of code
to be tested by unit test
20
using any code coverage
tools
Define an appropriate
metrics for at least 3 quality
21 attributes for any software
application of your
interest..
Define a complete call
graph for any C/C++ code.
22 (Note: The student may use
any tool that generate call
graph for source code)
There are a number of reasons why breaking down a large project is beneficial. It helps you to.
Estimate the cost of a project.
Establish dependences
Determine a project time lines and develop a schedule
Write a Statement of work
Assign Responsibilities and Clarity roles
Track the progress of a project
Identify risk
Rules to Create a work breakdown Structure
1. Include 100 % of the work necessary to complete the goal.
2. Don’t account for any amount of work twice.
3. Focus on outcomes, not actions.
4. A work package should take no less than 8 hours and no more than 80 hours of effort.
5. Include about three levels of detail.
6. Assign each work package to a specific team or individual.
RESULT:
AIM:To Schedule all the activities and sub-activities Using the PERT/CPM charts
Description:
Program evaluation Review Technique(PERT)
A PERT chart ia a project management tool that provides a graphical representation of a
project’s timeline.The program evaluation review technique breaks down the individuals tasks
of a project for analysis.
APERT chart uses circles or rectangles called nodes to represent project events or mile
stones.These nodes are linked by vector or lines that represent various tasks.If an arrow is drawn
from Task NO.1 to Task NO.2 on a PERT chart,Task NO.1 must be completed before work ok
Task NO.2 begins.
Critical path Method(CPM)
The critical path Method(CPM) is Step by Step project Mangement technique for process
planning that defines critical and non-critical tasks with the goal of presenting time-frame
problems
In applying the CPM, there are several steps that can be summarized as follows:
1. Define the required tasks and put them down in an ordered(Sequence)list.
2. Create a flowchart or other diagram showing each task in relation to the others.
3. Identify the critical and non-critical relationships(Paths)among tasks.
4. Determine the expected-completion or execution time for each task.
5. Locate or device alternatives(backups)for the most critical paths.
Let's imagine you decided to build a new fence around your property and want to accurately
assess how much time you'll need to do it. Based on your daily availability, if the weather
conditions are good, you should be able to finish the projects in five days. Unfortunately, the
weather forecast predicts there might be some scattered storms in the next few days, and it looks
like the worst-case scenario is a total of nine days of work. Seven days seem the most
reasonable, accounting for some delays due to the weather, but not being overly pessimistic. So,
all in all, you have:
According to the program evaluation and review technique estimate, you should be able to finish
your fence in 7 days, with a standard deviation of 0.67 days (which means about 16 hours).
RESULT:
RESULT:
Exp-4 Analyze all the possible risks and its risk mitigation plan
AIM: To identify and analyze all the possible risks and its risk mitigation plan for the
system to be automated.
Description:
Risk is defined in financial terms as the change that an outcome or investments actual gains will
differ from an expected outcome or return.Risk includes the Possibility of losing some or all of
an original investment. Software development is a multistage approach of
design,documentation,programming,prototyping,testing etc, which follows a software
development Life cycle (SDLC)process.
Schedule Risks:
1. Time is not estimated perfectly
2. Improper resource allocation
3. Tracking of resources like system skill,staff etc
4. Frequent project scope expansion
5. Failure in function identification and its completion.
Budget Risk:
1. Wrong/Improper budget estimation
2. Un excepted project scope expansion
3. Mismanagement in budget handling
4. Cost overruns
5. Improper tracking of Budget
Technical Risk:
1. Frequent changes in Requirement
2. Less use of future technologies
3. Less number of skilled employee
4. High complexity in implementation
RESULT:
AIM: To diagnose any risk using Ishikawa Diagram (Can be called as Fish Bone Diagram
or Cause & Effect Diagram).
Description:
A fishbone diagram is a visualization tool for catogirizing the potential causes of a problem.this
tool is used in order to identify a problems root causes.Typically used for root cause analysys, a
fishbone diagram combines the practice of brain storming with a type of mind map template. It
should be efficient as a test case technique to determine cause and effect.
RESULT:
AIM:To Define Complete Project plan for the system to be automated using Microsoft
Description:
Microsoft project ia a project management software Made for project manager so they can control
their projects Depending on your plan Microsoft projects lets you plan projects,assign tasks,manage
resourses make reports and more
Launch MS Project:
Windows 7- Click on start menu, point to all programs,click Microsoft office,and then click
project 2013.
Windows 8- On the Start screen, tap or click Project 2013.
Windows 10- Click on Start menu → All apps → Microsoft Office → Project 2013
RESULT:
AIM: To define the Features, Vision, Bussiness objectives, Bussiness rules and stakeholders in
the vision document
Description:
In general the vision represents the end users or customer ideas and view of the software product
to be development. In an enterpreners environment, the entrepreneur starts with an idea which
is later turned into a tangible product,service,etc some is the case with software projects,they
All start with an idea or vision related to the types of needs that might be addressed by a system
having certain features.
RESULT:
Description:
The numbering requirements part discusses the functionalities required from the system.The
system considered to perform a set of high-level fuctions{f1}.The functional view of the system
is shown in fig (Online Shopping System)Each function fi of the system can be considered as a
transformation of a set of input data to the corresponding set of output devices.The user can get
some meaningful piece of work done using a High-level fuction.
Example:
Example:
RESULT:
Usecases:
Use then drive one or more use cases from each feature,A use case defines how a user
achieves a goal using our product.
Use cases are a way to document a specific type of requirement called Functional
Requirements. These are many benefits to using use cases to document functional
requirements.
Functional requirements are a set of requirements,mostly in text that defines the system
functionality being developed. Use case diagram is requirements elicitation of a software
system.Both can be used and there are clear advantages in doing so. The functional
requirements can easily be used as until test cases,whereas the use cases can be used for user
acceptance and integration tests.Depending on the level of detail usecase diagram can be
used for Unit tests.
RESULT:
AIM: To Estimate the effort using the following methods for the system to be automated:
1. Function point metric
2. Usecase point metric
Description:
Functional point analysys functional point analysis in 1979 at IBM and it has been further
modified by the international function point users group.FPA is used to make estimate of the
software project, including its testing in terms of functionality or function size of the software
Product.
Objectives of FDA:
The basic and primary purpose of the functional point analysis is to measure and provide
The software application functional size to the client,customer, and the stakeholder on their
request.
The functional complexities are multiplied with the corresponding weights against each
function, and the values are added up to determine the UFP of the Subsystem.
Example:
Given the following values, compute function point when all complexity adjustment factor
(CAF) and weighting factors are average.
User Input = 50
User Output = 40
User Inquiries = 35
User Files = 6
External Interface = 4
Explanation:
Step-1: As complexity adjustment factor is average (given in question), hence,
scale = 3.
F = 14 * 3 = 42
Use-Case: It is a series of related interactions between a user and a system that enables the user
to achieve a goal.
Use-Cases are a way to capture functional requirements of a system. The user of the system is
referred to as an ‘Actor’. Use-Cases are fundamentally in text form.
Use-Case Points – Definition: Use-Case Points (UCP) is a software estimation technique used
to measure the software size with use cases. The concept of UCP is similar to FPs.The number
of UCPs in a project is based on the following −
RESULT:
AIM:To . Develop a tool which can be used for quantification of all the non-functional
Requirements
Description:
Requirement analysis is considered as the most important phase for the development of quality
software.Because of errors caused by poor and inadequate requirement analysis are likely to
creep in design and implementation phase.
These errors are observed as time-consuming and most experience to repair.thus, requirement
analysis is the phase, which determines the success or failure of a software project.
RESULT:
Description:
Coupling of java: In object oriented design, coupling refers to the degree of direct knowledge
that one element has of another.In other words how often do changes in class a force related
changes in class B
Tight Coupling: In general , Tight coupling means the two classes often change
together.inother word, if A knows more than it should acout the way in which B was
implemented, then A and B are tightly coupled.
Example: If you want to change the skin, you would also have to change the design of your
body as well because the two are joined together – they are tightly coupled. The best example of
tight coupling is RMI(Remote Method Invocation).
Tight coupling is not good at the test-ability. But loose coupling improves the test
ability.
Tight coupling does not provide the concept of interface. But loose coupling helps us
follow the GOF principle of program to interfaces, not implementations.
In Tight coupling, it is not easy to swap the codes between two classes. But it’s much
easier to swap other pieces of code/modules/objects/components in loose coupling.
Tight coupling does not have the changing capability. But loose coupling is highly
changeable.
RESULT:
AIM:To Write a C/C++/Java/Python program for classifying the various types of cohesion.
Description:
Cohesion in java : In object oriented design,cohesion refers all about how a single class is
designed Cohesion is the object oriented principle most closely associated with making sure that
a class is designed with a single,well defined perpose.
The More focused a class is the Cohesiveness of that class is more. the advantage of high
cohesion is that such classes with low Cohesion another benefit of high cohesion is that classes
with a well-focused perpose tend to be more reasonable than other classes.
Example:
Let us understand the structure of High Cohesive
Program:
classDisplay {
publicstaticvoidmain(String[] args)
{
Multiply m = newMultiply();
System.out.println(m.mul(5, 5));
}
}
RESULT:
AIM:To Write a C/C++/Java/Python program for object oriented metrics for design
proposed Chidamber and kremer . (Popularly called as CK metrics)
Description:
The ck metrics can be used to measure some characteristics of oo system such as classes,
message passing, inheritance, and encapsulation.On other hand the software maintenance phase
requires that changes are made to the existing system Although the existing metrices,such as the
ck metrics can be used to predict outcomes during the software maintance, such as efforts and
defects they do not provide sufficient information regarding the difficulty in the implementing
such changes, as well as the potential effects of those changes.
Thus, the object – oriented projects, different sets of metrices have been proposed.
These are listed below:
Number of Scenario Scripts
Number of key classes
Number of support classes
Average number of support classes per key class
Number of subsystems
Weighted methods per class (WMC). Assume that n methods of complexity c1, c2, . . ., cn are
defined for a class C. The specific complexity metric that is chosen (e.g., cyclomatic
complexity) should be normalized so that nominal complexity for a method takes on a value of
1.0.
WMC=ci
for i = 1 to n. The number of methods and their complexity are reasonable indicators of the
amount of effort required to implement and test a class. In addition, the larger the number of
methods, the more complex is the inheritance tree (all subclasses inherit the methods of their
parents). Finally, as thenumber of methods grows for a given class, it is likely to become more
and more application specific, thereby limiting potential reuse. For all of these reasons, WMC
should be kept as low as is reasonable
RESULT:
Description:
A mapping technique, called structured design, is often characterized as a data flow-oriented
design method because it provides a convenient transition from a data flow diagram to software
architecture.
The transition from information flow to program structure is accomplished as part of a six step
process:
(1) The type of information flow is established,
(2) Flow boundaries are indicated,
(3) The DFD is mapped into the program structure,
(4) Control hierarchy is defined,
(5) The resultant structure is refined using design measures.
(6) The architectural description is refined and elaborated.
Example of data flow mapping, a step-by-step “transform” mapping for a small part of the
SafeHome security function. In order to perform the mapping,The type of information flow must
be determined. It is called transform flow and exhibits a linear quality.
Data flows into the system along an incoming flow path where it is transformed from an
external world representation into internalized form. Once it has been internalized, it is
processed at a transform center. Finally, it flows out of the system along an outgoing flow
path that transforms the data into external world
RESULT:
AIM:To Draw complete class diagram and object diagrams using Rational tools
Description:
Launch rose select file new select file save as business Model later select file new --?
Save as requirements –analysys Model-note when requirement-analysis is complete then save as
design implementation model select view to check status bar browser, documentation, as
unified,
7.Once you have clicked on the class button, position the new mouse pointer wherever you
want on the page and click again. A rectangle representing the class will now appear on the
page. Now, type in a name for your class. To reposition the class, just click once on the class.
To change its property like name, click twice.
8.Now we need to add some attributes to the class. Let’s insert an attribute. To do this, right
click on the class. Select new attribute. Now, type in the name of the attribute of the class.
The icon that appears beside the attribute specifies whether it is public, private, or protected.
Perform the steps below to create a UML object diagram in Visual Paradigm.
3.Click Next.
4.Enter the diagram name and description. The Location field enables you to select a model
to store the diagram.
5.Click OK.
RESULT:
AIM:To Define the design activities along with necessary artifacts using Design Document
Description:
Design activity includes collaboratively creating visual-tools –rough sketches,mock-
ups,models,and drawings-potentiating the potentiating the communication ,coordination ,and
intergration between function. And enchancing the production and circulation of knowledge
with in and between projects
“Artifact” is a pretty broad term when it comes to software development. Most pieces of
software have a lot of artifacts that are necessary for them to run. Some artifacts explain how a
piece of software is supposed to work, while others actually allow that program to run.
Typically, a software development team will come up with a list of necessary artifacts for a
piece of software before coding anything. These include things like risk assessments, source
code, diagrams, and use cases. This is done during the research phase of the project.
Developing a piece of software without any of this is like building a house without blueprints.
The process would be a huge mess, and crucial pieces would inevitably be left out. In this way,
getting all your artifacts together is one of the most crucial parts of the software development
life cycle.
Once all the initial artifacts are compiled, a development team can begin programming and
building the actual program. Throughout this process, further artifacts might be developed.
These can come up at any time and include everything from new sketches to use cases.
Software Artifacts:There are a lot of different parts of any given piece of software that can be
artifacts. Here are a few of the most common examples.
There are three main categories that software artifacts fall under. These are code-related
artifacts, project management artifacts, and documentation. Here’s a closer look at all three.
Code Artifacts:Every program is made up of codes, and each coded process produces artifacts.
These include:
Test Suites: Coded test to run against the program in order to make sure a certain process
is working
Complied Code: The final, compiled code that goes out to the user
Test Output: Logs and information that comes from the testing process
Code artifacts are unavoidable, important by-products of the coding process. They let a
developer test the ins and outs of their software, allowing them to perfect it for the user.
RESULT:
AIM: To Reverse Engineer any object-oriented code to an appropriate class and object
diagrams.
Description:
Reverse engineering is an object oriented code into uniform modelling language class diagram
object-oriented code Similarly c++ implement or algorithm and like the previously done Work
on reverse engineering into UML algorithm generates tools for a complete set of constructs
available in UML class diagrams.
Forward engineering can be understood as being a process that moves from high-level and
abstract models and artifacts to increasingly concrete ones.
• Reverse engineering reconstructs higher-level models and artifacts from code.It is a process
that transforms one low-level representation to another, while recreating the higher-level
artifacts along the way.
Reverse Engineering Tools:
Reverse engineering if done manually would consume lot of time and human labour and hence
must be supported by automated tools. Some of tools are given below:
CIAO and CIA: A graphical navigator for software and web repositories along with a
collection of Reverse Engineering tools.
Rigi: A visual software understanding tool.
Bunch: A software clustering/modularization tool.
GEN++: An application generator to support development of analysis tools for the C++
language.
PBS: Software Bookshelf tools for extracting and visualizing the architecture of program
RESULT:
AIM: To Test a piece of code which executes a specific functionality in the code to be tested
and asserts a certain behavior or state using Junit.
Description:
A JUnit test is a method contained in a class which is only used for testing. This is called a Test
class. To mark a method as a test method, annotate it with the @Test annotation. This method
executes the code under test.
The following code defines a minimal test class with one minimal test method.
packagecom.vogella.junit.first;
importstatic org.junit.jupiter.api.Assertions.assertTrue;
importorg.junit.jupiter.api.Test;
classAClassWithOneJUnitTest
{
@Test
void demoTestMethod(){
assertTrue(true);
}
You can use assert methods, provided by JUnit or another assert framework, to check an
expected result versus the actual result. Such statement are called asserts or assert statements.
Example for developing a JUnit test for another class
The following example defines a Java class and defines software tests for it.
Assume you have the following class which you want to test.
Packagecom.vogella.junit5;
publicclassCalculator{
publicint multiply(int a,int b){
return a * b;
}
includes all of its subdirectories and all Java filenames that end with Test.
includes all of its subdirectories and all Java filenames that end with Tests.
Where should the test be located?
Typical, unit tests are created in a separate source folder to keep the test code separate from the
real code. The standard convention from the Maven and Gradle build tools is to use:
src/main/java - for Java classes
src/test/java - for test classes
Testing for exceptions
Testing that certain exceptions are thrown are be done with
the org.junit.jupiter.api.Assertions.expectThrows() assert statement. You define the expected
Exception class and provide code that should throw the exception.
importstatic org.junit.jupiter.api.Assertions.assertThrows;
@Test
void exceptionTesting(){
// set up user
Throwable exception = assertThrows(IllegalArgumentException.class,()->
user.setAge("23"));
assertEquals("Age must be an Integer.", exception.getMessage());
}
This lets you define which part of the test should throw the exception. The test will still fail if an
exception is thrown outside of this scope.
Testing multiple assertions (grouped assertions) with assertAll
If an assert fails in a test, JUnit will stop executing the test and additional asserts are not
checked. In case you want to ensure that all asserts are checked you can assertAll.
In this grouped assertion all assertions are executed, even after a failure. The error messages get
also grouped together.
@Test
void groupedAssertions(){
Address address =newAddress();
assertAll("address name",
()-> assertEquals("John", address.getFirstName()),
()-> assertEquals("User", address.getLastName())
);
}
RESULT:
AIM: To Test the percentage of code to be tested by unit test using any code coverage tools
Description:
Code coverage:
Code coverage is a software testing metric that determines the number of lines of code that is
successfully validated under a test procedure, which in turn, helps in analyzing how comprehensively a
software is verified. It is one such software testing metric that can help in assessing the test
performance and quality aspects of any software.Code coverage scripts generate a report that details
how much of the application code has been executed. This is a white-box testing technique
Top 3 Benefits of Code Coverage: Code coverage analysis can only be used for the validation
of test cases that are run on the source code and not for the evaluation of the software product.
Also, it neither evaluates whether the source code is bug-free nor proves if a written code is
correct.
Easy maintenance of code base – Writing scalable code is crucial to extend the software
program through the introduction of new or modified functionalities. However, it is difficult to
determine whether the written code is scalable. It can prove to be a useful metric in that context
The analysis report will help developers to ensure code quality is well-maintained and new
features can be added with little-to-no efforts.
Exposure of bad code – Continuous analysis will help developers to understand bad, dead, and
unused code. As a result, they can improve code-writing practices, which in turn, will result in
better maintainability of the product quality.
Faster time to market – With the help of this metric, developers can finish the software
development process faster, thereby increasing their productivity and efficiency. As a result,
they will be able to deliver more products, allowing companies to launch more software
applications on the market in lesser time. This will undoubtedly lead to increased customer
satisfaction and high ROI.
Branch Coverage: This is used to ensure that every branch in a decision-making process is
executed. Let’s say a tester is including a fallback for cross browser compatibility using an
If…Else conditional statement or a Do…While statement in the code. Branch coverage will
ensure that all branches (If, Else, Do, While) are tested with appropriate input.
Function Coverage: This ensures that all necessary functions are tested. It also includes testing
functions with different input parameters to test the logic in the functions.
Statement Coverage: In this, the code is created in a way that every executable statement in the
source code is executed at least once. This includes corner cases or boundary cases.
Loop Coverage: This ensures that every loop in the source code is executed at least once.
Certain loops may be executed based on results achieved at runtime. One must be careful to test
such loops so as to fortify the code completely.
Condition Coverage: This reveals how variables in the conditional statements are evaluated. It
helps to provide proper coverage to the control flow.
Finite State Machine Coverage: This works based on the frequency of visits from static states
and other transactions. Finite state machine coverage is the most complicated form of code
coverage as it functions on the design of the software structure.
Code coverage verifies with instrumentation. Instrumentation monitors performance inserts
trace information and detects errors in the source code. The types of instrumentation are
discussed below.
Test coverage can also be evaluated through different types of testing. However, the type
of tests that must be run depends on the business priorities of the testing team and the
organization behind them. For example, user-centric web apps prioritize UI/UX tests over
functional tests. Conversely, financial apps will prioritize usability and security testing over all
other tests.
In case, one wants to test their website for cross-browser compatibility or UI/UX bugs, check
this page out.
Some of the test coverage mechanisms:
Unit Testing: Performed at a unit level or module level. Bugs at this level are widely
differentfrom issues encountered at the integration stage.
Functional Testing: Functions or features are tested against requirements mentioned in the
Functional Requirement Specification (FRS) documents.
Acceptance Testing: Determines whether a product is suitable to be released for customer use.
At this stage, developers will have to receive approval from testers and SMEs to push code
changes from Staging to Production.
Integration Testing: Also called system testing, since testing occurs on the system level. These
tests are performed once all software modules are integrated.
The purpose of test coverage varies depending on the level at which tests are performed. It also
depends on the type of software being tested. Additionally, test coverage metrics for mobile
phones would differ from those for website testing.
RESULT:
AIM: To Define an appropriate metrics for at least 3 quality attributes for any software
application of your interest.
Description:
Quality can be defined in a different manner. The quality definition may differ from person to
person. But finally, there should be some standards. So Quality can be defined as
Degree of excellence – Oxford dictionary
Fitness for purpose – Edward Deming
Best for the customer’s use and selling price – Feigenbaum
The totality of characteristics of an entity that bear on its ability to satisfy stated or
implied needs – ISO Each attribute can be used to measure product performance. These
attributes can be used for Quality assurance as well as Quality control.
Quality Assurance activities are oriented towards the prevention of the introduction of
defects and Quality Control activities are aimed at detecting defects in products and
services.
Reliability
Measure if the product is reliable enough to sustain in any condition. Should give
consistently correct results.Product reliability is measured in terms of working of the
project under different working environments and different conditions.
Maintainability
Different versions of the product should be easy to maintain. For development it should
be easy to add code to the existing system, should be easy to upgrade for new features
and new technologies from time to time.Maintenance should be cost-effective and easy.
The system is easy to maintain and correcting defects or making a change in the
software.
Usability
This can be measured in terms of ease of use. The application should be user-friendly.
Should be easy to learn. Navigation should be simple.
SoftwareMetrics Terminologies
Metric Classification
1.Processes
-Activities related to production of software
2.Products
- Explicit results of software development activities.
- Deliverables, documentation, by products
3.Project
- Inputs into the software development activities
- hardware, knowledge,people
Function PointMetrics
– Function point metrics provide a standardized method for measuring the various
functions of a software application.
– Function point metrics, measure functionality from the user’s point of view, that is,
on the basis of what the user requests and receives inreturn.
RESULT:
AIM: To Define a complete call graph for any C/C++ code. (Note: The student may use
any tool that generate call graph for source code)
Description:
Turing program source into call graph is on creating and analzing type qualifiers for functions
that constrain where those functions can and cannot be called.the central notion be this sort of
type checking is that every program as a call graph and that there are certain patterns in call
graph which be prevented. A program call is a directed graph where each function is vertex and
where each call is an edge directed from caller to caller.
There are two main approaches to analyzing a call graph: the function calls first approach, and
the call graph top/down approach. Both methods are complementary.
Function Calls First Approach
This method involves looking first at the function table on the left side of the Blackfire
interface.First, sort the table by exclusive time (default sort), and focus on functions in the top
25 only, in this order of importance:
calls coming from your code;
calls coming from third-party libraries
Call Graph Top/Down Approach
This method involves following the critical path on the call graph to better understand how the
code is executed by PHP.
On the call graph, the critical path is composed of all the nodes with a red border. Start at
the main node, then follow its children by navigating the call graph with the mouse.
Example C program. The call graph for this program
int breed_and_release_pandas() {
Panda *baby_panda = malloc(sizeof(Panda));
release_panda(baby_panda);
}
int save_the_pandas() {
stop_deforestation());
if (pandas_are_saved()) {
printf("Stopping deforestation saved the pandas!\n");
return 1;
}
breed_and_release_pandas();
if (pandas_are_saved()) {
printf("Breeding pandas in captivation and releasing them has saved the
pandas!\n");
return 1;
}
return 0;
}
int main(void) {
if (save_the_pandas()) {
printf("The pandas have been saved!\n");
}
}
Example Call Graph. The source code associated with this call graph
RESULT:
Description:
Class diagrams are generally used for conceptual modelling of static view of software
application, and for modelling translating models in to programming code in a detailed Manner.
At time of developing or construction software systems, a class diagram is widely used.
They are also used for data modelling. It is used to show classes, relationships amomg
them,interface,association,etc, class in a class diagram simply is a blueprintof an object. It
simply describes and explaind different type of objects in system, and different types of
relationships that exist between them
RESULT:
Description:
Hospital management system class diagram is a graphical representation of the systems
relationships and classes. ThisUML class diagram was created to assist programmers in the
development of a hospital management system. It includes the class attributes,methods, and
relationships between classes. These contents ensure that your hospital management system
development is in line with that its functions should be
Class diagrams reveal the class structure blueprint of Hospital Mangement system. Also, it is
used to model the items that makeuo the system and depict their relationships lastely, this is to
define the function of an object and the operation it provides.
RESULT:
Viva-Voce Questions
Q. What is computer software?
A. Computer software is a complete package, which includes software program, its documentation and
user guide on how to use the software.
Q. When you know programming, what is the need to learn software engineering concepts?
A. A person who knows how to build a wall may not be good at building an entire house. Likewise, a
person who can write programs may not have knowledge of other concepts of Software Engineering. The
software engineering concepts guide programmers on how to assess requirements of end user, design the
algorithms before actual coding starts, create programs by coding, testing the code and its
documentation.
A. A software project manager is a person who undertakes the responsibility of carrying out the software
project.
Q. What is baseline?
A. Baseline is a measurement that defines completeness of a phase. After all activities associated with a
particular phase are accomplished, the phase is complete and acts as a baseline for next phase.
Q. What is SRS?
A. SRS or Software Requirement Specification is a document produced at the time of requirement
gathering process. It can be also seen as a process of refining requirements and documenting them.
Q. What is modularization?
A. Modularization is a technique to divide a software system into multiple discreet modules, which are
expected to carry out tasks independently.
Q. What is cohesion?
A. Cohesion is a measure that defines the degree of intra-dependability among the elements of the
module.
Q. What is coupling?
A. Coupling is a measure that defines the level of inter-dependability among modules of a program.
Q. What is the difference between function oriented and object oriented design?
A. Function-oriented design is comprised of many smaller sub-systems known as functions. Each
function is capable of performing significant task in the system. Object oriented design works around the
real world objects entities, their classes categories and methods operating on objects functions.
*******