Defect Tracking System: Jss College, Computer Science Dept. Dharwad
Defect Tracking System: Jss College, Computer Science Dept. Dharwad
Current System:
In software test management, bug reporting is a complex and complicated
process that requires precision, detailing and a whole lot of information. Reporting and
tracking bugs manually works fine in case of small projects, whereas for mission-critical
or large projects, a paper-based approach can result in chaos and confusion. QA test
management teams need an effective defect tracking management system to log the
identified bugs and to monitor them.
Proposed System:
Online bug tracking software is designed to work on a much larger scale than
intranet based bug tracking software. Before software is available for purchase, a beta
version of the software is released so users other than the company's testers can test
the software. Beta versions of software are shipped to various destinations all over the
world and are not restricted to a limited network. Not all beta testers are professional
software testers; this means that a bug tracking system has to be user friendly so that all
levels of users can report bugs easily.
The bug tracking software allows testers to report bugs directly. Users can log
onto the online bug tracking software and input any bugs encountered directly into the
system. Direct error reporting ensures that users can enter specific details that an
automated error reporting system cannot. Online bug tracking software has multiple
advantages. The first advantage is that online bug tracking software is almost always
available to users.
Let’s assume in your application under test you want to create a new user with
user information, for that you need to logon into the application and navigate to USERS
menu > New User, then enter all the details in the ‘User form’ like, First Name, Last
Name, Age, Address, Phone etc. Once you enter all these information, you need to click
on ‘SAVE’ button in order to save the user. Now you can see a success message saying,
“New User has been created successfully”. But when you entered into your application
by logging in and navigated to USERS menu > New user, entered all the required
information to create new user and clicked on SAVE button. BANG! The application
crashed and you got one error page on screen. (Capture this error message window and
save as a Microsoft paint file)
2. Project Manager
3. Developer / team
4. Tester / User
Report a bug
It’s easy to keep track of one bug, but keeping track of many bugs is hard work. A
tool helps you easily find out what bugs are still open, fixed, and closed. Bug
tracking tools normally allow you to sort and filter your bugs and create reports
on the bugs.
You can track other stuff about bugs, such as how important they are and who is
fixing them. This can help you prioritize which bugs are important and require
urgent fixing.
You can start seeing clusters of bugs which indicates there may be underlying
issues in parts of the code
Lots of people can see the status of the bugs, not just the tester and the
developer. The overall bug status can be quickly reviewed by many avoiding nasty
surprise syndrome (NSS) at the end of development/testing.
Sometimes not all bugs are fixed in the current release but will be fixed and
tested in a future release. This means long after software release the bugs still
need to kept open and tracked. A bug tracking tool ensures that these bugs are
not overlooked in the future.
A bug tracking tool can centralize information. Often a bug tracking tool can be
used to track new features as well as issues and can act as a document repository
A bug tracking tool can improve productivity by increasing bug awareness and
responsiveness. It is also handy when a project is scattered geographically and
works across different time zones.
Security Architecture.
UNDERSTANDING MICROSOFT.NET:
Microsoft .NET is an umbrella term that describes a number of recently released
technologies from Microsoft. Taken together, these technologies are the most
substantial changes to the Microsoft development platform since the transition from 16-
bit to 32-bit development
The Common Language Runtime (CLR) provides a run-time environment for the
execution of code written in any .NET code, including memory and object lifetime
management.
The individual language compliers compile the code written by developers into an
intermediate language called Microsoft Intermediate Language (IL or MSIL). The IL is
then Just-In-Time (JIT) compiled at first execution.
The .NET framework class library is designed to support the efforts of developers
by providing base classes from which developers can inherit. This class library is a
hierarchical set of .NET classes that developers can use in their own applications. These
classes, which are organized by containers referred to as namespaces, provide both
basic and advanced functionality that developers can easily reuse. They include classes
that support basic common data types that provide access to data and classes that
support such system services.
One of the best things about the .NET platform is that whereas classic ASP
restricted developers to using scripting languages. ASP.NET lets you work with any .NET
complaint language. This means that the code you write in ASP.NET is Compiled for
better performance and you can take full advantage of advanced language features.
For the .NET platform, languages are probably one of the most important topics
to discuss. Let’s take a high-level look at some of the languages and tools that will be
available for developing .NET applications.
Features of ASP.NET:
Web forms: This is the new programming model of ASP.NET Web Forms combines
the best of ASP with the ease of development and productivity of Visual Basic.
Server controls: A major component of the Web Form programming model, the
ASP.NET server control map approximately to HTML elements.
What is ASP.NET?
Power and Flexibility : Because ASP.NET is based on the common language runtime,
the power and flexibility of that entire platform is available to Web application
developers. The .NET Framework class library, Messaging, and Data Access solutions
are all seamlessly accessible from the Web. ASP.NET is also language-independent, so
you can choose the language that best applies to your application or partition your
application across many languages. Further, common language runtime
interoperability guarantees that your existing investment in COM-based development
is preserved when migrating to ASP.NET.
Simplicity : ASP.NET makes it easy to perform common tasks, from simple form
submission and client authentication to deployment and site configuration. For
example, the ASP.NET page framework allows you to build user interfaces that
cleanly separate application logic from presentation code and to handle events in a
simple, Visual Basic - like forms processing model.
Additionally, the common language runtime simplifies development, with managed
code services such as automatic reference counting and garbage collection.
Manageability : ASP.NET employs a text-based, hierarchical configuration system,
which simplifies applying settings to your server environment and Web applications.
Because configuration information is stored as plain text, new settings may be
applied without the aid of local administration tools. This "zero local
administration" philosophy extends to deploying ASP.NET Framework applications
as well. An ASP.NET Framework application is deployed to a server simply by
copying the necessary files to the server. No server restart is required, even to
deploy or replace running compiled code.
Scalability and Availability : ASP.NET has been designed with scalability in mind,
with features
The ability to create and use reusable UI controls that can encapsulate common
functionality and thus reduce the amount of code that a page developer has to write.
The ability for developers to cleanly structures their page logic in an orderly fashion
(not "spaghetti code").
This section of the Quick Start provides a high-level code walkthrough of some key
ASP.NET Web Forms features. Subsequent sections of the
Internet Integration
Scalability and Availability
Enterprise-Level Database Features
Data warehousing
Internet Integration:
The SQL Server 2000 database engine includes integrated XML support. It also has
the scalability, availability, and security features required to operate as the data storage
component of the largest Web sites. The SQL Server 2000 programming model is
integrated with the Windows DNA architecture for developing Web applications, and
SQL Server 2000 supports features such as English Query and the Microsoft Search
Service to incorporate user-friendly queries and powerful search capabilities in Web
applications.
The same database engine can be used across platforms ranging from laptop
computers running Microsoft Windows 98 through large, multiprocessor servers running
Microsoft Windows 2000 Data Center Edition. SQL Server 2000 Enterprise Edition
supports features such as federated servers, indexed views, and large memory support
that allow it to scale to the performance levels required by the largest Web sites.
The SQL Server 2000 relational database engine supports the features required to
support demanding data processing environments. The database engine protects data
integrity while minimizing the overhead of managing thousands of users concurrently
modifying the database. SQL Server 2000 distributed queries allow you to reference
data from multiple sources as if it were a part of a SQL Server 2000 database, while at
the same time, the distributed transaction support protects the integrity of any updates
of the distributed data. Replication allows you to also maintain multiple copies of data,
while ensuring that the separate copies remain synchronized. You can replicate a set of
data to multiple, mobile, disconnected users, have them work autonomously, and then
merge their modifications back to the publisher.
Data warehousing:
SQL Server 2000 includes tools for extracting and analyzing summary data for
online analytical processing. SQL Server also includes tools for visually designing
databases and analyzing data using English-based questions.
Database:
A database is similar to a data file in that it is a storage place for data. Like a data
file, a database does not present information directly to a user; the user runs an
application that accesses data from the database and presents it to the user in an
understandable format.
Database systems are more powerful than data files in that data is more highly
organized. In a well-designed database, there are no duplicate pieces of data that the
user or application must update at the same time. Related pieces of data are grouped
together in a single structure or record, and relationships can be defined between these
structures and records.
When working with data files, an application must be coded to work with the
specific structure of each data file. In contrast, a database contains a catalog that
applications use to determine how data is organized. Generic database applications can
use the catalog to present users with data from different databases dynamically,
without being tied to a specific data format.
A database typically has two main parts: first, the files holding the physical database and
second, the database management system (DBMS) software that applications use to
access data. The DBMS is responsible for enforcing the database structure, including:
Maintaining relationships between data in the database. Ensuring that data is stored
correctly and that the rules defining data relationships are not violated.
Relational Database:
When organizing data into tables, you can usually find many different ways to
define tables. Relational database theory defines a process called normalization, which
ensures that the set of tables you define will organize your data effectively.
Scalable:
SQL Server 2000 supports having a wide range of users access it at the same time.
An instance of SQL Server 2000 includes the files that make up a set of databases and a
copy of the DBMS software. Applications running on separate computers use a SQL
Server 2000 communications component to transmit commands over a network to the
SQL Server 2000 instance. When an application connects to an instance of SQL Server
2000, it can reference any of the databases in that instance that the user is authorized
to access. The communication component also allows communication between an
instance of SQL Server 2000 and an application running on the same computer. You can
run multiple instances of SQL Server 2000 on a single computer.
SQL Server 2000 is designed to support the traffic of the largest Web sites or
enterprise data processing systems. Instances of SQL Server 2000 running on large,
multiprocessor servers are capable of supporting connections to thousands of users at
the same time. The data in SQL Server tables can be partitioned across multiple servers,
so that several multiprocessor computers can cooperate to support the database
processing requirements of extremely large systems. These groups of database servers
are called federations.
Although SQL Server 2000 is designed to work as the data storage engine for
thousands of concurrent users who connect over a network, it is also capable of working
as a stand-alone database directly on the same computer as an application. The
scalability and ease-of-use features of SQL Server 2000 allow it to work efficiently on a
single computer without consuming too many resources or requiring administrative
work by the stand-alone user. The same features allow SQL Server 2000 to dynamically
acquire the resources required to support thousands of users, while minimizing
database administration and tuning. The SQL Server 2000 relational database engine
dynamically tunes itself to acquire or free the appropriate computer resources required
to support a varying load of users accessing an instance of SQL Server 2000 at any
specific time. The SQL Server 2000 relational database engine has features to prevent
the logical problems that occur if a user tries to read or modify data currently used by
others.
To work with data in a database, you have to use a set of commands and
statements (language) defined by the DBMS software. Several different languages can
be used with relational databases; the most common is SQL. The American National
Standards Institute (ANSI) and the International Standards Organization (ISO) define
software standards, including standards for the SQL language. SQL Server 2000 supports
the Entry Level of SQL-92, the SQL standard published by ANSI and ISO in 1992. The
dialect of SQL supported by Microsoft SQL Server is called Transact-SQL (T-SQL). T-SQL is
the primary language used by Microsoft SQL Server applications.
Microsoft SQL Server 2000 is capable of supplying the database services needed
by extremely large systems. Large servers may have thousands of users connected to an
instance of SQL Server 2000 at the same time. SQL Server 2000 has full protection for
these environments, with safeguards that prevent problems, such as having multiple
users trying to update the same piece of data at the same time. SQL Server 2000 also
allocates the available resources effectively, such as memory, network bandwidth, and
disk I/O, among the multiple users.
Extremely large Internet sites can partition their data across multiple servers, spreading
the processing load across many computers, and allowing the site to serve thousands of
concurrent users.
Multiple instances of SQL Server 2000 can be run on a single computer. For
example, an organization that provides database services to many other organizations
can run a separate instance of SQL Server 2000 for each customer organization, all on
one computer. This isolates the data for each customer organization, while allowing the
service organization to reduce costs by only having to administer one server computer.
SQL Server 2000 applications can run on the same computer as SQL Server 2000.
The application connects to SQL Server 2000 using Windows Interprocess
Communications (IPC) components, such as shared memory, instead of a network. This
allows SQL Server 2000 to be used on small systems where an application must store its
data locally.
The illustration shows an instance of SQL Server 2000 operating as the database server
for both a large Web site and a legacy client/server system.
The largest Web sites and enterprise-level data processing systems often generate more
databases processing than can be supported on a single computer. In these large
systems, the database services are supplied by a group of database servers that form a
database services tier. SQL Server 2000 does not support a load-balancing form of
clustering for building a database services tier, but it does support a mechanism that can
be used to partition data across a group of autonomous servers. Although each server is
administered individually, the servers cooperate to spread the database-processing load
across the group. A group of autonomous servers that share a workload is called a
federation of servers
PROJECT SUBJECT:
The defect tracking system allows testers to report bugs directly. Users can log
onto the online defect tracking system and input any bugs encountered directly
into the system. Direct error reporting ensures that users can enter specific
details that an automated error reporting system cannot. Defect tracking system
has multiple advantages. The first advantage is that defect tracking system is
almost always available to users.
Software Requirements:
Language : ASP.NET
Hardware Requirements:
In the traditional S.D.L.C data flow diagrams were generated in the analysis phase
and structure charts were used in the design phase. Modern day software experts
suggested an amendment to this. According to them instead of drawing two versions of
the same concept (one for the end users & another for the programmers). Only one
format could be designed to satisfy both the parties. Today the role of the programmer
has changed from being a programmer to being one of the members of the design team.
So, even though the end user might require the easy to understand data flow diagrams,
the programmer can himself may arrive at the structure of the system. Thus data flow
diagrams have thought of as the new basis for the design.
Designing with the Data Flow Diagrams involves creating a model of the system.
The entities and attributes are a model, of the states of the system. Processes model the
rules of a System. The stimuli and response are modeled by Data Flows. All of these
models are combined into one graphic model called a Data Flow Diagram.
DFD’s have a notation for each of the components of the system. They also have a
notation for representing different levels in a hierarchy of detailed used to describe the
system. This notation makes it possible to represent an overall view of a large complex
system and a detailed view of a part of a system using the same notation. Parts of the
system can be isolated into independent sub-system. These work together as a unit to
perform a set of processes that must be done together at on time.
The Gone & Sarson Notation for the Data Flow Design has been followed for the
current documentation. The nomenclature for the Gone & Sarson Notation is discussed
next.
PROCESSES:
Processes show what the system does. Each process has one or more inputs and
one or more outputs. If a process does not have an output then it is considered to a
Black Hole. The notation for the process is:
Process Name
A file or Data store indicates a respiratory of data. Process can Enter and Retrieve
Data from Data Store. Each Data Source has a unique name. The notation for the Data
Store is:
TABLE NAME
EXTERNAL ENTITIES:
External entities are outside the system but they either supply input data into the
system or make use of the system output. They are entities on which the designer has
no control. They may be an organizations customer or others with which the system
interacts. External entities, which supply the data into the system, are some times called
sinks. The notation for external entity is
ENTITY NAME
DATA FLOWS:
Data flows model the flow of data in the system. It is indicated by line joining the
system components. An arrowhead indicates the direction of data flow and the labels
above the line indicates the name of the data-flow. The notation for the Data Flows is:
ENTITY-RELATIONSHIP DIAGRAM :
(E-R DIAGRAM):
E-R diagrams represent the schemas rather than the instances. This is more useful
because a database schema changes rarely, whereas the extension changes frequently.
In addition, the schema is usually easier to display than the extension of a database,
because it is much smaller.
BUG TABLE:
Component varchar 20
Os Varchar 10
Hardwareplatform varchar 10
Priority varchar 10
Status varchar 10
bugsassignedto varchar 20
LOGIN TABLE:
Employeecode int 4
Role varchar 20
PRODUCT TABLE:
Type varchar 50
version varchar 20
Releasedate datetime 8
REGISTER TABLE:
Name varchar 20
Company varchar 50
type varchar 20
SOLUTION TABLE:
LOGIN STAFF:
LOGIN USER :
USER REGISTRATION:
This registration page/ form is used by new user to create their account. After creating
account he/she will be the member of the site.
ADD PRODUCT:
This page/ form is used to assign managers to relative products. This form is used by
administrator.
This page/ form is used to view the managers assigned to relative products. This form
is used by administrator.
This page/ form is used to assign bugs to relative team member and this form is used
by manager.
This page/ form is used by Team member to check the bugs assigned to them.
VIEW SOLUTION:
This page/ form is used to view the solution for the particular bug.
Login staff:
using System;
using System.Data;
using System.Configuration;
using System.Collections;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Data.OleDb;
Response.Redirect("HomeManager.aspx");
else if (r == "TeamMember")
Response.Redirect("HomeTeamMember.aspx");
}
catch (Exception ex)
{
stmt.Parameters.Clear(); connection.Close();
lblMessage.Text="invalid login"
}
}
Login user:
using System;
using System.Data;
using System.Configuration;
using System.Collections;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Data.OleDb;
stmt.Connection = connection;
stmt.CommandText = "select username from register where username=? and
password=?";
stmt.Parameters.AddWithValue("username", txtUserName.Text);
stmt.Parameters.AddWithValue("password", txtPassword.Text);
try
{
connection.Open();
OleDbDataReader dr =
stmt.ExecuteReader(System.Data.CommandBehavior.SingleRow);
dr.Read();
string r = dr["username"].ToString();
dr.Close();
Session["username"] = txtUserName.Text;
Session["password"] = txtPassword.Text;
if (r == txtUserName.Text)
{
Response.Redirect("HomeUser.aspx");
}
}
catch (Exception ex)
{
stmt.Parameters.Clear();
connection.Close();
lblMsg.Text = "The username or password you entered is incorrect.";
}
}
}
User registration:
using System;
using System.Data;
using System.Configuration;
using System.Collections;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Data.OleDb;
stmt.Parameters.AddWithValue("username", txtUname.Text);
stmt.Parameters.AddWithValue("password", txtPassword.Text);
stmt.Parameters.AddWithValue("name", txtName.Text);
stmt.Parameters.AddWithValue("company", txtCompany.Text);
stmt.Parameters.AddWithValue("type", txtType.Text);
try
{
connection.Open();
stmt.ExecuteNonQuery();
stmt.Parameters.Clear(); connection.Close();
lblMsg.Text = "Registration Done";
txtUname.Text = ""; txtName.Text = "";
Add product:
using System;
using System.Data;
using System.Configuration;
using System.Collections;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Data.OleDb;
stmt.Connection = connection;
stmt.Parameters.AddWithValue("productcode",TxtPcode.Text);
stmt.Parameters.AddWithValue("productname",txtPname.Text);
stmt.Parameters.AddWithValue("type",txtType.Text);
stmt.Parameters.AddWithValue("version", txtVersion.Text);
stmt.Parameters.AddWithValue("releasedate", txtRdate.Text);
try
{
connection.Open();
stmt.ExecuteNonQuery();
stmt.Parameters.Clear();
connection.Close();
lblMsg.Text = "Registration Done";
TxtPcode.Text = "";
txtPname.Text = "";
txtRdate.Text = "";
txtType.Text = "";
txtVersion.Text = "";
lblMsg.Text = "";
}
catch (Exception)
{
stmt.Parameters.Clear();
connection.Close();
lblMsg.Text = "Registration Failed";
}
}
TxtPcode.Text = "";
txtPname.Text = "";
txtRdate.Text = "";
txtType.Text = "";
txtVersion.Text = "";
lblMsg.Text = "";
}
protected void Button1_Click(object sender, EventArgs e)
{
Response.Redirect("AddProduct.aspx");
}
}
try
{
connection.Open();
OleDbDataReader dr =
stmtGenerate.ExecuteReader(System.Data.CommandBehavior.SingleRow);
dr.Read();
int count = int.Parse(dr[0].ToString());
if (count == 0)
slno = 1;
else
slno = int.Parse(dr[1].ToString()) + 1;
dr.Close();
stmtGenerate.Parameters.Clear();
stmtproductmanager.Parameters.AddWithValue("productcode",ddlproductcode.Selecte
dItem.Value);
stmtproductmanager.Parameters.AddWithValue("productmanager",
ddlproductmanager.SelectedItem.Value);
stmtproductmanager.ExecuteNonQuery();
stmtproductmanager.Parameters.Clear();
connection.Close();
lblMsg.Text = "submission Done";
}
catch (Exception)
{
stmtproductmanager.Parameters.Clear();
connection.Close();
lblMsg.Text = "This product is already assigned to another manager";
}
DateTime reportdate;
try
{
connection.Open();
OleDbDataReader dr =
stmtGenerate.ExecuteReader(System.Data.CommandBehavior.SingleRow);
dr.Read();
int count = int.Parse(dr[0].ToString());
if (count == 0)
bugid = 1;
else
bugid = int.Parse(dr[1].ToString()) + 1;
dr.Close();
stmtGenerate.Parameters.Clear();
stmtbugs.Parameters.AddWithValue("bugid", bugid);
stmtbugs.Parameters.AddWithValue(" reportdate",
DateTime.Now.ToShortDateString());
stmtbugs.Parameters.AddWithValue("productcode", txtPcode.Text);
stmtbugs.Parameters.AddWithValue("username", txtUname.Text);
stmtbugs.Parameters.AddWithValue("component",
ddlComponant.SelectedItem.Value);
stmtbugs.Parameters.AddWithValue("bugsummary", txtBsummary.Text);
stmtbugs.Parameters.AddWithValue("stepstoreproduce", txtssProcedure.Text);
stmtbugs.Parameters.AddWithValue("expectedresult", txtEresult.Text);
stmtbugs.Parameters.AddWithValue("os", txtos.Text);
stmtbugs.Parameters.AddWithValue("hardwareplatform",
ddlHwPlatform.SelectedItem.Value);
stmtbugs.Parameters.AddWithValue("priority", ddlPriority.SelectedItem.Value);
stmtbugs.Parameters.AddWithValue("status",txtStatus.Text);
stmtbugs.ExecuteNonQuery();
stmtbugs.Parameters.Clear();
connection.Close();
lblMsg.Text = "Successfully Submited ";
txtPcode.Text = "";
txtUname.Text = "";
txtBsummary.Text = "";
txtEresult.Text = "";
txtos.Text = "";
txtssProcedure.Text = "";
txtStatus.Text = "";
}
catch (Exception ex)
{
stmtbugs.Parameters.Clear();
connection.Close();
lblMsg.Text = "Submission Failed" ;
}
}
}
protected void btnCancel_Click(object sender, EventArgs e)
{
Response.Redirect("AddBugUser.aspx");
}
protected void ddlPcode_SelectedIndexChanged(object sender, EventArgs e)
{
txtPcode.Text = ddlPcode.SelectedItem.Value;
}
}
Solution :
using System;
using System.Data;
using System.Configuration;
using System.Collections;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Data.OleDb;
string bugid;
int solutionid;
protected void Page_Load(object sender, EventArgs e)
{
txtBugid.Text = Request.QueryString["param"].ToString();
}
protected void btnUpdate_Click(object sender, EventArgs e)
{
OleDbDataReader dr =
stmtGenerate.ExecuteReader(System.Data.CommandBehavior.SingleRow);
dr.Read();
int count = int.Parse(dr[0].ToString());
if (count == 0)
solutionid = 1;
else
solutionid = int.Parse(dr[1].ToString()) + 1;
dr.Close();
stmtGenerate.Parameters.Clear();
stmtbugs.CommandText = "update bugs set status='closed' where bugid=?";
stmtbugs.Parameters.AddWithValue("BugId", txtBugid.Text);
stmtsolution.Parameters.AddWithValue("BugId", txtBugid.Text);
stmtsolution.Parameters.AddWithValue("solutiondate",DateTime.Now.ToShortDateStri
ng());
stmtsolution.Parameters.AddWithValue("solution",txtSolution.Text);
stmtsolution.ExecuteNonQuery();
stmtbugs.ExecuteNonQuery();
stmtsolution.Parameters.Clear();
stmtbugs.Parameters.Clear();
connection.Close();
Testing:
The web site is used experimentally to ensure that it does not fail i.e. it will run
according to the specification and in the way the user expects. Testing is one of the
essential parts in developing an application to demonstrate the correctness of the
software program. This is achieved though verification, validation and testing activities .
A strategy for web application testing integrates application test case design into a well
planned series of steps that results in successful construction of web site.
A web site testing strategy provides a road map for the developer, the quality assurance
organization and the customer. Testing is a set of activity that can be planned in
advance and conducted systematically.
A strategy for web application testing must accommodate low test that are necessary
to verify that a small source code has been correctly implemented as well as high level
test that validate major system against client requirement.
Unit Testing
System Testing
Unit Testing:
All the modules were tested individually after their completion were checked for
their correct functionality.
Specification testing:
Specification testing examines the specification starting what the program should
do and how it should perform under various conditions. Then test cases are developed
for each condition and combination of condition and to be submitted for processing.
In this, test cases are generated on the logical of each module by drawing flow
graphs of that module and logical decision are tested on all the cases. The test can be
carried out in the following cases:
System testing checks the readiness and accuracy of the system access, update
and retrieve data from new files. Finally the whole system was tested to implements the
functions as desired, incorporating all the specification specified. System testing is made
to ensure that the application does not fail. The purpose of testing is finding errors and
not providing programs errors.
(Wrox Publishers)
4. MS SQL Server 2000 E. Petroutsos