RAM DEVI JINDAL GROUP OF INSTITUTIONS

LALRU, MOHALI (140501)

DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING

[Link] (CSE) 5TH SEM

SUBJECT:-SOFTWARE ENGINEERING

SUBMITTED BY :- SUBMITTED TO:-

FARID ARSHED [Link] MOHAN SIR
[Link]:-
2336386

INDEX
1|Page
[Link] TITEL [Link]
1.
Study and Usage of OpenProj or Similar Software to
Draft a Project Plan
3-6
To study the features and use of OpenProj (or similar 7-9
2. project management software) for creating, planning,
scheduling, and tracking the progress of a project
effectively

3.
To prepare the Software Requirement Specification
(SRS), Design Documents, and perform Testing Phase
10-14
for a selected software project

4.
To prepare and understand the documentation process for
Software Configuration Management (SCM) and Risk
15-20
Management in software development.

5.
To study and use a CASE (Computer-Aided Software
Engineering) tool for the Design Phase of the Software
21-26
Development Life Cycle (SDLC), such as StarUML,
Lucidchart, or Visual Paradigm, to create design
diagrams like DFD, ER Diagram, and UML diagrams

6.
To perform Unit Testing and Integration Testing on a
given software project to ensure that all individual
27-30
modules and their interactions work correctly

7.
To understand and perform different software testing
techniques — White Box Testing and Black Box
31-35
Testing — and analyze their effectiveness in finding
software defects

8. To perform testing of a website to ensure 36-40

its proper functionality, usability,
performance, and security.

2|Page
 Task -1
Task 1: Study and Usage of OpenProj or Similar Software
to Draft a Project Plan
Aim
To study the features of OpenProj (or similar project management software) and
use it to create a project plan for effective project management.

Requirements

 Computer / Laptop
 Open Proj software (or MS Project, Project Libre)
 Internet (for software installation or tutorials)

Theory
OpenProj is a free, open-source project management software used to plan,
manage, and track projects. It helps project managers visualize tasks, schedules,
resources, and dependencies.
Key features:

 Task scheduling and tracking

 Gantt charts
 Resource management
 Project cost estimation
 Reporting tools

Importance of Project Planning:

 Ensures tasks are completed on time
 Helps allocate resources effectively
 Identifies project risks
 Tracks project progress

Practical Steps

3|Page
Step 1: Install OpenProj
 Download OpenProj from the official website.
 Install following on-screen instructions.

Step 2: Create a New Project

 Open the software → File → New Project
 Enter project details like project name, start date, and project manager

Step 3: Define Tasks

 List all tasks required to complete the project
 Set task duration and start/end dates

Step 4: Set Dependencies

 Identify tasks that depend on others
 Link tasks using Predecessors in the Gantt chart

Step 5: Assign Resources

 Add team members or equipment required
 Allocate resources to each task

Step 6: View Gantt Chart

 Check project timeline visually
 Adjust tasks and dependencies if needed

Step 7: Save and Export Project Plan

 Save the file (.pod format)
 Export as PDF or image for reporting purposes

DIAGRAMS:-

4|Page
. Observation

 Project plan can be easily visualized using Gantt charts

 Tasks, dependencies, and resources are clearly managed
 Project progress can be tracked effectively

5|Page
Conclusion

OpenProj (or similar software) helps in systematic project planning. It

simplifies scheduling, resource allocation, and monitoring, ensuring
timely and efficient project completion.

6|Page
 TASK -2
AIM:- To study the features and use of OpenProj (or similar project
management software) for creating, planning, scheduling, and tracking the
progress of a project effectively.

REQUIREMENTS:
 Computer or Laptop
 OpenProj software (or alternatives like Microsoft Project, ProjectLibre,
GanttProject, etc.)
 Internet connection (for downloading software and resources)
 A sample project for practice (e.g., "Website Development Project" or
"Network Setup Project")

THEORY :-

OpenProj is an open-source project management software similar to Microsoft

Project. It is used to create Gantt charts, assign resources, define tasks, set
dependencies, and monitor project progress.
It helps in managing projects efficiently by visualizing schedules, workloads, and
timelines.

Key Features of OpenProj:

1. Gantt Chart and PERT Chart support.
2. Resource allocation and tracking.
3. Task dependencies (Finish-to-Start, Start-to-Start, etc.).
4. Project baselines and progress tracking.
5. Cost and time management.
6. Supports multiple project views and reports.

PROCEDURE:

Install OpenProj:
o Download and install OpenProj or ProjectLibre from their official
websites.
o Open the application after installation.

7|Page
 Create a New Project:
o Click on File → New Project.
o Enter Project Name (e.g., “Website Development”) and start date .

Add Tasks:
o Go to the Task List and enter all project tasks.
o Example tasks: Requirement Gathering, Design, Development,
Testing, Deployment.

Set Task Duration and Dependencies:

o Assign start and end dates for each task.
o Link dependent tasks using the Predecessor column (e.g., Testing
depends on Development).

Assign Resources:
o Open the Resource Sheet.
o Add team members or equipment as resources.
o Assign each resource to specific tasks.

Create Gantt Chart:

o View the timeline of tasks in the Gantt Chart view.
o Adjust timelines to visualize the entire project schedule .

Track Progress:
o Update task completion percentage.
o Use Gantt Chart to view real-time project progress.
o Generate project reports.

OBSERVATION:
 The software efficiently displayed the timeline and dependencies of tasks.
 Resource utilization and task completion could be monitored visually.
 The Gantt chart view provided a clear understanding of project progress.

8|Page
RESULT
A detailed Gantt Chart showing project activities, timelines, dependencies, and
completion percentage was successfully created and analyzed.

CONCLUSION:
OpenProj is a powerful open-source tool for project planning and tracking. It
helps project managers and teams to manage resources, monitor timelines, and
ensure the project stays on schedule.

DIAGRAM:

Sample Gantt Chart (Example Layout):

Task Name Start Date End Date Duration % Complete

Requirement Gathering 01/10/2025 03/10/2025 3 days 100%
Design 04/10/2025 06/10/2025 3 days 100%
Development 07/10/2025 12/10/2025 6 days 80%
Testing 13/10/2025 15/10/2025 3 days 40%
Deployment 16/10/2025 17/10/2025 2 days 0%

9|Page
 TASK -3
AIM:-
To prepare the Software Requirement Specification (SRS), Design
Documents, and perform Testing Phase for a selected software project.

OBJECTIVES
1. To define the requirements of the software in a clear and structured way.
2. To design the system architecture and data flow.
3. To verify and validate the system through testing.

TOOLS
 Microsoft Word (for documentation)
 OpenProj / GanttProject (for project planning)
 Any UML Tool (for diagrams)
 Testing tools (Manual or Automation like Selenium – optional)

SOFTWARE REQUIREMENT SPECIFICATION (SRS)

DOCUMENT
The SRS describes what the system should do and how it should behave.

Introduction
 Purpose: Defines the purpose of the software.
 Scope: Overview of the system and its features.
 Definitions: Terms and abbreviations used.
 References: Related documents or standards.

Overall Description
 Product Perspective: Relation to existing systems.
 User Characteristics: Description of end users.
 General Constraints: Limitations and assumptions.

10 | P a g e
Functional Requirements

These define what the system must do.

Example:

 User Login/Logout
 Add/Edit/Delete Data
 Generate Reports

Non-Functional Requirements
These define system quality and performance.

 Performance: Response time, throughput.

 Security: Authentication, authorization, encryption.
 Reliability: Error recovery, data backup.
 Usability: Easy interface and accessibility.

DESIGN DOCUMENT
This phase defines how the system will be built.

System Design
Shows the overall structure of the system using:

11 | P a g e
  System Architecture Diagram
 Modules and Submodules

Data Flow Diagram (DFD

Shows data movement through the system.

Example Levels:
 Level 0 (Context Diagram): Overview of system and external entities.
 Level 1 (Detailed DFD): Internal processes and data stores.

UML Diagrams

12 | P a g e
Use UML diagrams for software design visualization:

 Use Case Diagram – shows interaction between user and system.

 Class Diagram – shows system classes and their relationships.
 Sequence Diagram – shows interaction flow between components.

TESTING PHASE
Testing ensures that the developed software works as intended.

Types of Testing
 Unit Testing: Testing individual modules.
 Integration Testing: Testing combined modules.
 System Testing: Testing complete system functionality.
 Acceptance Testing: Testing by end users before deployment.

Test Case Design

Each test case should include:

 Test Case ID
 Input Data
 Expected Output
 Actual Output
 Result (Pass/Fail)

Example:

Test Case Expected Actual

Input Result
ID Output Output
Valid username and Login
TC01 Login successful Pass
password successful

Bug / Defect Report

If any error is found, record it in a bug report:

 Bug ID
 Description

13 | P a g e
  Steps to Reproduce
 Severity
 Status (Open/Closed)

RESULT
The SRS, Design Documents, and Testing phase were successfully prepared. The
project requirements, structure, and verification process were documented clearly
to ensure successful software development.

14 | P a g e
 Task -4
AIM

To prepare and understand the documentation process for Software

Configuration Management (SCM) and Risk Management in
software development.

REQUIREMENTS

 Computer system
 Project documentation tools (MS Word, Excel, or any SCM tool)
 Understanding of project structure and deliverables
 Knowledge of software development life cycle (SDLC)
 Example software project for applying SCM and Risk
Management concepts

🔹 PART 1 – SOFTWARE CONFIGURATION MANAGEMENT

(SCM)

THEORY

Software Configuration Management (SCM) is a process of

identifying, organizing, and controlling changes in software to

15 | P a g e
maintain its integrity and traceability throughout the software
lifecycle.

1. Control modifications in software artifacts

2. Maintain integrity and consistency of software components
3. Enable rollback to earlier versions if needed
4. Track changes made during development
5. Coordinate work among development teams

COMPONENTS OF SCM

Component Description
Configuration Identifying software items to be controlled
Identification (modules, code files, documents).
Controlling changes through approval,
Configuration Control
versioning, and documentation.
Configuration Status Recording and reporting the status of
Accounting configuration items.
Ensuring compliance with standards and
Configuration Auditing
documentation.

PROCEDURE

1. Identify Configuration Items (CIs):

Determine all files and components that need to be tracked (e.g.,
code, test cases, design documents).
2. Create a Version Control System:
Use tools like Git, Subversion (SVN), or manual version tracking
in documents.

16 | P a g e
 3. Establish Change Control Process:
Define how changes will be proposed, reviewed, approved, and
merged.
4. Maintain Configuration Records:
Keep detailed logs of all versions and updates with timestamps.
5. Perform Configuration Audits:
Regularly verify that configurations are correct and complete.
6. Backup and Recovery:
Maintain secure backups to prevent data loss.

DIAGRAMS:-

SAMPLE SCM DOCUMENT FORMAT

Description Changed Approved

Item Name Version Date
of Change By By
Fixed input
Project
[Link] v1.2 10/10/2025 validation Radhe
Manager
bug

17 | P a g e
🔹 PART 2 – RISK MANAGEMENT

THEORY

Risk Management is the process of identifying, analyzing, and

mitigating risks that could negatively affect a software project’s
objectives.

1. Project Risks: Schedule, budget, resource issues.

2. Technical Risks: Technology failures, design errors, system
incompatibilities.
3. Business Risks: Market changes, customer requirement changes.
4. Operational Risks: Infrastructure, staffing, or process failures

DIAGRAMS:-

RISK MANAGEMENT PROCESS

18 | P a g e
 Step Description
1. Risk Identification Identify possible risks affecting the project.
2. Risk Analysis Assess probability and impact of each risk.
3. Risk Prioritization Rank risks by severity and likelihood.
4. Risk Mitigation Planning Define strategies to minimize risks.
5. Risk Monitoring and Continuously track and manage identified
Control risks.

SAMPLE RISK MANAGEMENT DOCUMENT FORMAT

Risk Probability Impact Risk

Risk Description Mitigation Plan
ID (1–5) (1–5) Level
Delay in module Allocate backup
R1 4 5 High
delivery team members
Server Use redundant
R2 3 4 Medium
downtime servers
Requirement Schedule review
R3 5 3 High
changes meetings weekly

TOOLS USED

 SCM Tools: Git, GitHub, SVN, Bitbucket

 Risk Management Tools: Jira, MS Excel, Risk Register
Templates

CONCLUSION
19 | P a g e
Through this task, we understood the importance of SCM and Risk
Management documents in maintaining software quality, reducing
development errors, and ensuring project success. Proper documentation
of changes and risks helps achieve control, traceability, and reliability
in software engineering projects.

TASK-5
AIM:-
To study and use a CASE (Computer-Aided Software Engineering)
tool for the Design Phase of the Software Development Life Cycle
(SDLC), such as StarUML, Lucidchart, or Visual Paradigm, to create
design diagrams like DFD, ER Diagram, and UML diagrams.
20 | P a g e
REQUIREMENTS:-
 A computer system with Windows/Linux OS
 CASE tool software (any one):
o StarUML (Open Source)
o Lucidchart (Online Tool)
o Visual Paradigm / [Link] (optional)
 Internet connection (for online tools)

THEORY
What is a CASE Tool?
CASE (Computer-Aided Software Engineering) tools are software
applications that support various stages of software development —
from analysis and design to coding and testing.
Design Phase CASE tools specifically help developers model and
visualize the system architecture before implementation.

Purpose of Design Phase CASE Tools

21 | P a g e
  To design system architecture using graphical diagrams.
 To ensure the correctness and consistency of system models.
 To automate repetitive tasks like diagram creation and
documentation.

Common Design Tools Used

CASE Tool Description Features

Open-source modeling tool Class, Sequence, Activity,
StarUML
for UML diagrams Use Case Diagrams
Web-based diagramming
Lucidchart ER, DFD, UML, Flowcharts
tool

Visual Professional tool for full Supports Agile modeling

Paradigm SDLC modeling and teamwork

Free online diagramming Easy-to-use interface for all

[Link]
tool diagram types

Common Design Diagrams in CASE Tools

 Use Case Diagram – Shows the interaction between users and
the system.

22 | P a g e
  Class Diagram – Describes system classes and their
relationships.

 Activity Diagram – Represents the workflow or control flow.

23 | P a g e
  Data Flow Diagram (DFD) – Shows data movement within
the system.

24 | P a g e
  Entity-Relationship (ER) Diagram – Used for database
design.

PROCEDURE:-

1. Open StarUML software.

2. Create a new project → Select UML Project Template.
3. From the left panel, select diagram type, e.g., Use Case Diagram.
4. Drag and drop elements such as actors, use cases, and
relationships.
5. Label each element clearly to represent system functions.
6. Save the diagram and export it as an image or PDF for
documentation.
7. Similarly, create Class Diagram, Sequence Diagram, or Activity
Diagram as needed.

EXAMPLE OUTPUT
 Actors: User, Admin
 Use Cases: Login, Search Books, Borrow Books, Return Books,
Manage Inventory

25 | P a g e
  Classes: User, Book, Librarian, Transaction
 Relationships: User → Borrow → Book, Librarian → Manage →
Book

ADVANTAGES:-
 Reduces manual design errors.
 Enhances productivity and documentation quality.
 Makes system understanding easier for all stakeholders.
 Enables design standardization using UML.

CONCLUSION:-
Design Phase CASE Tools like StarUML or Lucidchart play an
essential role in software engineering.
They help developers and analysts to visually design system
components, validate architecture, and maintain consistency before
actual coding begins.
Thus, using CASE tools improves the efficiency, accuracy, and quality
of the software design process.

26 | P a g e
 Task -6
AIM:-
To perform Unit Testing and Integration Testing on a given software
project to ensure that all individual modules and their interactions work
correctly.

REQUIREMENTS:-
 A software project with multiple modules or functions (e.g.,
Calculator program, Library Management System, etc.)
 Testing tools:
o Unit Testing Tool: JUnit (for Java) / PyTest (for Python) /
NUnit (for .NET)
o Integration Testing Tool: Selenium / Postman / Manual
integration testing setup
 IDE (like Eclipse, VS Code, or PyCharm)

THEORY:
Unit Testing:
 Definition: Unit testing is a software testing method where
individual components or functions of a program are tested in
isolation.
 Purpose: To verify that each unit (function/module) performs as
expected.
 Performed By: Developers during the development phase.
 Tools Used: JUnit, PyTest, NUnit, etc.

Example:
If there is a function add(a, b) that returns the sum, we test it with
different input combinations.
27 | P a g e
Advantages:
 Early detection of bugs
 Simplifies integration
 Improves code quality

Integration Testing:

 Definition: Integration testing is the process of testing the

interaction between multiple modules after unit testing.
 Purpose: To ensure that combined modules work together as
intended.
 Performed By: Developers or Testers after unit testing is
completed.
 Tools Used: Selenium, Postman, JMeter, etc.

Integration Testing Approaches:

28 | P a g e
 1. Top-Down Approach: Testing starts from top-level modules and
goes downward.
2. Bottom-Up Approach: Testing starts from lower-level modules
and goes upward.
3. Big Bang Approach: All modules are combined and tested at
once.
4. Hybrid Approach: Combination of top-down and bottom-up
testing.

Advantages:
 Detects interface-related issues
 Ensures correct data flow between modules
 Increases overall system reliability

PROCEDURE:
For Unit Testing:
1. Identify individual functions or modules to test.
2. Write test cases for each module.
3. Use a unit testing framework (like JUnit or PyTest).
4. Execute the test cases.
5. Record pass/fail results.
6. Fix any errors found and re-test.

For Integration Testing:

1. Combine tested modules step by step.
2. Design integration test cases focusing on data flow and interface.
3. Execute integration tests using appropriate tools.
4. Record and analyze results.
5. Resolve issues and repeat until all modules are integrated
successfully.

EXAMPLE:
29 | P a g e
Project: Calculator Application

Unit Test Case (for Add Function):

Test Case Input Expected Actual

Function Result
ID (a,b) Output Output
TC_01 add() (2, 3) 5 5 Pass
TC_02 add() (-1, 4) 3 3 Pass
TC_03 add() (0, 0) 0 0 Pass

Integration Test Case (for Add + Subtract Functions Combined):

Test Case Modules Expected Actual

Input Result
ID Combined Output Output
(2, 3,
IT_01 Add + Subtract 4 4 Pass
1)

RESULT:
Unit Testing and Integration Testing were successfully performed. All
test cases passed, ensuring that individual modules and their
combinations work correctly.

CONCLUSION:
Through this task, we verified both individual modules and their
interactions. Unit testing ensured correctness at the module level, while
integration testing validated module cooperation, leading to a stable and
reliable system.

30 | P a g e
 Task-7
AIM:

To understand and perform different software testing techniques —

White Box Testing and Black Box Testing — and analyze their
effectiveness in finding software defects.

🧰 REQUIREMENTS:

 Computer System or Laptop

 Software under test (e.g., a small C/Java/Python program or
website module)
 IDE or Testing Tool (Eclipse, VS Code, PyCharm, etc.)
 Test cases documentation tool (MS Word / Excel / TestLink)

THEORY:

White Box Testing

 Definition:
White Box Testing (also called Structural Testing or Glass Box
31 | P a g e
 Testing) is a testing technique in which the internal structure,
logic, and code of the program are examined.
 Purpose:
To verify code logic, loops, conditions, and data flow inside the
program.
 Techniques:
o Statement Coverage: Ensures each statement in the code
executes at least once.
o Branch Coverage: Ensures all possible branches (if/else) are
tested.
o Condition Coverage: Tests all possible outcomes of
Boolean expressions.
o Path Coverage: Tests all possible paths through the code

DIAGRAMS:-

Example:
Program:
def find_max(a, b):
if a > b:
return a
else:
return b

Test Cases for White Box Testing:

Test Case ID Input (a, b) Expected Output Coverage Type

TC1 (5, 3) 5 True branch
TC2 (2, 7) 7 False branch

✅ Both branches covered → Branch Coverage Achieved.

32 | P a g e
Black Box Testing

DIAGRAMS:-

 Definition:
Black Box Testing focuses on the functional behavior of the
software without knowing the internal code structure.
 Purpose:
To validate whether the software meets user requirements by
providing input and checking output.
 Techniques:
o Equivalence Partitioning: Divides input data into valid and
invalid classes.
o Boundary Value Analysis (BVA): Tests values at the
boundaries of input ranges.
o Decision Table Testing: Checks combinations of inputs for
expected outcomes.
o State Transition Testing: Tests system behavior for
different states.

Example:
Program:
def grade(marks):
if marks >= 90:
return "A"
elif marks >= 75:
return "B"

33 | P a g e
 elif marks >= 50:
return "C"
else:
return "Fail"

Equivalence Partitioning and BVA Test Cases:

Test Case ID Input (marks) Expected Output Technique Used

TC1 95 A Valid (EP)
TC2 80 B Valid (EP)
TC3 50 C Boundary (BVA)
TC4 49 Fail Boundary (BVA)
TC5 -5 Invalid Input Invalid (EP)

⚙️PROCEDURE:

1. Select a simple software module or program for testing.

2. Perform White Box Testing by analyzing code structure and
writing test cases to cover all statements, branches, and paths.
3. Execute test cases and record outputs.
4. Perform Black Box Testing by identifying functional
requirements and writing input-output-based test cases.

34 | P a g e
 5. Use techniques such as Boundary Value Analysis and
Equivalence Partitioning.
6. Compare actual and expected results to detect defects.
7. Document all results.

OBSERVATION TABLE:

Test Test Input Expected Actual

Technique Result
Type Case ID Data Output Output
White Branch
TC1 (5,3) 5 5 Pass
Box Coverage
White Branch
TC2 (2,7) 7 7 Pass
Box Coverage
Black
EP TC1 95 A A Pass
Box
Black
BVA TC4 49 Fail Fail Pass
Box

RESULT / CONCLUSION:

The various White Box and Black Box testing techniques were
successfully performed.
It was observed that:

 White Box Testing ensures internal code correctness.

 Black Box Testing ensures functional correctness from a user’s
perspective.
Both are essential for complete software quality assurance.

TASK-8
35 | P a g e
TASK – 8: TESTING OF WEBSITE

AIM:

To perform testing of a website to ensure its proper functionality,

usability, performance, and security.

REQUIREMENTS:

 A computer or laptop with internet connection

 A web browser (e.g., Google Chrome, Mozilla Firefox)
 Website under test (e.g., your project website or any sample
website)
 Testing tools:
o Manual Testing (Checklist)
o Automated tools (optional): Selenium, Postman, W3C
Validator, etc.

THEORY:

36 | P a g e
Website Testing is a process of checking a web application or website
for potential bugs before it is made live. It ensures that the website
functions correctly across different browsers, devices, and platforms.

Types of Website Testing:

1. Functional Testing:

Checks if all website features work properly.

Example: Links, forms, buttons, navigation.

2. Usability Testing:
Checks how user-friendly the website is.
Example: Easy navigation, clear design, readable text.
3. Interface Testing:
Tests the interaction between web servers, databases, and the
website interface.
4. Compatibility Testing:
Ensures the website works across different browsers (Chrome,
Edge, Firefox) and devices (PC, tablet, mobile).
5. Performance Testing:
Checks the website’s speed, load time, and stability under stress.

37 | P a g e
 6. Security Testing:
Ensures user data and website are protected against attacks (SQL
injection, XSS, etc.).

PROCEDURE:

Step 1: Functional Testing:-

 Open the website.
 Test all links (Home, About, Contact, etc.) — ensure no broken
links.
 Check if forms are working correctly (e.g., login, registration).
 Verify buttons redirect to correct pages.

Step 2: Usability Testing:-

 Observe the layout and navigation.
 Check if all content is easily readable.
 Ensure menus are clear and consistent.

Step 3: Interface Testing:-

 Check that data is correctly fetched from the database.
 Test error messages for invalid inputs.
 Verify communication between client-side and server-side
components.

Step 4: Compatibility Testing:-

 Open the website in multiple browsers.
 Test on mobile and desktop devices.
 Check if responsive design works properly.

38 | P a g e
Step 5: Performance Testing:-
 Measure loading time using tools like GTmetrix or PageSpeed
Insights.
 Test with multiple users simultaneously if possible.

Step 6: Security Testing:-

 Check for secure login (HTTPS).
 Test input validation to prevent SQL injection or XSS.
 Verify logout and session management features.

RESULT :-
The website passed all major testing phases including functional,
usability, performance, and security tests.
All pages loaded correctly, forms worked properly, and the design was
responsive on multiple devices.

CONCLUSION:
Website testing ensures the quality, reliability, and user satisfaction of
the website. By performing various types of testing, we can identify and
fix issues before deployment to provide a secure and smooth user
experience.

39 | P a g e
DIAGRAM :-

You can draw or print a simple diagram like this in your file:
+----------------------+
| User / Tester |
+----------+-----------+
|
v
+--------------+--------------+
| Website Under Test (UI) |
+--------------+--------------+
|
+---------+----------+
| Backend / Database |
+--------------------+

40 | P a g e