A.V.C.

COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS

A.V.C COLLEGE OF ENGINEERING – MANNAMPANDAL -609305

MAYILADUTHURAI

DEPARTMENT OF COMPUTER APPLICATIONS

PROJECT TITLE

PRIVACY PRESERVING DATA MINING SYSTEMS

FIRST PROJECT REVIEW REPORT

Name: D.S.Arun Francis Reg.No: 80106621006

Course: MCA Batch : 2006-2009

Date : 23-3-2009

External Guide Name :Mr.K.Vijayan Internal Guide Name: Mr.T.RamKumar

(Company) (College)

COMPANY NAME AND ADRRESS:

15,T.B.Road,Mappalayam,
Madurai-625 010.
 A.V.C.COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS
INTRODUCTION

Many organizations collect large amounts of data about their clients and customers. Such
data was used for record keeping. Data mining can extract valuable knowledge from this data
.Organizations can obtain better results by pooling their data together. However, the collected data
may contain sensitive or private information about the organizations or their customers, and
privacy concerns are exacerbated if data is shared between multiple organizations. Distributed
data mining is concerned with the computation of models from data that is distributed among
multiple participants. Privacy-preserving distributed data mining seeks to allow for the
cooperative computation of such models without the cooperating parties revealing any of their
individual data items. Our project makes two contributions in privacy-preserving data mining.
First, we introduce the concept of arbitrarily partitioned data, which is a generalization of both
horizontally and vertically partitioned data. Second, we provide an efficient privacy-preserving
protocol for k-means clustering in the setting of arbitrarily partitioned data. Privacy-preserving
distributed data mining allows the cooperative computation of data mining algorithms without
requiring the participating organizations to re- veal their individual data items to each other.
We present a simple I/O-efficient k-clustering algorithm that was designed with the goal of
enabling a privacy-preserving version of the algorithm. Our experiments show that this algorithm
produces cluster centers that are, on average, more accurate than the ones produced by the well
known iterative k-means algorithm. We use our new algorithm as the basis for a communication-
efficient privacy-preserving k-clustering protocol for databases that are horizontally partitioned
between two parties. Unlike existing privacy-preserving protocols based on the k-means
algorithm, this protocol does not reveal intermediate candidate cluster centers. In this work, we
propose methods for constructing the dissimilarity matrix of objects.
 A.V.C.COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS

Existing System:

The earlier techniques are data perturbation techniques for privacy preserving classification
model construction on centralized data , techniques for privacy preserving association rule mining
in distributed environments . Techniques from secure multiparty computation form one approach
to privacy-preserving data mining. Yao’s general protocol for secure circuit evaluation can be
used to solve any two-party privacy-preserving distributed data mining problem. However, since
data mining usually involves millions or billions of data items, the communication cost of this
protocol renders it impractical for these purposes.

Proposed System:

In this project, we propose a privacy preserving clustering technique on horizontally

partitioned data. Our method is based on constructing the dissimilarity matrix of objects from
different sites in a privacy preserving manner which can be used for privacy preserving clustering,
as well as database joins, record linkage and other operations that require pair-wise comparison of
individual private data objects distributed over multiple sites. We handle both numeric and
alphanumeric valued attributes. Our main contributions can be summarized as follows:
• Introduction of a protocol for secure multi-party computation of a dissimilarity
matrix over horizontally partitioned data,
• Proof of security of the protocol, analysis of communication costs ,
• Secure comparison methods for numeric, alphanumeric and categorical attributes,
• Application to privacy preserving clustering.
 A.V.C.COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS

Future Enhancement:

Most of the previous studies investigated the problem and proposed solutions based on the
assumption that all parties are honest or semi-honest. While it is sometimes useful, this
assumption substantially underestimates the capability of adversaries and thus does not always
hold in practical situations. We considered a space of more powerful adversaries which include
not only honest and semi-honest adversaries but also those who are weakly malicious and strongly
malicious.

Many extensions to our work exist, including

1) extending the information sharing function from intersection to other operations, and

2) dealing with multiple parties in the system, including dealing with correlated attacks from
multiple adversaries.

DATA FLOW DIAGRAM

 A.V.C.COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS

Cluster Checking

System-1 Start
FTP Server

Decrypt
IF
EXIT
Receive

System-2
Encrypt Choose File

Choose File Send

Receive

USECASE DIAGRAM
 A.V.C.COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS

System1
File Choosing

Starting the FTP

server

Clustering the
Selected File

Encryption

Decryption

Reclustering the
clustered File
 A.V.C.COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS

MODULE DESCRIPTIONS

Modules:
1. Data collection and mining
2. Formation of Cluster
3. Privacy preservation
4. Comparison evaluation of algorithms

1. Data Collection and mining:

The data collection is the important part of the project. The dataset is prepared by
Integrating the organizations details. Such data was initially used only for record keeping. These
large collections of data could be “mined” for knowledge that could improve the performance of
the organization. While much data mining occurs on data within an organization, it is quite
common to use data from multiple sources in order to yield more precise or useful knowledge.
However, privacy and secrecy considerations can prohibit organizations from being willing or
able to share their data with each other. Therefore we preserve Privacy-preserving data mining
technique.

2. Formation of Cluster:

The k-means of clustering algorithm is used for cluster formation. K-Means Clustering and
Fuzzy Clustering are different than Hierarchical Clustering and Diversity Selection in that the
number of clusters, K, needs to be determined at the onset. The goal is to divide the objects into K
clusters such that some metric relative to the centroids of the clusters is minimized. If the
clustering is over binary objects, medoids need to be used instead of centroids. A medoid is just a
bit string that minimizes the sum of distances to all objects in the cluster.

Various metrics to the centroids that can be minimized include

• Maximum distance to its centroid for any object.

 A.V.C.COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS
• Sum of the average distance to the centroids over all clusters.
• Sum of the variance over all clusters.
• Total distance between all objects and their centroids.
• 3. Privacy preservation:

Privacy-preserving data mining solutions have been presented both with respect to
horizontally and vertically partitioned databases, in which either different data objects with the
same attributes, are owned by each party, or different attributes for the same data objects are
owned by each party, respectively. We introduce the notion of arbitrarily partitioned data,
which generalizes both horizontally and vertically partitioned data. In arbitrarily partitioned
data, different attributes for different items can be owned by either party. Although extremely
“patchworked” data is unlikely in practice, one advantage of considering arbitrarily partitioned
data is that protocols in this model apply both to horizontally and vertically partitioned data, as
well as to hybrid that are mostly, but not completely, vertically or horizontally partitioned.

4. Comparison evaluation of algorithms :

In this project , we present a simple deterministic algorithm, Recluster,
for I/O-efficient k-clustering. This algorithm, which was explicitly designed with conversion to a
privacy-preserving version in mind, examines each data item only once and uses only sequential
access to the data. For fixed k, Recluster runs in O(n) time and uses O(log n) space. Our
experimental results show that Recluster is, on average, more accurate in identifying cluster
centers than the k-means clustering algorithm. Although there are other clustering algorithms that
improve on the k-means algorithm, this is the first for which an efficient cryptographic privacy-
preserving version has been demonstrated.

SCREEN SHOTS
 A.V.C.COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS
 A.V.C.COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS
 A.V.C.COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS
 A.V.C.COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS
 A.V.C.COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS
 A.V.C.COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS
 A.V.C.COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS
 A.V.C.COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS
 A.V.C.COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS
 A.V.C.COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS

DATABASE DESCRIPTION

PRIVACY PRESERVATION :

FIELD TYPE

ID Integer

IP ADDRESS String

LOGIN 1:

FIELD TYPE

ID Integer

USERNAME String

PASSWORD String

LOGIN 2:

FIELD TYPE

ID Integer

USERNAME String

PASSWORD String
 A.V.C.COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS

SAMPLE CODING

/*---------------Centroid.java-----------------*/

package distance;
class Centroid {
private double mCx, mCy;
private Cluster mCluster;
public Centroid(double cx, double cy) {
this.mCx = cx;
this.mCy = cy;
}
public void calcCentroid() { //only called by CAInstance
int numDP = mCluster.getNumDataPoints();
double tempX = 0, tempY = 0;
int i;
//caluclating the new Centroid
for (i = 0; i < numDP; i++) {
tempX = tempX + mCluster.getDataPoint(i).getX();
//total for x
tempY = tempY + mCluster.getDataPoint(i).getY();
//total for y
}
this.mCx = tempX / numDP;
this.mCy = tempY / numDP;
//calculating the new Euclidean Distance for each Data Point
tempX = 0;
tempY = 0;
for (i = 0; i < numDP; i++) {
mCluster.getDataPoint(i).calcEuclideanDistance();
}
//calculate the new Sum of Squares for the Cluster
mCluster.calcSumOfSquares();
}
public void setCluster(Cluster c) {
this.mCluster = c;
}
public double getCx() {
 A.V.C.COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS
return mCx;
}
public double getCy() {
return mCy;
}
public Cluster getCluster() {
return mCluster;
}
}
/*-----------------Cluster.java----------------*/
package distance;
import java.util.Vector;
class Cluster
{
private String mName;
private Centroid mCentroid;
private double mSumSqr;
private Vector mDataPoints;
public Cluster(String name)
{
this.mName = name;
this.mCentroid = null; //will be set by calling //setCentroid()
mDataPoints = new Vector();
}
public void setCentroid(Centroid c)
{
mCentroid = c;
}
public Centroid getCentroid()
{
return mCentroid;
}
public void addDataPoint(DataPoint dp)
{ //called from CAInstance
dp.setCluster(this); //initiates a inner call to
//calcEuclideanDistance() in DP.
this.mDataPoints.addElement(dp);
calcSumOfSquares();
}
public void removeDataPoint(DataPoint dp)
{
 A.V.C.COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS
this.mDataPoints.removeElement(dp);
calcSumOfSquares();
}
public int getNumDataPoints()
{
return this.mDataPoints.size();
}
public DataPoint getDataPoint(int pos)
{
return (DataPoint) this.mDataPoints.elementAt(pos);
}
public void calcSumOfSquares()
{ //called from Centroid
int size = this.mDataPoints.size();
double temp = 0;
for (int i = 0; i < size; i++)
{
temp = temp + ((DataPoint)
this.mDataPoints.elementAt(i)).getCurrentEuDt();
}
this.mSumSqr = temp;
}
public double getSumSqr()
{
return this.mSumSqr;
}
public String getName()
{
return this.mName;
}
public Vector getDataPoints()
{
return this.mDataPoints;
}

}
// GRAPH.java//
package Graph;
import java.awt.Point;
public class Cluster{
public Point point=null;
 A.V.C.COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS
public int finished=0;
public Cluster(int x,int y) {
// TODO Auto-generated constructor stub
x=setX(x);
y=setY(y);
this.point=new Point(x,y);
}
public int setX(int i){
i=(int) (Graph.p2.getX()+(i*(Graph.Xlength/Graph.Xedge)));
//i=(int) (Graph.p2.getX()+(i*Graph.Xp));
return i;
}
public int setY(int j){
j=(int)(Graph.p2.getY()-(j*(Graph.Ylength/Graph.Yedge)));
//j=(int) (Graph.p2.getY()-(j*Graph.Yp));
return j;
}
}
/*----------------DataPoint.java----------------*/
package distance;
public class DataPoint {
private double mX,mY;
private String mObjName;
private Cluster mCluster;
private double mEuDt;
public DataPoint(double x, double y, String name) {
this.mX = x;
this.mY = y;
this.mObjName = name;
this.mCluster = null;
}
public void setCluster(Cluster cluster) {
this.mCluster = cluster;
calcEuclideanDistance();
}
public void calcEuclideanDistance() {

mEuDt = Math.sqrt(Math.pow((mX - mCluster.getCentroid().getCx()),

2) + Math.pow((mY - mCluster.getCentroid().getCy()), 2));
// System.out.println(" medu "+mEuDt);
}
public double testEuclideanDistance(Centroid c) {
 A.V.C.COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS
return Math.sqrt(Math.pow((mX - c.getCx()), 2) + Math.pow((mY -
c.getCy()), 2));
}
public double getX() {
return mX;
}
public double getY() {
return mY;
}
public Cluster getCluster() {
return mCluster;
}
public double getCurrentEuDt() {
return mEuDt;
}
public String getObjName() {
return mObjName;
}
} // GRAPH//
package Graph;
import java.awt.Color;
import java.awt.Container;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.Polygon;
import java.util.Vector;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.UIManager;
import javax.swing.*;
import Ran.Ran;
import Util.Util;
public class Graph extends JFrame implements Runnable {
public JFrame frame=null;
public Container container=null;
public static JPanel panel1=null;
public String GraphName="";
public Point p1=new Point(50, 0);
public static Point p2=new Point(50, 600);
public Point p3=new Point(900, 600);
public Polygon polygon=new Polygon();
 A.V.C.COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS
public static boolean b=true;
public static int Xlength=0;
public static int Ylength=0;
public String Xname="";
public String Yname="";
public char[] Ychar=null;
public static int Xedge=0;
public static int Yedge=0;
public int Xunit=0;
public int Yunit=0;
public boolean UnitDisplay=true;
public int Xn=0;
public static int Xp=0;
public int Yn=0;
public static int Yp=0;
public Vector<Cluster> graph=new Vector<Cluster>();
public int OvalW=30;
public int OvalH=30;
public Graph(String string) {
this.GraphName=string;
frame=new JFrame(string);
container=frame.getContentPane();
Xlength=(int) (p3.getX()-p2.getX());
Ylength=(int) (p2.getY()-p1.getY());
panel1=new JPanel(){
public void paint(Graphics g){
drawGraph(g);
}
};
polygon.addPoint(50,0);
polygon.addPoint(900,0);
polygon.addPoint(900,600);
polygon.addPoint(50,600);
frame.setBounds(0, 0, 950, 650);
container.setBounds(0, 0, 900, 750);
panel1.setBounds(0, 0, 900, 750);
container.add(panel1);
frame.setLocationRelativeTo(null);
frame.setVisible(true);
}
public void setXname(String string){
 A.V.C.COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS
this.Xname=string;
}
public void setYname(String string){
this.Yname=string;
this.Ychar=this.Yname.toCharArray(); }
public void setXedge(int i){
this.Xedge=i; }
public void setYedge(int i){
this.Yedge=i;
}
public void setXunit(int i){
this.Xunit=i;
}
public void setYunit(int i){
this.Yunit=i;
}
public void setUnitDisplay(boolean b){
this.UnitDisplay=b;
repaint();
}
public void Add(int x,int y){
graph.add(new Cluster(x,y));}
public void Dopaint(){
repaint();}
public void drawGraph(Graphics g){
g.clearRect(0, 0, panel1.getWidth(), panel1.getHeight());
g.setColor(Color.black);
try {
Xn=Xedge/Xunit;
Xp=Xlength/Xn;
Yn=Yedge/Yunit;
Yp=Ylength/Yn;
} catch (RuntimeException e) {
}
System.out.println("System running");
g.drawString("0", (int)(p2.getX()-10), (int)(p2.getY()+10));
g.drawLine((int)p1.getX(),(int)p1.getY(),(int)p2.getX(),(int)p2.get
g.drawLine((int)p2.getX(),(int)p2.getY(),(int)p3.getX(),(int)p3.get
g.drawString(Xname,(int) p2.getX()+200,(int)p2.getY()+20);
g.drawString("RE-CLUSTER", 400, 700);
for (int i = 0,j=200; i < Ychar.length; i++) {
 A.V.C.COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS
j=j+30;
g.drawString(""+Ychar[i],(int)p1.getX()-20,(int)p1.getY()+
} try {
if (UnitDisplay) {
for (int i = 1; i <= Xn; i++) {
g.drawString(""+(i*Xunit), (int) (p2.getX()+(i*Xp)), (int) (p2.getY() +
10)); }
for (int i = 1; i <= Yn; i++) {
g.drawString(""+(i*Yunit), (int) (p2.getX()-10), (int) (p2.getY
(i*Yp)));
}} catch (RuntimeException e) {
}
for (int j=0,i = 0; j < graph.size(); j++,i++) {
System.out.println("Before oval");
int x1=(int)graph.elementAt(j).point.getX();
int y1=(int)(graph.elementAt(j).point.getY());
int x2=(int)graph.elementAt(j).point.getX();
int y2=(int)(graph.elementAt(j).point.getY());
g.setColor(Color.RED);
System.out.println("sys"+x1+" "+y1+" "+x2+" "+y2);
g.fillOval(x1-3, y1-3, 6, 6);
g.drawOval(
(int) (graph.elementAt(j).point.getX() - (OvalW / 2)),
(int) (graph.elementAt(j).point.getY() - (OvalH / 2)),
OvalW, OvalH);
g.setColor(Color.BLACK);
(int)graph.elementAt(j).point.getY(), 10, 20);
} }
System.out.println("Before for1");
for (int i = 0,j=0;j<10000 ; i++) {
Point tPoint=new Point(Ran.getRan(),Ran.getRan());
if(polygon.contains(tPoint)){
g.drawOval((int)tPoint.getX(), (int)tPoint.getY(), 1,
j++;
}
} }
public static void main(String[] args) {
try{
UIManager.setLookAndFeel("com.jtattoo.plaf.hifi.HiFiLookAndFeel
}catch(Exception e){
e.printStackTrace(); }
 A.V.C.COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS
Graph graph=new Graph("PRIVACY PRESERVING DATABASE APPLICATION TESTING
graph.setXname("Xname");
graph.setYname("Yname");
graph.setXedge(100);
graph.setYedge(100);
graph.setXunit(10);
graph.setYunit(10);
graph.Add(10,10);
graph.Add(20,10);
graph.Add(30,10);
graph.Add(40,10);
graph.Add(50,10);
graph.Add(10,20);
graph.Add(20,20);
graph.Add(30,20);
graph.Add(40,20);
graph.Add(50,20);
graph.Add(10,30);
graph.Add(20,30);
graph.Add(30,30);
graph.Add(40,30);
graph.Add(50,30);
graph.Add(10,40);
graph.Add(20,40);
graph.Add(30,40);
graph.Add(40,40);
graph.Add(50,40);
graph.Add(10,50);
graph.Add(20,50);
graph.Add(30,50);
graph.Add(40,50);
graph.Add(50,50);
for (int i = 10; i < 100; i=i+10) {
graph.setUnitDisplay(true); }
public void run() {
while(true){ repaint();
this.panel1.repaint();
}
}

REPORTS DETAILS
 A.V.C.COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS

 After browsing the ARFF file, click submit button .If the corresponding arff file is present
then a success page report will open indicating the ARFF file.

 Give the IP address in the textbox and then it get connected to the FTP server.(192.168.1.60)

 After the success page of ARFF file is Opened the report of clustering objects will be shown
in specifically in the graph.

 In the Login Page give the corresponding username and login,then the ARFF file will be
opened.

 Next Stage the ARFF file is encrypted in the SYSTEM1 and is viewed.

 The Encrypted file are Decrypted and is visualized in the SYSTEM2.

 After the process of encryption and decryption the process of reclustering takes place and
Clustered file is being reclustered..
 A.V.C.COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS
TESTING DETAILS

SYSTEM TESTING:
Testing is performed to identify errors. It is used for quality assurance. Testing is an
integral part of the entire development and maintenance process. The goal of the testing during
phase is to verify that the specification has been accurately and completely incorporated into the
design, as well as to ensure the correctness of the design itself. For example the design must not
have any logic faults in the design is detected before coding commences, otherwise the cost of
fixing the faults will be considerably higher as reflected. Detection of design faults can be achieved
by means of inspection as well as walkthrough.
Testing is one of the important steps in the software development phase. Testing checks for the
errors, as a whole of the project testing involves the following test cases:
 Static analysis is used to investigate the structural properties of the Source code.
 Dynamic testing is used to investigate the behavior of the source code by executing the
program on the test data.
UNIT TESTING:
Unit testing is conducted to verify the functional performance of each modular
component of the software. Unit testing focuses on the smallest unit of the software design (i.e.),
the module. The white-box testing techniques were heavily employed for unit testing.

FUNCTIONAL TESTS:
Functional test cases involved exercising the code with nominal input values for which
the expected results are known, as well as boundary values and special values, such as logically
related inputs, files of identical elements, and empty files.
 A.V.C.COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS
Three types of tests in Functional test:
 Performance Test
 Stress Test
 Structure Test
PERFORMANCE TEST:

It determines the amount of execution time spent in various parts of the unit, program
throughput, and response time and device utilization by the program unit.

STRESS TEST:

Stress Test is those test designed to intentionally break the unit. A Great deal can be
learned about the strength and limitations of a program by examining the manner in which a
programmer in which a program unit breaks.

STRUCTURED TEST:

Structure Tests are concerned with exercising the internal logic of a program and traversing
particular execution paths. The way in which White-Box test strategy was employed to ensure that
the test cases could Guarantee that all independent paths within a module have been have been
exercised at least once.

 Exercise all logical decisions on their true or false sides.

 Execute all loops at their boundaries and within their operational bounds.
 Exercise internal data structures to assure their validity.
 Checking attributes for their correctness.
 Handling end of file condition, I/O errors, buffer problems and textual errors in output
information

INTEGRATION TESTING:

Integration testing is a systematic technique for construction the program structure while at
 A.V.C.COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS
the same time conducting tests to uncover errors associated with interfacing. i.e., integration testing
is the complete testing of the set of modules which makes up the product. The objective is to take
untested modules and build a program structure tester should identify critical modules. Critical
modules should be tested as early as possible. One approach is to wait until all the units have passed
testing, and then combine them and then tested. This approach is evolved from unstructured testing
of small programs. Another strategy is to construct the product in increments of tested units. A
small set of modules are integrated together and tested, to which another module is added and tested
in combination. And so on. The advantages of this approach are that, interface dispenses can be
easily found and corrected.
The major error that was faced during the project is linking error. When all the modules
are combined the link is not set properly with all support files. Then we checked out for
interconnection and the links. Errors are localized to the new module and its intercommunications.
The product development can be staged, and modules integrated in as they complete unit testing.
Testing is completed when the last module is integrated and tested.
VALIDATION TESTING:
Software validation is achieved through a series of tests that demonstrates
conformity with requirements. A test plan outlines the classes of test to be conducted and a test
procedure defines specific test cases that will be used to demonstrate conformity with requirements.
Thus the proposed system under consideration has been tested by validation and found to be
working satisfactorily.
PROGRAM TESTING:
The logical and syntax errors have been pointed out by program testing. A syntax error
is an error in a program statement that in violates one or more rules of the language in which it is
written. An improperly defined field dimension or omitted keywords are common syntax error.
These errors are shown through error messages generated by the computer. A logic error on the
other hand deals with the incorrect data fields, out-off-range items and invalid combinations. Since
the compiler s will not deduct logical error, the programmer must examine the output. Condition
 A.V.C.COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS
testing exercises the logical conditions contained in a module. The possible types of elements in a
condition include a Boolean operator, Boolean variable, a pair of Boolean parentheses A relational
operator or on arithmetic expression. Condition testing method focuses on testing each condition in
the program the purpose of condition test is to deduct not only errors in the condition of a program
but also other a errors in the program.

SECURITY TESTING:
Security testing attempts to verify the protection mechanisms built in to a system well, in
fact, protect it from improper penetration. The system security must be tested for invulnerability
from frontal attack must also be tested for invulnerability from rear attack. During security, the
tester places the role of individual who desires to penetrate system.
SOFTWARE TESTING STRATEGIES:

A software testing strategy provides a road map for the software developer. Testing is a set activity
that can be planned in advance and conducted systematically. For this reason a template for
software testing a set of steps into which we can place specific test case design methods should be
strategy should have the following characteristics:

 Testing begins at the module level and works “outward” toward the integration of the
entire computer based system.
 Different testing techniques are appropriate at different points in time.
 The developer of the software and an independent test group conducts testing.
 Testing and Debugging are different activities but debugging must be accommodated
in any testing strategy.
 A.V.C.COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS

INDIVIDUAL PROJECT SCHEDULE

Planned Actual
S.No Activity Description Status Remark
Date Date
CLIENT 1 :

1.1 File choosing 28-12-08 3-1-09 Finished No

1.2 Using clustering algorithm 4-1-08 18-1-09 Finished No

1.3 Viewing the clustered graph 24-1-09 3-2-09 Finished No

1.4 Login form 5-2-09 7-2-09 Finished No

1.5 Start the FTP server 10-2-09 19-2-09 Finished No

CLIENT 2 :

2.1 Login Form 20-2-09 22-2-09 Finished No

2.2 Corresponding IP address 24-2-09 27-2-09 Finished

2.3 File sending option(client1) 2-3-09 8-3-09 Finished

2.4 Encryption process(client2)

2.5 Decryption process(client1)

2.6 File receiving option(client1)

D.S.Arun Francis

Signature of the Student

 A.V.C.COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS

STUDENT PERFORMANCE REPORT

Comments on the Project by External Guide :

• He has given his full effort to the project.

• He has learned a sound knowledge in java swing and in JSP.
• He finished his assigned task in the modules.
• He took part in all the project activities and work in our team.

Sign of External Guide

Comments on the Project by Internal Guide :

Sign of Internal Guide

Sign of Director
 A.V.C.COLEGE OF ENGINEERING
DEPARTMENT OF COMPUTER APPLICATIONS