A

Minor Project Report

On

IP ADDRESS
CALCULATOR

Submitted to

RAJIV GANDHI PROUDYOGIKI

UNIVERSITY BHOPAL (M.P)

In Partial fulfillment for the award of degree of

BACHELOR OF ENGINEERING IN
Computer Science & Engineering
By
Anjali Sahu (0608CS111005)
Surbhi Sahu(0608CS111058)
Shilpi Rajak (0608CS111050)

Under the Guidance of

Asst.Prof. Mr. Lalit Chourasia

BABULAL TARABAI INSTITUTE OF RESEARCH & TECHNOLOGY

(BTIRT)
May-June-2014
 BABULAL TARABAI INSTITUTE OF RESEARCH & TECHNOLOGY
NH-26, Narsinghpur Road, Sironja, Sagar (M.P.)
Approved by AICTE New Delhi & Affiliated to RGPV Bhopal M.P.

BTIRT

Declaration

I hereby declare that the project entitled IP ADDRESS

CALCULATOR is the actual work carried out by me in the department of

Computer Science Engineering under the guidance Ms. Shagufta khan,

Mr. Lalit chourasia.

Anjali Sahu(0608CS111005)
Surbhi Sahu(0608CS111058)
Shilpi Rajak (0608CS111044)
 BABULAL TARABAI INSTITUTE OF RESEARCH & TECHNOLOGY
NH-26, Narsinghpur Road, Sironja, Sagar (M.P.)
Approved by AICTE New Delhi & Affiliated to RGPV Bhopal M.P.

BTIRT

Declaration

We here by declare that the project entitled IP ADDRESS CALCULATOR

is the actual work carried out by us in the department of COMPUTER

SCIENCE ENGINEERING under the guidance of Asst. Prof. Mr. Lalit

chourasia.

Name Enrollment Number Signature

Anjali Sahu 0608CS111005

Surbhi Sahu 0608CS111058
Shilpi Rajak 0608CS111044

.
 BABULAL TARABAI INSTITUTE OF RESEARCH & TECHNOLOGY
NH-26, Narsinghpur Road, Sironja, Sagar (M.P.)
Approved by AICTE New Delhi & Affiliated to RGPV Bhopal M.P.

BTIRT

CERTIFICATE

This is to certify that the project entitled IP ADDRESS CALCULATOR has been

carried out by Anjali Sahu (0608CS111005),Surbhi Sahu

( 0 6 0 8 C S 1 1 1 0 5 8 ) a n d S h i l p i R a j a k ( 0 6 0 8 C S 1 1 1 0 4 4 ) under my

guidance in partial fulfillment for the award of (BACHELOR OF

ENGINEERING) in Computer Science Engineering by the Rajiv Gandhi

Technical University, Bhopal (M.P.), during the academic year 2014-2015.

Mr. Anil Pimpalapure Asst.Prof. Mr.Lalit

Head Chourasia
Department of Computer
Science & Engineering

Dr. S.V.S. Chauhan

Principal
 ACKNOWLEDGMENTS

It gives me immense pleasure to express my deepest sense of gratitude and sincere

thanks to my highly respected and esteemed guide Mr. Lalit Chourasia, Asst.
Professor, Computer Science Engineering , BTIRT, Sagar, for their valuable
guidance, encouragement and help for completing this work. Their useful
suggestions for this whole work and co-operative behavior are sincerely
acknowledged.

I would like to express my sincere thank to Dr. SVS Chouhan, Principal,

BTIRT, Sagar for giving me this opportunity to undertake this project.

I also wish to express my gratitude’s to Mr. Anil Pimplapure, HOD of Computer

Science Engineering for his kind hearted support.

I also wish to express my indebtedness to my parents as well as my family member

whose blessings and support always helped me to face the challenges ahead.

At the end I would like to express my sincere thanks to all my friends and others
who helped me directly or indirectly during this dissertation work.

Anjali Sahu(0608CS111005)
Surbhi Sahu(0608CS111058)
Shilpi Rajak(0608CS111044)
 INDEX

Page no
Abstract
(i) Aim Of Project
(ii) Need Of Project

Chapter - 1 Analysis
1. Hardware And Software Required
2. System Analysis
3. Software Development Life Cycle
4. E- R Diagram
5. DFD Diagram
Chapter -2 Front end And Back end technology
2.1
2.2
2.3
Chapter-3 Design Methodology
3.1
3.2
3.3
Chapter -4 Coding
Chapter -5Testing
4.1
4.2
4.3
Chapter -6 Scope and Conclusion
Chapter -7 Reference
 ABSTRACT

An internet protocols address is a numerical label assigned to each device (e.g. computer,
printer) participating in a computer network that use the internet protocol for
communication. Subnetting an IP network allows for the flow of network traffic to be
segregated based on a network configuration. It essentially organizes the hosts into logical
groups, and provides for improving network security and performance. The most common
reason for Subnetting IP networks is to control network traffic. Traditionally, in an Ethernet
network, it is very common for all nodes on a segment to see all the packets transmitted by
all the other nodes on that segment, which introduces collisions, and the resulting
retransmissions under heavy traffic loads. An IP address service to principal function: host
or network interface identification and location addressing.
 AIM OF PROJECT
The main aim of this project is to reduce the lengthy calculation of Subnetting. As
we know that Subnetting is too lengthy and a big process that’s why it takes more time to
do calculation. To reduce that waste of time, we made this. This is a desktop application
that can install in any operating system, without any problem. This project that is IP
ADDRESS CALCULATOR has made in visual studio 2010 by C# language. This is a
more straightforward and faster IP subnet calculator, giving you a complete list of
information concerning an IP address and Subnet Mask, including the Network and Host
address size.

IP Subnetting is a fundamental subject that's critical for any IP network engineer to

understand, yet students have traditionally had a difficult time grasping it. Over the years,
I've watched students needlessly struggle through school and in practice when dealing with
Subnetting because it was never explained to them in an easy-to-understand way. I've
helped countless individuals learn what Subnetting is all about using my own graphical
approach and calculator shortcuts, and I've put all that experience into this article. The IP
address Calculator enables subnet network calculations using network class, IP address,
subnet mask, subnet bits, mask bits, maximum required IP subnets and maximum required
hosts per subnet.
 NEED OF PROJECT
The overall objective of IP ADDRESS CALCULATOR is to provide an efficient
result of subnetting and reduse the complexcity of subnetting and provide valid IPs to users.
This IP ADDRESS CALCULATOR is small and easy to use and can be install in any
operating system.There are some important criteria thats why we use IP ADDRESS
CALCULATOR.

 To reduse the complexcity of subnetting.

 To reduse the calculation of network IP, broadcast IP,valid IPs range etc.
 To reduse the time of calculation of subnetting.
 To make subnetting understandable,easy and user friendly to user.

This calculator we have made to provide efficient result and it take less input and
provide more output. Subnetting is essentially the modificationof a single IP network to
create two or more logically visible sub-sections. Itentails changing the subnet mask of the
local network number to produce an evennumber of smaller network numbers, each with a
corresponding range of IPaddresses. When is subnetting necessary? Subnetting is required
when onenetwork number needs to be distributed across multiple LAN segments. This may
be the case in instances when: A company uses two or more types of LAN technology (for
example, Ethernet, Token Ring) on their network. Two network segments arerestricted by
distance limitations (for example, remote offices linked viapoint-to-point circuit). Segments
need to be localized for network managementreasons (accounting segment, sales segment,
etc.). Hosts which dominate mostof the LAN bandwidth need to be isolated.
CHAPTER-1
ANALYSIS
1.1 HARDWARE AND SOFTWARE REQUIREMENT

HARDWARE REQUIREMENT:-

Processor : Dual core

RAM : 1GB & above
Hard disk : 5GB
Printer : HP DeskJet
Keyboard : multimedia
Mouse : 3 Button scroll

SOFTWARE REQUIREMENT:-
Operating System : Window 7, Window 8, Window XP
Language : C# visual basic
1.2 SYSTEM ANALYSIS:-

Systems analysis is an explicit formal inquiry carried out to help someone (referred
to as the decision maker) identify a better action and make a better decision than he might
otherwise have made. The characteristic attributes of a problem situation where systems
analysis is called upon are complexity of the issue and uncertainty of the outcome of any
course of action that might reasonably be taken. Systems analysis usually has some
combination of the following: identification and re-identification) of objectives, constraints,
and alternative courses of action; examination of the probable consequences of the
alternatives in terms of costs, benefits, and risks; presentation of the results in a comparative
framework so that the decision maker can make an informed choice from among the
alternatives. The typical use of systems analysis is to guide decisions on issues such as
national or corporate plans and programs, resource use and protection policies, research and
development in technology, regional and urban development, educational systems, and
other social services. Clearly, the nature of these problems requires an interdisciplinary
approach. There are several specific kinds or focuses of systems analysis for which different
terms are used: A systems analysis related to public decisions is often referred to as a
POLICY ANALYSIS (in the United States the terms are used interchangeably). A systems
analysis that concentrates on comparison and ranking of alternatives on basis of their known
characteristics is referred to as decision analysis.

That part or aspect of systems analysis that concentrates on finding out whether an intended
course of action violates any constraints is referred to as FEASIBILITY analysis. A systems
analysis in which the alternatives are ranked in terms of effectiveness for fixed cost or in
terms of cost for equal effectiveness is referred to as COST-
EFFECTIVENESS analysis. COST- BENEFIT ANALYSIS is a study where for each
alternative the time stream of costs and the time stream of benefits are discounted to yield
their present values. The comparison and ranking are made in terms of net benefits (benefits
minus cost) or the ratio of benefits to costs. In risk-BENEFIT ANALYSIS , cost (in
monetary units) is assigned to each risk so as to make possible a comparison of the
discounted sum of these costs (and of other costs as well) with the discounted sum of
benefits that are predicted to result from the decision.

1.1 SOFTWARE DEVELOPMENT LIFE CYCLE:-

SDLC is a process followed for a software project, within a software organization. It

consists of a detailed plan describing how to develop, maintain, replace and alter or
enhance specific software. The life cycle defines a methodology for improving the
quality of software and the overall development process.
A typical Software Development life cycle consists of the following stages:

Planning and Requirement Analysis:

Requirement analysis is the most important and fundamental stage in SDLC. It is

performed by the senior members of the team with inputs from the customer, the sales
department, market surveys and domain experts in the industry. This information is then
used to plan the basic project approach and to conduct product feasibility study in the
economical, operational, and technical areas.Planning for the quality assurance
requirements and identification of the risks associated with the project is also done in the
planning stage. The outcome of the technical feasibility study is to define the various
technical approaches that can be followed to implement the project successfully with
minimum risks.

Requirements: -
Once the requirement analysis is done the next step is to clearly define and document the
product requirements and get them approved from the customer or the market analysts. This
is done through ‘SRS’ – Software Requirement Specification document which consists of
all the product requirements to be designed and developed during the project life cycle.

Designing the product architecture:-

SRS is the reference for product architects to come out with the best architecture for the
product to be developed. Based on the requirements specified in SRS, usually more than
one design approach for the product architecture is proposed and documented in a DDS -
Design Document Specification. This DDS is reviewed by all the important stakeholders
and based on various parameters as risk assessment, product robustness, design modularity ,
budget and time constraints , the best design approach is selected for the product.
A design approach clearly defines all the architectural modules of the product along
with its communication and data flow representation with the external and third party
modules (if any). The internal design of all the modules of the proposed architecture should
be clearly defined with the minutest of the details in DDS.

Building or Developing the Product:-

In this stage of SDLC the actual development starts and the product is built. The
programming code is generated as per DDS during this stage. If the design is performed in a
detailed and organized manner, code generation can be accomplished without much hassle.
Developers have to follow the coding guidelines defined by their organization
and programming tools like compilers, interpreters, debuggers etc are used to generate the
code. Different high level programming languages such as C, C++, Pascal, Java, and PHP
are used for coding. The programming language is chosen with respect to the type of
software being developed.

Testing the Product:

This stage is usually a subset of all the stages as in the modern SDLC models, the
testing activities are mostly involved in all the stages of SDLC. However this stage refers to
the testing only stage of the product where products defects are reported, tracked, fixed and
retested, until the product reaches the quality standards defined in the SRS.

Maintenance:
Once the product is tested and ready to be deployed it is released formally in the
appropriate market. Sometime product deployment happens in stages as per the
organizations’ business strategy. The product may first be released in a limited segment and
tested in the real business environment .
Then based on the feedback, the product may be released as it is or with suggested
enhancements in the targeting market segment. After the product is released in the market
segment.
 1.4 E-R diagram of ip Address Calculator
An entity–relationship model (ER model) is a data model for describing the data or
information aspects of a business domain or its process requirements, in an abstract way
that lends itself to ultimately being implemented in a database such as arelational database.
The main components of ER models are entities (things) and the relationships that can exist
among them.
 1.5 DFD of IP Address calculator
A data flow diagram (DFD) is a graphical representation of the "flow" of data through an
information system, modeling its process aspects. Often they are a preliminary step used to
create an overview of the system which can later be elaborated.DFDs can also be used for
the visualization of data processing (structured design).
 CHAPTER-2
Frontend Technology
2.1 Frontend technology
Visual C# - Visual C# is a modern, type-safe, and object-oriented programming language
designed for developing applications for the .NET Framework. It also provides an
Integrated Development Environment (IDE) with a collection of development tools,
debuggers, and visual designers. Visual C# 2010 simplifies programming and deployment
with the Microsoft Office APIs, allows easier interop with dynamic languages, and
provides greater support for Test-Driven Development and quick code navigation.

Microsoft Visual C# IDE -

When you start Visual C#, Start Page is displayed. Start Page has two columns; the left
column holds Start and Recent sections. These sections contain options for developers to
create a new application or work with an existing one, respectively.

Visual C# places Get Started and Latest News tabs in the left column so developers can find
useful information about application development, resources, and a tutorial. It is necessary
for the user to have an internet connection to access the latest news.

Menubar provides functions to developers for coding, maintaining and executing their
programs. Menubar contains:

 DEBUG: used for compiling, debugging and running apps.

 TEAM: contains functions to connect to Team Foundation Server.
 FORMAT: contains commands to arrange and modify Form’s controls.
 TOOLS: contains commands to customize the IDE.

Windows application programing -

Controls

Visual C# uses System.Windows.Forms.Control class to create most controls for

developers. These controls are inherited as shown in the figure. The most common controls
are Label, Textbox, Button, and Checkbox.
Properties

Properties describe shape, size and other characteristics of control. Controls inherit or
override properties, which defined in the System.Windows.Forms.Control class to create
their own properties. The following table lists some common properties of Visual C#
controls.

Name Description
BackColor Get or set the background color.
Get or set Enabled characteristic of control. Set to "True" means that
Enabled control can receive data from a user and "False" means users can't
interact with control.
ForeColor Get or set the ForeColor.
Height Get or set the height of control.
Get or set the name of control. Developer uses this name to refer to the
Name
control when they are coding.
Right Get the right edge of control relative to the top of its container.
Text Get or set the text presented in control.
Top Get or set the top edge of control relative to the top of its container.
Visible Get or set the visible of control.
Width Get or set the width of control.
CHAPTER-3
DESIGN
METHODOLOGY
3.1- Design Of Ip address Calculator

To design IP Address Calculator I have use a From to draw the window and I have also
use some contols they are-

1.Labels

2. Textbox

3.Listbox

4.Button

5.Image Icons
CHAPTER-4
CODING
 Coding

using System;
using System.Net;

namespace NetCalc
{
/// <summary>
/// Summary description for IPTool.
/// </summary>
public class IPTool
{
// first (0x00) only for fill - so array starts with bit 1
static byte [] bit = { 0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40,
(byte)0x80 };

protected string ip = null;

protected byte [] ipBytes = null;
//protected byte a,b,c,d;
protected int networkPrefix; // z.b. 24 for /24
protected bool firstSubNetBit = false;

public IPTool(string ip)

{
this.setIp(ip);
}

public static byte getBit(int bit)

{
byte r = 0;
if(bit >= 1 && bit <= 8)
r = IPTool.bit[bit];

return r;
}

public static byte setBit(byte b, int bit)

{
if(bit >= 1 && bit <= 8)
return (byte) (b | IPTool.bit[bit]);
else return 0;
}

public static bool isBitSet(byte b, int bit)

 {
bool r = false;
if(bit >= 1 && bit <= 8)
r = ((b & IPTool.bit[bit]) != 0);

return r;
}

/*
* return true if domainName is an IP
*/
static public bool isIP (String domainName)
{
//if (domainName.matches("[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-
9]{1,3}"))
if (domainName.Equals("[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-
9]{1,3}"))
return true;
else return false;
}

/*
* Converts (unsigned)byte to int
*/
public static int byte2int (byte b)
{
int i = b;
if (b < 0) i = b & 0x7f + 128;

return i;
}

// return first byte of IP

public byte get1Byte ()
{
return this.ipBytes[0];
}

// return second byte of IP

public byte get2Byte ()
{
return this.ipBytes[1];
}

// return third byte of IP

public byte get3Byte ()
{
return this.ipBytes[2];
 }

// return fourth byte of IP

public byte get4Byte ()
{
return this.ipBytes[3];
}

// return array with all bytes of IP

public byte [] getBytes()
{
//return InetAddress.getByName(this.ip).getAddress();
//return Dns.GetHostByName(this.ip).AddressList;
return IPAddress.Parse(this.ip).GetAddressBytes();
}

public String getIp()

{
return this.ip;
}

public void setIp(String ip)

{
this.ip = ip;
this.ipBytes = getBytes();
this.setPrefix2NetworkClassPrefix();
}

public void setPrefix2NetworkClassPrefix ()

{
this.setNetworkPrefix(this.getNetworkClassPrefix());
}

public int getNetworkClassPrefix ()

{
// set network-prefix with Class-Type
int netClass = getNetworkClass();
switch (netClass)
{
case 0: return 8; // Class A
case 1: return 16; // Class B

case 2: return 24; // Class C

//default: setNetworkPrefix(-1); // other Classes
have no default Prefix
}
return -1;
}
/*
* return -1 if out of range (0-255) or other error
*/
private int convertIPByte(String ipByte)
{
//int res = Integer.valueOf(ipByte).intValue();
int res = Int32.Parse(ipByte);
if (res < 0 || res > 255)
{
res = -1;
this.ip = null;
}
return res;
}

/**
* @return
*/
public int getNetworkPrefix()
{
return this.networkPrefix;
}

/**
* @param prefix
*/
public void setNetworkPrefix(int prefix)
{
this.networkPrefix = prefix;
}

public String getNetworkClassName ()

{
switch (this.getNetworkClass())
{
case 0: return "Class A";
case 1: return "Class B";
case 2: return "Class C";
case 3: return "Class D/Multicast";
case 4: return "Class E/not used";
default: return "error";
}
}

/*
* 0=Class A
* 1=Class B
* 2=Class C
* 3=Class D
 * 4=Class E
* -1=error
*/
public int getNetworkClass ()
{
// Test Class A: first bit=0
if (!IPTool.isBitSet(this.get1Byte(),8)) return 0;
// Test Class B: first 2bit=10
else if (!IPTool.isBitSet(this.get1Byte(),7)) return 1;
// Test Class C: first 3bit=110
else if (!IPTool.isBitSet(this.get1Byte(),6)) return 2;
// Test Class D: first 4bit=1110
else if (!IPTool.isBitSet(this.get1Byte(),5)) return 3;
// Test Class E: first 4bit=1111 ( = all other)
// else if (!IPTool.isBitSet(this.get1Byte(),8))
return 4;
else return 4;

/*
// Test Class A: first bit=0
if ((this.get1Byte() | (byte)0x7f) == (byte)0x7f) return
0;
// Test Class B: first 2bit=10
if ((this.get1Byte() | 0xbf) == 0xbf) return 1;
// Test Class C: first 3bit=110
if ((this.get1Byte() | 0xdf) == 0xdf) return 2;
// Test Class D: first 4bit=1110
if ((this.get1Byte() | 0xef) == 0xef) return 3;
// Test Class E: first 4bit=1111
if ((this.get1Byte() & 0xf0) == 0xf0) return 4;

return -1;
*/

public String getNetworkMask ()

{
return getNetworkMaskByPrefix (this.networkPrefix);
}

public String getNetworkMaskByPrefix (int prefix)

{
switch (prefix)
{
case 8: return "255.0.0.0";
case 9: return "255.128.0.0";
case 10: return "255.192.0.0";
 case 11: return "255.224.0.0";
case 12: return "255.240.0.0";
case 13: return "255.248.0.0";
case 14: return "255.252.0.0";
case 15: return "255.254.0.0";
case 16: return "255.255.0.0";
case 17: return "255.255.128.0";
case 18: return "255.255.192.0";
case 19: return "255.255.224.0";
case 20: return "255.255.240.0";
case 21: return "255.255.248.0";
case 22: return "255.255.252.0";
case 23: return "255.255.254.0";
case 24: return "255.255.255.0";
case 25: return "255.255.255.128";
case 26: return "255.255.255.192";
case 27: return "255.255.255.224";
case 28: return "255.255.255.240";
case 29: return "255.255.255.248";
case 30: return "255.255.255.252";
default: return "";
}
}

public int getMaxNetworkHosts ()

{
// 2^(32-networkprefix)
// -2 ... because .0 and .255
return ((int)Math.Pow(2,(32-this.networkPrefix)))-2;
}

public int getMaxSubNets ()

{
// Bits from Subnet = prefix-class_prefix

int count = (int)Math.Pow(2, this.networkPrefix -

this.getNetworkClassPrefix());

// -2 because 1 bit for routing

if (!this.isFirstSubNetBit() ||
this.getNetworkClassPrefix()==this.networkPrefix)
count-=2;

if (count < 0 ) count = 0;

return count;
}

public long getNetworkLong ()

{
 long mask = (long)Math.Pow (2, this.networkPrefix)-1;
mask = mask << (32-this.networkPrefix);

return (mask & ip2Long());

}

public String getNetwork ()

{
return long2String(getNetworkLong());
}

public long getBroadCastLong ()

{
long netMask = (long)Math.Pow (2, this.networkPrefix)-1;
netMask = netMask << (32-this.networkPrefix);
long hostMask = (long) Math.Pow(2, 32-this.networkPrefix)-1;

return (netMask = (ip2Long() & netMask) | hostMask);

}

public String getBroadCast ()

{
return long2String(getBroadCastLong());
}

public String[] getNetworkIPRange ()

{
String [] result = new String [2];
//String from, to;
/**
* Start
* +1 because first = network
*/
result [0] = long2String (getNetworkLong() + 1);
/**
* End
* -1 because last = broadcast
*/
result [1] = long2String(getBroadCastLong() -1);
return result;
}

public long ip2Long ()

{
return ((long)(IPTool.byte2int(this.get1Byte()) * 256 +
IPTool.byte2int(this.get2Byte())) * 256 +
IPTool.byte2int(this.get3Byte())) * 256 +
IPTool.byte2int(this.get4Byte());
}

public String long2String (long ip)

{
long a = (long)(ip & 0xff000000) >> 24;
long b = (long)(ip & 0x00ff0000) >> 16;
long c = (long)(ip & 0x0000ff00) >> 8;
long d = (long)(ip & 0xff);

return a+"."+b+"."+c+"."+d;
}

public bool isFirstSubNetBit()

{
return firstSubNetBit;
}

public void setFirstSubNetBit(bool b)

{
firstSubNetBit = b;
}

public static IPTool getNextIP (String ip)

{
IPTool nextIp = new IPTool (ip);
nextIp.setIp(nextIp.long2String(nextIp.ip2Long()+(long)1));

return nextIp;

public IPTool getNextSubNet (long numberOfHosts)

{
IPTool ip = IPTool.getNextIP(this.getBroadCast());
ip.setIp(this.long2String(ip.ip2Long()+(long)1));
ip.setFirstSubNetBit(this.isFirstSubNetBit());

int lastPrefix = ip.getNetworkClassPrefix();

int prefix = 30;

do
{
if (prefix < ip.getNetworkClassPrefix())
return null; // no subnet found
ip.setNetworkPrefix(prefix);
prefix--;
// ignore subnetbit?
if (!ip.isFirstSubNetBit() && prefix == lastPrefix+1) prefix--;
 }
while (ip.getMaxNetworkHosts() < numberOfHosts);

return ip;
}
}
}
CHAPTER-4
TESTING
5.1 TESTING
In software development process, error can be at any stage during development.
For each phase, different techniques are used for detecting errors. During testing the
program to be tested and executable with a set of test cases is evaluated to determine the
program is performing as expected.
During the requirement analysis and design, the output is a document that is
usually textual and no executable. After the coding phase, the program are available that
cannot be executable for the testing purpose.
Hence the different level of testing is used.

5.2 Objective of testing:

 The objective is to design tests that systematically uncover different classes of errors
and do so with minimal amount of time and effort.

 It is a process of executing a program with the intent of finding an error.

 A good testing case is one that has a high probability of finding a uncovered errors.

5.3 Testing principles:

 All testing should be traceable to customer requirement.

 Test should be planned long before testing begins.

 Testing should begins in the small and progress towards testing in the large.

5.4 Unit testing:

Testing of individual software components or modules. Typically done by the programmer

and not by testers, as it requires detailed knowledge of the internal program design and
code may require developing test deriver modules.
5.5 Integration testing:

Testing of integrated modules to verify combined functionality after integration. Modules

are typically code modules, individual application etc. This type of testing is especially
relevant to the distributed system.

5.6 Black box testing:

Black box testing treats the software as black box without any knowledge of internal system
design is not considered in this type of testing. Tests are based on requirements and
functionality. Black box tester has no bonds with the code and a tester perception is very
simple, a code must have bugs. Therefore, black box testing has the advantage of an
unaffiliated opinion on the other hand, disadvantage of blind exploring.

5.7 White box testing:

This testing is based on knowledge of the internal logic of an application code. Also known
as glass box testing. Internal software and coding works should be known for this type of
testing. Tests are based on coverage of code statements, branches, paths, conditions.

5.8 System testing:

After the system is integrated, system testing is performed. Hence the system is tested
against the system requirement to see all requirement are meet and the system performs as
specified by the requirement.

Finally, acceptance testing is performed to see all the requirement is satisfied in the user
view.
After completion of coding part, the system was tested under various tests. For each and
every module all possible condition is tested to find out the traced errors.

After integration all the modules, the software thoroughly tested by simulating all possible
situation for both outline and offline activities and found to be satisfactory.
CHAPTER 6
SCOPE AND
CONCLUSION
 SCOPE

These types of software are available in market rarely. So we have made this
software for the users to calculate the subnet mask, network ip, broadcast ip, valid max.
range of IP, max no. of host. Users can also implement ipv6 in it, in future. User can also
get output in binary format if they want, in future after implementation of this feature.
In future It will also calculate the Ipv6 addresses. There are many things can implement in
this application in future. It will become less light weighted application.So the scope of this
application is very bright.
 CONCLUSION
Its just a desktop software which is use for calculate the subnet mask, as we know
that the subnetting process is to lenthy . So reduse the complexity and provide
efficient and better output to user ,that why we have made this.

This application can install in any type of operating system , it means its platform
independent,easy to install and understanable to user. By this user can calculate
Subnet mask, Network IP , Broadcast IP , IP range , No of host etc. In a few second.

It provide more output in some input.It is small application so it take less space in
your system memory.
CHAPTER 7
REFERENCE
 Reference
1.IP Addressing and Subnetting, Including IPv6
by Syngress (Author).

2. IP Fundamentals: What Everyone Needs to Know About Addressing and Routing

by Thomas Albert Maufer (Author).

3.IP Subnetting made Easy! by John Kowalski

4. Subnetting Secrets by Paul Browning

5.Fundamentals Of Computer Programming with C#(Svetlin Nakov)