--------------------------------------------------------------------------Test

Case:

Subheading for a test case:

Test Case ID -> test condition -> pre-requisitries -> Test Procedure Steps ->
expected Result -> Actual Result -> Pass/Fail -> Priority

Use Case Defination:

-A Use Case is based on the overall system requirments to help understand the end-
user action and system behaviour. Can be decribed using a model, E.G. Paypal
Transaction

Traceability matrix: Ensures the requirements are covered by test cases and can
outline any missing test cases which have not been covered

--------------------------------------------------------------------------Software
Testing:

Software Testing is a method to check whether the actual software product matches
expected requirements and to ensure that software product is Defect free

Software Testing types:

-functional testing (Unit Testing, System Testing, component Testing, black-box and
white-box Testing, UAT)
-non-functional testing (Performace Testing, Usability Testing)
-Maintance testing (Regression Testing)

Importance of software testing is to ensure bugs or errors within a software can be

detected early durning the software development life cycle to ensure their
are less maintance when released. In addition, it helps to save costs and time for
the company

Benefits of Software Testing:

-Cost effective (bugs caught in earely stages of the cycle)
-Security (enusres a trusted product)
-Product quality (essntial requirements for customers)
-Customer satisfaction (UI/UX Testiing eo enhance customer experiance, user-
friendly)

Test suite: is a collection of scenarios (test cases) defining the scope of testing
for a given execution requirement.

Regression Testing: when there is a change in enviroment or a new

functionality/feature has been implemented, test the new feature as well as
previous
test cases and functionality to ensure no new defects have been developed. Occurs
at all test levels within the V-Model

--------------------------------------------------------------------------7
Principles of Software Testing:

1. Testing shows a presence of defects:

- Software Testing reduces the amount of undiscovered defects remaining in the
software

2. Exhaustive testing is impossiable:

- Optimal amount of testing is based on the risk assessment of an application

3. Early Testing:
- Testing should start early in the SDLC so defects in the requirements or design
phase can be captured early as its much cheaper and effective

4. Defect Clustering:
- Small number of modules contain most of the defects detected

5. Pesticide Paradox:
- If the same set of repetitive tests are conducted, the method will be useless for
discovering new defects
- Therefore, to overcome this, Test cases need to be reviewed and adding new,
different test cases top help find more defects

6. Testing is context dependent:

- Testing can be done in varieties of ways

7. Absesnce of errors fallancy:

- Finding and fixing defects doesn’t help if the system if the requirements are do
not suit the users expectations

--------------------------------------------------------------------------Test
Types:

Functional -> Black box testing -> All Levels -> Internal -> Key features i.e
button, text-field -> Specification-based
Non-Functional -> Black box testing -> All Levels -> Internal -> Performace, Load -
> Specification-based
Structural -> White box testing -> Component, Integration and accepptance ->
external -> Measures coverage i.e code coverage, design ->Structure-based

Experianced-based Testing: Knowledge and experience of testers, users and

developers of the software and likely defects

Experiance-based Techniques:
-Error guessing -> Use knowledge of systems and testing to anticipate defects
-Exploratory testing

--------------------------------------------------------------------------Static vs
Dynamic:

Static Testing: is performed on code or other project documentation without the

execution of the code

Two static testing techniques:

Review:
Manual examination of documents
Done by humans

Static analysis: (SonarCloud)

Automated analysis of source code and software models
Done by tools

Dynamic Testing: Execute software/Code and analyse the results

Static Testing:
-Performed early in the lifecycle, before software is written
-Analyse code or documents without running software
-Find defects in code or documents directly
-Defects are cheap to fix
-Add quality into software

Dynamic Testing:
-Performed late in the lifecycle, after software is written
-Execute software and analyse results
-Observe failures in system which could identify defects in code
-Defects are expensive to fix
-Check quality of software