Software Testing Procedures

The main aim of this paper is discussing the software testing approaches for ensuring quality of a software. In this report software testing has been done of a java program which calculates the taxes and income of the individuals. For this testing, white box testing approach has been used and in the white box testing, unit testing method has been utilized in this case. JUnit tool has been used for performing the tests. The tested program is capable of executing various type of functions. The detailed functionality of the system has been demonstrated in this report. Analysis of the white box testing has been also demonstrated within the report. This report on the software testing has also demonstrated the test case chapter and the test demonstration chapter of the software testing procedures.

Running head: SOFTWARE TESTING PROCEDURES
Software Testing Procedures
Name of the Student
Name of the University
Author Note

1SOFTWARE TESTING PROCEDURES
Executive Summary
The main aim of this paper is discussing the software testing approaches for ensuring quality of a
software. In this report software testing has been done of a java program which calculates the
taxes and income of the individuals. For this testing, white box testing approach has been used
and in the white box testing, unit testing method has been utilized in this case. JUnit tool has
been used for performing the tests. The tested program is capable of executing various type of
functions. The detailed functionality of the system has been demonstrated in this report. Analysis
of the white box testing has been also demonstrated within the report. This report on the software
testing has also demonstrated the test case chapter and the test demonstration chapter of the
software testing procedures.

2SOFTWARE TESTING PROCEDURES
Table of Contents
Introduction:........................................................................................................................3
Details of the Tested Program:............................................................................................3
Analysis of the White Box Testing:.....................................................................................4
Conclusion:..........................................................................................................................7
Bibliography:.......................................................................................................................8

3SOFTWARE TESTING PROCEDURES
Introduction
Software testing is very much crucial concept in the software engineering methodology.
The process of software testing is initiated for ensuring that all the functionalities of the software
is working successfully according to the software development plan. By this software testing
procedures different types of malfunction cases within the test cases can be identified
successfully. In an overall structure the software testing ensures that best quality of software has
been developed from the software development process.
In this aspect a white box software testing approach will be utilized for assessment of the
developed software. The white box testing consists of McCabe path; Def-use path and MM path
are used for integration. These are the methods of testing and fall under the white box testing.
Through the white box testing regarding security holes, expected output, flow of the input codes
and all of the statements can be verified easily. The white box testing method that has been used
in this context is the unit testing method. The testing tool that has been used in this context is the
JUnit. The unit testing method is a typical type of testing method by using which individual unit
of the software source code can be tested properly. With that by using the unit testing procedures
of the usage, operating procedures, computer program module set can be tested together. The
JUnit can be considered as a unit testing framework which is mainly used for the Java
programming language. In this case also, the Java language has been utilized for this reason the
JUnit has been selected here. The report deals with the testing of a program using the methods of
testing. The report discusses on the details of the program that is being tested. The report focuses
on the analysis of white box testing. The report also discusses in detail the test case chapter and
the test demonstration chapter.

4SOFTWARE TESTING PROCEDURES
Details of the Tested Program
The main program that has been tested in this context is a tax calculator program. This
software is capable of calculating different types of taxes as per the general taxation rule in
Australia. The implemented program of tax calculator is different type of functionalities. This
software is currently capable of calculating the return tax for the individual peoples. For this
section the user of the software needs to input some data so that the return tax can be calculated.
Here the user needs to input their income, medicare levy, LI levy, TBR levy and their age. This
software is also capable of calculating the medicare tax and the actual income of the individual
users. For the calculation of medicare tax the user inputs which are required in this case are the
income of the individual, overall levy, tax rate and any type of additional taxes. Actual income of
the individuals is also calculated by this software program. In this aspect the actual income is the
deducted tax amount from the gross income of the individuals.
Analysis of the White Box Testing
In this aspect for perfect testing of thesoftware which is being developed, testing
procedures of white box has been chosen. Here, testing process of white box will be executed
over the developed software program using the method of unit testing. For performing the unit
testing procedures the JUnit tool will be utilized here. The unit testing method of testing is
consisting several of advantages, for which the unit testing procedure has been selected in this
context. The main reasons due to which unit testing has been chosen is that it is capable of fixing
the bugs in the software in the early life cycle of the process of software development. Also, the
unit testing assists the developers to understand the base of the code and in this way they can
make the changes quickly. There are various testing procedures which need to be performed for
the white box testing procedures. This testing procedures include conditional testing, expression

5SOFTWARE TESTING PROCEDURES
testing, domain testing, path testing and data flow testing. Conditional testing is one of the
important testing procedure in the case of unit testing. Within the conditional testing each of the
clause in all the condition is forced to take all the possible values with having the combination of
other type of clauses. The conditional testing will be done of the developed taxation software for
reducing the conditional coverage problem. With the conditional testing, the expression testing is
also very much important in this context. The main fundamental of the expression testing is that
all the expressions assumes different of values at the time of performing a test in such a way that
none of the expressions is replaceable by a simpler type of expression. The expression testing is
quite important in this case for successful testing of the developed software, that it is currently
functioning in the desired way. Domain testing of the developed software is also required in this
context. The input domain of the developed software can be partitioned easily. This partitioning
works accordance with which of the input causes each path to become executing. These
partitions are actually known as the path domains. The domain testing has been performed in this
context so that any of existing domain fault in the developed program can be discovered easily.
In this case the domain testing will be done by assuming that there is no occurrence of
coincidental correctness. In the simple process the domain testing assumes the program will be
failed in such of the cases if an input follows the wrong path.
The definition-use testing, McCabe testing and the MM path testing are the methods by
which are the testing of the program that is given is done. A definition-use path or Def-use path
with respect to a variable let’s say v that is denoted as du-path is a path in the set of the entire
paths in P, PATHS(P), such that for some v € V, there are define and usage nodes DEF(v,m) and
USE(v,n) such that m and n are the initial and the final nodes of the path.

6SOFTWARE TESTING PROCEDURES
The McCabe’s basis path method would need the number test cases= Cyclomatic
Complexity value. Cyclomatic complexity = E-N+2P where E is the number of edges, N is the
number of nodes and P is the number of connected components. The cyclomatic complexity = E-
N+P if each exit point is connected back to the point of entry in order to form connected
components that are strong.
An MM path in software that is object oriented is a series of executions of methods that
are linked by messages. P-path is a procedure path that means the direct of the method that is
public. MM- path is a path of method-message that means that all the methods that were called.
With the above testing procedures path testing is also very much important in this
context. In the cases of path testing, data is selected for ensuring that all of the paths of the
developed taxation program has been executed. In the practices achieving this type of coverage
is actually impossible for some of reasons. If it is considered that the developed taxation program
is consisting an indefinite loop and this loop is containing many paths infinitely for each of the
iteration of the loop then, finite data set will be able to execute all of the paths. Also, infeasible
path is another problem in this case. In such type of cases it becomes undecidable whether the
arbitrary path in an arbitrary type of program is executable or not. The path testing is important
for this developed software as it is capable of generating important testing data which includes
infeasible paths. It is futile but unavoidable in nature. With that, it is also undecidable whether
the arbitrary program will be halting for an arbitrary input or not. The path testing is quite
important in this case as the path testing allows the developer of the program to perform an
analysis on the flow of the program at the time of testing process. The path testing is very much
dependent on the program’s source code. At least, by using the path testing it can be ensured that
each and every path that has been defined in the program is executed at least once.

7SOFTWARE TESTING PROCEDURES
In the aspect of unit testing, the data flow testing is also very much important. The
analysis of data flow is capable of forming the basis for testing procedures. With that it can also
exploit the relationship among the points where the definition of the variable is provided. The
data flow testing is capable of establishing some important conditions which are necessary for
the partial propagation and infection. The main motivation which works behind the process of
data flow testing is that the data regarding tests are inadequate if exercise is not done of these
several of def-use combination. In this aspect for the developed software program the data flow
testing is quite crucial due to some important reasons. This type of testing is a family of the test
strategy which are currently dependent on selection of paths within theprogram’s control flow so
that eventssequences can be explored. These events are related with the data status or variable
objectives. The dataflow testing is currently focused on the particular points at which variables
are receiving the values and the specific points at which these values are currently used.
In an overall perspective the unit testing is very much important for the developed
taxation software. There are several of reasons due to which the unit testing plays an important
role.While developing a software the developers always looks to learn what are the
functionalities that is provided by a unit and how it can be used so that it can focus on the unit
tests so that simple understanding of the unit API can be gained. This is one of the important
advantage of the unit testing.Also, by using the unit testing, the programmer can refactor the
code at a later date. The programmer here ensures that the module functions in proper way. In
this aspect the main procedure is writing the cases for all of the methods and functions so that if
of the initiated changes cause a fault, then it can be identified quickly and can be fixed with no
delay. In overall, the unit testing consists a modular type of nature. Due to this nature parts of a
project can be tested easily without waiting for full completion of the project. Due to this

8SOFTWARE TESTING PROCEDURES
advantages selection of the unit testing of the white box testing is quite viable for this software
project.
Test casechapter
In order to test the provided code segment, following test cases are used in order to
check the correct functionality of the implemented code segment. There are mainly five data
attributes that can be varied which should present the correct results for multiple tiers of the
taxable income of an individual. Following table shows the test cases;
Income Age medicareLevy TBRLevy LILevy Expected
Actual
Income
15000 25 true true true 15000
15000 25 false false false 15000
26000 25 false false false 24518
26000 25 true false false 23998
70000 25 false false false 55703
70000 25 true true true 54303
170000 25 false false false 115753
170000 25 true true true 119153

9SOFTWARE TESTING PROCEDURES
Test demonstration chapter
For Income less than threshold
Code used
public GeneralTaxationRuleTest() {
GeneralTaxationRule gtx = new GeneralTaxationRule(15000, 25, true, true, true);
double exp = 15000.0;
double actual = gtx.getActualIncome();
assertEquals(exp, actual, 0.00001);
}
As the threshold value is set to 18200, thus irrespective of the true or false values of the
levy taxes the actual income and the income after tax deductions remains the same. As depicted
in the following two respective tests.

10SOFTWARE TESTING PROCEDURES
For all false
public GeneralTaxationRuleTest() {
GeneralTaxationRule gtx = new GeneralTaxationRule(15000, 25, false, false, false);
double exp = 15000.0;
double actual = gtx.getActualIncome();
assertEquals(exp, actual, 0.00001);
}

11SOFTWARE TESTING PROCEDURES
In the next section, the actual income for first tier which is 37000 is tested with the input
values 26000. The following results depicts the results one for all false value of levy taxes and
another with all true for levy taxes.
public GeneralTaxationRuleTest() {
GeneralTaxationRule gtx = new GeneralTaxationRule(26000, 25, false, false, false);
double exp = 24518.0;
double actual = gtx.getActualIncome();
assertEquals(exp, actual, 0.00001);
}

12SOFTWARE TESTING PROCEDURES
public GeneralTaxationRuleTest() {
GeneralTaxationRule gtx = new GeneralTaxationRule(26000, 25, true, false, false);
double exp = 23998.0;
double actual = gtx.getActualIncome();
assertEquals(exp, actual, 0.00001);
}

13SOFTWARE TESTING PROCEDURES
In the next section, the actual income for second tier which is 80000 is tested with the
input values 70000. The following results depicts the results one for all false value of levy taxes
and another with all true for levy taxes.

14SOFTWARE TESTING PROCEDURES
Code used for the test (using all conditions false)
public GeneralTaxationRuleTest() {
GeneralTaxationRule gtx = new GeneralTaxationRule(70000, 25, false, false, false);
double exp = 55703.0;
double actual = gtx.getActualIncome();
assertEquals(exp, actual, 0.00001);
}
Code used for the test (for all true conditions)
public GeneralTaxationRuleTest() {

15SOFTWARE TESTING PROCEDURES
GeneralTaxationRule gtx = new GeneralTaxationRule(70000, 25, true, true, true);
double exp = 54303.0;
double actual = gtx.getActualIncome();
assertEquals(exp, actual, 0.00001);
}
For third tier, the actual income for second tier which is 180000 is tested with the input
values 170000. The following results depicts the results one for all false value of levy taxes and
another with all true for levy taxes.

16SOFTWARE TESTING PROCEDURES
public GeneralTaxationRuleTest() {
GeneralTaxationRule gtx = new GeneralTaxationRule(170000, 25, true, true, true);
double exp = 115753.0;
double actual = gtx.getActualIncome();
assertEquals(exp, actual, 0.00001);
}
For All false conditions
public GeneralTaxationRuleTest() {

17SOFTWARE TESTING PROCEDURES
GeneralTaxationRule gtx = new GeneralTaxationRule(170000, 25, false, false,
false);
double exp = 119153.0;
double actual = gtx.getActualIncome();
assertEquals(exp, actual, 0.00001);
}

18SOFTWARE TESTING PROCEDURES
Conclusion
From the above discussion it can be concluded that software testing is very much
important for the software development process as through this quality of the software can be
ensured. Assuring quality of the software is very much important as it proactively identifies all
the present bugs within the system at the very beginning. In this way all the problems in the
software can be founded and can fixed proactively. In this way the quality of the software can be
assured. In this report a java program has been tested by using themethod of unit testing. Here,
for execution of the tests,JUnit has been utilized. This java program is a taxation program for the
tax and income calculations of the individuals. Detail illustration of the program has been shared
in this report. Following that, analysis of the white box testing approach has been elaborated and
validity of the testing approaches has been defied. In the following section of this report, test
cases has been defined in a proper way which has explained all the test cases. Further, test
demonstration has been also shared in this report.

19SOFTWARE TESTING PROCEDURES
Bibliography
[1]W. Lewis, D. Dobbs and G. Veerapillai, Software testing and continuous quality
improvement.
[2]M. Harman, Y. Jia and Y. Zhang, "Achievements, Open Problems and Challenges for Search
Based Software Testing", 2015 IEEE 8th International Conference on Software Testing,
Verification and Validation (ICST), 2015. Available: 10.1109/icst.2015.7102580
[3]L. Briand, S. Nejati, M. Sabetzadeh and D. Bianculli, "Testing the untestable", Proceedings of
the 38th International Conference on Software Engineering Companion - ICSE '16, 2016.
Available: 10.1145/2889160.2889212.
[4]I. Komargodski, M. Naor and E. Yogev, "White-Box vs. Black-Box Complexity of Search
Problems", Journal of the ACM, vol. 66, no. 5, pp. 1-28, 2019. Available: 10.1145/3341106
[5]C. Henard, M. Papadakis, M. Harman, Y. Jia and Y. Le Traon, "Comparing white-box and
black-box test prioritization", Proceedings of the 38th International Conference on Software
Engineering - ICSE '16, 2016. Available: 10.1145/2884781.2884791
[6]J. Álvez, M. Hermo, P. Lucio and G. Rigau, "Automatic white-box testing of first-order logic
ontologies", Journal of Logic and Computation, vol. 29, no. 5, pp. 723-751, 2019. Available:
10.1093/logcom/exz001
[7]M. Gulzar, S. Mardani, M. Musuvathi and M. Kim, "White-box testing of big data analytics
with complex user-defined functions", Proceedings of the 2019 27th ACM Joint Meeting on
European Software Engineering Conference and Symposium on the Foundations of Software
Engineering - ESEC/FSE 2019, 2019. Available: 10.1145/3338906.3338953

20SOFTWARE TESTING PROCEDURES
[8]U. Markiegi, A. Arrieta, L. Etxeberria and G. Sagardui, "White-box and black-box test quality
metrics for configurable simulation models", Proceedings of the 23rd International Systems and
Software Product Line Conference volume B - SPLC '19, 2019. Available:
10.1145/3307630.3342396
[9]P. Stefan, V. Horky, L. Bulej and P. Tuma, "Unit Testing Performance in Java
Projects", Proceedings of the 8th ACM/SPEC on International Conference on Performance
Engineering - ICPE '17, 2017. Available: 10.1145/3030207.3030226
[10]J. Dooley, "Unit Testing", Software Development, Design and Coding, pp. 253-269, 2017.
Available: 10.1007/978-1-4842-3153-1_16
[11]S. Gulati and R. Sharma, "Understanding Core JUnit 5", Java Unit Testing with JUnit 5, pp.
25-44, 2017. Available: 10.1007/978-1-4842-3015-2_2
[12]S. Gulati and R. Sharma, "Dynamic Tests and Migration from JUnit 4", Java Unit Testing
with JUnit 5, pp. 139-147, 2017. Available: 10.1007/978-1-4842-3015-2_8