The document discusses various software testing techniques including white box testing and black box testing. It provides details on test cases, test suites, and testing conventional applications. Specifically: - It describes white box and black box testing techniques, and explains that white box tests the implementation while black box tests only the functionality. - It defines what a test case is and lists typical parameters for a test case like ID, description, test data, expected results. It provides an example test case. - It explains that a test suite is a container that holds a set of tests and can be in different states. A diagram shows the relationship between test plans, test suites and test cases. - It discusses unit testing and

1. Software Engineering (2160701)
VADODARA INSTITUTE OF ENGINEERING
ACTIVE LEARNING ASSIGNMENT
Presented By:
Kashyap Patel 150800107046
Krishna Patel 150800107047
Maitree Patel 150800107048
TOPIC :Testing techniques, Test case, Test suites design,
Testing Conventional Applications

2. Contents
Testing techniques
– White box testing
– Black box testing
Test case
– What is Test case?
– Typical Test Case Parameters
– Test Case Example
Test suites design
Testing Conventional Applications
– Unit testing
– Integration testing

3. Testing Techniques
• Tests can be conducted based on two approaches –
1. Functionality testing
2. Implementation testing
•.When functionality is being tested without taking the actual implementation in
concern it is known as black-box testing. The other side is known as white-box
testing where not only functionality is tested but the way it is implemented is also
analyzed.
•.Exhaustive tests are the best-desired method for a perfect testing. Every single
possible value in the range of the input and output values is tested. It is not
possible to test each and every value in real world scenario if the range of values
is large.

4. Black Box Testing
• It is carried out to test functionality of the program. It is also called ‘Behavioral’
testing.
• The tester in this case, has a set of input values and respective desired results. On
providing input, if the output matches with the desired results, the program is
tested ‘ok’, and problematic otherwise.
• In this testing method, the design and structure of the code are not known to the
tester, and testing engineers and end users conduct this test on the software.

5. Black Box Testing
Black-box testing techniques:
• Equivalence class - The input is divided into similar classes. If one element of a class
passes the test, it is assumed that all the class is passed.
• Boundary values - The input is divided into higher and lower end values. If these values
pass the test, it is assumed that all values in between may pass too.
• Cause-effect graphing - Cause (input) – Effect (output) is a testing technique where
combinations of input values are tested in a systematic way.
• Pair-wise Testing - In pairwise testing, the multiple parameters are tested pair-wise for their
different values.
• State-based testing - The system changes state on provision of input. These systems are
tested based on their states and input.

6. White-box Testing
• It is conducted to test program and its implementation, in order to
improve code efficiency or structure. It is also known as ‘Structural’
testing.
• In this testing method, the design and structure of the code are
known to the tester. Programmers of the code conduct this test on
the code.

7. White-box Testing
The below are some White-box testing techniques:
• Control-flow testing - The purpose of the control-flow testing to set up test cases
which covers all statements and branch conditions. The branch conditions are
tested for both being true and false, so that all statements can be covered.
• Data-flow testing - This testing technique emphasis to cover all the data variables
included in the program. It tests where the variables were declared and defined
and where they were used or changed.

8. Test Case
What is Test Case ?
• A test case is a set of conditions or variables under which a tester will determine
whether a system under test satisfies requirements or works correctly.
• The process of developing test cases can also help find problems in the
requirements or design of an application.
• A test case is a document, which has a set of test data, preconditions, expected
results and postconditions, developed for a particular test scenario in order to
verify compliance against a specific requirement.
• Test Case acts as the starting point for the test execution, and after applying a set of
input values, the application has a definitive outcome and leaves the system at
some end point or also known as execution postcondition.

9. Test Case Parameters
• Test Case ID
• Test Scenario
• Test Case Description
• Test Steps
• Prerequisite
• Test Data
• Expected Result
• Test Parameters
• Actual Result
• Environment Information
• Comments

10. Test Case Parameters
• Let us say that we need to check an input field that can accept maximum of 10
characters.
• While developing the test cases for the above scenario, the test cases are
documented the following way. In the below example, the first case is a pass
scenario while the second case is a FAIL.
Scenario Test Step Expected Result Actual Outcome
Verify that the input
field that can accept
maximum of 10
characters
Login to application
and key in 10
characters
Application should be
able to accept all 10
characters.
Application accepts all
10 characters.
Verify that the input
field that can accept
maximum of 11
characters
Login to application
and key in 11
characters
Application should NOT
accept all 11
characters.
Application accepts all
10 characters.

11. Test Suits Design
What is a Test Suite?
• Test suite is a container that has a set of tests which helps testers in executing and
reporting the test execution status. It can take any of the three states namely
Active, In progress and completed.
• A Test case can be added to multiple test suites and test plans. After creating a test
plan, test suites are created which in turn can have any number of tests.
• Test suites are created based on the cycle or based on the scope. It can contain any
type of tests, viz - functional or Non-Functional.

12. Test Suite - Diagram

13. Testing Conventional Applications
The following characteristics lead to testable software.
Operability
• “The better it works, the more efficiently it can test.”
• If a system designed and implemented with quality in mind, relatively few bugs will block
the execution of tests, allowing testing to progress without fits and starts.
Observability
• “What you see is what you test.”
• Moreover, Inputs provided as part of testing produce distinct outputs.
• Also, System states and variables visible or queriable during execution. An incorrect
output easily identified. Internal errors are automatically detected and reported. The source
code accessible.

14. Testing Conventional Applications
Controllability
• “The better we can control the software, the more the testing can automate and optimized.”
• All possible outputs can generate through some combination of input, and I/O formats
consistent and structured.
• Moreover, All code executable through some combination of input. Software and hardware
states and variables can be controlled directly by the test engineer.
• Also, Tests can conveniently specified, automated, and reproduced.
Decomposability
• “By controlling the scope of testing, we can more quickly isolate problems and perform
smarter retesting.”
• The software system built from independent modules that can test independently.

15. Testing Conventional Applications
Simplicity
• “The less there to test, the more quickly we can test it.”
• Also, The program should exhibit functional simplicity (e.g., the feature set the
minimum necessary to meet requirements); structural simplicity (e.g., architecture
modularized to limit the propagation of faults), and code simplicity (e.g., a coding
standard is adopted for ease of inspection and maintenance).
Stability
• “The fewer the changes, the fewer the disruptions to testing.”
• Moreover, Changes to the software infrequent, controlled when they do occur, and do
not invalidate existing tests.
• Also, The software recovers well from failures.

16. Testing Conventional Applications
Understandability
• “The more information we have, the smarter we will test.”
• Moreover, The architectural design and the dependencies between internal,
external, and shared components well understood.
• Similarly, Technical documentation instantly accessible, well organized, specific
and detailed, and accurate. Changes to the design communicated to testers.

17. Testing Conventional Applications
Unit Testing
• While coding, the programmer performs some tests on that unit of program to
know if it is error free.
• Testing is performed under white-box testing approach. Unit testing helps
developers decide that individual units of the program are working as per
requirement and are error free.
Integration Testing
• Even if the units of software are working fine individually, there is a need to find
out if the units if integrated together would also work without errors. For example,
argument passing and data updating etc.

18. Thank You