Professional Documents
Culture Documents
Abstract
Description PAGE NO
1. Introduction
● Features ...………………...
● Objective ..………………....
2.System Requirements
3.System Analysis
4.System Design
6.Testing
8.Conclusion …………………....
10.Bibliography
● References …………………….
Abstract
An e-ticket is a paperless electronic document used for e ticketing. It can be used for crowd
management in museums and heritage sites. A QR can be used as an e-ticket replacing paper-based
tickets. The main motto of this project is to develop a QR based ticketing system for the seamless
visitor experience in museums and heritage sites and in addition, the prediction of the expected crowd
is added as a feature.
1. Introduction
An electronic ticket, more efficient method of ticket entry, processing and marketing for companies in
the airline, railways and other transport and entertainment industries. Many sports, concert venues,
and cinemas use electronic ticketing for their events. Electronic tickets, or "eTickets" as they are
sometimes referred, are often delivered as PDFs or another downloadable format that can be
received via email or through a mobile app. Electronic tickets allow spectators to download their
tickets, as opposed to waiting for physical tickets to arrive in the mail. A printed copy of these tickets
or a digital copy on a mobile phone should be presented on coming to the venue
This document applies to e-ticketing website of a museum. This software is for designing tickets,
managing reservation and creating a unique bar code for every ticket. It allows the user to book a
ticket for the interested musuem and wished time.
The software takes as input the e-mail id or phone number for a primary verification to create an
account. Payment should be through online transactions like net banking, or through debit/ credit
cards or other UPI’s. So, it also takes input of their choice like either details of net banking, or
debit/credit cards, or UPI id.
The software produces an e-ticket as an output. The user can download it in PDF format.
This software allows the user to access different museums and shows in them through an
application. This software also allows to search user’s liked content and displays the available shows
in different museums. The user is supposed to select wished seats and book them by making an
online transaction.
Implementation
User Registration
Museum Selection
Booking slots
QR Generation
Database
Classification
● Features ...………………...3
2.2.1 Administrators
Admin can reject the user if he/she does not accept terms and conditions.
2.2.2 Users
Account: Members are given a provision to check their account’s information and change it.
Transaction: To book the time slot the user must pay the total amount including taxes and other
charges through online transactions like net banking, or debit/credit cards, or through UPIs. A
transaction id is created and given to the user for future purposes.
Ticketing: A ticket is produced with time and place on it and also a QR code.
Cancellation: User also may cancel the tickets and get a 50% cashback excluding taxes.
In general way, every museum has a manual ticketing system. A person collects money from
tourists and issues tickets. Initially, printed papers or tokens are used as tickets. As a result, there are
days when the queue before the museum is very lengthy and appears very crowded with tourists. The
crowd management is very difficult for curators of the museum, and it is very uncomfortable for
tourists to stand in a line for a longer period of time.
Disadvantages
In proposed system we introduce online registration and booking using QR code. The users
must register themselves on the website and can access it using login credentials whenever needed.
The users must select the museum which they like to visit along with number of people for which the
slot should be booked. Next step will be payment for the ticket. Finally, the QR code will be generated
which contains all the details of the booking. The QR code will be sent as a ticket to the user’s mobile.
Methodology
After Login the user will have to book slot for desired museum on a specific date where slots are
available.
The ticket will be generated in the form of QR and it will be sent to user's mail-id.
Advantages:
1. This application reduces tourists waiting time as QR code system is more feasible than the
manual ticketing system.
2. The crowd management is easy.
3. Prediction of expected tourists helps in proper arrangements for their better experience.
4. This application reduces tourists waiting time as QR code system is more feasible than the
manual ticketing system.
● Objective ..………………....5
This project applies to e-ticketing website of a museum. This software is for designing tickets,
managing reservation and creating a unique bar code for every ticket. It allows the user to book a
ticket for the interested museum and wished time.
The software takes as input the e-mail id or phone number for a primary verification to create an
account. Payment should be through online transactions like net banking, or through debit/ credit
cards or other UPI’s. So, it also takes input of their choice like either details od net banking, or
debit/credit cards, or UPI id.
The software produces an e-ticket as an output. The user can download it in PDF format
2.System Requirements
Registration: If customer wants to book some seats, then he/she must be registered, unregistered
user can’t book the seats.
Login: Customer logins to the system by entering valid email id and password for the seats to be
booked.
Search: The user can search their required shows and check for available seats at different
museums.
Payment: Payment is done through net banking or debit/credit cards or through UPI. The seats will be
booked and blocked only after a successful payment.
Receipt Generation: A unique transaction id is generated for future references.
Ticket Generation: A ticket is produced with seat numbers, time and place of show on it and also a
QR code.
Error handling: If any of the above validation/sequencing flow does not hold true, appropriate error
messages will be prompted to the user for doing the needful.
Developer Machine
Intel I3 or later
8 GB RAM or more
40 GB Disk
Server Machine
32 GB RAM or more
160 GB Disk
Client Machine
PHP
MY SQL Database
Python
● Software Description ………………….8-10
The software is created using PHP for server side programming, HTML/CSS/JS for client side
design, MYSQL for server side data storage. It is made up of the following modules:
User Registration
Museum Selection
Booking slots
QR Generation
Database
Classification
3.System Analysis
ETicket
Download QR System
Code Verify QR
Codes
Admin
Economic
Free and Open Source software development and deployment technology stack is preferred.
Technical
Online web portal with information management systems are typical developed with LAMP. It
is acronym for Linux operating system, Apache web server, Mysql database and PHP server side
technologies are all open source and free.
4.System Design
The Unified Modeling Language is a general-purpose, developmental, modeling language in the field
of software engineering that is intended to provide a standard way to visualize the design of a system.
The creation of UML was originally motivated by the desire to standardize the disparate notational
systems and approaches to software design. It was developed by Grady Booch, Iva
In UML 2.2 there are 14 types of diagrams divided into two categories. Seven diagram types
represent structural information, and the other seven represent general types of behavior, including
four that represent different aspects of interactions.
UML 1.x
Under the technical leadership of those three, a consortium called the UML Partners was organized in
1996 to complete the Unified Modeling Language specification, and propose it to the Object
Management Group for standardisation.
Structure diagrams
Structure diagrams emphasize the things that must be present in the system being modeled. Since
structure diagrams represent the structure, they are used extensively in documenting the software
architecture of software systems. For example, the component diagram describes ho…
Behavior diagrams
Behavior diagrams emphasize what must happen in the system being modeled. Since behavior
diagrams illustrate the behavior of a system, they are used extensively to describe the functionality of
software systems
The Unified Modeling Language (UML) is used to specify, visualize, modify, construct and document
the artifacts of an object-oriented software-intensive system under development. UML offers a
standard way to visualize a system's architectural blueprints, including elements such as activities,
actors, business processes, database schemas, components, programming language
To draw UML diagrams, all you need is a pencil and a piece of paper. However, for a software
engineer that seems a little outdated, hence most of us will use tools. The simplest tools are simply
drawing programs, like Visio or Dia. The diagrams generated this way look nice, but are not really that
useful, since they do not include the code generation feature.
The current UML standards call for 13 different types of diagrams: class, activity, object, use case,
sequence, package, state, component, communication, composite structure, interaction overview,
timing, and deployment. These diagrams are organized into two distinct groups: structural diagrams
and behavioral or interaction diagrams.
Activity Diagram
● Use Case Diagram ………………..22-25
Use case diagram
● Deployment Diagram…………………33
Deployment Diagram
i. Museum.php
<html>
<head>
<style>
body
background-image:url("334616.jpg");
.loginbox
{
width:300px;
height:350px;
text-align:center;
opacity:none;
border-radius:30px;
color:black;
top:25%;
left:40%;
position:absolute;
transfrom:translate(-25%, -25%);
box-sizing:border-box;
padding:70px 10px;
button
width:200px;
height:40px;
border-radius:25px;
text-align:center;
</style>
</head>
<body>
<div class="loginbox">
<h1 align="center">Price Rs250/-</h1>
<p>Number of people:</p>
<p>Email Id:</p>
<p>Slots:</p>
<option>Morning</option>
<option>Evening</option>
</select>
<br><br>
</form>
</div>
</body>
</html>
Momentum.php
<html>
<head>
<style>
body
background-image:url("334616.jpg");
.loginbox
{
width:300px;
height:350px;
text-align:center;
opacity:none;
border-radius:30px;
color:black;
top:25%;
left:40%;
position:absolute;
transfrom:translate(-25%, -25%);
box-sizing:border-box;
padding:70px 10px;
button
width:200px;
height:40px;
border-radius:25px;
text-align:center;
</style>
</head>
<body>
<div class="loginbox">
<p>Number of people:</p>
<p>Email ID:</p>
<p>Slots:</p>
<option>Morning</option>
<option>Evening</option>
</select>
<br><br>
</form>
</div>
</body>
</html>
App.py
import smtplib
import random as r
import re as regex
import pathlib
from flask import Flask, flash, redirect, render_template, request, session, abort
import os
import pandas
import mysql.connector
import sys
import glob
import math
import numpy as np
import pyqrcode
import png
app = Flask(__name__)
@app.route('/')
def home():
return render_template('index.html',msg="")
@app.route('/aboutushome')
def aboutushome():
return render_template('aboutushome.html')
@app.route('/contactus')
def contactus():
return render_template('contactus.html')
@app.route('/userhome')
def userhome():
username=session['uname']
return render_template('userhome.html',uname=username,msg="")
@app.route('/adminhome')
def adminhome():
return render_template('adminhome.html',msg="")
@app.route('/Momentum')
def Momentum():
import socket
x=socket.gethostbyname(socket.gethostname())
# Generate QR code
url = pyqrcode.create(s)
url.svg("static/qrcode/momentum.svg", scale = 8)
url.png('static/qrcode/momentum.png', scale = 6)
return render_template('adminhome.html')
@app.route('/muawum')
def muawum():
import socket
x=socket.gethostbyname(socket.gethostname())
s = x+"/museum.php"
# Generate QR code
url = pyqrcode.create(s)
url.svg("static/qrcode/museum.svg", scale = 8)
# Create and save the png file naming "myqr.png"
url.png('static/qrcode/museum.png', scale = 6)
return render_template('adminhome.html')
@app.route('/adminlogin')
def adminlogin():
return render_template('adminlogin.html')
@app.route('/bMuseums')
def bMuseums():
return render_template('bMuseums.html')
@app.route('/bMomentum')
def bMomentum():
return render_template('bMomentum.html')
@app.route('/userlogin')
def userlogin():
return render_template('userlogin.html')
@app.route('/userreg')
def userreg():
return render_template('userreg.html')
@app.route('/sendmail')
def sendmail():
cur=db.cursor()
data=cur.fetchall()
s=row[2]+" "+str(row[1])
url = pyqrcode.create(s)
url.png("static/tickets/"+str(row[0])+".png", scale = 6)
fromaddr = "pravashranjansahoo@gmail.com"
toaddr = row[2]
# instance of MIMEMultipart
msg = MIMEMultipart()
msg['From'] = fromaddr
msg['To'] = toaddr
# storing the subject
msg['Subject'] = "Ticket"
body = "Body_of_the_mail"
msg.attach(MIMEText(body, 'plain'))
filename = "static/tickets/"+str(row[0])+".png"
p = MIMEBase('application', 'octet-stream')
p.set_payload((attachment).read())
encoders.encode_base64(p)
msg.attach(p)
# creates SMTP session
s = smtplib.SMTP('smtp.gmail.com', 587)
s.starttls()
# Authentication
s.login(fromaddr, "drgehhutbtqfgsne")
text = msg.as_string()
s.quit()
print(sql)
cur.execute(sql)
db.commit()
return render_template('adminhome.html')
@app.route('/naval')
def naval():
import pyqrcode
import png
# Generate QR code
os.chdir("static/qrcode")
fname="naval.svg"
#f.save(secure_filename(fname))
#cfname="static/qrcode/"+str(fname)
url.svg(fname, scale = 8)
os.chdir('..')
os.chdir('..')
os.chdir("static/qrcode")
fname="naval.png"
#f.save(secure_filename(fname))
#cfname="static/qrcode/"+str(fname)
url.png(fname, scale = 6)
os.chdir('..')
os.chdir('..')
return render_template('adminhome.html')
@app.route('/ins')
def ins():
import pyqrcode
import png
# Generate QR code
url = pyqrcode.create("ins:Rs 200")
os.chdir("static/qrcode")
fname="ins.svg"
#f.save(secure_filename(fname))
#cfname="static/qrcode/"+str(fname)
url.svg(fname, scale = 8)
os.chdir('..')
os.chdir('..')
os.chdir("static/qrcode")
fname="ins.png"
#f.save(secure_filename(fname))
#cfname="static/qrcode/"+str(fname)
url.png(fname, scale = 6)
os.chdir('..')
os.chdir('..')
return render_template('adminhome.html')
#momentum
@app.route('/Chowmahalla')
def Chowmahalla():
import pyqrcode
import png
# Generate QR code
os.chdir("static/qrcode")
fname="Chowmahalla.svg"
#f.save(secure_filename(fname))
#cfname="static/qrcode/"+str(fname)
url.svg(fname, scale = 8)
os.chdir('..')
os.chdir('..')
os.chdir("static/qrcode")
fname="Chowmahalla.png"
#f.save(secure_filename(fname))
#cfname="static/qrcode/"+str(fname)
url.png(fname, scale = 6)
os.chdir('..')
os.chdir('..')
return render_template('Momentum.html')
@app.route('/Penukonda')
def Penukonda():
import pyqrcode
import png
os.chdir("static/qrcode")
fname="Penukonda.svg"
#f.save(secure_filename(fname))
#cfname="static/qrcode/"+str(fname)
url.svg(fname, scale = 8)
os.chdir('..')
os.chdir('..')
os.chdir("static/qrcode")
fname="Penukonda.png"
#f.save(secure_filename(fname))
#cfname="static/qrcode/"+str(fname)
url.png(fname, scale = 6)
os.chdir('..')
os.chdir('..')
return render_template('Momentum.html')
@app.route('/Gandhi')
def Gandhi():
import pyqrcode
import png
# Generate QR code
os.chdir("static/qrcode")
fname="Gandhi.svg"
#f.save(secure_filename(fname))
#cfname="static/qrcode/"+str(fname)
url.svg(fname, scale = 8)
os.chdir('..')
os.chdir('..')
os.chdir("static/qrcode")
fname="Gandhi.png"
#f.save(secure_filename(fname))
#cfname="static/qrcode/"+str(fname)
url.png(fname, scale = 6)
os.chdir('..')
os.chdir('..')
return render_template('Momentum.html')
@app.route('/Warangal')
def Warangal():
import pyqrcode
import png
# Generate QR code
os.chdir("static/qrcode")
fname="Warangal.svg"
#f.save(secure_filename(fname))
#cfname="static/qrcode/"+str(fname)
url.svg(fname, scale = 8)
os.chdir('..')
os.chdir('..')
os.chdir("static/qrcode")
fname="Warangal.png"
#f.save(secure_filename(fname))
#cfname="static/qrcode/"+str(fname)
url.png(fname, scale = 6)
os.chdir('..')
os.chdir('..')
return render_template('Momentum.html')
#momentum end
@app.route('/upload')
def Upload():
import pyqrcode
import png
# Generate QR code
url = pyqrcode.create("museum")
os.chdir("static/qrcode")
fname="museum.svg"
#f.save(secure_filename(fname))
#cfname="static/qrcode/"+str(fname)
url.svg(fname, scale = 8)
os.chdir('..')
os.chdir('..')
os.chdir("static/qrcode")
fname="museum.png"
#f.save(secure_filename(fname))
#cfname="static/qrcode/"+str(fname)
url.png(fname, scale = 6)
os.chdir('..')
os.chdir('..')
return render_template('adminhome.html')
@app.route('/UserList')
def do_UserList():
flag=False
cursor = db.cursor()
sql = "SELECT * FROM users"
print("Sql is ",sql)
cursor.execute(sql)
rows_count = cursor.fetchall()
print(rows_count)
return render_template('userlist.html',data=rows_count)
@app.route('/dashboard')
def do_dashboard():
flag=False
cursor = db.cursor()
print("Sql is ",sql)
cursor.execute(sql)
rows_count = cursor.fetchall()
print(rows_count)
print("Rows 1 ",rows_count[0])
return
render_template('userdashboard.html',data=rows_count[3:],data1=rows_count[0],data2=rows_
count[1],data3=rows_count[2])
@app.route('/adminlogin', methods=['POST'])
def do_adminlogin():
flag=False
username=request.form['username']
password=request.form['password']
session['logged_in'] = True
flag=True
else:
flag=False
if flag:
else:
@app.route('/userlogin', methods=['POST'])
def do_userlogin():
flag=False
cursor = db.cursor()
username=request.form['username']
password=request.form['password']
sql = "SELECT * FROM users WHERE userid= '%s' and password = '%s' " %
(username,password)
print("Sql is ",sql)
cursor.execute(sql)
rows_count = cursor.fetchall()
print("XXX ",type(rows_count))
if len(rows_count) > 0:
session['logged_in'] = True
session['uid'] = username
session['uname'] = rows_count[0][1]
flag=True
else:
flag=False
if flag:
else:
@app.route('/profile')
def do_profile():
flag=False
cursor = db.cursor()
un=session['uid']
print("Sql is ",sql)
cursor.execute(sql)
rows_count = cursor.fetchall()
print("XXX ",type(rows_count))
return render_template('profile.html',data=rows_count,msg1="")
@app.route('/changepassword', methods=['POST'])
def do_changepassword():
msg=""
cpwd=request.form['cpwd']
npwd=request.form['npwd']
cnpwd=request.form['cnpwd']
if npwd==cnpwd:
flag=False
cursor = db.cursor()
un=session['uid']
cursor.execute(sql)
rows_count = cursor.fetchall()
print("XXX ",type(rows_count))
if(rows_count[0][5]==cpwd):
cur1 = db.cursor()
sqlu = "update users set password='%s' where userid= '%s'" % (npwd,un)
cur1.execute(sqlu)
db.commit()
else:
else:
return render_template('profile.html',data=rows_count,msg1=msg)
@app.route('/ChangeDetails', methods=['POST'])
def do_ChangeDetails():
msg=""
un=session['uid']
email=request.form['email']
phone=request.form['phone']
address=request.form['address']
cur1 = db.cursor()
print("Sql is ",sqlu)
cur1.execute(sqlu)
db.commit()
cursor = db.cursor()
rows_count = cursor.fetchall()
return render_template('profile.html',data=rows_count,msg1=msg)
@app.route('/registration', methods=['POST'])
def do_registration():
flag=False
name=request.form['username']
email=request.form['email']
phone=request.form['phone']
address=request.form['address']
userid=request.form['userid']
password=request.form['password']
#f = request.files['photos']
#os.chdir("static/profile")
#fname=userid+".jpg"
#f.save(secure_filename(fname))
#cfname="/static/profile/"+str(fname)
#os.chdir('..')
#os.chdir('..')
cursor1 = db.cursor()
print("Sql is ",s)
cursor1.execute(s)
db.commit()
@app.route("/logout")
def logout():
session['logged_in'] = False
return home()
if __name__ == "__main__":
app.secret_key = os.urandom(12)
app.run(debug=True,host='0.0.0.0', port=8000)
6.Testing
Software testing techniques are the ways employed to test the application under test against the
functional or non-functional requirements gathered from business. Each testing technique helps to
find a specific type of defect. For example, Techniques which may find structural defects might not be
able to find the defects against the end-to-end business flow. Hence, multiple testing techniques are
applied in a testing project to conclude it with acceptable quality.
Principles Of Testing
Exhaustive testing is not possible. As we need the optimal amount of testing based on the risk
assessment of the application.
It follows the Pareto rule(80/20 rule) which states that 80% of errors come from 20% of program
components.
Static Testing Techniques are testing techniques which are used to find defects in Application under
test without executing the code. Static Testing is done to avoid errors at an early stage of the
development cycle and thus reducing the cost of fixing them.
Dynamic Testing Techniques are testing techniques that are used to test the dynamic behavior of the
application under test, that is by the execution of the code base. The main purpose of dynamic
testing is to test the application with dynamic inputs- some of which may be allowed as per
requirement (Positive testing) and some are not allowed (Negative Testing).
Each testing technique has further types as showcased in the below diagram. Each one of them will
be explained in detail with examples below.
Testing Techniques
As explained earlier, Static Testing techniques are testing techniques that do not require the
execution of a code base. Static Testing Techniques are divided into two major categories:
Reviews: They can range from purely informal peer reviews between two developers/testers on the
artifacts (code/test cases/test data) to totally formal Inspections which are led by moderators who can
be internal/external to the organization.
Peer Reviews: Informal reviews are generally conducted without any formal setup. It is between
peers. For Example- Two developers/Testers review each other’s artifacts like code/test cases.
Walkthroughs: Walkthrough is a category where the author of work (code or test case or document
under review) walks through what he/she has done and the logic behind it to the stakeholders to
achieve a common understanding or for the intent of feedback.
Technical review: It is a review meeting that focuses solely on the technical aspects of the document
under review to achieve a consensus. It has less or no focus on the identification of defects based on
reference documentation. Technical experts like architects/chief designers are required for doing the
review. It can vary from Informal to fully formal.
Inspection: Inspection is the most formal category of reviews. Before the inspection, The document
under review is thoroughly prepared before going for an inspection. Defects that are identified in the
Inspection meeting are logged in the defect management tool and followed up until closure. The
discussion on defects is avoided and a separate discussion phase is used for discussions, which
makes Inspections a very effective form of reviews.
Static Analysis: Static Analysis is an examination of requirement/code or design with the aim of
identifying defects that may or may not cause failures. For Example- Reviewing the code for the
following standards. Not following a standard is a defect that may or may not cause a failure. There
are many tools for Static Analysis that are mainly used by developers before or during Component or
Integration Testing. Even Compiler is a Static Analysis tool as it points out incorrect usage of syntax,
and it does not execute the code per se. There are several aspects to the code structure – Namely
Data flow, Control flow, and Data Structure.
Data Flow: It means how the data trail is followed in a given program – How data gets accessed and
modified as per the instructions in the program. By Data flow analysis, You can identify defects like a
variable definition that never got used.
Control flow: It is the structure of how program instructions get executed i.e conditions, iterations, or
loops. Control flow analysis helps to identify defects such as Dead code i.e a code that never gets
used under any condition.
Data Structure: It refers to the organization of data irrespective of code. The complexity of data
structures adds to the complexity of code. Thus, it provides information on how to test the control flow
and data flow in a given code.
1. Structure-based Testing:
These are also called White box techniques. Structure-based testing techniques are focused on how
the code structure works and test accordingly. To understand Structure-based techniques, We first
need to understand the concept of code coverage.
Code Coverage is normally done in Component and Integration Testing. It establishes what code is
covered by structural testing techniques out of the total code written. One drawback of code coverage
is that- it does not talk about code that has not been written at all (Missed requirement), There are
tools in the market that can help measure code coverage.
3. Conditional/Multiple condition coverage: It has the aim to identify that each outcome of every logical
condition in a program has been exercised.
2. Experience-Based Techniques:
These are techniques of executing testing activities with the help of experience gained over the years.
Domain skill and background are major contributors to this type of testing. These techniques are used
majorly for UAT/business user testing. These work on top of structured techniques like Specification-
based and Structure-based, and it complements them. Here are the types of experience-based
techniques:
1. Error guessing: It is used by a tester who has either very good experience in testing or with the
application under test and hence they may know where a system might have a weakness. It cannot
be an effective technique when used stand-alone but is really helpful when used along with structured
techniques.
2. Exploratory testing: It is hands-on testing where the aim is to have maximum execution coverage
with minimal planning. The test design and execution are carried out in parallel without documenting
the test design steps. The key aspect of this type of testing is the tester’s learning about the strengths
and weaknesses of an application under test. Similar to error guessing, it is used along with other
formal techniques to be useful.
3. Specification-based Techniques:
This includes both functional and nonfunctional techniques (i.e. quality characteristics). It basically
means creating and executing tests based on functional or non-functional specifications from the
business. Its focus is on identifying defects corresponding to given specifications. Here are the types
of specification-based techniques:
1. Equivalence partitioning: It is generally used together and can be applied to any level of testing.
The idea is to partition the input range of data into valid and non-valid sections such that one partition
is considered “equivalent”. Once we have the partitions identified, it only requires us to test with any
value in a given partition assuming that all values in the partition will behave the same. For example, if
the input field takes the value between 1-999, then values between 1-999 will yield similar results, and
we need NOT test with each value to call the testing complete.
2. Boundary Value Analysis (BVA): This analysis tests the boundaries of the range- both valid and
invalid. In the example above, 0,1,999, and 1000 are boundaries that can be tested. The reasoning
behind this kind of testing is that more often than not, boundaries are not handled gracefully in the
code.
3. Decision Tables: These are a good way to test the combination of inputs. It is also called a Cause-
Effect table. In layman’s language, One can structure the conditions applicable for the application
segment under test as a table and identify the outcomes against each one of them to reach an
effective test.
It should be taken into consideration that there are not too many combinations, so that table becomes
too big to be effective.
Take an example of a Credit Card that is issued if both credit score and salary limit are met. This can
be illustrated in below decision table:
Decision Table
4. Use case-based Testing: This technique helps us to identify test cases that execute the system as
a whole- like an actual user (Actor), transaction by transaction. Use cases are a sequence of steps
that describe the interaction between the Actor and the system. They are always defined in the
language of the Actor, not the system. This testing is most effective in identifying the integration
defects. Use case also defines any preconditions and postconditions of the process flow. ATM
machine example can be tested via use case:
Use case-based Testing
5. State Transition Testing: It is used where an application under test or a part of it can be treated as
FSM or finite state machine. Continuing the simplified ATM example above, We can say that ATM
flow has finite states and hence can be tested with the State transition technique. There are 4 basic
things to consider –
8.Conclusion …………………....85
Our Ticketless entry system completely eliminates the manual ticketing system in museums. All the
difficulties attached with the manual ticketing system will be completely eradicated with this system.
Museum virtual tours can be added to display the various interesting sections of the facility and route
map and proximity to railway station and airports.
10.Bibliography
● References …………………….89
https://ieeexplore.ieee.org/abstract/document/8745493
25/06/2019 · In this paper, we propose a methodology for estimating the crowd speed using WiFi
devices without relying on people to carry any device. Our approach not only enables speed
estimation in the region where WiFi links are, but also in the adjacent possibly WiFi-free regions. More
specifically, we use a pair of WiFi links in one region, whose RSSI measurements are then …
Papers - IEEEVR
https://ieeevr.org/2021/program/papers
To tackle this problem, this paper proposes a novel approach that can precisely estimate the
illumination of the input image, and collaboratively utilizes illumination-based data augmentation
https://www.researchgate.net/publication/260508372_Estimating_Crowd...
Abstract — Crowd density estimating is a crucial service in. many applications (e.g., smart guide, cr
owd control, etc.), which. is often conducted using pattern r ecognition technologies based ...
https://www.sciencedirect.com/science/article/pii/S0925753597000817
01/04/1998 · The technique described in this paper uses this fact to estimate crowd densities. The
estimation of crowd densities is based on texture measures of the images and is given in terms of
ranges such as very low, low, moderate, high and very high densities.
https://www.researchgate.net/publication/313348170_On_Crowd_Density...
To estimate crowd density for urban analysis, surveillance cameras are installed in different locations
in a given area; computer-vision techniques are then applied to the captured data to count ...
https://www.emerald.com/insight/content/doi/10.1108/JPMD-10-2019-0090/...
16/04/2020 · This paper aims to explore the development and application of place crowd safety
management tools for areas of public assembly and major events, from a practitioner
https://ieeexplore.ieee.org/document/4637334
18/09/2008 · Recent years have seen advances in many enabling augmented reality technologies.
Furthermore, much research has been carried out on how augmented reality can be used to enhance
existing applications. This paper describes our experiences with an AR-museum guide that combines
some of the latest technologies. Amongst other technologies, markerless …
https://ieeexplore.ieee.org/document/8537302
05/01/2018 · Buses are an integral means of public transport in India. In metropolitan cities like
Mumbai and Delhi, 10-15 million people travel through public transport buses daily. Today, in the era
of Digital India (a campaign launched by the Government of India) and Cashless.