In mutation testing we are making some changes in code and 
again run the test cases in order to find whether that test 
cases are capable of finding bugs.

Mutation Test is to Make changes over the Passed Test Case & See
That the Build should show defect.

forcibly injecting bug and testing the functionality

With mutation testing, the system/program under test is 
changed to create a faulty version called a mutant. You 
then run the mutant program through a suite of test cases, 
which should produce new test case failures. If no new 
failures appear, the test suite most likely does not 
exercise the code path containing the mutated code, which 
means the program isn't fully tested. You can then create 
new test cases that do exercise the mutant code.

This is one of the White Box Testing Technique . Generally 
programmer are following this technique to test the change 
in the program to estimate the correctness & completeness 
of the program.

  for example
  1. if all tests passed in the program that is good program.

 2. If all tests passed but in the program some change is 
there .don't say passed. this is not a good testing

3. in all tests passed except change test failed. this is 
the complete testing.

mutations are introduced into a program to test the adequacy 
of the test data. A mutation is a SMALL CHANGE made to the 
program. The effects of that data should be made up in some 
tests. If it doesn't ,the test set is probably inadequate.
  and this type of testing is called mutation testing...also called as debugging

The person who is changing the code by adding mutations 
should see how the code works.

Mutation means a change.

While u r doing unit testing u'l prepare some unit 
test cases and test the program. After that to estimate the 
testing u have conducted u'll introduce some mutations
(changes) in ur program/unit and repeat the same tests then 
few test should give wrong results as u use the same data 
and test procedure then it shows the completeness of ur 
test cases for ur unit test. if ur test passes even after 
making these mutations means u r not test all flows of ur 
program which implies that ur test case r not completely 
tests the unit.

Mutation testing is performed as part of Unit Testing. In 
this testing phase, programmers will perform some change in 
the coding and execute previously completed tests. If all 
the tests are passed, then he will concentrates on the 
same. If any one of the test is failed then he will 
concentrate on the further coding.

it is nothing but estimating the efficiency of test data by 
deliberately introducing bugs

Mutation means absolutely bug injection

it means that purposely u introduce bugs & it is also known 
as debugging.

A testing methodology in which two or more program mutations
are executed using the same test cases to evaluate the
ability of the test cases to detect differences in the
mutations.

or

A method whereby errors are purposely inserted into a
program under test to verify that the test can detect the
error. Also known as error seeding.

or

A method to determine test set thoroughness by measuring the
extent to which a test set can discriminate the program from
slight variants of the program. Non-intrusive Testing:
Testing that is transparent to the software under test; ie,
testing that does not change the timing or processing
characteristics of the software under test from its behavior
in a real environment. ...

After the initial testing is complete, mutation testing is 
taken up. The idea behind mutation testing is to make a few 
arbitrary small changes to a program at a time, each
time the program is changed it is called a mutated program; 
the change is called a mutant.

A mutated program tested against the full test suite of the 
program. If there at least one test case in the test suite 
for which a mutant gives an incorrect result, then the 
mutant is said to be dead. 

If a mutant remains alive even after all test cases have 
been exhausted, the test suite is enhanced to kill the 
mutant.

The process of generation and killing of mutants can be 
automated by predefining a set of primitive changes that 
can be applied to the program.

The primitive changes can be:
? Altering an arithmetic operator,
? Changing the value of a constant,
? Changing a data type, etc.

A major disadvantage of mutation testing:
? computationally very expensive,
? A large number of possible mutants can be generated.

Make perfection in coding the developers intentionally made 
mistakes for particular object to check whether it will 
work same as correct code

Mutation test means a change in your program  programmers
are perform changes in tested programs to estimate
completeness and correctness of the program testing

In the mutation testing we create the mutants(duplicate
copy) and then we test on the mutants and finds whether any
difference is there between the mutants and the original
program after the test.

Mutation testing is done to find the coverage of test cases.
Some mutants will be inserted in the code, then the 
negative test cases will be failed.

Mutation testing means testing the test cases.
ie testing the effectiveness of the test cases in finding the
error.

A testing methodology in which two or more program 
mutations are executed using the same test cases to 
evaluate the ability of the test cases to detect 
differences in the mutations.
  ---------------------------------------------
Mutation Testing is a fault-based testing technique
Measure the effectiveness of test cases
Assumption: a program will be well tested if all simple 
faults are detected and removed

Simple faults are introduced into the program by creating a 
set of faulty version, called MUTANTS

A mutant P’ is a program that is similar to the program P 
being tested

It differs from P only by a mutation (mutant operators)
Mutant operators example: Istruction delete, Change of a 
constant value, Change of a variable 

Test cases are used to execute these mutants with the goal 
of causing each mutant P’ to produce incorrect output
If  P produce different results from P, running the same 
test case T ; Mutant killed

Doing test to the tested application to check whether 
testing is completely done or not.
nothing but testing to a tested application is mutation 
testing

This comes in White box testing. This is to find the 
effectiveness of a test case after making some changes in 
the code. Here we have some terms like killed mutants, live 
mutants

Here mutation is nothing but alteration  ...

A method to determine test set thoroughness by measuring 
the extent to which a test set can discriminate the program 
from slight variants of the program.

mutation is comes under white box testing. mutation is 
nothing but a complex change in coding.In this we r 
forcibly making some changes in the coding and checking 
whether it gives the correct (or) wrong results. if it give 
wrong result then our test is passed and if it give correct 
result then the test is failed.

Mutation : What is Mutation ?
Change in Order (Can be Software code or Genetic Code).

Mutation Testing: Change the Existing Software Code(Normal 
Functionality) Through mutation & Test The Application.

Result: The Application Should show Bugs while Text 
Execution.

When some minor changes has made in application its call 
mutation code and against them we test that application is 
called Mutation Testing.

mutation is comes under white box testing. mutation is 
nothing but a complex change in coding.In this we r 
forcibly making some changes in the coding and checking 
whether it gives the correct or wrong inputs. if it give 
wrong input then our test is passed and if it give correct 
input then the test is failed.It's is working everything 
under white box resting.Mutation Testing is a fault-based 
testing technique Measure the effectiveness of test cases
 and the test result.Testing that is transparent to the 
software under test