Software Testing: Techniques for Test Case Generation and Analysis

This assignment provides an overview of software testing techniques, focusing on test case generation. It discusses two primary methods: specification-based and source code-based testing. Specification-based testing involves generating test cases based on user requirements, ensuring the software meets all specified needs. The assignment highlights the benefits of this approach, including early test case generation and easier code updates. Source code-based testing, on the other hand, uses the software's code and algorithms to create test cases. This method categorizes test cases into random, path-oriented, and goal-oriented techniques. The random technique uses the tester's intuition, while path-oriented testing ensures that the software follows specific paths for given inputs. Goal-oriented testing involves defining expected inputs and outputs to verify the software's behavior. The document emphasizes the importance of testing throughout the software development life cycle to minimize errors and ensure software quality.

Software testing is an important phase of software development life cycle. Software
testing is a time consuming and costly process but to get a software with minimum error
we have do its testing in all aspects. To do the software testing we have to generate its
test cases, predefine expected result, and the actual result which will be only shown
when we run the software and then compare the actual result to the expected result to
check weather this software fail or pass in that particular case.
The first technique that I will use to write my test cases is specification based test case
generation technique, in this method the test cases are generated on the basis of
requirement specification given by the user. There will a requirement document given by
the user in which there is all the necessary things are mentioned which we have to do in
the software. I choose this technique to test the software because as it is the basic need
that a softare have to meet all the requirements that are give by the user. To generate
test cases using this technique I have to first read and understand all the requirements
given by the user, and then check on every point that the software had fulfil the user
requirement or not and on that basic the that particular test case is fail or pass. Another
reason to choose this technique is that the testing engineer can generate the test cases
very early, as you know that the software requirement document is given by the first and
then the developer starts developing it, as the software is developed it comes to test
engineer for testing and then test engineer starts writing the test case but in this
technique test engineer can start writing test cases while the developer are working on
the software because in this case test engineer have to write the test cases on the basis
of requirement document and that is also available for the testing engineer, other benefit
of this is that it will reduce the time for software testing because the software will be in

the early phase while we can do that testing and if the software fails on any of the test
cases then it will be easy for the developer to update the code because it is easy to
change the software code when it is in early phase of developing.
Another technique that I will use to generate test cases is source code based test
generation technique . This technique has been chosen by me is because we have
given the algorithm to develop the software and the coding have to be done on that
algorithm and in this technique the test cases generated on the basis of coding style
and fulfill all the conditions of the the user that in all situation the software will not crash
and produce the appropriate result. The test case that will generate using this technique
are categorized into three parts and that are random technique, path oriented technique
and goal oriented technique. In random technique the test engineer use its imagination
and common sense to develop the test cases, as the test engineer has the idea of the
whole software and its functionality he can imagine where the software can crash and
made it a test case. In path oriented testing the test cases are develop by keeping in the
mind that while given that a particular input the software have to follow a specific path
and to check this we generate all the possible test cases by which the software cover
different path for different input and will cover all the possible path that are situated in
the software, in this the test engineer has to check that for the given input the software
has to follow a certain path and he checks that the software follow that path or not. In
goal oriented technique which is most common technique and has to follow by every
test engineer, in this we make a list of all possible output and also input list to get
desired output and then only checks that all the output are coming when input is given
to desired input or not.