0% found this document useful (0 votes)
29 views5 pages

Software Testing Overview and Models

Uploaded by

siddharthvare9
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
29 views5 pages

Software Testing Overview and Models

Uploaded by

siddharthvare9
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd

software:--> A software is collection of computer programs that helps to perform a

task

types; 3
system software --> os,servers..etc
application software-->web apps, mobile apps, desktop apps...etc
programming software--> debuggers, complilers....etc

Manual testing: Manual testing is a software testing process in which test cases
are executed manually without using any automated tool

Software testing :
it is process of identify correctness,completeness,quality of the
application

Software Quality: cost/budget


timelines
Bug free
meets requirement
maintainable

"Project and Product"


------------------->
project: a software application is developed for specific customer based on the
requirement
eg:- company websites,
Product: a software application is developed for multiple customers based on market
requirements
eg:-whatsapp,flipkart

Why do we need testing ?


we have to deliver quality product to customer

ERROR/BUG/FALIURE;
ERROR : incorrect human action
BUG/Defect : Deviation from expected results to actual results
FAILURE: deviation identified by enduser

Why software has bugs?


mainly 5 reasons
1. miscommunication or no communnication b/w devolopers and testers
[Link] Complexity
[Link] errors
[Link] changing requirements
[Link] of skilled testers

SDLC (Software Development Life Cycle)

Business analys---> Requirement Collection ->BRS/CRS/URS

Req Analysis -> "

Design -> GUI Design


DB Design
app Design documents
->HLD(Root to leaf of modules)

LLD(each module functionality)

Coding

Testing --> WBT(Unit & Integration


Testing)
BBT
UAT

release

Maintainance -> CR's (change


requirements)

types ;

1.*"" WATERFALL MODEL""

Req analysis, design , coding/Implimentation , testing , Deployement ,


maintainance

Adv : changes req are not allowed SO no bugs


Qualty of product will be good
preferd for small projects

Disadv: change req not allowed


if any req changes in later phase allowed
cost more becoz time taking for re work on defect
testing will only start after coding

2.* ""v model"" or ""VV model""

Verification validation

(BA) BRS/URS/CRS ----------- UAT (testers along with users)

(PM) SRS ------------------- system testing (testers)(BBT)

(Designers)HLD
LLD ----------------Integration testing (WBT)

(developers)coding---------------- unit testing(WBT)

Adv : testing is involved in each and every phase


Dis adv : documentation is more
cost is high
3.*""prototype model""
prototype means sample/ blue print
blue print of the software
intial req from the customer --> design,coding,testing.......

[Link] process
[Link]

6.* ""SPIRAL (ITERATIVE)""

planning ( Req analysis) , Risk Analysis, dev & testing (engineering &
execution) , Evaluation ( customer evaluation)

preferd for proudct based companies


updates ,upgrades of applications
it overcome draw backs of water fall model
In every cycle new software will be realeased
software will be released in multiple versions so it is called version
controlled model

adv : testing is done in every cycle , before going to new cycle


customer will get to use the software for every module
Requirements changes are allowed after every cycle

Dis adv : req changes not allowed b/w the cycle


every cycle of spiral model lools like a water fall model
there is no testing in req & design phase

[Link]
[Link]

Static testing : Testing the project related documents

Dynamic testing : Testing the actual Software

-> Verification: whether we are building the right product


Focus on documention

review :- conducts on documents to ensure correctness and completeness

walk through:- informal review (no plan)

Inspection:- formal review ,meetings

-> Validation : whether we are buliding the product is right


Focus on software
unit testing :- testing of each unit or an individual component of the software
, it uses module for testing
integration testing :- unit testing modules are combined and tested. or testing
performed b/w 2 or more modules

system testing :- whether software is working customer requirements or not

* Functional testing : behaviour of application


how feature should work ->object property testing : eg.
drop down, list boxes , select male/female
->DB testing : back end testing
, table form
->Error Handling : tester
verify error messages while performing incorrect actions
-> caluclation/manipulation
testing : numbers caluclation
->links existence& links
execution : where links are placed, clink on link navigating proper next page
-> cookies : temporary files
created by browser while browsing the pages through internet
eg ; remember
password check box
-> session : session expired
time slot like payments doing time

* NON Functional Testing: functonality is stable then we do Non functional


testing
focus on performance, load it can take and security
etc.

-> perfomance testing ; speed of the application


(response time)
Load : number of users
increased load on the application
Stress : suddenly
increased/decreased load on the application
Volume : (size) how much data
is able to handle

-> Security testing : how secure our application


Autherization /
Authentication

-> Recovery testing : by mistake we loose data


application is able to recover data

-> Compatability testing : versions are able to


upgrade

-> Installation testing : check screens are clear to


understand

-> Sanitation/Grabage testing : If any application


provides extra features then we called it is bug
UAT testing :- testers along with the user and setup enviornment

** QA vs QC**
QA:- process related (people process product)
focus on buiding in quality
preventing the defects

QC:- actual testing software


focus on testing for quality
detects the defects

Regression Testing: Testing conducts on the modified build to make sure there will
not be impact on existing functionality because of changes like
adding/deleting/modifying features

* Unit Regresson Testing : Testing only on the changes done by the developer

* Regional Regression Testing :testing modified module along with the impacted
modules with QA & dev

* Full Regression : Testing the main feature & remaining part of the application

Common questions

Powered by AI

The V-model enhances testing throughout the software development lifecycle by integrating testing phases parallel to each development stage, ensuring that testing is performed continuously and simultaneously with development. This contrasts with traditional models like the Waterfall model, where testing occurs only after the implementation phase, potentially leading to late discovery of defects .

The primary difference between manual testing and automated testing is that manual testing is executed by a human without automated tools, while automated testing uses software tools and scripts to run tests. Manual testing may be more beneficial in scenarios where tests require human observation, such as usability testing, where user interactions, look, and feel matter significantly. It is also preferred in small projects where setting up automated processes might be cost-ineffective .

A company might opt to use the prototype model over the Waterfall model to allow customers to interact with a sample version of the software early on, providing valuable feedback for iterative refinement. This is particularly beneficial for consumer products needing frequent adjustments based on user input, which are harder to implement in the rigid phases of the Waterfall model .

The Spiral model integrates risk analysis and customer feedback iteratively in each cycle, allowing for continuous improvements and mitigations before proceeding to the next phase. This approach contrasts with the Waterfall model, which lacks built-in risk management and customer feedback mechanisms, making changes more difficult to implement after the initial phases .

Regression testing ensures that recent code changes have not adversely affected existing functionality, often involving retesting entire software modules. It differs from unit testing, which focuses solely on verifying individual components in isolation. Regression testing confirms the integrity of the software as a whole post-modification, while unit testing ensures each part initially functions correctly .

Functional testing focuses on verifying the behavior of software applications, ensuring features work according to requirements, while non-functional testing assesses aspects like performance, security, and usability. Both are critical because functional testing ensures the application does what it is supposed to, and non-functional testing ensures it performs well under expected conditions .

Unit testing verifies individual components of the software in isolation, ensuring each part functions correctly. Integration testing assesses combined units, revealing issues in their interactions. System testing evaluates the entire software against customer requirements, providing validation that the software works as intended. Together, these stages ensure comprehensive coverage of potential defects, enhancing the software's quality and integrity .

Software defects can arise from miscommunication between developers and testers, software complexity, programming errors, frequently changing requirements, and lack of skilled testers. To minimize these defects, development teams should enhance communication, simplify software designs when possible, implement rigorous testing at every development phase, manage requirement changes effectively, and invest in training for testers .

Static testing involves reviewing and inspecting project-related documents to ensure correctness and completeness without executing the code, focusing on verification of the project plan. Dynamic testing, on the other hand, involves executing the actual software, focusing on validation that the final product matches requirements. Together, they provide a comprehensive testing approach, validating both the design and functionality of the software .

The Agile process benefits software development in rapidly changing markets by allowing for iterative development and frequent reassessment, enabling teams to adapt quickly to changes. However, challenges include the need for significant stakeholder engagement, potential for scope creep without proper management, and the demand for skilled teams to ensure efficient delivery .

You might also like