Software engineering practical

LUCKNOW INSTITUTE OF TECHNOLOGY
LUCKNOW
Practical lab
Files
“SOFTWARE ENGINEERING LAB”
Lab code:-RCS 452
Name: - Nitesh Kumar Dubey
Branch:- computer science and engineering
Semester:- 4th

Index
Sr .no Experiment Remarks
1
2
3
4
5
6
7
8
Develop requirements specification for a given
problem.
Develop DFD model (level-0, level-1 DFD and
Data dictionary) of the project.
Develop Structured design for the DFD model
developed.
Develop UML Use case model for a problem.
Develop sequence diagram.
Develop Class diagrams
Use testing tool such as Joint.
Using one project management tool -Libra

Experiment No.1
Objective:
Develop requirements specification for a given problem
Procedure:
Step 1:
Introduction: Purpose
Identify the product whose software requirements are specified in this document. Describe the scope of the
product that is covered by this SRS, particularly if this SRS describes only part of the system or a single
subsystem.Describe the different types of user that the document is intended for, such as developers,
project managers, marketing staff, users, testers, and documentation writers. Describe what the rest of this
SRS contains and how it is organized. Suggest a sequence for reading the document, beginning with the
overview sections and proceeding through the sections that are most pertinent to each reader type.
PROJECT SCOPE
Provide a short description of the software being specified and its purpose, including relevant
benefits, objectives, and goals. Relate the software to corporate goals or business strategies. If a separate
vision and scope document is available, refer to it rather than duplicating its contents here. An SRS that
specifies the next release of an evolving product should contain its own scope statement as a subset of the
long-term strategic product vision.
Step 2:
OVERALL DESCRIPTION :-PRODUCT PERSPECTIVE
Describe the context and origin of the product being specified in this SRS. For example, state
whether this product is a follow-on member of a product family, a replacement for certain existing systems,
or a new, self-contained product. If the SRS defines a component of a larger system, relate the requirements
of the larger system to the functionality of this software and identify interfaces between the two. A simple
diagram that shows the major components of the overall system, subsystem interconnections, and external
interfaces can be helpful.
PRODUCT FEATURES
Summarize the major features the product contains or the significant functions that it performs or
lets the user perform. Only a high level summary is needed here. Organize the functions to make them
understandable to any reader of the SRS. A picture of the major groups of related requirements and how
they relate, such as a top level data flow diagram or a class diagram, is often effective.
USER CLASSES AND CHARACTERISTICS
Identify the various user classes that you anticipate will use this product. User classes may be
differentiated based on frequency of use, subset of product functions used, technical expertise, security or
privilege levels, educational level, or experience. Describe the pertinent characteristics of each user class.
Certain requirements may pertain only to certain user classes. Distinguish the favored user classes from
those who are less important to satisfy.
OPERATING ENVIRONMENT

Describe the environment in which the software will operate, including the hardware platform,
operating system and versions, and any other software components or applications with which it must
peacefully coexist.
DESIGN AND IMPLEMENTATION CONSTRAINTS
Describe any items or issues that will limit the options available to the developers. These might
include: corporate or regulatory policies; hardware limitations (timing requirements, memory
requirements); interfaces to other applications; specific technologies, tools, and databases to be used;
parallel operations; language requirements; communications protocols; security considerations; design
conventions or programming standards (for example, if the customer’s organization will be responsible for
maintaining the delivered software).
STEP 3:
SYSTEM FEATURES
This template illustrates organizing the functional requirements for the product by system features,
the major services provided by the product. You may prefer to organize this section by use case, mode of
operation, user class, object class, functional hierarchy, or combinations of these, whatever makes the most
logical sense for your product.
SYSTEM FEATURE 1
Don’t really say “System Feature 1.” State the feature name in just a few words.
1 Description and Priority
Provide a short description of the feature and indicate whether it is of High, Medium, or
Low priority. You could also include specific priority component ratings, such as benefit,
penalty, cost, and risk (each rated on a relative scale from a low of 1 to a high of 9).
2 Stimulus/Response Sequences
List the sequences of user actions and system responses that stimulate the
behavior defined for this feature. These will correspond to the dialog elements associated
with use cases.
3 Functional Requirements
Itemize the detailed functional requirements associated with this feature. These
are the software capabilities that must be present in order for the user to carry out the
services provided by the feature, or to execute the use case. Include how the product
should respond to anticipated error conditions or invalid inputs. Requirements should be
concise, complete, unambiguous, verifiable, and necessary.
<Each requirement should be uniquely identified with a sequence number or a meaningful tag of
some kind.>
REQ-1:
REQ-2:
STEP 4:
EXTERNAL INTERFACE REQUIREMENTS
USER INTERFACES

Describe the logical characteristics of each interface between the software product and the users.
This may include sample screen images, any GUI standards or product family style guides that are to be
followed, screen layout constraints, standard buttons and functions (e.g., help) that will appear on every
screen, keyboard shortcuts, error message display standards, and so on. Define the software components for
which a user interface is needed. Details of the user interface design should be documented in a separate
user interface specification.
HARDWARE INTERFACES
Describe the logical and physical characteristics of each interface between the software product
and the hardware components of the system. This may include the supported device types, the nature of the
data and control interactions between the software and the hardware, and communication protocols to be
used.
SOFTWARE INTERFACES
Describe the connections between this product and other specific software components (name and
version), including databases, operating systems, tools, libraries, and integrated commercial components.
Identify the data items or messages coming into the system and going out and describe the purpose of each.
Describe the services needed and the nature of communications. Refer to documents that describe detailed
application programming interface protocols. Identify data that will be shared across software components.
If the data sharing mechanism must be implemented in a specific way (for example, use of a global data
area in a multitasking operating system), specify this as an implementation constraint.
COMMUNICATIONS INTERFACES
Describe the requirements associated with any communications functions required by this product,
including e-mail, web browser, network server communications protocols, electronic forms, and so on.
Define any pertinent message formatting. Identify any communication standards that will be used, such as
FTP or HTTP. Specify any communication security or encryption issues, data transfer rates, and
synchronization mechanisms.
NONFUNCTIONAL REQUIREMENTS
PERFORMANCE REQUIREMENTS
If there are performance requirements for the product under various circumstances, state them here
and explain their rationale, to help the developers understand the intent and make suitable design choices.
Specify the timing relationships for real time systems. Make such requirements as specific as possible. You
may need to state performance requirements for individual functional requirements or features.
SAFETY REQUIREMENTS
Specify those requirements that are concerned with possible loss, damage, or harm that could
result from the use of the product. Define any safeguards or actions that must be taken, as well as actions
that must be prevented. Refer to any external policies or regulations that state safety issues that affect the
product’s design or use. Define any safety certifications that must be satisfied.
SECURITY REQUIREMENTS
Specify any requirements regarding security or privacy issues surrounding use of the product or
protection of the data used or created by the product. Define any user identity authentication requirements.
Refer to any external policies or regulations containing security issues that affect the product. Define any
security or privacy certifications that must be satisfied.
SOFTWARE QUALITY ATTRIBUTES

Specify any additional quality characteristics for the product that will be important to either the
customers or the developers. Some to consider are: adaptability, availability, correctness, flexibility,
interoperability, maintainability, portability, reliability, reusability, robustness, testability, and usability.
Write these to be specific, quantitative, and verifiable when possible. At the least, clarify the relative
preferences for various attributes, such as ease of use over ease of learning.
OTHER REQUIREMENTS
Define any other requirements not covered elsewhere in the SRS. This might include database
requirements, internationalization requirements, legal requirements, reuse objectives for the project, and so
on. Add any new sections that are pertinent to the project.

Experiment No. 2
Objective :-
Develop DFD model (level-0, level-1 DFD and Data dictionary) of the project.
OVERALL DESCRIPTION :
Data analysis attempts to answer four specific questions:
 What processes make up a system?
 What data are used in each process?
 What data are stored?
 What data enter and leave the system?
Data drive business activities and can trigger events (e.g. new sales order data) or be processed to provide
information about the activity. Data flow analysis, as the name suggests, follows the flow of data through
business processes and determines how organization objectives are accomplished. In the course of handling
transactions and completing tasks, data are input, processed, stored, retrieved, used, changed and output.
Data flow analysis studies the use of data in each activity and documents the findings in data flow
diagrams, graphically showing the relation between processes and data.
PHYSICAL AND LOGICAL DFDS
There are two types of data flow diagrams, namely physical data flow diagrams and logical data flow
diagrams and it is important to distinguish clearly between the two:
PHYSICAL DATA FLOW DIAGRAMS
An implementation-dependent view of the current system, showing what tasks are carried out and
how they are performed. Physical characteristics can include:
Names of people,Form and document names or numbers,Master and transaction files
Equipment and devices used
LOGICAL DATA FLOW DIAGRAMS
An implementation-independent view of the a system, focusing on the flow of data between processes
without regard for the specific devices, storage locations or people in the system. The physical
characteristics listed above for physical data flow diagrams will not be specified.

Fig. A typical DFD
Data Flow Diagram (DFD)
The DFD (also known as a bubble chart) is a hierarchical graphical model of a system that shows
the different processing activities or functions that the system performs and the data interchange among
these functions. Each function is considered as a processing station (or process) that consumes some input
data and produces some output data. The system is represented in terms of the input data to the system,
various processing carried out on these data, and the output data generated by the system. A DFD model
uses a very limited number of primitive symbols [as shown in fig. 5.1(a)] to represent the functions
performed by a system and the data flow among these functions.
Symbols used for designing DFDs
Here, two examples of data flow that describe input and validation of data are considered.
In Fig. 5.1(b), the two processes are directly connected by a data flow. This means that
the ‘validate-number’ process can start only after the ‘read-number’ process had supplied
data to it. However in Fig 5.1(c), the two processes are connected through a data store.
Hence, the operations of the two bubbles are independent. The first one is termed
‘synchronous’ and the second one ‘asynchronous’.
Importance of DFDs in a good software design
The main reason why the DFD technique is so popular is probably because of the fact that DFD is a very
simple formalism – it is simple to understand and use. Starting with a set of high-level functions that a
system performs, a DFD model hierarchically represents various sub-functions. In fact, any hierarchical
model is simple to understand. Human mind is such that it can easily understand any hierarchical model of
a system – because in a hierarchical model, starting with a very simple and abstract model of a system,
different details of the system are slowly introduced through different hierarchies. The data flow
diagramming technique also follows a very simple set of intuitive concepts and rules. DFD is an elegant
modeling technique that turns out to be useful not only to represent the results of structured analysis of a
software problem, but also for
ORDERS
CUSTOMERS
INVOICES

several other applications such as showing the flow of documents or items in an organization.
Data dictionary
A data dictionary lists all data items appearing in the DFD model of a system. The data
items listed include all data flows and the contents of all data stores appearing on the
DFDs in the DFD model of a system. A data dictionary lists the purpose of all data items
and the definition of all composite data items in terms of their component data items. For
example, a data dictionary entry may represent that the data gross Pay consists of the
components regular Pay and overtime Pay.
Balancing a DFD
The data that flow into or out of a bubble must match the data flow at the next level of
DFD. This is known as balancing a DFD. The concept of balancing a DFD has been
illustrated in fig. 5.3. In the level 1 of the DFD, data items d1 and d3 flow out of the
bubble 0.1 and the data item d2 flows into the bubble 0.1. In the next level, bubble 0.1 is
decomposed. The decomposition is balanced, as d1 and d3 flow out of the level 2
diagram and d2 flows in.

Lab Experiment No.3
Objective:-
Develop Structured design for the DFD model developed.
A DFD model of a system graphically depicts the transformation of the data input to the
system to the final result through a hierarchy of levels. A DFD starts with the most
abstract definition of the system (lowest level) and at each higher level
DFD, more details are successively introduced. To develop a higher-level DFD model,
processes are decomposed input data to these functions and the data output by these
functions and represent them appropriately in the diagram.
If a system has more than 7 high- level functional requirements, then some of the related
requirements have to be combined and represented in the form of a bubble in the level 1
DFD. Such a bubble can be split in the lower DFD levels. If a system has less than three
high-level functional requirements, then some of them need to be split into their sub-
functions so that we have roughly about 5 to 7 bubbles on the diagram.
Decomposition:-
Each bubble in the DFD represents a function performed by the system. The bubbles are
decomposed into sub-functions at the successive levels of the DFD.
Decomposition of a bubble is also known as factoring or exploding a bubble. Each
bubble at any level of DFD is usually decomposed to anything between 3 to 7 bubbles.
Too few bubbles at any level make that level superfluous. For example, if a bubble is
decomposed to just one bubble or two bubbles, then this decomposition becomes
redundant. Also, too many bubbles, i.e. more than 7 bubbles at any level of a DFD makes
the DFD model hard to understand. Decomposition of a bubble should be carried on until
a level is reached at which the function of the bubble can be described using a simple
algorithm.
Numbering of Bubbles:-
It is necessary to number the different bubbles occurring in the DFD. These numbers help
in uniquely identifying any bubble in the DFD by its bubble number. The bubble at the
context level is usually assigned the number 0 to indicate that it is the 0 level DFD.
Bubbles at level 1 are numbered, 0.1, 0.2, 0.3, etc, etc. When a bubble numbered x is
decomposed, its children bubble are numbered x.1, x.2, x.3, etc. In this numbering
scheme, by looking at the number of a bubble we can unambiguously determine its level,
its ancestors, and its successors.
Example:-
A supermarket needs to develop the following software to encourage regular customers.
For this, the customer needs to supply his/her residence address, telephone number, and
the driving license number. Each customer who registers for this scheme is assigned a
unique customer number (CN) by the computer. A customer can present his CN to the
check out staff when he makes any purchase. In this case, the value of his purchase is
credited against his CN. At the end of each year, the supermarket intends to award
surprise gifts to 10 customers who make the highest total purchase over the year. Also, it
intends to award a 22 caret gold coin to every customer whose purchase exceeded
Rs.10,000. The entries against the CN are the reset on the day of every year after the

prize winners’ lists are generated.
prize winners’ lists are generated.

Software engineering practical

Experiment No.4
Develop UML Use case model for a problem
Objective :
To understand the users view of a project using Use case Diagram
Software Required :-
Visual Paradigm for UML 8.2
Procedure :-
You can draw use case diagrams in VP-UML as well as to document the event flows of use cases using the flow-of-
events editor of UML 8.2 .The steps are as follows.
Step 1:
Right click Use Case Diagram on Diagram Navigator and select New Use Case Diagram from the
pop-up menu.
Step 2:-
Enter name for the newly created use case diagram in the text field of pop-up box on the top left corner.
Step 3: Drawing a system

To create a system, select System on the diagram toolbar and then click it on the diagram pane. Finally, name the
newly created system when it is created.
Step 4:
Drawing an actor
To draw an actor, select Actor on the diagram toolbar and then click it on the diagram pane. Finally, name the
newly created actor when it is created.
Step 5 :-
Drawing a use case
Besides creating a use case through diagram toolbar, you can also create it through resource icon.
Move the mouse over a shape and press a resource icon that can create use case. Drag it and then release the mouse
button until it reaches to your preferred place. The source shape and the newly created use case are connected.
Finally, name the newly created use case.

Step 6:-
Create a use case through resource icon
Line wrapping use case name
If a use case is too wide, for a better outlook, you may resize it by dragging the filled selectors. As a result, the name
of use case will be line-wrapped automatically.
Step 7:
Resize a use case
To create an extend relationship, move the mouse over a use case and press its resource iconExtend -> Use Case.
Drag it to your preferred place and then release the mouse button. The use case with extension points and a newly
created use case are connected. After you name the newly created use case, a pop-up dialog box will ask
whether you want the extension point to follow the name of use case. Click Yes if you want it to do so; click NO if
you want to enter another name for extension point.
Step 8:
Create an extend relationship
Drawing <<Include>> relationship
To create an include relationship, mouse over a use case and press its resource icon Include -> Use Case. Drag it to
your preferred place and then release the mouse button. A new use case together with an include relationship is
created. Finally, name the newly created use case.
Step 9:
Include relationship is created
Structuring use cases with package
You can organize use cases with package when there are many of them on the diagram.
Select Package on the diagram toolbar (under Common category).
Step 10:
Create a package
Drag the mouse to create a package surrounding those use cases.

Lab Experiment No.5
“Develop sequence diagram”
Objective :
To understand the interactions between objects that are represented as lifelines in a sequential
order of a project using Sequence Diagram.
Procedure :-
A sequence diagram
is used primarily to show the interactions between objects that are represented as lifelines in a
sequential order.
Step 1:-
Right click Sequence diagram on Diagram Navigator and select New Sequence Diagram from the pop-up menu
to create a sequence diagram.
Step 2:-
Enter name for the newly created sequence diagram in the text field of pop-up box on the top left corner.
Creating actor
To create actor, click Actor on the diagram toolbar and then click on the diagram.

Creating lifeline
To create lifeline, you can click LifeLine on the diagram toolbar and then click on the diagram.
Alternatively, a much quicker and more efficient way is to use the resource-centric interface. Click on the Message -
> LifeLine resource beside an actor/lifeline and drag.
Step 3:-
Move the mouse to empty space of the diagram and then release the mouse button. A new lifeline will be created
and connected to the actor/lifeline with a message.
Auto extending activation
When create message between lifelines/actors, activation will be automatically extended.

Step 4:-
Using sweeper and magnet to manage sequence diagram
Sweeper helps you to move shapes aside to make room for new shapes or connectors. To use sweeper,
click Sweeper on the diagram toolbar (under the Tools category).
The picture below shows the message specify visit time is being swept downwards, thus new room is made for
new messages.
Step 5:-
You can also use magnet to pull shapes together. To use magnet, click Magnet on the
diagram toolbar (under the Tools category).
Magnet
Click on empty space of the diagram and drag towards top, right, bottom or left. Shapes affected will be pulled to
the direction you dragged.
The picture below shows when drag the magnet upwards, shapes below dragged position are pulled upwards.

Experiment No. 6:
Develop Class diagram
Objective:-
To show diagrammatically the objects required and the relationships between them while
developing a software product.
Procedure :-
Step 1:-
Right click Class Diagram on Diagram Navigator and select New Class Diagram from the pop-up menu to create
a class diagram.
Step 2:-
Creating class
To create class, click Class on the diagram toolbar and then click on the diagram.
Creating association
To create association from class, click the Association -> Class resource beside it and drag.
Drag to empty space of the diagram to create a new class, or drag to an existing class to connect to it. Release the
mouse button to create the association.

To create aggregation, use the Aggregation -> Class resource instead.
Step 3:-
To edit multiplicity of an association end, right-click near the association end, select Multiplicityfrom the popup
menu and then select a multiplicity.
To show the direction of an association, right click on it and select Presentation Options > Show Direction from
the pop-up menu.
Step 4:-
The direction arrow is shown beside the association.
Creating generalization
To create generalization from class, click the Generalization -> Class resource beside it and drag.
Drag to empty space of the diagram to create a new class, or drag to an existing class to connect to it. Release the
mouse button to create the generalization.

Creating attribute
To create attribute, right click the class and select Add > Attribute from the pop-up menu.
An attribute is created.
Creating attribute with enter key
After creating an attribute, press the Enter key, another attribute will be created. This method lets you create
multiple attributes quickly and easily.
Creating operation
To create operation, right click the class and select Add > Operation from the pop-up menu.
An operation is created.
Similar to creating attribute, you can press the Enter key to create multiple operations continuously.
Drag-and-Drop reordering, copying and moving of class members

To reorder a class member, select it and drag within the compartment, you will see a thick black line appears
indicating where the class member will be placed.
Release the mouse button, the class member will be reordered.
To copy a class member, select it and drag to the target class while keep pressing the Ctrl key, you will see a thick
black line appears indicating where the class member will be placed. A plus sign is shown beside the mouse cursor
indicating this is a copy action.
Release the mouse button, the class member will be copied.
To move a class member, select it and drag to the target class, you will see a thick black line appears indicating
where the class member will be placed. Unlike copy, do not press the Ctrl key when drag, the mouse cursor without
the plus sign indicates this is a move action.
Release the mouse button, the class member will be moved.
Model name completion for class
The model name completion feature enables quick creation of multiple views for the same class model. When create
or rename class, the list of classes is shown.

Step 5:-
Continue to complete the diagram.
Generalization set
A generalization set defines a particular set of generalization relationships that describe the way
in which a general classifier (or superclass) may be divided using specific subtypes. To define a generalization set,
select the generalizations to include, right click and select Generalization set > Create Generalization Set... from the
popup menu.

Step 6:-
Name the set in the Manage Generalization Sets dialog box, and confirm by pressing OK.
The selected generalizations are grouped. Adjust the connector to make the diagram tidy.
Repeat the steps for other generalizations.
.

Lab Experiment No.7
Objective :-
Use testing tool such as Junit.
Testing is the process of checking the functionality of the application whether it is
working as per requirements and to ensure that at developer level, unit testing
comes into picture. Unit testing is the testing of single entity (class or method).
Unit testing is very essential to every software company to give a quality product
to their customers.
Unit testing can be done in two ways
Manual testing Automated testing
Executing the test cases manually without any tool support
is known as manual testing.
 Time consuming and tedious: Since test cases are
executed by human resources so it is very slow
and tedious.
 Huge investment in human resources: As test
cases need to be executed manually so more
testers are required in manual testing.
 Less reliable: Manual testing is less reliable as
tests may not be performed with precision each
time because of human errors.
 Non-programmable: No programming can be done
to write sophisticated tests which fetch hidden
information.
Taking tool support and executing the test cases by
using automation tool is known as automation testing.
 Fast Automation runs test cases significantly
faster than human resources.
 Less investment in human resources:Test
cases are executed by using automation tool so
less tester are required in automation testing.
 More reliable: Automation tests perform
precisely same operation each time they are
run.
 Programmable: Testers can program
sophisticated tests to bring out hidden
information.
WHAT IS JUNIT ?
JUnit is a unit testing framework for the Java Programming Language. It is important in the test driven development,
and is one of a family of unit testing frameworks collectively known as xUnit.
JUnit promotes the idea of "first testing then coding", which emphasis on setting up the test data for a piece of code
which can be tested first and then can be implemented . This approach is like "test a little, code a little, test a little,
code a little..." which increases programmer productivity and stability of program code that reduces programmer
stress and the time spent on debugging.
FEATURES
 JUnit is an open source framework which is used for writing & running tests.

 Provides Annotation to identify the test methods.
 Provides Assertions for testing expected results.
 Provides Test runners for running tests.
 JUnit tests allow you to write code faster which increasing quality
 JUnit is elegantly simple. It is less complex & takes less time.
 JUnit tests can be run automatically and they check their own results and provide immediate feedback.
There's no need to manually comb through a report of test results.
 JUnit tests can be organized into test suites containing test cases and even other test suites.
 Junit shows test progress in a bar that is green if test is going fine and it turns red when a test fails
WHAT IS A UNIT TEST CASE ?
A Unit Test Case is a part of code which ensures that the another part of code (method) works as expected. To
achieve those desired results quickly, test framework is required .JUnit is perfect unit test framework for java
programming language.
A formal written unit test case is characterized by a known input and by an expected output, which is worked out
before the test is executed. The known input should test a precondition and the expected output should test a
postcondition.
There must be at least two unit test cases for each requirement: one positive test and one negative test. If a
requirement has sub-requirements, each sub-requirement must have at least two test cases as positive and negative.
ONLINE
You really do not need to set up your own environment to start learning Java &JUnit programming
language. Reason is very simple, we already have setup Java Programming environment online, so
that you can compile and execute all the available examples online at the same time when you are
doing your theory work. This gives you confidence in what you are reading and to check the result
with different options. Feel free to modify any example and execute it online.
Try following example using Try it option available at the top right corner of the below sample code
box:
public class MyFirstJavaProgram {
public static void main(String []args) {
System.out.println("Hello World");
}
} .
LOCAL ENVIRONMENT SETUP
JUnit is a framework for Java, so the very first requirement is to have JDK installed in your machine.
SYSTEM REQUIREMENT

JDK 1.5 or above.
Memory no minimum requirement.
Disk Space no minimum requirement.
Operating System no minimum requirement.
STEP 1 - VERIFY JAVA INSTALLATION IN YOUR MACHINE
Now open console and execute the following java command.
OS Task Command
Windows Open Command Console c:> java –version
Linux Open Command Terminal $ java –version
Mac Open Terminal machine:~ joseph$ java -version
Let's verify the output for all the operating systems:
OS Output
Windows
java version "1.6.0_21"
Java(TM) SE Runtime Environment (build 1.6.0_21-b07)
Java HotSpot(TM) Client VM (build 17.0-b17, mixed mode, sharing)
Linux
Java HotSpot(TM) Client VM (build 17.0-b17, mixed mode, sharing)
Mac
Java HotSpot(TM)64-Bit Server VM (build 17.0-b17, mixed mode, sharing)
STEP 2: SET JAVA ENVIRONMENT
Set the JAVA_HOME environment variable to point to the base directory location where Java is installed on your
machine. For example
Windows Set the environment variable JAVA_HOME to C:Program FilesJavajdk1.6.0_21
Linux export JAVA_HOME=/usr/local/java-current
Mac export JAVA_HOME=/Library/Java/Home
Append Java compiler location to System Path.

OS Output
Windows Append the string ;C:Program FilesJavajdk1.6.0_21bin to the end of the system variable, Path.
Linux export PATH=$PATH:$JAVA_HOME/bin/
Mac not required
Verify Java Installation using java -version command explained above.
STEP 3: VERIFY THE RESULT
Compile the classes using javac compiler as follows
C:JUNIT_WORKSPACE>javac TestJunit.java TestRunner.java
Now run the Test Runner to see the result
C:JUNIT_WORKSPACE>java Test Runner
Verify the output.

EXPERIMENT NO-8
Objective:-
Using configuration management tool-libra
INSTALLATION AND USE
The Libra features can be installed from the p2 repository of the Indigo Simultaenous Release (since
Indigo M6). As a prerequisite you may install Eclipse IDE for Java EE Developers.
The update site contains:
 OSGi Bundle Facet feature that introduces:
1. A new facet OSGi Bundle for Dynamic Web, JPA and Utility projects.
2. Wizard for converting WTP standard projects to OSGi Enterprise bundle projects:
 Dynamic Web projects to Web Application Bundle projects
 JPA projects to Persistent Bundle projects
 Utility projects and simple Java projects to OSGi Bundle projects
Both options modify project's MANIFEST.MF in order to become a valid OSGi bundle.
The facet may be enabled during the project creation or after that from the Properties page of the project.
The wizard is available from project's context menu Configure > Convert to OSGi Bundle Projects...
Note that you may need to adjust your target platform accordingly.
 WAR Products feature which provides WAR deployment for Equinox based applications
CREATE NEW WEB APPLICATION BUNDLE
1. Call the New Dymanic Web Project wizard: New > Project... > Web > Dynamic Web Project
2. Enter the necessary project information like Project name, Target runtime, etc.
3. Add the OSGi Bundle facet in the Configuration:
1. Click on the Modify... button in the Configuration group.
2. Choose the OSGi Bundle facet in the Project Facets dialog and click OK.
4. Click Finish to create the Web Application Bundle project.
CREATE NEW OSGI BUNDLE
1. Call the New Faceted Project wizard: New > Project... > General > Faceted Project
2. Enter the necessary project information like Project name.
3. Click the Next button.
4. Select the OSGi Bundle and Java facets.
5. Click Finish to create the OSGi Bundle project.

OBTAINING SOURCES
You can find the sources available in Git repository
In order to synchronize them locally, you may use the EGit step-by-step procedure.
The EGit/User Guide provides detailed instruction how to work with EGit.
UPDATING/INSTALLING EGIT
 Start your Eclipse IDE and navigate to Help->Install New Software->Add...
 Enter the software update site [1]
 Select the Eclipse EGit (Incubation) and Eclipse JGit (Incubation) and choose Next> to finish
the installation.
During the installation you will be asked to accept the License Agreements.
IDENTIFYING YOURSELF
To identify yourself, follow these instructions these instructions
SETTING UP THE HOME DIRECTORY ON WINDOWS
To set up the HOME directory, go through these steps
CONFIGURING SSH IN ECLIPSE
To configure ssh, proceed as follows.
CLONE GIT REPOSITORY
 Open the Git Repository Exploring perspective and in the Git Repositories view choose the
Clone a Git Repository toolbar button
 In the URI field of the opened Clone Git Repository wizard enter the URI of the libra git
repository: [2] and choose Next
 Select the added repository and from its context menu choose Import Projects...
 Expand the repository tree to Remote Tracking level, select the remote branch origin/master
and from its context menu choose Create Branch... to create a new local branch
UPDATING SOURCES
To keep the sources up to date you have to pull the new changes from the upstream branch.
BUILD INFRASTRUCTURE
The build is based on Maven (at least 3.0.0) and Tycho, executed on the Hudson server, hosted at Eclipse
Foundation.
There are two Hudson jobs available for Libra:

 libra - for building the master git branch.
 libra-indigo - for building the indigo git branch.
MAVEN BUILD SEQUENCE
Complete build sequence for a clean build (assuming $M2_HOME/bin is on the path and local Maven
repository at ~/.m2/repository):
[~/org.eclipse.libra/development/org.eclipse.libra.releng] $ mvn clean install
Note that you may need to configure your proxy settings
PROPOSING AND COMMITTING A PATCH
The patch file contains a description of changes of a set of resources which can be automatically applied
to another eclipse workspace or git repository. If you want to propose or commit a patch you need to
know that the Eclipse update hook will examine the Committer's entries of an incoming push. All the
committer's entries have to be made by the committer performing the push, otherwise the push will fail.
Furthermore, your committer ID, or the committer e-mail address registered with your committer account
at the Eclipse Foundation must be present in the Committer Email record. For more information on that
restriction see: this page.
PROPOSING A PATCH
If you want commit a change on a local feature or bugfix branch and then to export this change into a
patch file, follow the steps below:
1. Open a bug
 Specify the bug component (General; OSGi Facet or WAR)
 Complete the fields about the product version, bug severity, type of your hardware,
operating systems and write a summary and description of the patch
2. Open the History view of your Eclipse IDE and choose Create Patch... (The patch file will
contain the difference between the commit and its parent in the history view. Note that the filter of
the history view applies also for patch creation.)
3. Start the Patch Wizard, select the location of the patch and choose Next (The name of the patch
file is created from the first line of the commit message.)
4. Change the patch format, if necessary.
5. Attach the patch created to the bug
6. Submit the bug

Software engineering practical

More Related Content

What's hot (20)

Similar to Software engineering practical (20)

More from Nitesh Dubey (20)

Recently uploaded (20)

Software engineering practical