Documente Academic
Documente Profesional
Documente Cultură
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
Mr. H.S. Bhatia
(HOD OF C.E.)
SUBMITTED BY:
ROHIT NANDAN SHAKYA
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)
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)
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.
ABSTRACT
ATM SIMULATION
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.
5. If at all the card number does not match with the pin no. the user is
appropriately informed of this.
8
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.
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.
OBJECTIVE
After understanding the complete problem, our objective was absolutely clear
regarding what we have to develop that can effectively solve the banks purpose.
To achieve that:
10
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
banks goodwill & improve the response times to customers and we also
took user-friendliness as well as scalability into account before developing
this application.
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
11
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:
12
13
ANALYSIS
The analysis of the system was done rigorously because this is such a phase where all the
loopholes had to be discovered keeping companys 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
14
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
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.
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 systems 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 doesnt support a particular type of hardware then we can
install the hardware equipment again using its device driver. And if we dont 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.
16
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
most frequently used technique for evaluating the effectiveness of a proposed
system. It is more commonly known as COST/BENEFIT ANALYSIS.
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
17
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
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.
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
18
Environmental analysis
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.
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).
20
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.
2. Objects
21
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
(e.g., a reference) and the name of the operation,together with the appropriate
parameters.
22
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
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
23
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
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
24
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.
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
25
4. Polymorphism
C++ supports polymorphism by allowing member functions defined in classesto
be
overridden
with
(operatoroverloading),
member
but
functions
different
having
implementations,
the
in
same
names
derived
classes
5. Encapsulation
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
26
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(inti){returnv[i];}//...};
The prefix template<classT>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
template
class.Examples
might
be
DESIGN
Architectural Design
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.
31
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.
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.
32
33
SYSTEM PLANNING
TASK
DURATION
DESCRIPTION
(DAYS)
DEPENDENCY
T1
Requirements gathering
15
None
T2
T3
Analysis
Designing
Development & testing of
15
15
T1
T2
T4
Account Verification
T3
T4
T5
T5
T6
module
Development & testing of
Account Details module
Development & testing of
Amount Deposit module
Development & testing of
T7
Amount Withdrawal
T6
T8
T9
module
Overall system testing
Documentation
7
7
T7
T8
35
DFD
Account
Verification
User
Main Menu
Account
Details
Amount
Deposit
36
Exit
Amount
Withdrawal
37
38
ER DIAGRAM
Accno.
passwor
d
user
Login
Withdra
w/Depos
it
Chec
k
Balance
Balance
currentbalance
Lastdepositamount
Lastwithdrawlamount
39
Amoun
t
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 menudriven 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.
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
40
mistakenly he does, the system flashes a user message and inform him
about the same.
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
banks 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.
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.
42
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.
CODE IMPLEMENTATION
# include <stdio.h>
# include <conio.h>
43
# 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,
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,
44
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,
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,
45
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");
gotoxy(27,16);
cprintf("**************");
gotoxy(26,20);
printf("INSERT YOUR CARD");
gotoxy(23,24);
cprintf("Press enter to continue");
}
};
class secondscreen
{
public:
46
temp = 2;
break;
case 51:
temp = 3;
break;
case 52:
temp = 4;
break;
case 53:
temp = 5;
break;
case 54:
temp = 6;
break;
case 55:
temp = 7;
break;
case 56:
temp = 8;
break;
case 57:
temp = 9;
break;
48
}
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;
}
};
class thirdscreen
{
public:
int menu()
{
int i;
gotoxy(21,16);
cprintf("Choose from the following options");
gotoxy(21,17);
cprintf("---------------------------------");
gotoxy(21,19);
49
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);
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;
51
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);
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);
52
gotoxy(49,22);
textcolor(2);
cprintf("Rs.%lu/-",l[var].currentbalance);
textcolor(15);
gotoxy(25,27);
printf("Press enter to continue");
getch();
}
};
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();
54
if(temp == 1)
{
clrscr();
do
{
clrscr();
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);
55
default:
gotoxy(16,35);
textcolor(15);
textcolor(2);
cputs("!!! INVALID OPTION ENTERED. PLEASE
CHECK. !!!");
getch();
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;
}
56
class seventhscreen
{
public:
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();
57
}
};
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
{
58
clrscr();
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();
59
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;
}
60
61
GANTT CHART
62
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
63
September
October
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.
64
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.
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
65
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
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.
66
67
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 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.
1.
Valid Record
Output
procedded
2.
and passowrd
To check account no
Invalid Record
Error message.
3.
and password
To deposit amount
Invalid Record
No error
N
Y
4.
To check deposited
Valid record
Message
procedded
5.
amount
To check functionality
Invalid Record
Error message
6.
of interface button
To check functionality
Invalid Record
Blank interface
of interface button
69
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 users 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.
EXIT
This module will be work of EXIT. If users 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:70
Implementation
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.
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
USER MANUAL
95
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.
96
CONCLUSIONS
97
RECOMMENDATIONS
98
BIBLIOGRAPHY
Object Oriented Programming with C++ by E. Balagurusamy
The C Programming language by Kernighan & Ritchie
99
WEB REFERENCES
www.cprogramming.com/tutorial.html
www.cplusplus.com/doc/tutorial/
www.coronadoenterprises.com/tutorials/cpp/index.html/
100
101