tsl925

What is Testing ?

------------------

Just Imagine :

A process in which we compare expected Behavior with actual Behavior.



What is Software Testing ?

------------------

Just Imagine :

A process in which we compare expected Behavior with actual Behavior with Software.


Why Testing is done ?(Objective of Testing)

Tester's Objective:

>Finding as many as Defect possible & get them fixed from Developer.


Client/Customer Objective:

>To check whether it is meeting their business Expectations or not


If Type of Testing or Levels of Testing is Change then Objective will also change


Any Software/Product which is not working Fine May lead to following losses

1.Loss of time

2.Loss of Reputation

3.Loss of Business

4.Loss of Human Life



Why Seperate Software Testers are required ?(Why devloper is not right for Testing ?)

>To Avoid Auther biasness (To avoid any emotional Attachment)

Independant testing: Testing done by any other person who has not written code

With Help of Independant testing number of Defect will increase & if Defect is fixed then It will increase Quality of Product


Low Independance  : If Developer doing testing of Thier own code

High Independance : If Seperate Testing Team is involve for Testing or

    Testing of Product is Outsourced to some other Organization

-----------------------------------------------------------------------------------


SDLC :(Software Development Life Cycle):

----------------------------------------

1.Requirement Gathering & Requirement Analysis::

Requirement Gathering:

>Collecting Requrement from Customer

>It is done by BA(Business Analyst)

>BRS(Business Requirement Specification) document will be created

(It is document which is written in user's(non-tech) language)


Requirement Analysis:

-------------------

Requirement is ________

>Correct 

>Complete

>Testable 

>Actionable/feasible


WebSite should Open very fast.

>Done By Sr.BA 

>SRS(Software Requirement Specification) is Created

(It will be Technical Document. It  will detail information like numbers of fields, maxlength, type of field etc.)


Type of Requirement:

1.Functional 

>What the Software should do ?

-WhatsApp  should be able to do registration

-WhatsApp should be Able to do login

-WhatsApp should be able to do voice call

-WhatsApp should be able to do video call etc.

2.Non-Functional Requirement

>Requirements related to look & Feel (How Factor)

>Allingments of Various options

>Color and Font

>Consistancy in Layout


2.Planning & Design

Planning:

>Project Manager will do Planning.

>Since Failing Plan means Planning Fail, Hence to have effective  outcome you should Plan Properly

>Project Plan is Created in this Phase

>Some Other Activities also Happens

i,e. Deciding Scope of Developement, Risk identication,  deciding  Schedule etc.

Design:

>It is BluePrint/template/Architectur of Application.

>There is Two Types of Design Documents:

1.HLD : High Level Design (System Level Design): 

>It will be complete System Flow

>Use Case Diagram Which shows complete flow of Application

2.LLD : Low Level Design (Module/Unit/Component Level)

i.e. Login Page LayOut


3.Coding(Implementation)

>Programmer does coding in Selected Language

>Source Code Document is Created.


4.Testing:

>Comparision of Application with Specified Requirement happens

>Software Testers are involve in this Phase

>Documents which are prepared as

Test Plan, Test Cases, Defect Report, Test Scenario(What to Test )

Test Case:

1.Enter UserName > Entered UserName should display

2.Enter PAssword > Encrypted PassWord Should display

3.Click on Login > Home Page should Should display


Test Case is Document which contains steps for Performing Testing with Expected Result.


5.Deployment/Installation:

>Deployment Team which is group of Developer & Tester visits client side & install the product.

>Documents like Execution log, Defect report, proof of product acceptance.

6.Maintenance:

>G & W Period of Application

>If Defect is found then that will be fixed free of Cost

You found defect > report to developer > developer will fix defect (By Changing Source Code >Corrective Changes)

Corrective Change: Defect Fixing  > free of Change

Adaptive Change: Adding some new Requirement >


>Maintenance Team which is group of Developer & Tester is involve in this Phase

>Defect Report, Requirement Document, Test Cases, Execution logs etc. will be produced in this phase.

----------------------------------------------------------------------------------------

 

6 Month Project:


1 R

1 D

2 C

---- After 4 Months

1 Testing


SDLC > It is followed By developers

STLC( Software Testing Life Cycle) - It is followed By Software Tester.

----------------------------------------------------------------------------------------

Test Method:

------------

1.Black-Box Testing/Closed Box Testing/Specification Based Testing/Functional Testing

>You give i/p's & Check o/p without knowing internal Structure of Application

>It will be done By Software Tester


2.White-Box Testing/Glass Box Testing/Open-Box Testing/Structure Based Testing

>You give i/p's & Check o/p with knowing internal Structure of Application

>It will be done By Software Developer


Software Testing Life Cycle:

----------------------------

1.Test Planning

>Done By Test Manager | Test Lead

>Test Plan is Created

>Scope of Testing(Feature to be Tested/ not to be tested)

>Schedule

>Risk identification & do some backup plan for minimizing impact of Risk in advance

>Roles & Responsibility(Who is incharge of Which activity)

>Defination of Done(Exit Criteria/Passing Criteria of Testing):

i.e Application should be 90% good in Quality & All Test Cases is Executed at least Once then Pass Testing 

2.Test Monitoring & COntrolling

>Monitoring all Testing activity so that if any deviation/difference then it should be immediatly removed By Some doing some controlling activity so that  project should be on track.

> For this some measurement units like TestCase written/Day, TestCase written/Tester, TC written/Week ,TC execcuted/Day, TC executed/Tester,

Defect identfied /Tester, Defect identified /day, etc > Called as Test Matrics

>Done By Test Lead/Test Manager/ Sr. SoftWare Tester.


3.Test Analysis:

>Done by Software Tester

>UnderStanding SRS/BRS(requirment Documents)

>And think from Testability P.O.V

4.Test Design:

>Writting Scenarion(Chossing Functions to be Tested)

>Writing High Level End to End Testcase(Not in Detail)

>Done By Software Tester Only

5.Test Implementation:

>Automation Test Script Writing will be happening with help of Automation Test Engineer (Conversion of Normal Test Cases into language of Tool> Test Script)

>Test Environment SetUp will be happening with the help of System Engineer

Manual Testing:

Steps mention in Test Cases will be followed  by Human(Tester) manually on  AUT

Automation  Testing

Steps mention in Test Cases will be followed  by Some Tool/Software on AUT


Test Case:

1.Enter UserName > Entered UserName should display

2.Enter PAssword > Encrypted PassWord Should display

3.Click on Login > Home Page should Should display

Test Case > language of Tool > Java in Selenium > Test Script


6.Test Execution:

>Test Execution means following steps mention in Test Case on AUT/SUT.

>Test Execution of STLC & Testing phase of SDLC will be Overlapping Here.

>Any Difference between expected & Actual Results will be reported as Defect.

>Till the Time Exit Criteria is not met you will be in Test Execution Phase Only

>Execution Log(Test Cases Executed By indivisual Tester & Thier Status (Pass/Fail)).

 

7.Test Completion | Clouser

>Store(Archive) (For future re-use) & Share TestWare or Test WorkProduct as Proof of Testing.

>Store & Share learnings(Experience)

>Test Summary Report is Generated(Combination of All tester's report)


Testing & De-bugging

---------------------

Testing:

>It's Tester's Activity

>Mostly it deals with finding defects


You found defect While performing Testing > report to developer > developer will reproduces that defect by following steps mention in defect report & Analyzes cause of Problem & removes cause of Problem By Doing some Changes in Source Code.


De-bugging :

It is Developers Activity

>Reproducing Defect

>Anlyzing Cause

>Removing Cause of Defect


What is Defect & types:

------------------------

Defect/Bug/Incident: Difference Between Expected Result & Actual Result.


Types of Defect:

---------------

Functional : Defect in Functional Requirement will be called as Functional Defect.


Wrong: Requirement is mention in Specification(SRS|BRS) & Application is having that        feature/Function but it is not working as per Expectation

For Example : WhatsApp Web login was not happening even if phone is in network

      Oxymeter giving oxygen level of Parle-G biscuit


Missing: Requirement is mention in Specification but application is not having that feature/Function

For Example : Option of Web login in Telegram is not there.


Extra: Requirement is not mention in Specification but Application is having it.

For Example : WhatsApp Pay feature is available.


Non-Functional Defect:Defect in Non-Functional Requirement will be Called as Non-       Functional Defect.


For Example: 1.Close/Cross Button if it is not in RED then it is GUI Defect.

     2.Heading is not in bigger Font Size.


Difference between Error, Defect & Failure:

-------------------------------------------

Error|Mistake : An Incorrect human Action that Mostly developer does.

It is at Developement Phase

if(length>4 && length <=10)


Defect: It is difference between Expected & Actual

It is at Testing Phase

Failure: It is defect which is visible to customer|client

It is at live/production Phase


Error|Mistake > Defect|Bug| Incident  > Failure.


Some Principles of Testing Out of 7:

-----------------------------------

1.Testing shows presence of Defect not their absence

With the help of Testing you can tell software is having defect but you can never say your software is defect free(there is no defect in my software).

But with help of Testing we will be minimizing failure ratio.


Facebook.com

1.Do not do any testing

2.Do complete Testing

3.Do Partial/important feature testing


2.Exhaustive | Complete Testing is not possible except in  trivial Cases

Since trying every combination of i/p's will consume lots of time & resources.

In place of Exhaustive testing we do risk base testing where testing is more  focused on important features.


3.Early Testing:

Testing should start as soon as possible to minimize defect multiplication.


R = Correct Requirement + Incorrect Requirement

D = Correct Design + Incorrect Design + IR

C = Correct Coding + Incorrect Coding +ID + IR

T =

Dep

M


monjil.mehta@lntinfotech.com


--------------------------------------------------------------------------------


QA , QC, QMS:


QMS: Quality Management System > Making Rules/Protocol/Process

QA: Quality Assurance > Checkes Processs(All rules are being followed or not)

QC: Quality Control    > Checking End Product


Developement Testing  Live

RG&A, D ,C     > Software


-------------------------------------------------------------------------

Types of SDLC Model :

---------------------

1.Sequential Model:

>WaterFall

-Every Activity is sequenced in this case means next activty can not be started till the time previous phase is completed

>And You can rollBack to previoud phase if you went to next Phase

>Testing Happens Only in Testing Phase 

>And Customer is not able to see thier product before deployment

>It is Base Model for Model

>Best suited for Small Scale Project Since There will less chance  of Change & defect Multiplication also.


DisAdvantage:

>Not Suited for Larger or Complex Project Since Good Chances of Defect Multiplication.

>Customer can not add/Change Requirment

>Customer can not see thier product before deployment

>High Chances of Defect Multiplication in case of Complex Project Since testing Starts in Testing Phase.

2.V Model


2.Iterative & Incremental Model

Just Imagine: MyBank


1000 req

250 req > R1

250 req > R2

250 req > R3

250 req > R4


R1> >D >C >T >Dep >M Iteration 1

R1+R2 >D >C >T >Dep >M Iteration 2

R1+R2+R3 >D >C >T >Dep >M       Iteration 3

R1+R2+R3+R4 >D >C >T >Dep >M Iteration 4


Adv:

1.Getting working software in Short Period 

2.Feedback from Previous Version can be added in next iteration

DisAdvantage:

1.For Smaller Project Can not be used

2.It is time & Cost consuming


Agile:

------

1000 req

250 req > R1

250 req > R2

250 req > R3

250 req > R4


Product Backlog: 1000

Sprint Backlog :  250


Day 1:   40 Pending Subjects : 40 Backlog  > For Whole 4 Year

5 Pending Subjects  : 5 Backlog   > For 1 Semester


For Whole Iteration 1000 req> 

For 1 iteration 250 req


R1> >D >C >T >Dep >M Iteration 1 : Sprint 1

PB: 1000 PB:750

SB: 250 SB:0


R1+R2 >D >C >T >Dep >M Iteration 2 : Sprint 2

PB: 750 PB:500

SB: 250 SB:0


R1+R2+R3 >D >C >T >Dep >M       Iteration 3

PB:500 PB:250

SB:250 SB:0


R1+R2+R3+R4 >D >C >T >Dep >M Iteration 4

PB:250 PB:0

SB:250 SB:0


Scrum MAster : Team Lead

Product Owner : BA

Whole Team Approach:

-------------------

>Customer

>Tester

>Designer

>Programmer


Adv:

1.Quality is not responsibility of individual Person It is Group responsibility.

2.Customer is acting as immediate Validator

3.transparency with Customer & With Team(By using Scrum Board)

4.There will be 15-minutes Daily stand up meeting. (By this also Transparancy)

-What happened Yesterday

-Any Bottleneck

-Why is Planned for Today.

5.Agile release happens in 1-4 weeks

User Story:

-----------

As a Customer 

I want login Function

So that I can do login at anytime


Retrospective Meeting:

Held at end of every Sprint/Iteration to check what went right, what went wrong, what is improvement areas for future.

----------------------------------------------------------------------------------


Are we building product right ?

>Checking Process

>QA Activity

>Verification

Are we building right product ?

>Checking Product

>QC Activity

>Validation


Verification Validation:

1.Are we building product right? 1.Are we building right product ?

2.Checks Process 2.Checks End Product

3.QA activity 3.QC Activity

4.Static Testing 4.Dynamic Testing

5.Done By just reading documents 5.Done by Executing Product/Software

6.All phases of SDLC 6.Last 3 Phases(Testing, Deployment & M)

Since every phase has some doc

7.It is defect Preventive Approach 7.Defect Detective & Corrective Approach

8.Cost less for fixing defect 8.Cost more for fixing Defect.


9.Verification can tell 9.It can not tell exact root cause 

Exact root cause of Problem since Black box testing approach is followed.


10.Tech: 10.Validation techniques(Levels of Testing)

1.WalkThrough 1.Unit Testing

2.Inspection 2.Integration Testing

3.System Testing

4.Acceptance Testing

---------------------------------------------------------------------------------

Verification Techniques:

------------------------

1.Walkthrough:

>It is meeting lead by author of the Document

>Explaining document to everyone so that everyone should at same level about document

>Learning, understanding & finding defect is purpose of Verification

>Can be formal( planning, scheduling & some rules are followed) or 

informal(No planning, scheduling or rules are followed)


2.Inspection:

>Done at the end of Every Phase to check whether the phase is completed & Can we move to move to next phase ?

>Finding defect is main purpose 

>It is pure formal Process(Proper Planning, scheduling & rules are followed )

>Checklist is used to increase number of defects


--------------------------------------------------------------------------------

Validation Techniques(Levels of Testing)

1.Unit Testing/Component Testing/Module Testing/Programme Testing:

>Checking small piece of Executable code that is able to Provide some Output

>Done By Devloper

>Test Method

>White Box Testing

>Black Box Testing

2.Integration Testing:

>Checking the communication between two or more modules happen

>In Case of Integration Testing communication/intraction between two or more module is focused not the indivisual Modules.

>Approaches:

1.Top Down:

>Parent module is ready & Child module is not ready

>And Before Development of Actual Child Module, the dummy of Child module is developed so that we get early defect of Compatibility. And this will save our development hours

>Child Dummy module is Called STUB

2.Bottom up:

>Child Module is Ready & Parent module is not ready

>Here, Dummy module of Parent is made. Reason of making Dummy of Parent is getting compatibility Problem in advance

>Parent Dummy Module is Called as Driver


>80-90% applications are in Maintenance Phase Hence Top-Down approach will be used a lot.

----------------------------------------------------------------------------------

System Testing:

---------------

>It is done after combining all modules into single unit(If we combine all module into single unit then it will become System)

>It is final phase of Testing from Testing hence Main Objective will be to find as many as defect.

>Independent Testing team is responsible for this.

>All requirements including Functional & Non-Functional requirement is tested in detail.


Acceptance Testing:

-------------------

>It is decision making point whether to accept the product or not.

>Done by Client or client representative


a.User Acceptance Testing

>Done by Business Category People

>These category people will be checking whether business needs are full filled as not ?


Alpha Testing:

Customer comes to development's organization & Checks the product

Beta Testing:

Deployment team visits customer side & then Customer/Client Checks whether it is fulfilling business needs or not?


b.Operational Acceptance Testing

>Done by System engineer 

>And System Engineer Checks installation, re-installation, uninstallation & 

User Management Process Since He/She want to make decision whether these

activity is possible to do or not?

>If it is possible then System Engineer will accept the product for these activity.


c.Contractual & Regulatory Acceptance Testing:

Contractual AT:

>When two parties agrees for some project then Contract criteria is made.

>During delivery of product contract criteria is Checked.


Regulatory AT:

>Checking application is following all the guidelines given by controlling body of particular domain

i.e All Banking Software should follow RBI Guidelines

i.e All Insurance Software should follow IRDA Guidelines.


At all levels functional requirement and Non-functional requirement both can be tested.


Life Cycle Testing:

------------------

Every Development Activity should have testing activity associated with it.

Advantage:

To avoid Defect Multiplication to further phases



Module 3: Types of Testing:

----------------------------

Testing Related to Change:

You found a defect & you will report to developer > Developer will do some Changes in Source Code(Corrective Changes) > ReTesting (To make sure reported defect is actually fixed or not).


ReTesting/Confirmation Testing:

What : Re-Execution of Failed Test Cases 

Why: To verify/confirm the reported defect is fixed or not

When : after defect is found & Fixed by developer.

Regression Testing:

What : Checking Impact of Change/Modified part on  unChange/unModified Part (Re-execution of Test Cases which was getting pass previously ) 

When : After any Changes mentioned below.

>Defect fixing

>Any modification in exisiting functionality

>after removing/deleting function

>Any environment Change (i.e RAM or Processor Change)

Why : Due to Changes there shuould not produce any new defect.

Since regression testing is repitative in nature hence it should be done with help of Automation Testing Tool i.e Selenium, QTP, RFT

1000 TC: 

After Execution of TC's


800 tc's getting pass ( UnChange)

200 tc's getting fail  (Dev will do Changes for Fixing)


Retesting: 200 

Regression Testing: Unknown(<=800 Pass TC)


For getting number of Regression Testing tc we need to do Impact Anlysis using RTM.

Impact Analysis: A Process in which we analyse number of linked pass TC to Fail Test Cases.

RTM(Requirement Tracebility Matrix):

>It is document in which mapping between Requirement &  respective test case is there.

>Also known as Bi-directional tracebility matrix


Uses: 1. It is used in impact Analysis for getting Number of Test Cases

      2. Getting Coverage of Testing(If any requirement do not test cases  in RTM then that requirement is not covered for testing)


Testing Related to Function:

>Smoke Testing | BVT | BAT| Intake Testing:

>It is decision Making point to accept the product or reject the product

What:It is Checking of Basic Functionality/Critical functionality

When: Before Starting detail testing|Major Testing| System Testing

Why:To Check is the build Strong enough to face Major Testing (Stability &             Testability)


Accoring to ISTQB both(Smoke & Sanity) are same. but it depends on Organization 


>Sanity Testing:

What : Checking of New functionalities & bug fixes  

When : after receiving build from developer & if build is mature

(Multiple rounds of regression already happened)

Why:To Check is the build Strong enough to face Major Testing (Stability & Testability)

>Checking Links

>Checking Forms(With valid Data or invalid Data)


Testing Related to Non-Function

Performance Testing:

>Checking behavior of the application w.r.t. response time

(How quickly Application is Opening)

Load Testing: Checking within customer specified load

Stress Testing : Checking with load which is beyond customer specified load. And you keep on adding load gradually to find break or crash point.

Performance Testing also should be done by some Tool i.e Jmeter, LoadRunner, RPT etc Since Arranging multiple physically next to impossible.


Compatibility Testing (Multi-Platform Testing):

>In Case of Web Application Checking with different-different Browser(i.e Chrome, Firefox, opera) or different version of same browser.

>In Case of desktop application Checking with different OS or different version of same OS. 


Usability Testing:

>Checking How easy the application to use ?

>To make application easy to use there should be less number of  clicks, forms, There should be shortcuts etc.

>It should be done by end user only developer & Tester already know  how to complete any task/operation


User Interface testing:

>It is related to GUI(Graphical user interface)

>Checking of Color, Font, Size, allingment etc.

>Website appearance should be consistant else user will face dificulty in finding options.

>Spelling & Grammatical Mistakes also will be Checked here. 

>If your application is having GUI defects then it will become hard  to use immediatly


Maitenance Testing:

It is regression testing done Maintenance phase.

What : Checking impact of Change part of unChange 

When : After doing any Changes

Why  : To Check due to Changes there should not be any new defects.

Comments