INTRODUCTION TO BASIC OF SOFTWARE TESTING & TERMINOLOGY

Software program and its objective, Software development techniques

SDP is abbreviated as Software Development Plan which describes a process of developers
planning to develop a software project. SDP also helps to make sure if software
development is performed systematically or not. In this article a detailed knowledge has
been provided about Software Development Planning and the process of how it can be done
to complete a particular software development project.
Objective of Software Development Plan (SDP)
The main objective of a Software Development Plan is to provide a type of framework
where the team members can have a clear knowledge and understanding on that particular
software project on which they are working and the problems which the team members
want to solve. The SDP is also used to find the time and cost effective solutions to complete
and deliver reliable, high quality projects to the users.
Steps of SDP
There are major six steps which are associated in a Software development plan which are
mentioned below:
 Step 1: Team formation
 Step 2: Create a Plan
 Step 3: Develop an overview
 Step 4: Prepare the Draft
 Step 5: Submit for the review purpose
 Step 6. Lastly Finalize the SDP
Top-Down Design Model:
In the top-down model, an overview of the system is formulated without going into detail
for any part of it. Each part of it then refined into more details, defining it in yet more
details until the entire specification is detailed enough to validate the model. if we glance at
a haul as a full, it’s going to appear not possible as a result of it’s so complicated For
example: Writing a University system program, writing a word processor. Complicated
issues may be resolved victimization high down style, conjointly referred to as Stepwise
refinement where,
1. We break the problem into parts,
2. Then break the parts into parts soon and now each of parts will be easy to do.

Advantages:
 Breaking problems into parts help us to identify what needs to be done.
 At each step of refinement, new parts will become less complex and therefore
easier to solve.
 Parts of the solution may turn out to be reusable.
 Breaking problems into parts allows more than one person to solve the problem.

Bottom-Up Design Model:

In this design, individual parts of the system are specified in detail. The parts are linked to
form larger components, which are in turn linked until a complete system is formed.
Object-oriented language such as C++ or java uses a bottom-up approach where each object
is identified first.
Advantage:
 Make decisions about reusable low-level utilities then decide how there will be
put together to create high-level construct. ,
Modular Approach in Programming
Modular programming is the process of subdividing a computer program into separate sub-
programs. A module is a separate software component. It can often be used in a variety of
applications and functions with other components of the system.
Points which should be taken care of prior to modular program development:
1. Limitations of each and every module should be decided.
2. In which way a program is to be partitioned into different modules.
3. Communication among different modules of the code for proper execution of the
entire program.
Advantages of Using Modular Programming Approach –
1. Ease of Use :This approach allows simplicity, as rather than focusing on the
entire thousands and millions of lines code in one go we can access it in the form
of modules. This allows ease in debugging the code and prone to less error.
2. Reusability :It allows the user to reuse the functionality with a different
interface without typing the whole program again.
3. Ease of Maintenance : It helps in less collision at the time of working on
modules, helping a team to work with proper collaboration while working on a
large application. Example of Modular Programming in C

Structured Programming

Structured programming (sometimes known as modular programming) is a programming

paradigm that facilitates the creation of programs with readable code and reusable
components. All modern programming languages support structured programming, but the
mechanisms of support, like the syntax of the programming languages, varies.

Advantages of structured programming

The primary advantages of structured programming are:

1. It encourages top-down implementation, which improves both readability and
maintainability of code.
2. It promotes code reuse, since even internal modules can be extracted and made
independent, residents in libraries, described in directories and referenced by many other
applications.
3. It's widely agreed that development time and code quality are improved through structured
programming.
4. It is user friendly and easy to understand.
5. Similar to English vocabulary of words and symbols.

Disadvantages of structured programming

The following are the disadvantages of structured programming

1. A high level language has to be translated into the machine language by translator and
thus a price in computer time is paid.
2. The object code generated by a translator might be inefficient compared to an equivalent
assembly language program.
3. Data types are proceeds in many functions in a structured program. When changes occur in
those data types, the corresponding change must be made to every location that acts on those
data types within the program. This is really a very time consuming task if the program is
very large.
Introduction of Object Oriented Programming

As the name suggests, Object-Oriented Programming or OOPs refers to languages that use
objects in programming. Object-oriented programming aims to implement real-world entities
like inheritance, hiding, polymorphism, etc in programming. The main aim of OOP is to bind
together the data and the functions that operate on them so that no other part of the code can
access this data except that function.
OOPs Concepts:
 Class
 Objects
 Data Abstraction
 Encapsulation
 Inheritance
 Polymorphism
 Dynamic Binding
 Message Passing
1. Class:
A class is a user-defined data type. It consists of data members and member functions, which
can be accessed and used by creating an instance of that class. It represents the set of
properties or methods that are common to all objects of one type. A class is like a blueprint
for an object.
For Example: Consider the Class of Cars. There may be many cars with different names and
brands but all of them will share some common properties like all of them will have 4 wheels,
Speed Limit, Mileage range, etc. So here, Car is the class, and wheels, speed limits, mileage
are their properties.
2. Object:
It is a basic unit of Object-Oriented Programming and represents the real-life entities. An
Object is an instance of a Class. When a class is defined, no memory is allocated but when it
is instantiated (i.e. an object is created) memory is allocated. An object has an identity, state,
and behavior. Each object contains data and code to manipulate the data. Objects can interact
without having to know details of each other’s data or code, it is sufficient to know the type
of message accepted and type of response returned by the objects.
For example “Dog” is a real-life Object, which has some characteristics like color, Breed,
Bark, Sleep, and Eats.

Object
3. Data Abstraction:
Data abstraction is one of the most essential and important features of object-oriented
programming. Data abstraction refers to providing only essential information about the data
to the outside world, hiding the background details or implementation. Consider a real-life
example of a man driving a car. The man only knows that pressing the accelerators will
increase the speed of the car or applying brakes will stop the car, but he does not know about
how on pressing the accelerator the speed is increasing, he does not know about the inner
mechanism of the car or the implementation of the accelerator, brakes, etc in the car. This is
what abstraction is.
4. Encapsulation:
Encapsulation is defined as the wrapping up of data under a single unit. It is the mechanism
that binds together code and the data it manipulates. In Encapsulation, the variables or data of
a class are hidden from any other class and can be accessed only through any member
function of their class in which they are declared. As in encapsulation, the data in a class is
hidden from other classes, so it is also known as data-hiding.

Consider a real-life example of encapsulation, in a company, there are different sections like
the accounts section, finance section, sales section, etc. The finance section handles all the
financial transactions and keeps records of all the data related to finance. Similarly, the sales
section handles all the sales-related activities and keeps records of all the sales. Now there
may arise a situation when for some reason an official from the finance section needs all the
data about sales in a particular month. In this case, he is not allowed to directly access the
data of the sales section. He will first have to contact some other officer in the sales section
and then request him to give the particular data. This is what encapsulation is. Here the data
of the sales section and the employees that can manipulate them are wrapped under a single
name “sales section”.
5. Inheritance:
Inheritance is an important pillar of OOP(Object-Oriented Programming). The capability of a
class to derive properties and characteristics from another class is called Inheritance. When
we write a class, we inherit properties from other classes. So when we create a class, we do
not need to write all the properties and functions again and again, as these can be inherited
from another class that possesses it. Inheritance allows the user to reuse the code whenever
possible and reduce its redundancy.
6. Polymorphism:
The word polymorphism means having many forms. In simple words, we can define
polymorphism as the ability of a message to be displayed in more than one form. For
example, A person at the same time can have different characteristics. Like a man at the same
time is a father, a husband, an employee. So the same person posses different behavior in
different situations. This is called polymorphism.

7. Dynamic Binding:
In dynamic binding, the code to be executed in response to the function call is decided at
runtime. Dynamic binding means that the code associated with a given procedure call is not
known until the time of the call at run time. Dynamic Method Binding One of the main
advantages of inheritance is that some derived class D has all the members of its base class B.
Once D is not hiding any of the public members of B, then an object of D can represent B in
any context where a B could be used. This feature is known as subtype polymorphism.
8. Message Passing:
It is a form of communication used in object-oriented programming as well as parallel
programming. Objects communicate with one another by sending and receiving information
to each other. A message for an object is a request for execution of a procedure and therefore
will invoke a function in the receiving object that generates the desired results. Message
passing involves specifying the name of the object, the name of the function, and the
information to be sent.
Basic software quality parameters and its metrics
There is a number of metrics available based on which software quality is
measured. But among them, there are a few most useful metrics which are
essential in software quality measurement. They are –
1. Code Quality
2. Reliability
3. Performance
4. Usability
5. Correctness
6. Maintainability
7. Integrity
8. Security
Now let’s understand each quality metric in detail –

1. Code Quality – Code quality metrics measure the quality of code used for
software project development. Maintaining the software code quality by writing
Bug-free and semantically correct code is very important for good software
project development. In code quality, both Quantitative metrics like the number
of lines, complexity, functions, rate of bugs generation, etc, and Qualitative
metrics like readability, code clarity, efficiency, and maintainability, etc are
measured.
2. Reliability – Reliability metrics express the reliability of software in different
conditions. The software is able to provide exact service at the right time or not
checked. Reliability can be checked using Mean Time Between Failure (MTBF)
and Mean Time To Repair (MTTR).
3. Performance – Performance metrics are used to measure the performance of
the software. Each software has been developed for some specific purposes.
Performance metrics measure the performance of the software by determining
whether the software is fulfilling the user requirements or not, by analyzing how
much time and resource it is utilizing for providing the service.
4. Usability – Usability metrics check whether the program is user-friendly or
not. Each software is used by the end-user. So it is important to measure that the
end-user is happy or not by using this software.
5. Correctness – Correctness is one of the important software quality metrics as
this checks whether the system or software is working correctly without any error
by satisfying the user. Correctness gives the degree of service each function
provides as per developed.
6. Maintainability – Each software product requires maintenance and up-
gradation. Maintenance is an expensive and time-consuming process. So if the
software product provides easy maintainability then we can say software quality
is up to mark. Maintainability metrics include the time required to adapt to new
features/functionality, Mean Time to Change (MTTC), performance in changing
environments, etc.

7. Integrity – Software integrity is important in terms of how much it is easy to

integrate with other required software which increases software functionality and
what is the control on integration from unauthorized software’s which increases
the chances of cyberattacks.
8. Security – Security metrics measure how secure the software is. In the age of
cyber terrorism, security is the most essential part of every software. Security
assures that there are no unauthorized changes, no fear of cyber attacks, etc when
the software product is in use by the end-user.

Software Configuration Change and types of errors

Processes involved in SCM – Configuration management provides a disciplined

environment for smooth control of work products. It involves the following activities:
1. Identification and Establishment – Identifying the configuration items from
products that compose baselines at given points in time (a baseline is a set of
mutually consistent Configuration Items, which has been formally reviewed and
agreed upon, and serves as the basis of further development). Establishing
relationships among items, creating a mechanism to manage multiple levels of
control and procedure for the change management system.
2. Version control – Creating versions/specifications of the existing product to
build new products with the help of the SCM system. A description of the
version is given below:

Suppose after some changes, the version of the configuration object changes
from 1.0 to 1.1. Minor corrections and changes result in versions 1.1.1 and 1.1.2,
 which is followed by a major update that is object 1.2. The development of
object 1.0 continues through 1.3 and 1.4, but finally, a noteworthy change to the
object results in a new evolutionary path, version 2.0. Both versions are
currently supported.
3. Change control – Controlling changes to Configuration items (CI). The change
control process is explained in Figure below:

A change request (CR) is submitted and evaluated to assess technical merit,

potential side effects, the overall impact on other configuration objects and
system functions, and the projected cost of the change. The results of the
evaluation are presented as a change report, which is used by a change control
board (CCB) —a person or group who makes a final decision on the status and
priority of the change. An engineering change Request (ECR) is generated for
each approved change. Also, CCB notifies the developer in case the change is
rejected with proper reason. The ECR describes the change to be made, the
constraints that must be respected, and the criteria for review and audit. The
object to be changed is “checked out” of the project database, the change is
made, and then the object is tested again. The object is then “checked in” to the
database and appropriate version control mechanisms are used to create the next
version of the software.
4. Configuration auditing – A software configuration audit complements the
formal technical review of the process and product. It focuses on the technical
correctness of the configuration object that has been modified. The audit
confirms the completeness, correctness, and consistency of items in the SCM
system and tracks action items from the audit to closure.
5. Reporting – Providing accurate status and current configuration data to
developers, testers, end users, customers, and stakeholders through admin
guides, user guides, FAQs, Release notes, Memos, Installation Guide,
Configuration guides, etc.
Key objectives of SCM
1. Control the evolution of software systems: SCM helps to ensure that changes
to a software system are properly planned, tested, and integrated into the final
product.
 2. Enable collaboration and coordination: SCM helps teams to collaborate and
coordinate their work, ensuring that changes are properly integrated and that
everyone is working from the same version of the software system.
3. Provide version control: SCM provides version control for software systems,
enabling teams to manage and track different versions of the system and to
revert to earlier versions if necessary.
4. Facilitate replication and distribution: SCM helps to ensure that software
systems can be easily replicated and distributed to other environments, such as
test, production, and customer sites.
5. SCM is a critical component of software development , and effective SCM
practices can help to improve the quality and reliability of software systems, as
well as increase efficiency and reduce the risk of errors.
The main advantages of SCM
1. Improved productivity and efficiency by reducing the time and effort required to
manage software changes.
2. Reduced risk of errors and defects by ensuring that all changes were properly
tested and validated.
3. Increased collaboration and communication among team members by providing
a central repository for software artifacts.
4. Improved quality and stability of software systems by ensuring that all changes
are properly controlled and managed.
The main disadvantages of SCM
1. Increased complexity and overhead, particularly in large software systems.
2. Difficulty in managing dependencies and ensuring that all changes ar.0e
properly integrated.
3. Potential for conflicts and delays, particularly in large development teams with
multiple contributors.
Quality management models: ISO, SPICE, IEEE, CMM

CMM is similar to ISO 9001, one of the ISO 9000 series of standards specified
by the International Organization for Standardization. The ISO 9000 standards
specify an effective quality system for manufacturing and service industries; ISO
9001 deals specifically with software development and maintenance.