ATM SIMUATION

A PROJECT REPORT SUBMITTED IN PARTIAL FULFILL MENT

OF THEREQUIREMENT FOR THE AWARD OF THEE YEAR
DIPLOMA
IN
Computer Engineering

AMBEDKAR POLYTECHNIC
GOVERNMENT OF NCT OF DELHI
BOARD OF TRAINING AND TECHNICAL EDUCATION
DELHI: - 110092
SESSION: 2012 - 2015

UNDER SUPERVISION OF SUBMITTED BY:

Mr. H.S. Bhatia ROHIT NANDAN SHAKYA
(HOD OF C.E.) BTE Roll No: - 325252
 CERTIFICATE

This is to certify that ROHIT NANDAN SHAKYA, B.T.E. Roll No:

325252 student of Computer Engg. Third year (6th Semester), of
Ambedkar Polytechnic, Shakarpur worked on project “ATM
SIMULATION” From Dec 2014 to Feb 2015.
He was regular in his work and devoted around 10 Weeks for the
project including analysis and design. He has completed the project
satisfactorily.
This project has not been submitted to any other university or institution for
the award of any degree.

Project Guide
Mr. H.S. Bhatia
(HOD OF C.E)

2
 CERTIFICATE

This is to certify that ROHIT NANDAN SHAKYA, B.T.E. Roll No:

325252 student of Computer Engg. Third year (6th Semester), of
Ambedkar Polytechnic, Shakarpur worked on project “ATM
SIMULATION” From Dec 2014 to Feb 2015.
He was regular in his work and devoted around 10 Weeks for the
project including analysis and design. He has completed the project
satisfactorily.
This project has not been submitted to any other university or institution for
the award of any degree.

Project Guide
Mr. H.S. Bhatia
(HOD OF C.E)

3
 ACKNOWLEDGEMENT

I take this opportunity to express my gratitude to my Project Guide, Mr. H.S.

Bhatia for his unwavering encouragement and support throughout this
endeavor. His insight and expertise in this field motivated and supported me
during the duration of this project. It is my privilege and honor to have
worked under his supervision. His invaluable guidance and helpful
discussion in every stage of this project really helped me in materialized this
project. Without his constructive direction and invaluable advice, this work
would not have been completed.
I would also like to take this opportunity to present my sincere regards to
Mr. H.S Bhatia, Head of the department (Computer Engineering) Ambedkar
Polytechnic Delhi: -110092, for the support provided by him during the
entire duration of diploma course and especially for this thesis. My gratitude
is also extended to all teaching and non-teaching staff for their un- wavering
encouragement and support in my pursuit for academics.

ROHIT NANDAN SHAKYA

BTE ROLL NO: 325252
AMBEDKAR POLYTECHNIC

4
 ABSTRACT

The Automated Teller Machine ATM Banking System is a banking

application developed to perform different banking services through the
Automated Teller Machines. The all functions include the regular
transactions like cash deposits, cash withdrawals, balance enquiry, balance
statements, savings account, and current account; change PIN Number,
Credit card Withdrawals and so on. The application design maintains the
information of the accounts of various customers including the information
of the ATM cards, their types Credit cards, Debit Cards and the transactions
done by the customers through the ATM machine centers with co-relation of
the Banking Services.
The stored details also include the information of the various centers in and
around the ATM services, which help in the relational maintenance of every
transaction in the ATM Machine by the customers with their concerned
branch operations.

5
 SELF DECLARATION OF STUDENT

This project is submitted as partial fulfillment of the requirement of

DIPLOMA IN COMPUTER ENGINEERING of AMBEDKAR
POLYTECHNIC SHAKARPUR NEW DELHI:-110092 affiliated to BTE
DELHI, under the guidance of Mr. H.S Bhatia, Head of Computer
Engineering Department, AMBEDKAR POLYTECHNIC, Shakarpur
Delhi:-110092.

I hereby declare that present project report on “ATM SIMULATION” is

partially original and a bona fine work done by me and wherever the matter
has been replicated with or without modification the same has been specially
mentioned with the reasons for its usage.

ROHIT NANDAN SHAKYA

BTE Roll No. 325252
Computer Engineering
Final Year (2015)

6
ATM SIMULATION

7
8
 TABLE OF CONTENTS
TOPIC
Introduction
Problem Definition
Objective
Scope
Methodology
Analysis
Design
Modularization
System Planning
Hardware & Software Requirements
DFD
ER Diagram
Validation
Cost & Benefit Analysis
System Maintenance
Coding
Gantt Chart
Testing
User Manual
Limitations
Conclusions
Recommendations
Organizational Background
Bibliography
Web References
Notes
 INTRODUCTION
The topic “ATM Simulation” has been chosen keeping the functions of an ATM
machine and kiosk in mind. When we swipe our card through the machine, we are
able to extract all the relevant information of our account. A same attempt has
been made through this application to simulate those functions:

1. We have devised a menu-driven program that lets the user view his last
account activity combined with deposit & withdrawal of money from his
account.

2. Before the starting of this application, we have assumed that the account
information of 50 users would be stored by our application and the
variables like account balance, deposit & withdrawal would be initialized in
the very beginning to give a good look & feel of the application.

3. As the application starts, we assume that the user swipes his ATM debit
card which is effectively read by the machine though this is performed
through the human input because we are not integrating any such reader
with our application.

4. After that the user, enters his/her secret pin no. which is accepted by the
system in the form of a password. If the card no. which we are eventually
assuming as the account number entered manually by the user matches the
pin no., the user is redirected to the menu where he can see all the details
related to his account and can also do any account activity according to his
desires.

8
5. If at all the card number does not match with the pin no. the user is
appropriately informed of this.

PROBLEM DEFINITION

1. Before making this application, we assumed that a fictitious bank which

had recently started its operations found it very difficult to handle their
customers.

2. It was due to their great customer service and efficient handling of daily
operations that they customer base started growing and in a day, they
started to handle lot of customer requests.

3. When this happened, the bank authorities realized that the customer had lot
of different queries but the most common ones was account information,
deposit and withdrawal of money.

4. Slowly & slowly the count of such customers started to grow very rapidly
and the bank employees had to devote their maximum time in handling
such customers.

5. This resulted in large response times of the bank employees who found
themselves unable to give adequate time to some more important customers
like NRIs or people who were interested in opening a fresh account.

9
6. Slowly, the bank started loosing its important or gold customers due to poor
response times by the bank employees and they even started loosing those
customers whose requests could not be fulfilled.

7. After this, the bank decided to install a system that can effectively &
efficiently service the request of such customers and can the corresponding
work of its employees who were overburdened with such tasks.

8. This action was a step towards serving important or fresh customers with a
minimum possible and improve the response times & efficiency of the bank
employees.

10
 OBJECTIVE

After understanding the complete problem, our objective was absolutely clear
regarding what we have to develop that can effectively solve the bank’s purpose.
To achieve that:

1. We have just started with the top 50 customers of the bank who had such
normal queries and frequent account transaction in a day.

2. Our objective was to encourage those customers to use the system and help
them serve all their general requests themselves.

3. For this, we requested the bank to provide the account details & the
frequency of the account activity of such customers.

4. We finally used this data in our system as an input and tried to generate the
exactly same level of output as received by them by bank employees.

5. While devising the solution, we also took care of value addition in our work
which meant that the customers should find the system easy to use.

6. We had clear directions from the bank that the system should increase the
bank’s goodwill & improve the response times to customers and we also
took user-friendliness as well as scalability into account before developing
this application.
11
 SCOPE

After understanding the problem and a clear objective, we actually defined the
scope of application by formulating the functions that it would perform:

1. The first function we actually decided was the tracing of a customer

account. For this, it was necessary that when a customer interacts with our
system, he/she should be straightaway presented with an interface that is
easy & self-explanatory and which enables a customer complete his
transaction successfully, without any hassles.

2. The system had a challenge to effectively pull out the details of the
customer account in a minimum possible time so that the response time is
good and the remaining people do not have to wait long.

3. We also considered that the system should properly inform a customer

about his actions through descriptive messages i.e. if a customer is trying to
input something that the system in unable to understand, the customer
should be duly informed about the same.

4. The scope was defined in such a manner that spans all the common
functions which the customer is able to select through numeric options. If
any wrong option is entered, the message should be such that is

12
 understandable by a common man and should help the user check & correct
his actions.

5. Any transaction that the customer makes should be updated there & then in
the account so that if the customer wants to review his account information,
he/she should be presented with an updated one.

METHODOLOGY

We have developed this system after duly spending time on each software
development phase individually and freezing the status before we move on to the
next phase i.e. we have used “Linear Sequential” model in this application under
which:

1. In the analysis phase, we have attempted to understand the system

completely in terms of its objectives & the problems faced. All the
objectives were further subdivided into a set of smaller objectives which in
turn were subdivided in to the set of actions. The analysis also gave us an
overview about the individual expectations from each function and the
challenges faced by that function due to which the ultimate objective is not
achieved.

2. Before we moved to the designing phase, the objectives & challenges were
clearly understood and we actually converted the set of objectives & actions
into modules.

13
 The modules were designed in terms of their input, output, flow of
information, storage of information & communication amongst each other,
with the user and with the system. All the data objects were carefully
designed and classified in terms of their inputs & outputs.

3. After the analysis & design phases were over, we moved on to coding
phase, where the implementation of tasks or functions on-paper were
actualized. This was the phase where we actually became the use to have
the look & feel of the application, where we actually thought from the
user’s perspective & company’s perspective keeping all the objectives &
challenges into consideration.

4. Then came the testing phase in which after developing the complete
system, we rigorously tested it using all the testing types and checked every
characteristic / attribute of the application of whether it coincides and is
inline with the company’s objectives and user’s comfort.

14
 ANALYSIS

The analysis of the system was done rigorously because this is such a phase where all the
loopholes had to be discovered keeping company’s objectives & challenges in mind.

ANALYSIS PHASE. 50% of the total time in solving the project is allotted for this
phase. System analysis is the analysis of the problem that the organization will try
to solve with an information system. It consists of defining the problem,
identifying its causes, specifying the solution, and identifying the information
requirements that must be met by a system solution. System Analysis is an
important activity that takes place when at building new Information Systems or
changing existed ones.
System analysis refers to investigation into the system operation and possible
changes to the system. System analysis uses the understanding of the existing
system and its problems to design that eventually built a better system. They must
also determine that users may require a new system. It must spent a lot of time
talking to users and finding out that what are the problems that the user find with
the system, and what they expect from it.

We performed the analysis in 02 parts i.e. Feasibility Analysis & Requirements

Analysis.

Feasibility Analysis

15
When complex problems and opportunities are to be defined, it is generally
desirable to conduct a preliminary investigation called FEASIBILITY STUDY. A
feasibility study is conducted to obtain an overview of the problem and to roughly
assess whether the feasible solutions exist prior to committing substantial
resources to an information systems development project. Feasibility study
involves investigating the information needs of the prospective end users and the
objectives, constraints, basic resource requirements, costs, benefits and feasibility
of a proposed project.
By intent, the feasibility study is very rough analysis of the viability of the project.
It is, however, a highly desirable checkpoint that should be completed before
committing more resources.
The outcome of the feasibility study is very clear. So, depending upon the aspect
on which feasibility is being done is categorized into following classes: -
 Technical feasibility
 Economical Feasibility
 Operational Feasibility
Technical Feasibility
In technical Feasibility, the following issues are taken into consideration:
 Whether the required technology is available or nor?
 Whether the required resources are available –
Manpower-programmers, testers and debuggers
Software/Hardware
Therefore, it is mainly concerned with the satisfying equipment i.e. hardware and
software that will successfully satisfy the user requirements. The technical needs
of the system may vary, but might include:
 The facility to produce outputs in a given time.
 Response time under certain conditions.

16
  Ability to process a certain volume of transaction at a particular speed.
 Facility to communicate data to a distant location
After examining the technical feasibility, we give more importance to the
configuration of the system than the actual make of the hardware. The
configuration gives the complete and true picture of the system’s requirements.
The proposed system can be operated on a two PC. The PC will have its own color
monitor, keyboard and mouse. And it will also require a peripheral device i.e. a
printer. The computer system should have enough speeds of input and output to
achieve a good quality printout. The software, which has been used in the
proposed system, is C++. These soft wares are very popular and easily available in
the market. The system can be upgraded from time to time when new versions of
software are available from either the Internet or in the market. If by any chance
our operating system doesn’t support a particular type of hardware then we can
install the hardware equipment again using its device driver. And if we don’t have
the device driver available then we can download that particular device driver
using the Internet to suit to our requirements.
The main problem of running after the programmer who developed the system or
generated the system as now any software engineer will be able to solve the
problem, which may occur in the future. It is also important to consider the
monetary factors also. Since it might happen that developing a particular system
may be technically possible but it may require huge investments and benefits may
be less. For evaluating this, economical feasibility of the proposed system is
carried out.

Economical Feasibility
It is the most frequently used method for evaluating the effectiveness of the
system. The procedure is to determine the benefits and savings that are expected
from the system in comparison with the cost involved. If the benefits outweigh the
cost, then the system is said to be economically feasible. Economic analysis is the
17
most frequently used technique for evaluating the effectiveness of a proposed
system. It is more commonly known as COST/BENEFIT ANALYSIS.
Cost/Benefit analysis of the proposed system
 Cost Analysis
In case of computerization, the cost involvement is not that high as it was 5-7
years back. For this project to run successfully, the office initially requires a
Desktop computer, a printer and a UPS to maintain continuous supply of
electricity. The cost of installation including the hardware and software will come
around Rs.40, 000 with an annual maintenance contract of Rs.10, 000.
Cost of stationary (ink cartridges, printing paper) involves approximately Rs.15,
000 annually. The cost of electricity is incurred at Rs.7, 000 per year.
One person has to be hired who have the knowledge about the operation of
computers. His salary will come about to be Rs.1, 20, 000 per year.
Miscellaneous expenditure will be around Rs.15, 000 per annum.
So the total cost will come around Rs.1, 97, 000 including all possible expenses
plus a one-time investment of Rs.40, 000.
 Benefit Analysis
As it is necessary to do cost analysis of the developed project, it is also very
essential to do benefit analysis along with it. The analysis of the benefit arising
from the use of the software named “ATM” has been done in a very efficient
manner.
The points that have been kept in mind while performing the task of benefit
analysis of the software are as follows:
Stationary cost
The cost of purchasing stationary is also very high. It includes the cost of record
registers to maintain records of the Customer, Projects running and , cost of
photocopying daily. The approximate cost of stationary is between Rs.30000 and
Rs.35000. But, after the implementation of the proposed software, all the record

18
maintenance has become fully computerized; this step would save a big amount of
money, which was previously used for purchasing the stationary. Now, all the
work for which a large amount of stationary was required before can now be done
using a computer.

Operational Feasibility
It is mainly related to human organizational and political aspects. For operational
feasibility study we appointed a small group of people, which included the
Customers. This group worked with the new system and found that the system was
very user friendly, and very efficient. It was found that no special training was
required to operate the system. It takes about 5 minutes to enter the issue details as
compared to the 30-40 minutes of the manual system. And the customer found that
they can prepare the statistical reports with more speed, accuracy and in very less
time.
Other Feasibility Dimensions
Legal Feasibility
It includes study concerning contracts, liability, violations and legal other traps
frequently unknown to the technical staff.

Analysis Methodology
System analysis is a step-by-step approach to problem solving. It consists of the
following stages:
 Environmental Analysis
 Review of object organization
 Analysis of existing information system
 System requirement analysis
Environmental analysis

19
An organizational environment analysis is an important first step in system
analysis. Environmental analysis primarily involves identifying the employees and
their role in direction and control of various activities of the organization being
analysed. Environmental analysis helps the system analysts to identify the external
sources and destination of data/information.

Review Of Physical (Object) Organization

Before the information needs of end users can be identified it is necessary to have
a good knowledge of object system under consideration. This step involves the
following activities: -
1. Study of organizational objectives including key result areas (KRAs) or
critical success factors.
The aim of the objective is to make an efficient and effective system for the overall
administration of the office regarding employees, projects and issues information.
2. Organizational activities to achieve the objectives.
3. Identifying decision centers.
Analysis Of Existing Information System
The next stage is to analyze the existing information system. The requirement
analyst has to identify the requirement by talking to people and understanding
their needs.
In the existing system we have Administrator, Project Manager. Employees,
Trainees and office personnel and staff to mainly store the project information.
The staffs on duty in the front office include the following duties: -
 Maintaining employee records.
 Report Generation
 Assigning Issues to employees and giving them the particular project
information.
 Handling the enquiries.
System requirement analysis
20
Requirement analysis is the process of understanding the problem and the
requirements for a workable solution. Once the requirement has been gathered
they become the basis for “Requirements Analysis”.

System Requirements
To run this project successfully it is required that certain software and hardware
requirements should be kept in mind. Following are the requirements:

Hardware Requirements:
Ram: 256 M.B. or more
Processor: Pentium-III or above.
Hard Disk: 40GB or more.
Display: Any Color CRT or flat panel display
Any windows compatible mouse-pointing device.
Printer ( Inkjet / Laser Jet)

Software Requirements:
Microsoft Windows XP operating system (with service pack 2 will be better).
C++
MS-Word for Documentation

Requirement Analysis

1) This was a subset of feasibility analysis in which we defined a set of objectives

for the complete system after thoroughly analyzing it.

2) All the objectives were further subdivided into a set of function(s).

21
3) The input(s) required by each function & the expected output(s)/behavior
was/were clearly defined.

4) The source of information/input to every function was determined & its

corresponding processing, usage & storage were also taken into account.

5) After this the interdependency & communication was finalized.

Choice of the Platform

S/W Used: Turboc C++
The software for the ATM is written in Turboc C++ IDE3.0 , mainly because of
it’s suitability for this type of application. Its user friendly nature and in-built
documentation, complication, error detection, binding facilities and interaction
with other software packages make it most powerful tool for software
development. Moreover .Turboc C++ consists of all the technologies that help in
creating and running robust, scalable and distributed packages.
C++(called Object oriented Language) is based on some features which is mention
below:

C++ is a general-purpose object-oriented programming language, and isintended

to be an improved C with object capabilties.

1. Basic Concepts

In C++, an object is a region of storage with associated semantics.In the context of

the object model of C++, the term object refersto an instance of a class. A class
defines the characteristics of its instancesin terms of members: data members
(state) and member functions (methodsor operations), and the visibility of these
members to other classes. C++is statically typed.

22
2. Objects

In C++, an object is a region of storage with associated semantics.The declaration

int i;, specifies that iis an object of type int. In the context ofthe object model of
C++, the term object refers to an instance ofa class. Thus a class defines the
behavior of possibly many objects (instances).Objects are usually referred to by
references, which are aliasesfor an object. "The obvious implementation of a
reference is as a(constant) pointer that is dereferenced each time it is used." [Str92]

A C++ class definition generates a user-defined type. A class definesthe

characteristics of its instances in terms of members: data members(state) and
member functions (methods or operations), and the visibilityof these members to
other classes. The class defines the form of all objectsthat belong to that class.
Each object of the class that is created getsa copy of all the class data members,
except for those declared as static(see entry under state). All objects of a
particular class sharethe member functions for that class.

Operations

Operations are defined by functions. In the context of the C++ objectmodel,

functions may be globally defined (independently of object classes),or as part of
class definitions (member functions). C++ essentially supportsa classical object
model, in that member functions are associated withthe definition of a single
object class. However, friend functionsmay be defined that, though not part of a
class' definition, have accessto the internals of instances of that class. See entry
under 5. Encapsulation.

requests

Class data members and member functions are accessed as if they wereelements of
a data structure. A request for access is given by specifyingthe name of an object

23
(e.g., a reference) and the name of the operation,together with the appropriate
parameters.

specification of behavioral semantics

The behavior of a C++ object is defined by its member functions. (seeOperations

and methods). A definition of a memberfunction specifies argument types and the
result type. There is no formalspecification of the semantics of an operation; the
semantics are specifiedby the code of the member function.

methods

The behavior of a C++ object is defined by its member functions.All objects of a

particular class share the member functions for that class.Every member function
for a class must be declared with a function prototypein the class declaration. This
prototype lists the arguments for the memberfunction. C++ adds an additional
argument, this, to the beginningof the argument list for every member function.
The this argumentis a pointer to the individual object for which the member
function isbeing called (and is similar in some respects to self in Smalltalk).The
this argument is implicit; it does not have to be explicitlyincluded in the function's
argument list, nor does it have to be providedwhen the function is called.

The keyword virtualpreceding a member function declaration indicates that the

function canbe redefined in classes derived from the current class (subclasses).
Avirtual member function for a class is called through a jump table associatedwith
the class. This allows a derived class' member function to be correctlycalled even
when the variable used to access it is declared as being ofa base type. Non-virtual

24
member function calls are bound at compile time.The derived class member
function can invoke the base class member functionif this is required.

The keyword staticpreceding a member function declaration indicates that the

function hasno this pointer. Static member functions (for example) provide away
to access static data members without needing an actual instance ofthe class (static
data members are data members shared by all instancesof the class; these would be
equivalent to the instance variables of aSmalltalk class object). A static member
function can access nonstaticmembers of its class only if passed an instance of the
class (using the. or ->member access operators to refer to the particular member).

state

The state of a C++ object is defined by its data members. Eachobject of the class
that is created gets a copy of all the data members,except for those declared as
static.static data members aredata members shared by all instances of the class;
these would be equivalentto the instance variables of a Smalltalk class object.

object lifetime

The life-cycle for an object begins when it is created, and ends whenit is
destroyed. In a C++ class definition, a member function with thesame name as the
class is a constructor. This is a function whichis called automatically whenever an
instance of the class is created. Constructorsare typically used to initialize the data
members of the object to theirdefault state, but may also be used to allocate
resources (memory, files,etc.). For any class, a number of constructor functions
may be declared,each taking different types of arguments, providing different
ways of initializinginstances. A default constructor for a class is a constructor
ofthat class that can be called without any arguments. A default constructorfor a
class will be automatically generated if no constructor has beenexplicitly declared

25
for that class. A copy constructor for a classis a constructor that can be called to
copy an object of that class (ithas a single argument of the corresponding type). A
copy constructor iscalled when, for example, an argument object is passed by
value to a function,or when an object is initialized with the value of another object.
A copyconstructor for a class will be automatically generated if no copy
constructorhas been explicitly declared for that class. A member function with
thesame name as the class with a leading tilde (~) is a destructor.This is a function
that is called automatically when the object is deleted.The destructor is typically
used to deallocate any memory allocated forthe object (and may also release any
other resources acquired during construction).Constructors and destructors are not
required in class definitions.

There are several ways to create objects in a C++ program. One is todefine a
variable as being of a particular class, either as a global variableor as a local
variable within a block. When the declaration is encounteredduring program
execution, space is allocated for the object and the constructor,if any, for the
object is called. Similarly, when an object variable goesout of scope, its destructor
is called automatically. Another way to createan object is to declare a variable that
is a pointer to the object classand call the C++ new operator, which will
allocatespace for the object and call the constructor, if any, for the object.In this
case, the pointer variable must be explicitly deallocated withthe delete operator.
The constructor for theobject is executed when new is called, andthe destructor is
executed when delete is called.An object can also be constructed by the explicit
use of a constructorin an expression.

When a class is derived from another class, it inherits its parent class'constructor
and destructor. Parent constructors are invoked before derivedconstructors.
Destructors are invoked in the opposite direction, proceedingfrom the derived
class upward through its parent chain.

26
behavior/state grouping

C++ implements a classical object model. In C++, members, includingmember

functions, of objects are regarded as belonging to individual objectsand their
classes, and are accessed via the objects they belong to.

3. Binding

C++ supports both static and dynamic (run-time) binding of functioninvocations to

object member functions, depending on how the member functionswere declared
in class definitions. In dynamic binding, binding occursdepending on the dynamic
type of the object whose member functionis being invoked. The correct operation
for that object will be selectedautomatically by the run-time system. See also
entries under methods

4. Polymorphism

C++ supports polymorphism by allowing member functions defined in classesto

be overridden with member functions having the same names
(operatoroverloading), but different implementations, in derived classes
(subclasses).In selecting the appropriate member function to call in response to a
functioninvocation, C++ distinguishes between the static type of a referenceand
the dynamic type of the object it refers to at a given point. The dynamic type must
be a descendant of the static type. The invocationis type-checked based on the
static type of the reference. If the functioncalled is a virtual member function, the
member function associated withthe actual object pointed to is called dynamically
at run time. If thefunction is non-virtual, the call will have been statically bound to
themember function of the reference's class at compile time. See also entriesunder 7.
Types and Classes and 8. Inheritance and Delegation.

5. Encapsulation

27
C++ provides three levels of protection for data members and memberfunctions
within a class. The default protection level is private.A private data memberor
member function cannot be accessed by any function that is not a memberfunction
of that class. The next level of protection is protected.A protected data memberor
member function is accessible only to other member functions of thatclass or from
classes derived from that class. The least restrictive levelof protection is
public.public data members andmember functions can be accessed by any other
function. The protectionlevel of data members and member functions is specified
in the member declarationsusing the keywords public,protected, or private.

public members of a C++ base class do not automatically become publicmembers

of the derived class; the base class must be explicitly declaredas public to allow
this.

Specified non-member functions may be given access to private or protectedparts

of classes. These functions are specified using the friendkeyword, and may be
globally defined functions or members of other classes.Whole classes may be
declared as friends of another class, in which caseevery member of the friend class
can access the private members of thespecified class.

6. Identity, Equality, Copy

C++ supports both value and reference semantics (and supports both variablesthat
"contain" objects, and variables that contain pointers orreferences to objects). In
reference semantics, assignment essentiallycopies a pointer (or reference) to the
object. In value semantics, assignmentcopies the value itself. In C++, the
assignment operator can be used tocopy the object itself, or a reference to the
object can be created, andthen copied. (The C++ assignment operator itself can be
overridden, butthe default meaning is to copy the object itself). By contrast,
Smalltalkeffectively always uses reference semantics for assignment, using

28
alternativeoperations (shallowCopy, deepCopy) for value semantics. [Str92]
describesthe implementation of cloning, shallow copy, and deep copy operations
inC++ using the basic facilities.

7. Types and Classes

In C++, an object is a region of storage with associated semantics.The declaration

int i;, specifies that iis an object of type int. In the context ofthe object model of
C++, the term object refers to an instance ofa class. Thus a class defines the
behavior of possibly many objects (instances).Objects are usually referred to by
references, which are aliasesfor an object.

A C++ class definition generates a user-defined type. A class definesthe

characteristics of its instances in terms of members: data members(state) and
member functions (methods or operations), and the visibilityof these members to
other classes. The class defines the form of all objectsthat belong to that class.
Each object of the class that is created getsa copy of all the class data members,
except for those declared as static.All objects of a particular class share the
member functions for that class.If a class data member is defined with the
statickeyword, that data member is shared by all objects of that class (thereis only
one copy of the static data member).

C++ is a statically-typed language (although it supports explicit castsand unions

that allow type checking to be suspended). A class essentiallydefines a type, and a
derived class (subclass) is effectively a subtype.If a variable is of a type A, then it
may only refer to objects of classA or its derived classes (subclasses). When a
subclass is declared, thosemembers which redefine members declared in a
superclass must be declaredin a way that is consistent with the superclass
declaration, in order tomaintain substitutability of subclass instances.

An example rectangle class definition [Wes90] is:

29
 class TRect {public: // data members short fTop; short fLeft; short
fBottom; short fRight; // member functions short Area(void); Boolean
PointInRect(Point thePt);};

A class can be declared within another class; such a class is calleda nested class.
The name of a nested class is local to its enclosingclass. A class can also be
declared within a function definition; sucha class is called a local class. The name
of a local class is localto its enclosing scope.

An abstract class is a class that can be used only as a baseclass of some other
class; no objects of an abstract class can be createdexcept as objects representing a
base class of a class derived from it.Abstract classes support the notion of a
general concept, such as shape,of which only more concrete variants, such as
circleand square, can actuallybe used. An abstract class can also be used to define
an interface forwhich derived classes provide a variety of implementations [Str92].

A class is abstract if it has at least one pure virtual function.Specifying a function

in a base class as virtualmeans that if a derived class contains a function with the
same name andhaving the same type, a call of that function for an object of the
derivedclass always invokes the function in the derived class, even though
theinvocation was through a pointer or reference to the base class. In thiscase, the
derived class function is said to override the base classfunction. A virtual function
is specified pure by specifying itsimplementation as =0 inthe function declaration
in the class declaration.

C++ class templates provide a parameterized type facility (genericity).A class

template specifies how individual classes can be constructed. Forexample, an
example vector class template [Str92] might be:

template<class T> class vector { T* v; int sz;public: vector (int); T&

operator[] (int); T& elem(int i) { return v[i]; } // ...};
30
The prefix template<class T>specifies that a template is being declared and that a
type name Twill be used in the declaration (i.e., that vector is a parameterized
typewith T as its parameter).A class generated from a class template is called a
template class.Examples might be vector<int>,vector<complex>,etc. Such names
can be used in the same way as the names of ordinary classes.

8. Inheritance and Delegation

C++ supports multiple inheritance. Inheriting classes are called derivedclasses,

and the classes they inherit from are called base classes.The derived classes inherit
all the data members and member functions fromthe base class. The derived class
may extend the base class by addingnew data members or member functions. The
derived class may also overridemember functions from the base class by
supplying a new definition forthe function.

There are two forms of derivation, public and private.When the declaration of a
derived class contains the keyword publicpreceding the base class name, objects of
the derived class can be treatedas if they were instances of the base class. In
particular, an object ofthe derived class can be used to invoke member functions or
access datamembers defined for the base class. If the publickeyword is omitted,
then the class is privately derived by default, andobjects of the derived class
cannot be used as if they were objects ofthe base class. For privately derived
classes, only those data membersand member functions that are defined (or
overridden) in the derived classcan be accessed. Member functions of a privately
derived class can accessthe base class's data members and member functions, but
users of objectsof the derived class cannot used the derived objects to access data
membersand member functions of the base class. In other words, public
inheritanceis used to define subtypes (which can also share behavior), while
privateinheritance allows sharing of behavior, but does not permit an instanceof

31
the derived class to be used in situations where a base class instancewould be
expected.

For example, given a rectangle class [Wes90]:

class TRect {public: // data members short fTop; short fLeft; short
fBottom; short fRight; // member functions virtual short Area(void);
Boolean PointInRect(Point thePt);};

a round cornered rectangle might be defined as:

class TRoundRect : public TRect { protected: // added data members

short fHOval; short fVOval; // override the area member function
virtual short Area(void);};

A class may be derived from any number of base classes. The order ofderivation is
not significant except possibly for default initializationby constructor, for cleanup,
and for storage layout. The order in whichstorage is allocated for base classes is
implementation dependent. Accessto base class members must be unambiguous.
Ambiguities can be resolvedby qualifying a name with its class name [Str92].

DESIGN

Architectural Design

32
Under architectural design, after defining the whole system into a set of objectives
& further subdividing them into functions, we defined the basic dependency &
communication between them.

This means that all the prime functions, their required inputs, expected
output/behavior & interdependency between other functions were clearly defined.
The corresponding interfaces for the user for each function were designed to
ensure user-friendliness.

We actually addressed the system-level problems here and made a conscious effort
to build a robust design which can result in an effective communication within
itself and with the system in terms of raw data or processed information.

All the primary database design for data storage was also done in this phase.

Detailed Design

In this phase, we further subdivided every function into a set of modules &
defined required inputs & expected behavior for each of them. All the minute
correlations, interdependencies, communication between the modules were clearly
defined. The source, usage & processing of data for every module was carefully
done. The database design was also normalized at this stage to ensure that the data
is efficiently stored & retrieved.

Detailed design helped us to exactly concretize every problem into inputs &
outputs and visualize them in terms of their communication with each other. We
focused on interdependency & interoperability between the broken modules here.

33
It was this design phase where the factors like user-friendliness ease of use,
scalability and self-explanation of interfaces & outputs were actually realized. For
all the modules, the placement of controls, passing of information, communication
of different interfaces, user messages, data transfer to databases was defined.

MODULARIZATION

This particular phase comes under coding where, after completing the analysis &
design phases, freezing the system requirements and knowing about the challenges
& objectives of the function, we define the modules and their working.

In this application, as we discussed in the earlier sections, the major challenges

faced by the bank were large response times due to huge no. of most common
requests by a large number of customers.

Hence, it was decided to actually automate these categories of requests which are
most common amongst the customers.

1. The primary requirement of the system was to effectively scan the

customer’s card and mach the scanned number with the entered pin no. to
fetch the customer’s details. So we created one module for same.

2. Secondly, we realized that the most of the customers had a general enquiry
regarding their bank account like account balance and bank statement
containing details like last deposit & withdrawal amount. This was
dedicated to a module.

34
3. Then a lot of customers came to withdraw money from their account for
which we created a third module. In this module, we crosschecked the
customer’s balance and appropriately informed if he withdraw an amount
more than his balance.

4. For depository transactions, a fourth module was dedicated.

5. All the above modules were interlinked with a menu driven interface using
which a customer can select options as many times he wish and can serve
his multiple requests at the same time. If he/she intends to exit, there was a
clean exit using which all his information and transactions are securely
committed & finalized.

SYSTEM PLANNING

35
 DURATION
TASK DESCRIPTION DEPENDENCY
(DAYS)
T1 Requirements gathering 15 None
T2 Analysis 15 T1
T3 Designing 15 T2
Development & testing of
T4 “Account Verification” 4 T3
module
Development & testing of
T5 2 T4
“Account Details” module
Development & testing of
T6 2 T5
“Amount Deposit” module
Development & testing of
T7 “Amount Withdrawal” 1 T6
module
T8 Overall system testing 7 T7
T9 Documentation 7 T8

Total Duration: 15+15+15+4+2+2+1+7+7 = 68 days.

HARDWARE & SOFTWARE REQUIREMENTS

Hardware:

36
Intel Pentium D Processor with 3.00 GHz CPU clock speed
01 GB of RAM
80 GB of Hard Disk space

Software:

Microsoft Windows XP Professional (Service pack 2)

Turbo C++ IDE 3.0

DFD

Account
37 Verification
 User

Main Menu

Account Amount Amount

Details Deposit Withdrawal

Exit

Description of the data objects:

1[a]: Account & Pin number entered by the user

38
2[d]: If the Account number does not match with Pin number or vice
versa, the application cleanly exits to the system with a proper user
message like “Invalid Account / Pin no. entered”.

If the inputted details are correct, they are passed to the “Main Menu”
process and further to different modules which serve the customer’s
requests individually using those details.

2[a]: Account information & details like Present Balance, Last Deposit
& Last Withdrawal.

2[b]: Deposit details & account balance after deposit.

2[c]: This is withdrawal details & account balance after the withdrawal
in case the withdrawal amount entered is correct.

If the withdrawal amount entered is incorrect or invalid like greater

than the balance, a message is displayed to the user like “Invalid
amount entered”.

39
 ER DIAGRAM

Accno.

passwor
d

user Login Withdra

w/Depos
it Amoun
t

Chec
k Balance

Balance

currentbalance
Lastdepositamount

Lastwithdrawlamount

40
 VALIDATION

Validation is an important part in every application. It necessary to keep a check

on the user input so as to avoid any wrong processing by the system and thereby a
wrong / invalid / garbage output to the user.

In this application also, we have duly taken care of this part and ensured that the
user enters correct inputs at the points and wherever he does not, the system must
be able to inform him regarding this and exits cleanly if there is a need.

We have implemented validation at 03 points in the system as:

1. The first point is where the user enters his account & pin no. This is the
most important part of our application because the information which
would be fetched & is displayed to the user is confidential and it should be
displayed only after proper authentication. So, for security reasons, we have
given only one chance to the user to enter his pin correctly. If he does not,
the system issues a warning through a proper message and exits. The user
then again has to swipe his card, enter his account & pin no. to view the
account details or undertake any account activity.

2. The second point where this is implemented is the menu where the user
chooses from a list of options to process his requests. Since this is a menu-
driven program, we expect from the user to input correct option. But if, for
some reason, the user is unable to enter it correctly, we flash a message
which requests the user to enter a correct option.

41
3. The third point where we have taken care of user input is the place where
user wants to withdraw money from his account. Ideally, the user should
not enter the withdrawal amount greater that his total amount and if
mistakenly he does, the system flashes a user message and inform him
about the same.

42
 COST & BENEFIT ANALYSIS

The cost & benefit analysis is a part that was done both by us and the organization
which is assumed to be bank here that wants us to develop his application.

In this part, we analyzed whether the costs spent on this application did actually
benefit the bank in terms of benefit they are receiving after using it. The answer
was undoubtedly “YES”.

Initially the bank was handling all these processes manually which resulted in
serving a rush of customers with same kind of requests i.e. Account enquiry,
deposit & withdrawal. This resulted in bank employees devoting a chunk of their
time & resources for those customers who had common requests.

Soon the bank authorities realized that they are loosing on a lot of funds because
the response times of bank has gone down due to which they are not able to serve
all of their customers. Even those with these kinds of requests were left unattended
sometimes thereby creating unrest among the customers and directly affecting the
bank’s goodwill.

Moreover, the bank found itself unable to handle new big potential customers like
NRIs & people who had to open a bank account. Soon the bank decided to hire
additional people & spend on their training. There were also considerations about
opening a new branch altogether to share the workload.

43
 SYSTEM MAINTENANCE

We must say that the system is really easy to maintain. The greatest strengths of
the system are its simplicity & the ease with which it performs the tasks.

At every point, efficiency has been kept in mind and this has also been taken into
account that if at any point, the bank wants to automate more of its process, our
system should be easily adaptable to it.

The point where the maintenance factor of the system is tested is whenever there is
an increase in its customers. Even at this point, system would accommodate itself
perfectly. The proper user messages, effective communication between the
modules, system & more importantly customer, makes it all the more robust,
scalable, secure and ready to be enhanced.

44
CODE IMPLEMENTATION

# include <stdio.h>
# include <conio.h>
# include <dos.h>
# include <string.h>
# include <stdlib.h>
# include <ctype.h>

// This program simulates ATM

static int var;

struct logindetails
{
long int accountnumber;
int accountpin;
unsigned long int lastdepositamount;
unsigned long int lastwithdrawlamount;
unsigned long int currentbalance;
}l[] = {
72440,1,100000,1000,300000,
72441,2,1000,200,12000,

45
72442,3,200,340,13000,
72443,4,3000,4000,30000,
72444,5,340,450,1230,
72445,6,234,3400,45000,
72446,7,12300,34000,230000,
72447,8,4500,560,3400000,
72448,9,1000,2000,5000000,
72449,10,230,670,56778,
72450,11,345,678,29990,
72451,12,267,7893,12879,
72452,13,245,456,999,
72453,14,67,888,1234,
72454,15,456,666,8989,
72455,16,678,454,9999,
72456,17,567,890,1266,
72457,18,222,333,444,
72458,19,111,555,888,
72459,20,78,777,999,
72460,21,789,567,9090,
72461,22,567,787,12000,
72462,23,1000,2000,3000,
72463,24,345,678,890,
72464,25,6788,56565,120000,
72465,26,5675,67866,78878,
72466,27,123,456,999,
72467,28,7878,4545,34,
72468,29,345,567,3737,
72469,30,6768,4563,8293,
72470,31,456,657,72675,

46
72471,32,6786,4343,12,
72472,33,67,76,1,
72473,34,12,45,878,
72474,35,1,2,3,
72475,36,6768,3563,7685,
72476,37,657,363,74883,
72477,38,0,1,12,
72478,39,3,4,5,
72479,40,3,67,489,
72480,41,48,748,4784,
72481,42,54674,8484,7848,
72482,43,6737,738,3893,
72483,44,637,7389,883,
72484,45,474,849,4774,
72485,46,783,672,893,
72486,47,84,84,84,
72487,48,8484,484,74,
72488,49,2,3,4,
72489,50,1,2,34
};

class firstscreen
{
public:

void display()
{
gotoxy(27,15);
cprintf("ATM SIMULATION");

47
 gotoxy(27,16);
cprintf("**************");
gotoxy(26,20);
printf("INSERT YOUR CARD");
gotoxy(23,24);
cprintf("Press enter to continue");
}
};

class secondscreen
{
public:

long int i, accno, temp, password, flag;

int logindetails()
{
flag = temp = password = 0;

gotoxy(21,16);
cprintf("ENTER YOUR ACCOUNT NUMBER: ");
gotoxy(21,18);
cprintf("ENTER YOUR PASSWORD: ");
gotoxy(21,22);
cprintf("Press enter to continue\n");
gotoxy(47,16);
cscanf("%ld",&accno);
getch();
gotoxy(41,18);

48
while((temp=getch()) != 13)
{
switch(temp)
{
case 48:
temp = 0;
break;

case 49:
temp = 1;
break;

case 50:
temp = 2;
break;

case 51:
temp = 3;
break;

case 52:
temp = 4;
break;

case 53:
temp = 5;
break;

49
 case 54:
temp = 6;
break;

case 55:
temp = 7;
break;

case 56:
temp = 8;
break;

case 57:
temp = 9;
break;
}
putchar('*');
password = (password * 10) + temp;
}

for (i=0; i<50; i++)

{
if((l[i].accountnumber == accno) && (l[i].accountpin == password))
{
flag = 1;
var = i;
}
}
return flag;

50
 }
};

class thirdscreen
{
public:

int menu()
{
int i;

gotoxy(21,16);
cprintf("Choose from the following options");
gotoxy(21,17);
cprintf("---------------------------------");
gotoxy(21,19);
cprintf("1) BALANCE ENQUIRY & PRINT MINI STATEMENT");
gotoxy(21,21);
cprintf("2) WITHDRAWL");
gotoxy(21,23);
cprintf("3) DEPOSIT");
gotoxy(21,25);
cprintf("4) EXIT");
gotoxy(21,27);
cprintf("Enter option: ");
gotoxy(34,27);
scanf("%d",&i);
return i;
}

51
};

class fourthscreen
{
public:

void statement()
{
gotoxy(21,16);
cprintf("YOUR PREVIOUS TRANSACTIONS ARE");
gotoxy(21,17);
cprintf("------------------------------");
gotoxy(21,19);
cprintf("1) Last Deposit:");
gotoxy(38,19);
textcolor(2);
cprintf("Rs.%lu/-",l[var].lastdepositamount);
textcolor(15);
gotoxy(21,21);
cprintf("2) Last Withdrawl:");
gotoxy(40,21);
textcolor(2);
cprintf("Rs.%lu/-",l[var].lastwithdrawlamount);
textcolor(15);
gotoxy(21,24);
cprintf("YOUR PRESENT BALANCE IS:");
gotoxy(21,25);
cprintf("-----------------------");
gotoxy(46,24);

52
 textcolor(2);
cprintf("Rs.%lu/-",l[var].currentbalance);
textcolor(15);
gotoxy(23,30);
cprintf("Press enter to continue");
getch();
}
};

class fifthscreen
{
public:

unsigned long int wamt;

void withdrawl()
{
wamt = 0;
gotoxy(21,16);
printf("YOUR PRESENT BALANCE IS:");
gotoxy(46,16);
textcolor(2);
cprintf("Rs.%lu/-",l[var].currentbalance);
textcolor(15);
gotoxy(21,19);
printf("ENTER THE AMOUNT TO BE WITHDRAWN: Rs.");
gotoxy(58,19);
scanf("%lu",&wamt);

53
 if(wamt > l[var].currentbalance)
{
gotoxy(18,22);
textcolor(2);
cprintf("!!! INVALID AMOUNT ENTERED. PLEASE
CHECK. !!!");
textcolor(15);
}
else
{
l[var].lastwithdrawlamount = wamt;
l[var].currentbalance -= wamt;
gotoxy(21,22);
cprintf("YOUR NEW BALANCE AFTER WITHDRAWL:");
textcolor(2);
gotoxy(54,22);
cprintf("Rs.%lu/-",l[var].currentbalance);
textcolor(15);
gotoxy(25,27);
printf("Press enter to continue");
}

getch();
}
};

class sixthscreen
{
public:

54
 unsigned long int damt;
void deposit()
{
damt = 0;
gotoxy(21,16);
cprintf("YOUR PRESENT BALANCE IS:");
gotoxy(46,16);
textcolor(2);
cprintf("Rs.%lu/-",l[var].currentbalance);
textcolor(15);
gotoxy(10,19);
cprintf("ENTER THE AMOUNT TO BE DEPOSITED (Max. of 30
notes): Rs. ");
gotoxy(66,19);
scanf("%lu",&damt);
l[var].lastdepositamount = damt;
l[var].currentbalance += damt;
gotoxy(17,22);
cprintf("YOUR NEW BALANCE AFTER DEPOSIT: Rs. ");
gotoxy(49,22);
textcolor(2);
cprintf("Rs.%lu/-",l[var].currentbalance);
textcolor(15);
gotoxy(25,27);
printf("Press enter to continue");
getch();
}
};

55
int main()
{
highvideo();
textcolor(15);
clrscr();

int temp, temp1;

firstscreen f;
secondscreen s;
thirdscreen t;
fourthscreen f1;
fifthscreen f2;
sixthscreen s1;

f.display();
getch();
clrscr();

temp = s.logindetails();

if(temp == 1)
{
clrscr();

do
{
clrscr();

56
 temp1 = t.menu();

switch(temp1)
{
case 1:
clrscr();
f1.statement();
break;

case 2:
clrscr();
f2.withdrawl();
break;

case 3:
clrscr();
s1.deposit();
break;

case 4:
exit(0);

default:
gotoxy(16,35);
textcolor(15);
textcolor(2);
cputs("!!! INVALID OPTION ENTERED. PLEASE
CHECK. !!!");
getch();

57
 clrscr();
textcolor(15);
}

} while(temp1 != 4);
}
else
{
textcolor(15);
textcolor(2);
gotoxy(8,33);
cputs("!!! INCORRECT ACCOUNT NUMBER/PIN ENTERED. PLEASE
CHECK. !!!");
textcolor(15);
getch();
exit(0);
}

textcolor(15);
return 0;
}

class seventhscreen
{
public:

unsigned long int damt;

void deposit()

58
 {
damt = 0;
gotoxy(21,16);
cprintf("YOUR PRESENT BALANCE IS:");
gotoxy(46,16);
textcolor(2);
cprintf("Rs.%lu/-",l[var].currentbalance);
textcolor(15);
gotoxy(10,19);
cprintf("ENTER THE AMOUNT TO BE DEPOSITED (Max. of 30
notes): Rs. ");
gotoxy(66,19);
scanf("%lu",&damt);
l[var].lastdepositamount = damt;
l[var].currentbalance += damt;
gotoxy(17,22);
cprintf("YOUR NEW BALANCE AFTER DEPOSIT: Rs. ");
gotoxy(49,22);
textcolor(2);
cprintf("Rs.%lu/-",l[var].currentbalance);
textcolor(15);
gotoxy(25,27);
printf("Press enter to continue");
getch();
}
};

int main()
{

59
highvideo();
textcolor(15);
clrscr();

int temp, temp1;

firstscreen f;
secondscreen s;
thirdscreen t;
fourthscreen f1;
fifthscreen f2;
sixthscreen s1;

f.display();
getch();
clrscr();

temp = s.logindetails();

if(temp == 1)
{
clrscr();

do
{
clrscr();
temp1 = t.menu();

switch(temp1)

60
 {
case 1:
clrscr();
f1.statement();
break;

case 2:
clrscr();
f2.withdrawl();
break;

case 3:
clrscr();
s1.deposit();
break;

case 4:
exit(0);

default:
gotoxy(16,35);
textcolor(15);
textcolor(2);
cputs("!!! INVALID OPTION ENTERED. PLEASE
CHECK. !!!");
getch();
clrscr();
textcolor(15);
}

61
 } while(temp1 != 4);
}
else
{
textcolor(15);
textcolor(2);
gotoxy(8,33);
cputs("!!! INCORRECT ACCOUNT NUMBER/PIN ENTERED. PLEASE
CHECK. !!!");
textcolor(15);
getch();
exit(0);
}

textcolor(15);
return 0;
}

62
GANTT CHART

63
Gantt Chart

Gantt Chart is a project scheduling technique. Progress can be

represented easily in a Gantt chart, by coloring each milestone
when completed. The project will start in the month of August
and end after 4 months at the end of April.

System Design

Detailed Design

Coding

Unit Testing

Test Plan

Testing

July August September

October

64
TEST SCREENS
Testing Methodology
Software testing is the process of executing a program with the intention of
finding errors in the code. It is the process of exercising or evaluating a system or
system component by manual or by automatic means to verify that it satisfies
specified requirements or to identify differences between expected and actual
results.
The objective of testing is to show incorrectness and testing is considered to
succeed when an error is detected. An error is a conceptual mistake made by either
the programmer or the designer or a discrepancy between a computed value and a
theoretically correct value. A fault is a specific manifestation of an error. An error
may be cause of several faults. A failure is the inability of a system or component
to perform its required function within the specified limits. A failure may be
produced when a fault is executed or exercised.
Other activities that are often associated with software are static analysis and
dynamic analysis. Static analysis investigates the source code of software, looking
for problems and gathering metrics without actually executing the code. Dynamic
analysis looks at the behavior of software while it is executing, to provide
information such as execution traces, timing profiles and test coverage
information.

65
Unit Testing or Module Testing
The starting point of testing is Unit testing. In this, a module is tested separately at
each step. This helps to detect syntax and logical errors in the program and is
performed by the coder himself /herself during coding.

66
Integration Testing
The modules, which are tested in the Unit Testing, are integrated to build the
overall system. It is observed that many errors crop up when the modules are
joined together. Integration testing uncovers these errors while integrating the
modules. It helps in establishing confidence (correctness) in the complete,
assembled system. It tests the System Design. It focus on control, communication,
interfaces, performance (other system qualities). It make use of stubs, test-beds,
data generators. It is the phase of software testing in which individual software
modules are combined and tested as a group. It follows unit testing and precedes
system testing.
Integration testing takes as its input modules that have been unit tested, groups
them in larger aggregates, applies tests defined in an integration test plan to those
aggregates, and delivers as its output the integrated system ready for system
testing.
Integration testing concentrates entirely on module interactions, assuming that the
details within each module are accurate. Module and Integration testing can be
combined, verifying the details of each module's implementation in an integration
context. Many projects compromise, combining module testing with the lowest
level of subsystem integration testing, and then performing pure integration testing
at higher levels. Each of these views of integration testing may be appropriate for
any given project, so an integration testing method should be flexible enough to
accommodate them all.
System Testing
The System testing is bringing together of all programs that a system comprises
for testing purposes. System testing is testing conducted on a complete, integrated
system to evaluate the system's compliance with its specified requirements.
System testing falls within the scope of black box testing, and as such, should
require no knowledge of the inner design of the code or logic. Programs are
typically integrated in a top-down, incremental fashion. It is a series of different
67
tests whose primary purpose is to fully exercise the computer-based system. It
includes the following tests: -
 Recovery Testing: - It is a system test that forces the software to fail in a
variety of ways and verifies that recovery is properly performed.
 Stress Testing:- These are designed to confront program functions with
abnormal situations. It executes a system in a manner that demands
resources in abnormal quantity, frequency or volume.
 Security Testing:- This testing attempts to verify that protection
mechanism built into a system will protect it from unauthorized penetration.

The system testing is an investigatory testing phase, where the focus is to have almost a
destructive attitude and test not only the design, but also the behaviour and even the
believed expectations of the customer. It is also intended to test up to and beyond the
bounds defined in the software/hardware requirements specification(s).
Black Box Testing
It is also known as Functional Testing. It tests the overall functional requirements
of product. Inputs are supplied to product and outputs are verified. If the outputs
obtained are the same as the expected ones then the product meets the functional
requirements. In this, the internal procedures are not considered. In this the tester
would only know the "legal" inputs and what the expected outputs should be, but
not how the program actually arrives at those outputs. This Testing is more
effective on larger units of code. In this test’s are done from user point of view.

White Box Testing

It is also known as Structure Testing. It focuses on the internal functioning of the
product. It tests the loops of the Procedure, Decision points, Execution paths etc.
White box testing uses specific knowledge of programming code to examine
outputs. The test is accurate only if the tester knows what the program is supposed
to do. He or she can then see if the program diverges from its intended goal. White

68
box testing does not account for errors caused by omission, and all visible code
must also be readable. As the knowledge of internal coding structure is
prerequisite, it becomes very easy to find out which type of input/data can help in
testing the application effectively. The other advantage of white box testing is that
it helps in optimizing the code. It helps in removing the extra lines of code, which
can bring in hidden defects.

Acceptance Testing
This Testing is done when the software is developed for the specific customer. A
series of tests are conducted to enable the customer to validate all requirements.
The end user/ customer conducts these tests and may range from adhoc test to
well-planned systematic series of tests. Acceptance testing may be conducted for
few weeks or months. The discovered errors will be fixed and better quality
software will be delivered to the customer.
Acceptance testing is performed by the customer on a system prior to the customer
accepting delivery or accepting transfer of ownership of that system.
The customer specifies scenarios to test when a user story has been correctly
implemented. A story can have one or many acceptance tests, what ever it takes to
ensure the functionality works. Acceptance tests are black box system tests. Each
acceptance test represents some expected result from the system. Customers are
responsible for verifying the correctness of the acceptance tests and reviewing test
scores to decide which failed tests are of highest priority. Acceptance tests are also
used as regression tests prior to a production release. A user story is not
considered complete until it has passed its acceptance tests. This means that new
acceptance tests must be created each iteration or the development team will report
zero progress.
Test Data and Test cases

69
Test Data
Test Data are data that have been specifically identified for use in executing test
scripts, and are used to verify the expected results obtained.
It states:
 What the items to be tested are?
 At what level they will be tested?
 What sequence they are to be tested?
 How the strategy will be applied to the testing of each item and describes
the test environment.

Test Case
It describes an input description and an expected output description. These are
derived during all phases of the development cycle. It helps in determining
expected results before running a test case.

Some of the test cases for this project are:

Serial Action Input Excepted Pass (Y/N)
No. Output
1. To check account no. Valid Record procedded Y
and passowrd
2. To check account no Invalid Record Error message. Y
and password
3. To deposit amount Invalid Record No error N
Message
4. To check deposited Valid record procedded Y
amount
5. To check functionality Invalid Record Error message Y
of interface button
6. To check functionality Invalid Record Blank interface N
of interface button

Test Reports and Debugging

70
Test Reports
AccountVerification
In Account Verification form, First user enter own Account number and password.
If your entered Account number and password matched from backened Then
project will process next step. If user put wrong account number then project will
be show error message. On Go, validation for each text box is carried out and
attention is focused on to respective text box that does not meet validation
requirement, thus chances of error are eliminated.

Account Detail
In this, module display the account detail with user’s account number.
Account detail module display the Last Deposit , Last withdrawl, Present Balance
etc. regarding account number and user name.

Amount Deposit
In Amount Deposit module, User can deposit the amount but user can deposit
maximum three notes. When user choice the Amount Deposit Then this module
will be show three statement: user present balance, Enter the amount to be
deposited and Enter new balance after deposit. If user click add without deposit
amount then this project will display the error message..

Amount Withdrawl
By use of module, User can withdraw amount but if entered amount is available in bank.
If entered amount is not available then this project will be display error message. So user
can withdraw minimum amount than available in bank.

71
EXIT
This module will be work of EXIT. If user’s processing work have finish . Then user
will be exit from own Account .

Debugging
It is the activity of locating and correcting errors. It starts once a failure has been
detected.
In this the following debugging induction approach is used:-
1. Locate the pertinent data
In this step, we take into account what the program did correctly and what it
did incorrectly.

2. Organize the data

The next step is the structuring of data to allow one to observe patterns. For
e.g. in our program the error can occur if we are assigning more than two
project to the particular person.
3. Devise a hypothesis
A hypothesis is devised so that according to it we can find out the most
probable one, which is causing the error more frequently.
4. Prove the hypothesis
Comparing it to the original clues proves the hypothesis or data, making
sure that this hypothesis completely explains the existence of the clues. If it
does not either the hypothesis is invalid, or the hypothesis is incomplete, or
the multiple errors are present.

Implementation

72
Implementation is a process that carries out the operational plans developed at the
end of the information systems planning process. Therefore, implementation is an
important step in assuring the successful development of information systems for
end users.
Implementation involves a variety of acquisition, testing, documentation,
installation and conversion activities. Thus, implementation is a vital step in
assuring the success of new systems. Even a well-designed system can fail if it is
not properly implemented.

Post implementation Maintenance

Implementation of system means putting up system on user’s site. Therefore, the
system requires periodic maintenance. Maintenance can be for software or
hardware. User priorities, changes in organizational requirements or changes in
environmental factors call for system enhancements. This is very crucial for
system’s life.

73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
 USER MANUAL

Another positive point of the system is that it is extremely easy to

install.

1. We just need to copy the code in the home directory.

2. If Turbo C++ IDE is not already installed, we need to install it.

3. Open the source file in the Turbo C++ editor and compile it
using ctrl-F9.

4. If the system shows any errors related to header files not found,
then we need to change our ‘include’ & ‘library’ directories.

5. To change that, we need to select Options -> Directories in the

Turbo C++ editor and mention the path where ‘include’ and ‘lib’
directories are located in the system (C++ specific). It is
because these are directories that contain the definition of
header & library files.

97
 LIMITATIONS

We could not think of many limitations of the system but as we know,

nothing is perfect; our system also comes with few limitations.

1. The system would work more realistically if the equipment that

reads embossed characters from a credit card works in tandem
with it.

2. If a database of a large number of customers could be accessed

from a server in a real time mode, the efficiency of the system
could have been further explored.

3. The system does not give us an exhaustive balance with all the
calculations like tax but this functionality can be introduced in
same.

98
 CONCLUSIONS

We can hereby conclude that:

1. The system effectively automated the functions involved in the

processes being handled manually before.

2. The cost & benefit analysis shows that the system was quite
successful in saving costs for the bank & generate equivalently
huge benefits

3. The system is secure & scalable. The system design has been
done keeping user-friendliness and efficiency in mind.

99
 RECOMMENDATIONS

This system can be used by all those establishments, primarily banks

who have a huge customer base and found difficult to manage the
service requests by a lot of customers at the same time during rush
hour thereby resulting in hassles.

In crux, we can say that keeping the strengths of the system in mind,
we can easily trust upon its reliability and assurance that it would
provide the same level of benefits to any organization.

100
 BIBLIOGRAPHY

Object Oriented Programming with C++ by E. Balagurusamy

The ‘C’ Programming language by Kernighan & Ritchie

Teach yourself C by Yashwant Kanetkar

101
WEB REFERENCES

www.cprogramming.com/tutorial.html

www.cplusplus.com/doc/tutorial/

www.coronadoenterprises.com/tutorials/cpp/index.html/

102