Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

Transcript

1. Efficient and Effective Mutation Testing: Supporting the Implementation of Quality

   Software by Purposefully Inserting Defects Gregory M. Kapfhammer† Department of Computer Science Allegheny College http://www.cs.allegheny.edu/∼gkapfham/ University of Delhi – May 2, 2012 †Joint with Ren´ e Just and Franz Schweiggert (University of Ulm) and Jonathan Miller Kauffman (Allegheny College)

2. Introduction Mutation Analysis Empirical Evaluation Conclusion Important Points Presenter Introduction:

   Gregory M. Kapfhammer test testing software suites prioritization components coverage empirically regression suite applications evaluating algorithm analysis data effectiveness empirical genetic performance understanding using approach commercialofftheshelf comparison comprehensive constrained creation databasecentric environments execution finding framework identifying interactive java methods multiplots mutation party prioritized reduction relational study third timeaware towards 105 adequacy approaches array automatically building call challenges chapter communication compare compressing computer conditional cost cots covering creating criteria database databaseaware databasedriven databases declarative dependable detection devices distributed distributing duringsearchbased dynamic efficiency efficient engineering environment evaluate examination executing experimental family flow forward frameworks free generation greedy gui hamiltonian handbook heaps implementation improve incorporating increase information initial intranode invariant javaspace javaspacebased kernel knapsack linux measurement memory method monitoring operators paths poster potential preliminary primitives prioritizations prioritizers prioritizing problematic receive remote reports resource resourceconstrained results role runtime science searchbased selection solutions solvers space studies studying supported synthetic techniques transmission transparently trees tuple unstructured wrappers Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

3. Introduction Mutation Analysis Empirical Evaluation Conclusion Important Points Inspiration and

   Motivation The magic of myth and legend has come true in our time. One types the correct incantation on a keyboard, and a display screen comes to life, showing things that never were nor could be. Frederick P. Brooks, Jr. Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

4. Introduction Mutation Analysis Empirical Evaluation Conclusion Important Points Inspiration and

   Motivation The magic of myth and legend has come true in our time. One types the correct incantation on a keyboard, and a display screen comes to life, showing things that never were nor could be. Frederick P. Brooks, Jr. In reference to software! Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

5. Introduction Mutation Analysis Empirical Evaluation Conclusion Important Points Inspiration and

   Motivation I believe the hard part of building software to be the specification, design, and testing of this con- ceptual construct, not the labor of representing it and testing the fidelity of the representation. Frederick P. Brooks, Jr. Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

6. Introduction Mutation Analysis Empirical Evaluation Conclusion Important Points Inspiration and

   Motivation I believe the hard part of building software to be the specification, design, and testing of this con- ceptual construct, not the labor of representing it and testing the fidelity of the representation. Frederick P. Brooks, Jr. What happens if the “incantation” is incorrect? Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

7. Introduction Mutation Analysis Empirical Evaluation Conclusion Important Points Inspiration and

   Motivation I believe the hard part of building software to be the specification, design, and testing of this con- ceptual construct, not the labor of representing it and testing the fidelity of the representation. Frederick P. Brooks, Jr. How do we efficiently and effectively test software? Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

8. Introduction Mutation Analysis Empirical Evaluation Conclusion Software Testing What is

   a Test Case? Method Under Test Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

9. Introduction Mutation Analysis Empirical Evaluation Conclusion Software Testing What is

   a Test Case? Method Under Test Input Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

10. Introduction Mutation Analysis Empirical Evaluation Conclusion Software Testing What is

    a Test Case? Method Under Test Input Output Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

11. Introduction Mutation Analysis Empirical Evaluation Conclusion Software Testing What is

    a Test Case? Method Under Test Test Set Up Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

12. Introduction Mutation Analysis Empirical Evaluation Conclusion Software Testing What is

    a Test Case? Method Under Test Test Set Up Input Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

13. Introduction Mutation Analysis Empirical Evaluation Conclusion Software Testing What is

    a Test Case? Method Under Test Test Set Up Input Output Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

14. Introduction Mutation Analysis Empirical Evaluation Conclusion Software Testing What is

    a Test Case? Method Under Test Test Set Up Input Output Test Clean Up Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

15. Introduction Mutation Analysis Empirical Evaluation Conclusion Software Testing What is

    a Test Case? Method Under Test Test Set Up Input Output Test Clean Up Test Oracle Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

16. Introduction Mutation Analysis Empirical Evaluation Conclusion Software Testing What is

    a Test Case? Method Under Test Test Set Up Input Output Test Clean Up Test Oracle Expected Output Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

17. Introduction Mutation Analysis Empirical Evaluation Conclusion Software Testing What is

    a Test Case? Method Under Test Test Set Up Input Output Test Clean Up Test Oracle Expected Output Test Verdict Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

18. Introduction Mutation Analysis Empirical Evaluation Conclusion Software Testing What is

    a Test Case? Method Under Test Test Set Up Input Output Test Clean Up Test Oracle Expected Output Test Verdict Expected Output Output Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

19. Introduction Mutation Analysis Empirical Evaluation Conclusion Software Testing What is

    a Test Case? Method Under Test Test Set Up Input Output Test Clean Up Test Oracle Expected Output Test Verdict Expected Output Output Test Verdict The test case passes and the code is correct! Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

20. Introduction Mutation Analysis Empirical Evaluation Conclusion Software Testing What is

    a Test Case? Method Under Test Test Set Up Input Output Test Clean Up Test Oracle Expected Output Test Verdict Expected Output Output Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

21. Introduction Mutation Analysis Empirical Evaluation Conclusion Software Testing What is

    a Test Case? Method Under Test Test Set Up Input Output Test Clean Up Test Oracle Expected Output Test Verdict Expected Output Output Test Verdict The test case fails and a defect is found! Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

22. Introduction Mutation Analysis Empirical Evaluation Conclusion Software Testing What is

    a Test Suite? T1 T2 Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

23. Introduction Mutation Analysis Empirical Evaluation Conclusion Software Testing What is

    a Test Suite? T1 T2 T3 T4 Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

24. Introduction Mutation Analysis Empirical Evaluation Conclusion Software Testing What is

    a Test Suite? T1 T2 T3 T4 T5 T6 Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

25. Introduction Mutation Analysis Empirical Evaluation Conclusion Software Testing What is

    a Test Suite? T1 T2 T3 T4 T5 T6 T7 T8 Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

26. Introduction Mutation Analysis Empirical Evaluation Conclusion Software Testing What is

    a Test Suite? T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

27. Introduction Mutation Analysis Empirical Evaluation Conclusion Software Testing What is

    a Test Suite? T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 Test Suite T = T1, T2, . . . , T9, T10 Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

28. Introduction Mutation Analysis Empirical Evaluation Conclusion Software Testing What is

    a Test Suite? T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 Test Suite T = T1, T2, . . . , T9, T10 R1 R2 Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

29. Introduction Mutation Analysis Empirical Evaluation Conclusion Software Testing What is

    a Test Suite? T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 Test Suite T = T1, T2, . . . , T9, T10 R1 R2 R3 R4 Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

30. Introduction Mutation Analysis Empirical Evaluation Conclusion Software Testing What is

    a Test Suite? T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 Test Suite T = T1, T2, . . . , T9, T10 R1 R2 R3 R4 R5 R6 Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

31. Introduction Mutation Analysis Empirical Evaluation Conclusion Software Testing What is

    a Test Suite? T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 Test Suite T = T1, T2, . . . , T9, T10 R1 R2 R3 R4 R5 R6 F1 F2 Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

32. Introduction Mutation Analysis Empirical Evaluation Conclusion Software Testing What is

    a Test Suite? T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 Test Suite T = T1, T2, . . . , T9, T10 R1 R2 R3 R4 R5 R6 F1 F2 F3 F4 Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

33. Introduction Mutation Analysis Empirical Evaluation Conclusion Software Testing What is

    a Test Suite? T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 Test Suite T = T1, T2, . . . , T9, T10 R1 R2 R3 R4 R5 R6 F1 F2 F3 F4 B1 B2 Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

34. Introduction Mutation Analysis Empirical Evaluation Conclusion Software Testing What is

    a Test Suite? T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 Test Suite T = T1, T2, . . . , T9, T10 R1 R2 R3 R4 R5 R6 F1 F2 F3 F4 B1 B2 Requirements R = {R1 , . . . , R6 }, Features F = {F1 , . . . , F4 }, Bug Fixes B = {B1 , B2 } Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

35. Introduction Mutation Analysis Empirical Evaluation Conclusion Software Testing What is

    a Test Suite? T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 Test Suite T = T1, T2, . . . , T9, T10 R1 R2 R3 R4 R5 R6 F1 F2 F3 F4 B1 B2 Requirements R = {R1 , . . . , R6 }, Features F = {F1 , . . . , F4 }, Bug Fixes B = {B1 , B2 } B2 B2 B2 B2 Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

36. Introduction Mutation Analysis Empirical Evaluation Conclusion Software Testing What is

    a Test Suite? T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 Test Suite T = T1, T2, . . . , T9, T10 R1 R2 R3 R4 R5 R6 F1 F2 F3 F4 B1 B2 Requirements R = {R1 , . . . , R6 }, Features F = {F1 , . . . , F4 }, Bug Fixes B = {B1 , B2 } B2 B2 B2 B2 B2 B2 Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

37. Introduction Mutation Analysis Empirical Evaluation Conclusion Software Testing What is

    a Test Suite? T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 Test Suite T = T1, T2, . . . , T9, T10 R1 R2 R3 R4 R5 R6 F1 F2 F3 F4 B1 B2 Requirements R = {R1 , . . . , R6 }, Features F = {F1 , . . . , F4 }, Bug Fixes B = {B1 , B2 } B2 B2 B2 B2 B2 B2 B2 B2 B2 B2 Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

38. Introduction Mutation Analysis Empirical Evaluation Conclusion Software Testing What is

    a Test Suite? T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 Test Suite T = T1, T2, . . . , T9, T10 R1 R2 R3 R4 R5 R6 F1 F2 F3 F4 B1 B2 Requirements R = {R1 , . . . , R6 }, Features F = {F1 , . . . , F4 }, Bug Fixes B = {B1 , B2 } Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

39. Introduction Mutation Analysis Empirical Evaluation Conclusion Software Testing What is

    a Test Suite? T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 Test Suite T = T1, T2, . . . , T9, T10 R1 R2 R3 R4 R5 R6 F1 F2 F3 F4 B1 B2 Requirements R = {R1 , . . . , R6 }, Features F = {F1 , . . . , F4 }, Bug Fixes B = {B1 , B2 } How Good is Test Suite T? Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

40. Introduction Mutation Analysis Empirical Evaluation Conclusion Software Testing What is

    a Test Suite? T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 Test Suite T = T1, T2, . . . , T9, T10 R1 R2 R3 R4 R5 R6 F1 F2 F3 F4 B1 B2 Requirements R = {R1 , . . . , R6 }, Features F = {F1 , . . . , F4 }, Bug Fixes B = {B1 , B2 } How Good is Test Suite T? Coverage Analysis Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

41. Introduction Mutation Analysis Empirical Evaluation Conclusion Software Testing What is

    a Test Suite? T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 Test Suite T = T1, T2, . . . , T9, T10 R1 R2 R3 R4 R5 R6 F1 F2 F3 F4 B1 B2 Requirements R = {R1 , . . . , R6 }, Features F = {F1 , . . . , F4 }, Bug Fixes B = {B1 , B2 } How Good is Test Suite T? Coverage Analysis Mutation Analysis Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

42. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Conceptual Faults

    if(a > 10) Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

43. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Conceptual Faults

    if(a > 10) if(a >= 10) Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

44. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Conceptual Faults

    if(a > 10) if(a >= 10) Implemented Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

45. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Conceptual Faults

    if(a > 10) if(a >= 10) Implemented Potential Fault Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

46. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Conceptual Faults

    if(a > 10) if(a >= 10) a true false Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

47. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Conceptual Faults

    if(a > 10) if(a >= 10) a true false a true false Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

48. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Conceptual Faults

    if(a > 10) if(a >= 10) a true false a true false a = 0 Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

49. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Conceptual Faults

    if(a > 10) if(a >= 10) a true false a true false a = 0 false false Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

50. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Conceptual Faults

    if(a > 10) if(a >= 10) a true false a true false a = 15 Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

51. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Conceptual Faults

    if(a > 10) if(a >= 10) a true false a true false a = 15 true true Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

52. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Conceptual Faults

    if(a > 10) if(a >= 10) a true false a true false a = 10 Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

53. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Conceptual Faults

    if(a > 10) if(a >= 10) a true false a true false a = 10 false true Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

54. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Conceptual Faults

    if(a > 10) if(a >= 10) a true false a true false a = 10 false true Can the tests differentiate between implemented and potential fault? Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

55. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Conceptual Faults

    if(a > 10) if(a >= 10) a true false a true false a = 10 false true If yes, then the tests are adequate! Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

56. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Conceptual Faults

    if(a > 10) if(a >= 10) a true false a true false a = 10 false true If no, then the tests must be improved! Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

57. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Conceptual Faults

    if(a > 10) if(a >= 10) a true false a true false a = 10 false true Purposefully insert faults in order to implement quality software! Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

58. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Overview of

    Mutation Analysis Mutation Operator Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

59. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Overview of

    Mutation Analysis Mutation Operator Mutation Operator Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

60. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Overview of

    Mutation Analysis Mutation Operator Mutation Operator Mutation Operator Mutation Operator Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

61. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Overview of

    Mutation Analysis Mutation Operator Mutation Operator Mutation Operator Mutation Operator Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

62. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Overview of

    Mutation Analysis Mutation Operator Mutation Operator Mutation Operator Mutation Operator Methodically inject small syntactical faults into the program under test Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

63. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Overview of

    Mutation Analysis Mutation Operator Mutation Operator Mutation Operator Mutation Operator Methodically inject small syntactical faults into the program under test Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

64. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Overview of

    Mutation Analysis Mutation Operator Mutation Operator Mutation Operator Mutation Operator Methodically inject small syntactical faults into the program under test Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

65. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Overview of

    Mutation Analysis Mutation Operator Mutation Operator Mutation Operator Mutation Operator Methodically inject small syntactical faults into the program under test Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

66. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Overview of

    Mutation Analysis Mutation Operator Mutation Operator Mutation Operator Mutation Operator Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

67. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Overview of

    Mutation Analysis Test Case T1 Test Case T2 Test Case T3 Test Case T4 Execute the test suite after enabling a single mutant in the program under test Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

68. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Overview of

    Mutation Analysis Test Case T1 Test Case T2 Test Case T3 Test Case T4 Execute the test suite after enabling a single mutant in the program under test Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

69. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Overview of

    Mutation Analysis Test Case T1 Test Case T2 Test Case T3 Test Case T4 Execute the test suite after enabling a single mutant in the program under test Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

70. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Overview of

    Mutation Analysis Test Case T1 Test Case T2 Test Case T3 Test Case T4 Execute the test suite after enabling a single mutant in the program under test Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

71. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Overview of

    Mutation Analysis Test Case T1 Test Case T2 Test Case T3 Test Case T4 Execute the test suite after enabling a single mutant in the program under test Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

72. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Overview of

    Mutation Analysis Test Case T1 Test Case T2 Test Case T3 Test Case T4 Execute the test suite after enabling a single mutant in the program under test Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

73. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Overview of

    Mutation Analysis Test Case T1 Test Case T2 Test Case T3 Test Case T4 Execute the test suite after enabling a single mutant in the program under test Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

74. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Overview of

    Mutation Analysis Test Case T1 Test Case T2 Test Case T3 Test Case T4 Execute the test suite after enabling a single mutant in the program under test Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

75. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Overview of

    Mutation Analysis Test Case T1 Test Case T2 Test Case T3 Test Case T4 Execute the test suite after enabling a single mutant in the program under test Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

76. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Overview of

    Mutation Analysis Test Case T1 Test Case T2 Test Case T3 Test Case T4 Execute the test suite after enabling a single mutant in the program under test The test suite cannot kill the mutant – either a test suite weakness or an equivalent mutant! Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

77. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Overview of

    Mutation Analysis Test Case T1 Test Case T2 Test Case T3 Test Case T4 Execute the test suite after enabling a single mutant in the program under test Repeat this process for all of the test cases and mutants – calculate mutation score when finished Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

78. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Contributions of

    this Presentation Efficient Mutation Analysis Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

79. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Contributions of

    this Presentation Efficient Mutation Analysis Challenges Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

80. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Contributions of

    this Presentation Efficient Mutation Analysis Challenges Solutions Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

81. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Contributions of

    this Presentation Efficient Mutation Analysis Challenges Solutions Conditional Mutation Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

82. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Contributions of

    this Presentation Efficient Mutation Analysis Challenges Solutions Conditional Mutation Syntax Tree Transformation Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

83. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Contributions of

    this Presentation Efficient Mutation Analysis Challenges Solutions Conditional Mutation Syntax Tree Transformation Expressions and Statements Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

84. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Contributions of

    this Presentation Efficient Mutation Analysis Challenges Solutions Conditional Mutation Syntax Tree Transformation Expressions and Statements Compiler Integrated Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

85. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Contributions of

    this Presentation Efficient Mutation Analysis Challenges Solutions Conditional Mutation Syntax Tree Transformation Expressions and Statements Compiler Integrated Comprehensive Empirical Study Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

86. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Contributions of

    this Presentation Efficient Mutation Analysis Challenges Solutions Conditional Mutation Syntax Tree Transformation Expressions and Statements Compiler Integrated Comprehensive Empirical Study Efficient Technique - Fully Integrated into the Java 6 SE Compiler Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

87. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Understanding Mutation

    Analysis public int eval(int x){ int a=3, b=1, y; y = a * x; y += b; return y; } public int max(int a, int b){ int max = a; if(b>a){ max=b; } return max; } Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

88. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Understanding Mutation

    Analysis public int eval(int x){ int a=3, b=1, y; y = a * x; y += b; return y; } public int max(int a, int b){ int max = a; if(b>a){ max=b; } return max; } Methodically inject small syntactical faults into the program under test Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

89. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Understanding Mutation

    Analysis public int eval(int x){ int a=3, b=1, y; y = a * x; y += b; return y; } public int max(int a, int b){ int max = a; if(b>a){ max=b; } return max; } Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

90. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Understanding Mutation

    Analysis public int eval(int x){ int a=3, b=1, y; y = a * x; y += b; return y; } public int max(int a, int b){ int max = a; if(b>a){ max=b; } return max; } =⇒ =⇒ • y = a - x; • y = a + x; • y = a / x; • if(b < a) • if(b != a) • if(b == a) Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

91. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Understanding Mutation

    Analysis public int eval(int x){ int a=3, b=1, y; y = a * x; y += b; return y; } public int max(int a, int b){ int max = a; if(b>a){ max=b; } return max; } Unbiased and powerful method for assessing oracles and input values Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

92. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Understanding Mutation

    Analysis public int eval(int x){ int a=3, b=1, y; y = a * x; y += b; return y; } public int max(int a, int b){ int max = a; if(b>a){ max=b; } return max; } Unbiased and powerful method for assessing oracles and input values Useful method for fault seeding during the empirical study of testing techniques Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

93. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Mutation Analysis

    Challenges Mutant Generation Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

94. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Mutation Analysis

    Challenges Mutant Generation Mutation Operators Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

95. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Mutation Analysis

    Challenges Mutant Generation Mutation Operators Program Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

96. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Mutation Analysis

    Challenges Mutant Generation Mutation Operators Program Mutants Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

97. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Mutation Analysis

    Challenges Mutant Generation Mutation Operators Program Mutants Often Yields a Substantial Num- ber of Mutants Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

98. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Mutation Analysis

    Challenges Mutant Generation Mutation Operators Program Mutants Often Yields a Substantial Num- ber of Mutants High Time Over- head for Generation Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

99. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Mutation Analysis

    Challenges Mutant Generation Mutation Operators Program Mutants Often Yields a Substantial Num- ber of Mutants High Time Over- head for Generation Mutation Analysis Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

100. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Mutation Analysis

     Challenges Mutant Generation Mutation Operators Program Mutants Often Yields a Substantial Num- ber of Mutants High Time Over- head for Generation Mutation Analysis Tests Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

101. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Mutation Analysis

     Challenges Mutant Generation Mutation Operators Program Mutants Often Yields a Substantial Num- ber of Mutants High Time Over- head for Generation Mutation Analysis Tests Results Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

102. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Mutation Analysis

     Challenges Mutant Generation Mutation Operators Program Mutants Often Yields a Substantial Num- ber of Mutants High Time Over- head for Generation Mutation Analysis Tests Results Individually Executing the Mutants is Too Expensive Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

103. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Mutation Analysis

     Challenges Mutant Generation Mutation Operators Program Mutants Often Yields a Substantial Num- ber of Mutants High Time Over- head for Generation Mutation Analysis Tests Results Individually Executing the Mutants is Too Expensive Prior Solutions? Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

104. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Prior Work

     in Mutation Analysis Improving Mutation Analysis Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

105. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Prior Work

     in Mutation Analysis Improving Mutation Analysis Offutt and Untch Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

106. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Prior Work

     in Mutation Analysis Improving Mutation Analysis Offutt and Untch Do Fewer Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

107. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Prior Work

     in Mutation Analysis Improving Mutation Analysis Offutt and Untch Do Fewer Sampling Selection Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

108. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Prior Work

     in Mutation Analysis Improving Mutation Analysis Offutt and Untch Do Fewer Do Smarter Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

109. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Prior Work

     in Mutation Analysis Improving Mutation Analysis Offutt and Untch Do Fewer Do Smarter Distributed Weak Mutation Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

110. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Prior Work

     in Mutation Analysis Improving Mutation Analysis Offutt and Untch Do Fewer Do Smarter Do Faster Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

111. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Prior Work

     in Mutation Analysis Improving Mutation Analysis Offutt and Untch Do Fewer Do Smarter Do Faster Compiler Integrated Bytecode Transformation Mutant Schemata Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

112. Introduction Mutation Analysis Empirical Evaluation Conclusion Fundamental Concepts Prior Work

     in Mutation Analysis Improving Mutation Analysis Offutt and Untch Do Fewer Do Smarter Do Faster Higher Order Mutation Jia and Harman Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

113. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     Conditional Mutation Conditional Mutation Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

114. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     Conditional Mutation Conditional Mutation Encapsulates all mutants within the same block Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

115. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     Conditional Mutation Conditional Mutation Encapsulates all mutants within the same block Can be inte- grated within the compiler Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

116. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     Conditional Mutation Conditional Mutation Encapsulates all mutants within the same block Transforms the abstract syntax tree (AST) Can be inte- grated within the compiler Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

117. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     Conditional Mutation Conditional Mutation Encapsulates all mutants within the same block Transforms the abstract syntax tree (AST) Stmt → Conditional Stmt (if-then-else, switch) Expr → Conditional Expr (conditional operator ?:) Can be inte- grated within the compiler Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

118. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     Transforming the AST public int eval(int x){ int a=3, b=1, y; y = a * x ; y += b; return y; } Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

119. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     Transforming the AST public int eval(int x){ int a=3, b=1, y; y = a * x ; y += b; return y; } ⇓ ASSIGN IDENT y BINARY ∗ a x Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

120. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     Transforming the AST public int eval(int x){ int a=3, b=1, y; y = a * x ; y += b; return y; } ⇓ ASSIGN IDENT y BINARY ∗ a x Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

121. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     Transforming the AST public int eval(int x){ int a=3, b=1, y; y = a * x ; y += b; return y; } ⇓ ASSIGN IDENT y BINARY ∗ a x =⇒ =⇒ ASSIGN IDENT y COND-EXPR THEN BINARY + a x COND (M NO ==2) ELSE COND-EXPR THEN BINARY - a x COND (M NO ==1) ELSE BINARY ∗ a x Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

122. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     Source Code View of Inserting Mutants public int eval(int x){ int a=3, b=1, y; y = a * x ; y += b; return y; } 1 Define mutation operators MOP(x ∗ y) = {x − y, x + y, x/y} 2 Determine whether current expression or statement is affected by mutation 3 Apply mutation operators Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

123. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     Source Code View of Inserting Mutants public int eval(int x){ int a=3, b=1, y; y = a * x ; y += b; return y; } 1 Define mutation operators MOP(x ∗ y) = {x − y, x + y, x/y} 2 Determine whether current expression or statement is affected by mutation 3 Apply mutation operators Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

124. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     Source Code View of Inserting Mutants public int eval(int x){ int a=3, b=1, y; y = a * x ; y += b; return y; } 1 Define mutation operators MOP(x ∗ y) = {x − y, x + y, x/y} 2 Determine whether current expression or statement is affected by mutation 3 Apply mutation operators Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

125. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     Source Code View of Inserting Mutants public int eval(int x){ int a=3, b=1, y; y = (M_NO==1)? a - x : a * x ; y += b; return y; } 1 Define mutation operators MOP(x ∗ y) = {x − y, x + y, x/y} 2 Determine whether current expression or statement is affected by mutation 3 Apply mutation operators Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

126. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     Source Code View of Inserting Mutants public int eval(int x){ int a=3, b=1, y; y = (M_NO==2)? a + x : (M_NO==1)? a - x : a * x ; y += b; return y; } 1 Define mutation operators MOP(x ∗ y) = {x − y, x + y, x/y} 2 Determine whether current expression or statement is affected by mutation 3 Apply mutation operators Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

127. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     Source Code View of Inserting Mutants public int eval(int x){ int a=3, b=1, y; y = (M_NO==3)? a / x : (M_NO==2)? a + x : (M_NO==1)? a - x : a * x ; y += b; return y; } 1 Define mutation operators MOP(x ∗ y) = {x − y, x + y, x/y} 2 Determine whether current expression or statement is affected by mutation 3 Apply mutation operators Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

128. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     Source Code View of Inserting Mutants public int eval(int x){ int a=3, b=1, y; y = (M_NO==3)? a / x : (M_NO==2)? a + x : (M_NO==1)? a - x : a * x ; y += b; return y; } Mutants that are not ex- ecuted cannot be killed 1 Define mutation operators MOP(x ∗ y) = {x − y, x + y, x/y} 2 Determine whether current expression or statement is affected by mutation 3 Apply mutation operators Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

129. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     Collecting and Using Mutation Coverage public int eval(int x){ int a=3, b=1, y; y = (M_NO==3)? a / x : (M_NO==2)? a + x : (M_NO==1)? a - x : a * x ; y += b; return y; } Mutants that are not ex- ecuted cannot be killed Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

130. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     Collecting and Using Mutation Coverage public int eval(int x){ int a=3, b=1, y; y = (M_NO==3)? a / x : (M_NO==2)? a + x : (M_NO==1)? a - x : (M_NO==0 && COVERED(1,3))? a * x : a * x ; y += b; return y; } Mutants that are not ex- ecuted cannot be killed Determine covered mutants with addi- tional instrumentation Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

131. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     Collecting and Using Mutation Coverage public int eval(int x){ int a=3, b=1, y; y = (M_NO==3)? a / x : (M_NO==2)? a + x : (M_NO==1)? a - x : (M_NO==0 && COVERED(1,3))? a * x : a * x ; y += b; return y; } Mutants that are not ex- ecuted cannot be killed Determine covered mutants with addi- tional instrumentation Only execute and investi- gate the covered mutants Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

132. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     MAJOR’s Compiler MAJOR’s Compiler Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

133. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     MAJOR’s Compiler MAJOR’s Compiler Enhanced the Standard Java Compiler Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

134. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     MAJOR’s Compiler MAJOR’s Compiler Enhanced the Standard Java Compiler Source Files Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

135. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     MAJOR’s Compiler MAJOR’s Compiler Enhanced the Standard Java Compiler Source Files Common Compiler Options Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

136. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     MAJOR’s Compiler MAJOR’s Compiler Enhanced the Standard Java Compiler Source Files Common Compiler Options Domain Specific Language Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

137. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     MAJOR’s Compiler MAJOR’s Compiler Enhanced the Standard Java Compiler Source Files Common Compiler Options Domain Specific Language Bytecode with Embedded Mutants Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

138. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     Integration into the Java Compiler Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

139. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     Integration into the Java Compiler Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

140. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     Integration into the Java Compiler Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

141. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     Integration into the Java Compiler Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

142. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     MAJOR’s Domain Specific Language // variable declaration listCOR={&&, ||, ==, !=}; // Define replacement list BIN(+)<"org"> -> {-,*}; BIN(*)<"org"> -> {/,%}; // Define own operator myOp{ BIN(&&) -> listCOR; BIN(||) -> listCOR; COR; LVR; } // Enable built-in operator AOR AOR<"org">; // Enable operator myOp myOp<"java.lang.System@println">; Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

143. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     MAJOR’s Domain Specific Language // variable declaration listCOR={&&, ||, ==, !=}; // Define replacement list BIN(+)<"org"> -> {-,*}; BIN(*)<"org"> -> {/,%}; // Define own operator myOp{ BIN(&&) -> listCOR; BIN(||) -> listCOR; COR; LVR; } // Enable built-in operator AOR AOR<"org">; // Enable operator myOp myOp<"java.lang.System@println">; Specify mutation operators in detail Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

144. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     MAJOR’s Domain Specific Language // variable declaration listCOR={&&, ||, ==, !=}; // Define replacement list BIN(+)<"org"> -> {-,*}; BIN(*)<"org"> -> {/,%}; // Define own operator myOp{ BIN(&&) -> listCOR; BIN(||) -> listCOR; COR; LVR; } // Enable built-in operator AOR AOR<"org">; // Enable operator myOp myOp<"java.lang.System@println">; Specify mutation operators in detail Define own mutation operator groups Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

145. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     MAJOR’s Domain Specific Language // variable declaration listCOR={&&, ||, ==, !=}; // Define replacement list BIN(+)<"org"> -> {-,*}; BIN(*)<"org"> -> {/,%}; // Define own operator myOp{ BIN(&&) -> listCOR; BIN(||) -> listCOR; COR; LVR; } // Enable built-in operator AOR AOR<"org">; // Enable operator myOp myOp<"java.lang.System@println">; Specify mutation operators in detail Define own mutation operator groups Enable operators for a specific package, class, or method Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

146. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     Optimized Mutation Analysis Process 1 Embed and compile all mutants 2 Run test suite on instrumented program 3 Sort tests according to their runtime 4 Perform mutation analysis with reordered test suite Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

147. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     Optimized Mutation Analysis Process 1 Embed and compile all mutants 2 Run test suite on instrumented program 3 Sort tests according to their runtime 4 Perform mutation analysis with reordered test suite Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

148. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     Optimized Mutation Analysis Process 1 Embed and compile all mutants 2 Run test suite on instrumented program 3 Sort tests according to their runtime 4 Perform mutation analysis with reordered test suite Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

149. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis with MAJOR

     Optimized Mutation Analysis Process 1 Embed and compile all mutants 2 Run test suite on instrumented program 3 Sort tests according to their runtime 4 Perform mutation analysis with reordered test suite Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

150. Introduction Mutation Analysis Empirical Evaluation Conclusion Compilation Efficiency Mutant Generation

     and Compilation 1 2 3 4 5 6 7 8 9 10 11 12 0 20000 40000 60000 80000 100000 120000 140000 Compiler runtime in seconds Number of mutants apache ant jfreechart itext java pathfinder commons math commons lang numerics4j Overhead for generating and compiling mutants is negligible Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

151. Introduction Mutation Analysis Empirical Evaluation Conclusion Compilation Efficiency Mutant Generation

     and Compilation 1 2 3 4 5 6 7 8 9 10 11 12 0 20000 40000 60000 80000 100000 120000 140000 Compiler runtime in seconds Number of mutants apache ant jfreechart itext java pathfinder commons math commons lang numerics4j Overhead for generating and compiling mutants is negligible Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

152. Introduction Mutation Analysis Empirical Evaluation Conclusion Compilation Efficiency Time and

     Space Overhead Application Mutants Runtime of test suite Memory consumption original instrumented original instrumented wcs wcs+cov aspectj 406,382 4.3 4.8 5.0 559 813 apache ant 60,258 331.0 335.0 346.0 237 293 jfreechart 68,782 15.0 18.0 23.0 220 303 itext 124,184 5.1 5.6 6.3 217 325 java pathfinder 37,331 17.0 22.0 29.0 182 217 commons math 67,895 67.0 83.0 98.0 153 225 commons lang 25,783 10.3 11.8 14.8 104 149 numerics4j 5,869 1.2 1.3 1.6 73 90 • Runtime overhead is application dependent • Larger for CPU-bound applications • Small for I/O-bound applications • Even for large projects, applicable on commodity workstations Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

153. Introduction Mutation Analysis Empirical Evaluation Conclusion Compilation Efficiency Time and

     Space Overhead Application Mutants Runtime of test suite Memory consumption original instrumented original instrumented wcs wcs+cov aspectj 406,382 4.3 4.8 5.0 559 813 apache ant 60,258 331.0 335.0 346.0 237 293 jfreechart 68,782 15.0 18.0 23.0 220 303 itext 124,184 5.1 5.6 6.3 217 325 java pathfinder 37,331 17.0 22.0 29.0 182 217 commons math 67,895 67.0 83.0 98.0 153 225 commons lang 25,783 10.3 11.8 14.8 104 149 numerics4j 5,869 1.2 1.3 1.6 73 90 • Runtime overhead is application dependent • Larger for CPU-bound applications • Small for I/O-bound applications • Even for large projects, applicable on commodity workstations Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

154. Introduction Mutation Analysis Empirical Evaluation Conclusion Compilation Efficiency Time and

     Space Overhead Application Mutants Runtime of test suite Memory consumption original instrumented original instrumented wcs wcs+cov aspectj 406,382 4.3 4.8 5.0 559 813 apache ant 60,258 331.0 335.0 346.0 237 293 jfreechart 68,782 15.0 18.0 23.0 220 303 itext 124,184 5.1 5.6 6.3 217 325 java pathfinder 37,331 17.0 22.0 29.0 182 217 commons math 67,895 67.0 83.0 98.0 153 225 commons lang 25,783 10.3 11.8 14.8 104 149 numerics4j 5,869 1.2 1.3 1.6 73 90 • Runtime overhead is application dependent • Larger for CPU-bound applications • Small for I/O-bound applications • Even for large projects, applicable on commodity workstations Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

155. Introduction Mutation Analysis Empirical Evaluation Conclusion Compilation Efficiency Time and

     Space Overhead Application Mutants Runtime of test suite Memory consumption original instrumented original instrumented wcs wcs+cov aspectj 406,382 4.3 4.8 5.0 559 813 apache ant 60,258 331.0 335.0 346.0 237 293 jfreechart 68,782 15.0 18.0 23.0 220 303 itext 124,184 5.1 5.6 6.3 217 325 java pathfinder 37,331 17.0 22.0 29.0 182 217 commons math 67,895 67.0 83.0 98.0 153 225 commons lang 25,783 10.3 11.8 14.8 104 149 numerics4j 5,869 1.2 1.3 1.6 73 90 • Runtime overhead is application dependent • Larger for CPU-bound applications • Small for I/O-bound applications • Even for large projects, applicable on commodity workstations Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

156. Introduction Mutation Analysis Empirical Evaluation Conclusion Compilation Efficiency Time and

     Space Overhead Application Mutants Runtime of test suite Memory consumption original instrumented original instrumented wcs wcs+cov aspectj 406,382 4.3 4.8 5.0 559 813 apache ant 60,258 331.0 335.0 346.0 237 293 jfreechart 68,782 15.0 18.0 23.0 220 303 itext 124,184 5.1 5.6 6.3 217 325 java pathfinder 37,331 17.0 22.0 29.0 182 217 commons math 67,895 67.0 83.0 98.0 153 225 commons lang 25,783 10.3 11.8 14.8 104 149 numerics4j 5,869 1.2 1.3 1.6 73 90 • Runtime overhead is application dependent • Larger for CPU-bound applications • Small for I/O-bound applications • Even for large projects, applicable on commodity workstations Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

157. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis Efficiency Evaluating

     and Improving Mutation Analysis 0 20 40 60 80 100 120 140 160 180 0 20 40 60 80 100 Number of killed mutants Runtime in seconds optimized order (using coverage information) random order (using coverage information) original order (using coverage information) optimized order (without coverage information) random order (without coverage information) original order (without coverage information) • Mutation analysis is not feasible without coverage information • Reordering the test suite significantly speeds up the process, especially if runtimes of tests differ by orders of magnitude Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

158. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis Efficiency Evaluating

     and Improving Mutation Analysis 0 20 40 60 80 100 120 140 160 180 0 20 40 60 80 100 Number of killed mutants Runtime in seconds optimized order (using coverage information) random order (using coverage information) original order (using coverage information) optimized order (without coverage information) random order (without coverage information) original order (without coverage information) • Mutation analysis is not feasible without coverage information • Reordering the test suite significantly speeds up the process, especially if runtimes of tests differ by orders of magnitude Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

159. Introduction Mutation Analysis Empirical Evaluation Conclusion Mutation Analysis Efficiency Evaluating

     and Improving Mutation Analysis 0 20 40 60 80 100 120 140 160 180 0 20 40 60 80 100 Number of killed mutants Runtime in seconds optimized order (using coverage information) random order (using coverage information) original order (using coverage information) optimized order (without coverage information) random order (without coverage information) original order (without coverage information) • Mutation analysis is not feasible without coverage information • Reordering the test suite significantly speeds up the process, especially if runtimes of tests differ by orders of magnitude Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

160. Introduction Mutation Analysis Empirical Evaluation Conclusion Retrospective Improving Test Suite

     Quality Mutation Analysis Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

161. Introduction Mutation Analysis Empirical Evaluation Conclusion Retrospective Improving Test Suite

     Quality Mutation Analysis Program Test Suite Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

162. Introduction Mutation Analysis Empirical Evaluation Conclusion Retrospective Improving Test Suite

     Quality Mutation Analysis Program Test Suite Mutation Score Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

163. Introduction Mutation Analysis Empirical Evaluation Conclusion Retrospective Improving Test Suite

     Quality Mutation Analysis Program Test Suite Mutation Score Improve Tests Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

164. Introduction Mutation Analysis Empirical Evaluation Conclusion Retrospective Improving Test Suite

     Quality Mutation Analysis Program Test Suite Mutation Score Improve Tests Automated Manual Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

165. Introduction Mutation Analysis Empirical Evaluation Conclusion Retrospective Improving Test Suite

     Quality Mutation Analysis Program Test Suite Mutation Score Improve Tests Use Tests Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

166. Introduction Mutation Analysis Empirical Evaluation Conclusion Retrospective Improving Test Suite

     Quality Mutation Analysis Program Test Suite Mutation Score Improve Tests Use Tests Test improvement is only effective if mutation analysis is efficient! Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

167. Introduction Mutation Analysis Empirical Evaluation Conclusion Retrospective Reviewing MAJOR’s Contributions

     Mutation Analysis Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

168. Introduction Mutation Analysis Empirical Evaluation Conclusion Retrospective Reviewing MAJOR’s Contributions

     Mutation Analysis Efficiency: MAJOR has ac- ceptable time and space over- heads and scales to large, real-world programs Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

169. Introduction Mutation Analysis Empirical Evaluation Conclusion Retrospective Reviewing MAJOR’s Contributions

     Mutation Analysis Efficiency: MAJOR has ac- ceptable time and space over- heads and scales to large, real-world programs Usability: MAJOR’s inte- gration into the Java SE compiler makes it a no- hassle, drop-in tool Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

170. Introduction Mutation Analysis Empirical Evaluation Conclusion Retrospective Reviewing MAJOR’s Contributions

     Mutation Analysis Efficiency: MAJOR has ac- ceptable time and space over- heads and scales to large, real-world programs Usability: MAJOR’s inte- gration into the Java SE compiler makes it a no- hassle, drop-in tool We will release MAJOR as free and open source software Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

171. Introduction Mutation Analysis Empirical Evaluation Conclusion Conclusions and Future Work

     Conclusion Key Concepts and Features: • Compiler-integrated solution • Conditional mutation with the abstract syntax tree • Furnishes its own domain specific language • Collects and leverages mutation coverage information Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

172. Introduction Mutation Analysis Empirical Evaluation Conclusion Conclusions and Future Work

     Conclusion Key Concepts and Features: • Compiler-integrated solution • Conditional mutation with the abstract syntax tree • Furnishes its own domain specific language • Collects and leverages mutation coverage information Characteristics of MAJOR: • Fast and scalable technique • Configurable and extensible mutation tool • Enables an optimized workflow for mutation analysis Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

173. Introduction Mutation Analysis Empirical Evaluation Conclusion Conclusions and Future Work

     Recently Published Papers • Ren´ e Just, Gregory M. Kapfhammer, and Franz Schweiggert. Using conditional mutation to increase the efficiency of mutation analysis. In Proceedings of the 6th International Workshop on the Automation of Software Test, Honolulu, Hawaii, May 2011. • Ren´ e Just, Franz Schweiggert, and Gregory M. Kapfhammer. MAJOR: An efficient and extensible tool for mutation analysis in a Java compiler. In Proceedings of the 26th IEEE/ACM International Conference on Automated Software Engineering (Tool Paper), Lawrence, Kansas, November 2011. Kapfhammer Allegheny College Efficient and Effective Mutation Testing: Supporting the Implementation of Quality Software by Purposefully Inserting Defects

174. Efficient and Effective Mutation Testing: Supporting the Implementation of Quality

     Software by Purposefully Inserting Defects Gregory M. Kapfhammer Department of Computer Science Allegheny College http://www.cs.allegheny.edu/∼gkapfham/ Thank you for your attention! I welcome your questions and comments.