conducting testing on the modified build is called 
regression testing.

Regression Testing: The re execution of our test on 
modified build to ensure bug fix work and occurrences of 
side effects is called regression testing.

Regression testing is nothing but re execution of 
the modified build is called the regression testing

That when all bug are solved then time do this test

Then that time developer or client had some changes 
that changes based test is called the regression test

mainly two levels of regression testing is available .
1) regular regression 
2) final regression

    In regular regression every  built is tested to verify 
weather the fixed bugs have any bad impact on other parts 
of the functionalities.It is done regularly during the 
testing process evry after getting new built.

    Final regression is done after the complition of fixing 
all the bugs.It is advisible to have stable built during 
Final regression testing.

There are 3 types of Regression that need to be done.

Level 1 Regression- Done after initial Test cycle completes
Level 2 Regression- Done when all issues reported are fixed
Level3 Regression- Final Regression before delivering the Test
Derevirables; 

Testing Team should ensure complete concepts are traced and there
are no side effects of the fixes on the delivered product;

In our process there are two types of regression testing.
1.Initial level
2. final level

In regression testing is in that build what are the 
before the defect it solved or not any new requirements are 
add or not, if any changes or done this build this type of 
test here done

Regression Testing is to check the Retested Bug should not 
have Impact on other passed Test cases.

regression testing: here, we will check whether all bugs are 
fixed or not by developers & any new bugs are raised by 
fixing of new bugs.

while doing regression testing if we found the bug for the 
first time the status will be NEW, or already existed bug 
(the bug is in fixed state but still it is reproducing) 
then the status will be "Re-Open"

Regression:
Regression is a process of testing the software that has 
been modified to ensure that no defect has been introduced  
by the modification and the software still able to meet its 
specification.

   Regression Testing:After getting confirmation the bug is 
fixed we are going to check the fixation is going to create 
any problems in the application or not...

regression testing means testing an application after the 
defect has been fixed inorder to know whether the defect 
shows impact on the other subfeatures where the defect has 
been found in a certain feature.

After the Bug fixed ,testing the application whether the
fixed bug is affecting remaining functionality of the 
application or not.

Majorly in regression testing Bug fixed module and it's 
connected modules are checked for their integrity after bug 
fixation.

Regression Testing:
   
         After getting confirmation the bug is fixed we are 
going to check the fixation is going to create any problems 
in the application or not.

The re-execution of selected tests on the modified build to
estimate the completeness and correctness of that
modifications is called Regression Build.

Regression testing will be conducted after any bug fixed
or any functionality changed.

During defect fixing procedure some part of coding may be 
changed or functionality may be manipulated.In this case 
the old testcases will be updated or completely re written 
according to new features of the application where bug 
fixed area.

Here  possible areas
 are old test cases will be executed as usual
 or some new testcases will be added to existing testcases
 or some testcases may be deleted.

Any one of the situation may be arised.

Regression testing means checking the reported 
functionality and its dependents. so we need to select the 
test cases to test both the cases.

TC's will be prepared based on the FRD's(Functional 
Requirement Documents). so changing TC's will comes under 
CR (Change Request) process.

regression testing will be conducted after development team 
releases modified build when test engineers find any 
mismatches between expected and actual values in build.

some times the small changes in coding can have serious 
effects on other areas of the s/w,with out development team 
concern.so a test engineer has to know whether the changes 
in s/w coding impact others areas of s/w,for this he has to 
conduct regression testing using previous test cases ensure 
that defect has removed the defect and remainig 
functionality same as previous(customer expected).

selecting test cases is depend on severity of the defect as 
follows:
if defect is high severity defect we have conduct 
                 all p0->high priority
                 all p1->medium priority
                 care fully selected p2->low priority
test cases for regression testing 
if defect is medium severity defect we have conduct 
                 all p0->high priority
                 care fully selected p1->medium priority
                 care fully selected p2->low priority
test cases for regression testing 
if defect is high severity defect we have conduct 
                 care fully selected p0->high priority
                 care fully selected p1->medium priority
                 care fully selected p2->low priority
test cases for regression testing

Regression Testing:-Regression Testing is checking for the 
newly added functionality causing any errors in terms of 
functionality and the common functionality should be stable 
in the latest and the previous versions

In my point of view, time it will take for regression testing is
the time depends on the defect severity and complexity

time it will take for regression testing

Depending on the functionality of the code. if it is 
specific to some output then will go for automation of it 
my writing own script, eg., using rational robot for web-
based application. 

if code is to generate random values accepts only values 
from 1 to 100 and A to Z char does not accept any special 
characters or unicode charactes with respect to 
localization and globlization, then i check whether the 
code is hard coded or not. To check a single test case with 
1 to 2 minutes of time is enough. say enter 1 and you get 
xxxxyyyxxxyyxxxyyxxyy and when you enter the same number 1 
for the next time it "should not be" as 
xxxxyyyxxxyyxxxyyxxyy it should be some thing diffrent.

The re-execution of
selected test cases on modified build to ensure bug fix work
with out any side effects is called Regression Testing.
(Change Testing)

Level -2 (Regression Testing):
                                                     During
above level-1 comprehensive testing, testing people are
reporting mismatches between test cases expected and build
actual to development team as ?defect report?. After
reviewing and resolving the defect, development people are
releasing modified build to testing team. In this stage, a
development person is releasing ?release note? also. The
responsible test engineers are studying that release note
and try to understand  modifications in that modify build
and then test engineers are concentrating on regression
testing to ensure that modifications.

                            Level-0
                            
                             Level-1
			   
          Check in  Level-2  Check-out
                           (Regression)

	From the above diagram, test engineers are conducting
regression testing on modified build w.r.p.t modifications,
which are mentioned in ?release note?.

Study release note & consider severity of resolved bug

High                           Medium                        Low
all P0 (priority)           all P0                         
  some P0
all P1                          max P 1                    
    some P1
max P2 test cases       some P2 test cases         some P2
test cases

                             On modified build
Case1: If the development team resolved bug severity is high
then test engineers are re-executing all P0, all P1 and
carefully selected maximum P2 test cases on that modified
build w.r.p.t modifications mentioned in release note

Case2: If the development team resolved bug severity is
medium then test engineers are re-executing all P0 carefully
selected all P1 and some of P2 test cases.

Case3: If the development team resolved bug severity is low
then test engineers are re-executing carefully selected some
P0, P1, P2 test cases.

Case4: If testing team received modified build due to sudden
changes in customer requirements, then test engineers are
re-executing all P0, all P1, max P2 test cases. 

select test cases for Regression Testing

Consider an example of a form which has a username,password 
and and Login button.

There is a code change and a new button "Reset" is 
introduced. Regression testing(for that build) will include 
testing only the "Login" button and not the Reset button 
(testing Reset button will be a part of cunation testing). 

Hence the Regression tester need not worry about the change 
in code,functionality. But he has to make sure that the 
existing functionality is working as desired.

Testing of "Reset" button will be included as a part of 
Regression, for the next build

regression testing means,
 
testing an application if any changes made or new 
functionality is added to the application.

Regression Testing is testing the modified build and the 
the dependent functionalities/modules if the changes made 
to the module are affecting the other dependent modules or 
not.

We can trace the dependent functionalities or modules 
through requirements.

Regression testing is done on the modified build to check 
if the new added functionalities is affecting any of the 
Dependant modules.

We can trace the dependant functionalities through 
requirements. You can say that the impact analysis comes 
into picture. The child modules that gets impacted by 
changing the parent modules have to go through regression 
testing.

Regression testing is required for any
changes carried out at any level. Regression
testing is required for any changes carried out at any level.

Regression testing ensures that changes or corrections in a
program have not introduced new errors. Therefore, this
would be achieved only if the data used for regression
testing are the same as the data used in previous tests.

Regression testing is done after changes are made to the software,
and since the software already is being used, the job schedule
must be in place and may be reviewed later. This change does
not affect user manuals and any associated risks.

Regression testing is the
process of rerunning a portion of a test scenario or test
plan to ensure that changes or corrections have not
introduced new errors. The data used in regression testing
is the same as the data used in the original test.

Regression testing is the process of rerunning a
portion of a test plan to ensure that changes or corrections
have not introduced new errors.

Regression testing is used to
compare changes to an application to ensure that the
programs are working the same after a change as before the
change.

REGRESSION TESTING : We check the entire system whether the 
fixed bug make any adverse effect in the existing system or 
not.

REGRESSION TESTING: Test the bug fixes r working properly 
as the specification and test, by fixing these bug any 
other feature may get impacted (conduct impact analysis) is 
regression testing.

Regression testing: The re-execution of selected test cases 
on modified build to ensure bug fix work.

regression testing: re execution of testcases on the 
modified build to ensure that resolved bug has made any 
impact on other functionality

regression Testing : 

re execution of test cases on modify form of build is called 
regression testing..

Regression testing means after getting confirmation the bug 
is fixed we are going to check the fixation is going to 
create any problems in the application or not.. that means 
due to the fixation of the bug we got any side effects in 
the application or not..

Regression testing-- Nothing but retest, checking the 
functionality when the status was fixed by developer, the 
latest fixed functionality is effecting the other function or 
not & the current function is working properly or not.

Regression:  Testing the application on the different built 
Suppose: if the tester found the bugs, and Developer fixed 
it and they relised the new version of the build. so 
testing on the new version on the built is called Regression
Testing

regression testing: if the tester find any defect he /she
inform this defect to development team. development team
fixes that bug, again send to the testing team for testing
again whether bug is fixed or not,or the newly developed
build giving any side affects to other modules or not.

Regression Testing: Once the Bug is fixed tester has to 
test whether bug is fixed or not also test whether the 
impact of the bug is shows in other application

Regression Testing : some times Re execute some selected 
passed test cases also to check whether are there any side 
affects during the bug was fixed

Regression testing : Retesting the application after fixing 
the defects.

Regression:
If a tester finds a bug and after developer fixes that bug 
we retest and also check whether these enhancements or bug 
fixing have any side affects on the unchanged code.

To check for the bug fixes.
And this fix should not disturb other functionality.

To Ensure the newly added functionality or existing 
modified functionality or developer fixed bug arises 
any new bug or affecting any other side effect. this is 
called regression test and ensure already PASSED TEST CASES 
would not arise any new bug.

To ensure that there is no bug & side effects due to 
changes, enhancements in the application

regression testing plays major role testing side because it 
not only tests whether bug closed or not but also checks 
the impact of that bug fixing.

More the regression testing build is more stable

To Ensure the newly added functionality or existing 
modified functionality or developer fixed bug arises 
any new bug or affecting any other side effect. this is 
called regression test and ensure already PASSED TEST CASES 
would not arise any new bug.

There is a possibility of one error correction may introduce 
new errors..

Regression Testing Performed

1. To Check whether the Fixed Bug is eliminated with the 
same Functionality as we tested earlier.
                   &
2. To check whether the corrected build should not cause 
any side effect over their screen (or) In other Modules.

writing a separate testcase for Regression Testing

well we r not going to right separate test cases for  
regression testing. we execute the same test cases on 
newly modified build which ever failed in previous. 

writing a separate testcase for Regression Testing

we r not going to write new test cases. 
We will select the some of the test cases from test case 
document, and execute the test cases to check for the bug 
fixes. Here we selecting the test cases such way that, all 
the basic functionality test cases, and affected bug test 
cases.

writing a separate testcase for Regression Testing

we never write new test cases 4 regression testing
Sometimes we execute all test cases which we previously 
executed 
Sometimes we execute some part of it

after making changes in a built we will test the 
application whether it is effecting the application or not
so we can say ti is regression testing.....

regression testing is done after a new build
(modified_build) is released, we need to check the build 
whether it is affecting the functionality of the 
application.

(RT): It is the testing done on a module when its modified.
Some times RT is done using Automation Tools.

RT is of 3 kinds :

Unit : Testing is done only on that part where the module 
is modified.

Regional : Testing is done on those parts in an application 
whereever the changes made in the module gets affected.the 
modified modeule is also tested.

Full : the whole application is tested.

Regression Testing is done on modified build to ensure the 
old functionalities still works fine with new changes.
 
Regression Testing is done usually With Automation Tool
Steps involved in Manual Testing Process:
1. After one cycle of testing is completed and bugs are 
fixed then u will get a modified build.
2. Start downloading the modified build
3. Perform Smoke and Sanity tests
4. Execute Those test cases which are of Resolve/Fixed and 
Resolve/Works for me. 
5.If time permits execute all test cases other wise Execute 
only High priority and Regression suit test cases.

Regression testing is nothing but re-execution of selected 
test cases on modified build (means which ever failed in the 
previous build).

Retesting a previously tested program following 
modification to ensure that faults have not been introduced 
or uncovered as a result of the changes made.

The re-execution of the test with multiple test data 
on modified build,bug fix work and occurrences of the 
side effects is called regression testing

Regression testing is any new features added to the 
application,then you have to do the regression testing.

Why Automation is apparently used for Regression, at the 
time of doing regression testing, application is 
stable. All ready you loged the so many bugs, which is doing 
new feature testion.

retesting the entire application after the debugging, is 
called regression testing. 

In winrunner we r using batch test for testing the entire
application

We do regression testing whenever thr are new enhancements in 
the module of the application or an integration of new 
application with existing one  or whenerv a bug is fixed 
then we go for this kind of testing.

so,that added features /bug fixing didnt adversely affect 
the currently running application.

we do this kind of testing in between builds.

Usually for regression testing we write testcases for added 
feature modules.usually in companies they maintain 
checklists for important functionality testcases ,bcoz 
during regression testing we dont find ample time to test 
all the testcases.

Regression Testing Tools(also frequently called 
Functionality Testing tools)...we use Winrunner,QTP,...many 
more tools.

-->we usually automate the test scripts using ur testcases.
-->We enhance the scripts by adding wait 
statements,synchronization points,checkpoints,regular 
expressions,functions,recovery manager(to handle 
exceptions) only after WR7.6 VERSION,virtual object wizard
(for non-standard objects)  and many more...

All this to run until the error free scripts.

If any errors found,reporting the defects to developers 
through test director or PVCS OR any bug tracking tool ur 
company using.

re testing the application after fixes or modification to 
ensure the effect of regressed part on the remaining 
functionality of the application.

in winrunner by making use of RAPIDTEST SCRIPT WIZARD we 
can conduct GUI regression ,Bitmap regression.

Regression testing is testing of a build when the 
bug/defect re-opens.

for eg. a bug is found is build1, it is reported to a 
developer, u execute the same script on build2, if it re-
opens it is nothing but regression testing.

When we talk about manually performing regression 
testing ,its nothing but executing the same test case on 
various builds and it should be the same when it comes to 
automation too as regression testing is a main candidate 
for regression testing.

Regression testing is a series
of tests run on a build whenever any code has changed in the
existing code, and not necessarily just when a bug/defect
re-opens.

Execute the same test case on the various builds until the 
bug found is closed. It must'nt involve any tools :)

I think the use of 'Test Builder' comes into use for 
regression and smoke testing.

Regression test will be done when we got modified build
there we execute test cases to determine whether defects 
closed or not?
or checking 2 ensure that resolved bug has made any impact 
on the remaining part of code

Regression Testing is as discussed in above answer is done
after the first build release, and in regression testing we
test if the bugs that exited in the Build are actually fixed
or not, we also apply testcases for new requirements (if
any) to check if the system is working fine.

Regarding the regression testing procedure, it is same as
testing, we just re-run all those test that were previously
run, but this time we make sure that the test cases match
the new changes, or new requirements that were not there in
the system.

Regression testing is nothing but whenever we find out the 
bug , it has to be fixed ,given to developers they will fix 
the bug , this is known as regression testing

Regression Testing- "Testing to ensure that introduction of 
new functionality has not affected existing functionality"

Whenever tester gets the next fixed build:

1)He tests for the Fixed Bugs.

2)Test the whole application to  check whether these fixes, 
have not introduced new bugs.

3)If there are some update in the application, then test 
cases need to be updated , and executed the same.

All of the above steps used, while doing regression testing.

Re execution of test cases on modified form of build is 
called regression testing.

regression testing: when ever the bug is fixed from 
development team we can verify whether the bug is fixed or 
not and their related functionality is also working fine or 
not.

The regression testing is conducted on modified build, as
soon as we get the modified build from the development team
we conduct testing on previously failed test and then passed
tests and then related tests. If any mismatches occur then
we are submitting the bug report to the lead.

Regression testing is nothing but, retesting the modified
build to estimate the bug fix work and the occurances of
side effects in the build. 

  First we are conducting test on failed and then passed
tests on modified build and then on related tests.

In the Regression Testing we test apply the test case
again on the application which we applied previously and we
test whether the errors are being fixed or it is causing to
some new errors.We also check whether it affected the
functionality of the software.

Regression Testing Definition :-  After changes made in 
the application or After fixing some bugs - Application 
should not deliver any new bugs.
 
 How do you conduct manually - 
   by periodically - means definite day , Tester take the 
latest code and do testing for given set of bugs.

regression testing is nothing but re execution of test 
cases on the modifies build to determine whether the 
defects closed or not?

after getting bug fixed by the developer and received thru
for tester he want to conduct regression testing to check
whether the bug was fixed properly in an application.

Regression Testing is testing on modified build to check 
the correctness for the bugs reported

Regression testing means testing the Modified build with 
same test data to ensure bug fixings and occurances of side 
effects due to change in the build.

Regression testing validates the application after modified 
the code in the application.

regression:

re-testing the application after fixes or modifications to 
ensure the effect of regressed part(modified part)on the 
remaining functionality of the aplication.

Regression testing is nothing but execution of existing test
cases on the new build.

This is a black box testing, here we are going to ensure 
the whether code changes cause any change in the existing 
functionality

Regression Testing is Testing the software weather The bug 
fixed is working without affecting previously tested 
functionality

Regression testing as the name suggests is used to test / 
check the effect of changes made in the code.

Regression Testing is retesting unchanged segments of 
application. It involves rerunning tests that have been 
previously executed to ensure that the same results can be 
achieved currently as were achieved when the segment was 
last tested.

The selective retesting of a software system that has been 
modified to ensure that any bugs have been fixed and that 
no other previously working functions have failed as a 
result of the fixes and that newly added features have not 
created problems with previous versions of the software.

More on Regresison testing:
http://quality-assurance-software-
testing.blogspot.com/2005/09/regression-testing.html

Regression testing is testing of application after fixes or 
modification of software or its environment. In regression 
testing you have to check present changes should not make 
any problem with other data

retesting the previously tested applications to make sure
that changes are not cause any side effects.
 it is conducted on modified build

re execution of Subset or all test that have been conducted 
earlier to determine the resolved bug has made any impact 
on the remaining part of the code

Regression testing is a type of testing done on modified 
build  to ensure that the the defect is solved and it has 
no side effects on other functionality.

Regression is a  Testing to test that the
Fixes/Modifications have not create any other problems else
where in the Software.

Regression Testing:

Whenever tester find any defect it will given for developer 
for correction. After developer correct the defect it once 
again go to tester.The tester now do the testing from the 
beginning to ensure that cases are without any defect and 
particular defect has been corrected.This process of 
testing called regression testing.

Regression Testing:

   After getting confirmation the bug is fixed we are going 
to check the fixation is going to create any problems in 
the application or not.

Selective re-testing of a system to verify the modification
(bug fixes) have not caused unintended effects and that 
system still complies with its specified requirements.

Whenever there is a modification in existing functionality,
it has to be tested again which is called regression 
Testing.

for regression Testing we use 2 documents:
Design Document
Traceability metrics

Regression Testing means checking new or added 
functionalities effect on the existing system components. 

So that we can check changes are correct and it doesn't 
adversely affect the existing system.

This can be done using Batch Test using Call statements.
Hope this is enough for your query.

Regression testing means test the application on the 
modified build.
it can be done two types
1)Counter part of the integration test that means any chane 
in the existiing code due the modified code.
2)test the application on modified build

In this the primary objective of Integration Testing is to 
discover errors in the interface between modules / sub-
systems.

			In this many unit tested modules 
are combined into sub-systems. The goal here is to see if 
the modules are combined can be integrated properly.  
Follows white box testing techniques to verify coupling of 
corresponding modules.
Approach
i.	Top-down approach   --- this is used for new 
systems.
ii.	Bottom-up approach  --- this is used for existing 
systems.

Top-down Approach

	Testing main module without coming sub modules is 
called top-down approach. We can use temporary programs 
instead of sub modules is called stub.

Bottom-up approach:

	Testing sub modules with out coming main modules is 
called bottom-up approach. We can use temporary programs 
instead of main module is called driver.

Plz ignore aboveanswer  this is correct
To check the new functionalities have been incorporated 
correctly without failing the existing functionalities.
	
Approach:   Automation Tool.

	The bugs need to be communicated and assigned to 
developers that can fix it.  After the problem is resolved, 
fixes should be re-tested, and determination mode regarding 
requirements for regression testing to check that fixes did 
not create problems else where.

Regression Tersting Is not only Conduct the testing On mp
[o9dified Build but also Check out the modified build 
whether the effect of the previous defect fixed by developer
on the remaining Functionali8ty of the Appliucation or not

Regression Testing :

--> It is Re-Testing.

--> It is done after fixing or modifying any changes in s/w.

--> It is difficult how much retest is needed.

--> It is done at end of development cycle.

--> Automated Testing Tool is used in Regression Testing.

Regression Testing: Before going to Production, quality
analyst needs to do testing whether all the requirements are
fulfilled or not means just a last step of testing.

To Verify that the existing functionality should not been 
effected by adding the new functionality.

Visit Below link to Know Answer

http://www.fullinterview.com

Hi Friends,


Regression is nothing But checking weather changed 
functionality is effecting on unchanged Functionality. 

BUG===Fix==== Test again======= check weather Impacting on
other functionality.


If I M wrong please Let me know.

->enhancements in the middle of the project
->major changes in the code
->environment changes
       these are the main reasons for doing the regression 
testing. theme of this testing is bcoz of this enhancements it 
should not effect on the previous existing modules in the 
application. we r going to check that in this testing.

The objective of regression testing is to ensure the software remains intact. A 
baseline set of data and scripts is maintained and executed to verify changes 
introduced during the release have not "undone" any previous code. Expected 
results from the baseline are compared to results of the software under test. All 
discrepancies are highlighted and accounted for, before testing proceeds to the 
next level.

Regression Testing: RT means testing on test cases,which are
related to modified functionalities in SUT.

Hi all,

Regression testing is a testing process which deals with
testing the side-effects of a modified or corrected or newly
implemented module on neighbor modules.

Degree of regression testing mostly depends on the impact of
the new or modified module on others modules.

Most of the cases, regression testing are automated one as
we do regression testing whenever the software changes,
either as a result of fixes or new or changed functionality.
It is also a good idea to execute them
when some aspect of the environment changes

Thanks and regards
Sitam

Regression testing is a process in which we test a
previously tested program and following modifications done
then make sure that bug are not introduced in unchanged and
uncovered area of the build.
   Regression testing are mostly used in integrated systems
bcz component dependancey level is high so if defects found
in one module then we need to do test other dependent module
also.
   Regression testing level is also depends on severity of
defects.

Thanks 
Akhalesh Yadav
9555717928