Proposed Test Case Generation Model using Fuzzy Logic

(TCGMFL)

AHMED ALTHUNIBAT1, MUSTAFA MAHMOOD1, HEND ALNUHAIT2,

SALLY ALMANASRA2, HANEEN A AL-KHAWAJA3

Al-Zaytoonah University of Jordan, Amman,

JORDAN

JORDAN

Abstract: - This research addresses the pressing need to enhance software testing, specifically focusing on

white-box testing and basis path generation. Software testing is a linchpin in the software development process,

ensuring software operates flawlessly and aligns with its intended objectives. However, this phase often incurs

substantial time and resource investments. The primary aim of this study is to introduce an efficient and

automated approach for basis path generation, a crucial component of white-box testing. The model

commences by transforming source code into a tailored control flow graph (CFG), streamlining the automated

generation of test paths. Central to this model is an algorithm for generating test paths (AGTP), meticulously

traversing CFG nodes from source to destination. The algorithm's design aims to comprehensively cover all test

methodologies.

Key-Words: - Software Testing; Fuzzy logic (FL); Test Case Generation; k-mean clustering; Basis Path

Received: June 17, 2022. Revised: September 19, 2023. Accepted: October 21, 2023. Available online: November 22, 2023.

Software testing (ST) is an important component in

step in software testing, and successful testing is

supported by good test selection to make testing

more efficient. All features in the software that

should be checked must be covered by the test cases

in the software, [2].

The process of designing and validating a large

number of test cases that involve software testing is

considered a complicated process due to the effort,

time, and cost involved, [3]. One of the issues faced

by software testing is software accuracy, which

that the testing is thorough. When a product has a

complicated branching structure, the tester must

usually pick test cases manually. However,

manually determining test cases becomes incredibly

testing methods that are prone to human error,

particularly the generation of test data. The

development of testing data, in particular, improves

the efficiency of software testing as a whole. Rather

than creating data from scratch to test, [8].

Structure-oriented test methods are extensively

used and define test cases based on internal program

structures. During software development, one of the

most essential structure-oriented test methodologies

is the path-based test. How to construct linear

statement and branch coverage, necessitate the

discovery of a collection of executable paths that

match certain criteria. We must discover appropriate

values for the input variables to run each path. This

issue is known as test data generation. If the path

cannot be exercised with any set of input data, the

path is called an infeasible path, [10].

too large. the path coverage appears as the issue via

time complexity due to the height number of paths

which will increase the time in the testing process

and the size of a test suite, view aspects use the

concept of machine learning (ML) such as fuzzy

logic regarding fuzzy logic (FL) the outcome more

complexity versus other rules mechanism.

We developed an approach that automates the

process of test case generation in software testing by

proposing a technique that first generates all test

find these paths, moreover, the technique generates

test data in a given domain and group data into the

the process of test case selection. Also, the new

approach will reduce the time and cost in the testing

phase. The general objectives of this research are: to

investigate the terms test case, and fuzzy logic in the

software testing phase, to develop the model to

reduce the time complexity and improve the testing

process, and to evaluate the model using statistical

analysis measures, [12].

Software testing is the process of running software

against a set of test cases to find flaws. The various

testing approaches are defined by the artifact that is

used to generate Test cases. Functional – or black-

box – testing gets its name from the fact that it tests

the functionality of a system. Test cases are derived

from a program's specification or description;

structural – or white-box – testing is derived from

the program's specification or description. Test

cases are derived from implementations; fault-based

example, manual testing of programs is

prohibitively expensive; as a result, software testing

typically relies on tools to automate the generation,

execution, and collection of test results when flaws

are discovered during program testing, they must be

located, and corrected, [15], [16].

Software Testing (ST) Estimating testing

efforts, finding a competent test team, building Test

cases, running the program with those Test cases,

and reviewing the results produced by those

testing (ST) is defined as the process of validating

and verifying a software product.

tests is to trigger specific areas in the software, such

as specific statements, program branches, or paths to

be run. White Box testing is a sort of testing that is

used to test the structure of code. The expected

performance is determined using coverage metrics

such as path coverage, branch coverage, and data-

flow coverage, [20], [21].

*Functional Testing: is a sort of software testing

that validates a software system's functional

requirements/specifications. Black box testing is

Computer programs have now infiltrated every

part of life, enabling the manipulation of a wide

range of complex applications. Many of these

applications are large, complex, and life-threatening.

As a result, highly dependable software, or software

with a high level of reliability, is required. Software

testing is an important and commonly used

methodology, in addition to the many other

techniques for boosting reliability, [23].

efficient software free of bugs, faults, and failure,

[1]. Despite the fact that there are several resources

for assuring software quality through testing, the

majority of software products are not sufficiently

tested. Insufficient testing will result from a large

number of unhandled failures, resulting in increased

software development time and expenses. The

software development lifecycle entails more than

just developing code. Testing occurs after the

process, but it is just as important. Testing uncovers

for the definition of intermediate values between

conventional evaluations such as true/false, yes/no,

It's used to deal with the concept of partial truth,

where the true value can be somewhere between 100

percent true and 100 percent false, [28]. The truth

values of variables in Boolean logic, on the other

hand, can only be the integer values 0 or 1. [27],

established the theory of fuzzy sets, which gave rise

to fuzzy logic. A fuzzy set assigns a degree of

membership to elements of a universe, which is

commonly a real number from the interval [0, 1] [0,

1].

Not only does fuzzy logic provide a meaningful

and powerful representation for measuring

uncertainties, but it also provides a meaningful

representation of muddled concepts stated in

everyday language. Fuzzy logic is a mathematical

theory that deals with the idea of ambiguity in

defining concepts and meanings. Expressions like

"low" and "high," for example, include ambiguity or

fuzziness since they are imprecise and relative. As a

"fuzzy" rather than "crisp." Fuzziness is merely one

way of expressing uncertainty; (FL) employs a non-

binary logic (i.e., true or false),

Fuzzy set theory has been proved to be a

valuable tool for describing scenarios involving

imprecise or ambiguous data. Fuzzy sets deal with

these problems by assigning a degree of belonging

to a set to each object, [25], [26], [27]. The fuzzy set

is a variation of the traditional set. The membership

of items in classical crisp set theory follows a binary

a curve that specifies the feature of a fuzzy set by

assigning a membership value, or degree of

graph, and the edges reflect the control flow

between the statements. Except for the entry and

connected and undirected graphs, [38]. Figure 2

shows a section of the various pseudocodes and the

control flow graph.

possible paths, especially for real-world

applications. This is because I the total number

[41], and dynamic test generation, [41], has

made significant progress recently, they are still

constrained by the above-mentioned unbounded

computation complexity problem and have

many difficult-to-handle cases, such as loops.

path is also dependent on system states (such as

the time of day), hardware states (such as disk

condition), resource states (such as how much

virtual memory has been allocated), and

real-world programs, enforcing each test case

can take a significant amount of human labor

and time. As a result, the number of examples

that can be evaluated in the real world is

restricted; it's crucial to reduce the number of

test cases without reducing overall test

coverage, [41], [42].

cases using an evolutionary structural testing

technique. The genetic algorithm (GA) is an

evolutionary method that is used to automatically

generate test cases to cover its def-use associations.

The GA conducts its search by creating new test

data using previously generated test data that has

been determined to be effective. The technique

generates a set of randomly generated test cases

within a domain, which are then classified (clusters)

using the K-Mean clustering algorithm. Each cluster

improves software testing by combining the Genetic

Method (GA) with the Binary Search (BS)

performance of the GA in terms of finding

appropriate test cases and test data for the input Big

Data domain values has a positive influence. These

results, on the other hand, reduce the cost of testing.

[2], proposes a genetic algorithm-based method for

creating test cases. The paths of the graph are

described by following path coverage criteria when

a flow graph is built from the program source code.

The genetic algorithm is then utilized to create test

cases. Finally, we employ mutation testing to assess

technique with the static technique for test case

creation, it will be possible to eliminate all faults

and increase the quality of software in the future.

Clustering is the division of a data set into

subsets (clusters) so that the data in each subset

share certain common qualities, such as proximity

according to some defined distance metric.

Clustering is vital in our lives since we live in a

data-driven society where we encounter a

Classifying or grouping these data into a set of

categories or clusters is an important part of

working with them. Clustering is used in a variety of

fields. Data clustering, for example, is a common

statistical data analysis technique utilized in a

variety of domains such as machine learning, data

mining, pattern recognition, image analysis, and

bioinformatics. Clustering is also used to find

relevant knowledge in data, [43].

Clustering is an unsupervised classification

between different data points in the input. The

clusters are constructed based on the distance

between data points, and each cluster has its cluster

center. The clustering algorithms used in test case

generation are presented in Table 1.

The Test Case Generation Model using Fuzzy Logic

(TCGFL) is designed to automate and improve the

test case generation process in the context of

software testing. The primary objective is to reduce

the time complexity and enhance the effectiveness

of the software testing phase within the system

development life cycle (SDLC). Here is a detailed

description of how the TCGFL model operates:

1. Control Flow Graph (CFG) Construction: The

process begins by automatically constructing a

variables from the source code. These variables

are crucial for creating meaningful test cases that

assess the behavior of the software with different

input values.

3. Input Generation: Within a specified domain, the

model generates inputs. These inputs are used as

test data to evaluate the software. It's important

to cover a broad range of input values to test

various scenarios and uncover potential issues.

4. Basis Path Generation: The model proceeds to

extracted variables. Clustering helps group

similar variables together, making it easier to

handle and assess the data. This step contributes

to more organized and efficient testing.

6. Path Coverage Assessment: The clustered data is

used to assess path coverage for each basis path.

Path coverage is a critical metric in software

testing, ensuring that all possible paths through

the program are tested. The clustered data allows

for a more systematic and comprehensive path

selection.

The process and workflow of the TCGFL model

are summarized in Figure 3, providing a visual

representation of how the various components

interact to automate the test case generation process.

This research aims to make software testing more

efficient, reduce testing time and costs, and ensure

thorough testing, contributing to more effective

software development within the SDLC.

study and benchmark data, as well as a program to

check Prime Numbers to demonstrate the

application of our proposed methodology.

The triangle program accepts three variables as

input and returns the type of triangle formed as an

output on the other hand Prime program accepts one

variable as input and returns if the input is a prime

number or not to execute the program, we have used

an integrated development environment (IDE) for

python called visual studio code version 1.57.1 It is

Through transforming the code into a set of nodes

and edges, The Control flow graph (CFGs) is a

direct graph that usually focuses on a graph with a

set of edges and a set of nodes, with each node

focusing on a collection of sequential statements

that form a primary block, and edge connections

between the nodes. Because CFGs may precisely

reflect the flow inside a program, they are

commonly used in static analysis and compiler

applications. Every node in CFG represents a

statement in the program under test, allowing every

node.

With the help of cyclomatic complexity which

is calculated by the algorithm, the number of

independents is determined. A number of paths can

be determined for any graph but even so, doesn’t

ease our work as there are several infeasible paths in

the control flow graph. The cyclomatic complexity

V(G) = E-N+2. Where N is the number of nodes and

E is the number of edges, the algorithm traverses

each node from source to destination to find all

in section 2.2.1 Clustering Algorithms The

algorithm was used because it is suitable for the

scope of this work.

We employed k-mean on the datasets to group

test data into the different clusters, clustering is

applied on different data sets 1-dimensional space

for the prime program and 3-dimensional space for

the triangle program after all datasets are

transformed into numbers, and the data can be

Several procedures must be completed to group

these data into different clusters. Test Case

Generation for each path is accomplished through

symbolically executing each path through a program

the algorithm traverses a test path across the

program's flow graph from the source node to the

sink node, visiting each node along the path. When

a node is visited, the algorithm symbolically

executes the program's corresponding statement.

As inputs to the test case, the algorithm employs the

existing literature, the current study distinguishes

itself in several ways:

generation methods and offers a more

sophisticated way of selecting the most suitable

test cases.

• Application to Specific Programs: The study

focuses on two specific programs, the Triangle

Problem and a Prime Number checker, which

serve as ongoing case studies. This targeted

approach allows for practical and real-world

application of the proposed methodology, making

it more relevant and actionable.

• Comprehensive Path Coverage: The TCGFL

model aims to cover all possible test paths within

the control flow graph. It addresses the issue of

infeasible paths and ensures thorough testing. This

level of comprehensive path coverage is a notable

feature of the proposed methodology.

• Python Programming Language: The study

focuses on the Python programming language, and

the algorithm and approach are tailored

a more in-depth exploration of test case generation

within this language, which may have unique

characteristics and challenges.

• Detailed Algorithm Description: The study

provides a detailed explanation of the algorithm

used for generating test paths and symbolically

executing test cases. This transparency in the

methodology helps readers understand the process

clearly.

In summary, the current study distinguishes

from the customer or the developer, is required to

complete the testing or design test cases. The

approach used in this study was aimed to assist

developers or testers in automatically generating test

cases.

In this study, a control flow graph is

automatically created and weighted each edge to use

in optimal path determination then the source code

converts into XML to extract the variables and

generate random data in the given domain for thus

source to destination a clustering is done for the

variables test data to check the feasibility and

coverage of paths. Finally, the fuzzy logic will

determine the optimal path.

Triangle and Prime programs are used as a case

study to show how our test case generation tool

(TCGFL) was implemented with a completely

automated approach from the first phase to produce

test cases and evaluate paths. Furthermore, we use

an existing approach to analyze the model using