{"id":{"repo_id":"uiuc","oai_identifier":"oai:www.ideals.illinois.edu:2142/16865"},"canonical_url":"https://search.dev.ndltd.org/etd/uiuc/oai:www.ideals.illinois.edu:2142/16865","repository":{"repo_id":"uiuc","name":"University of Illinois - Urbana-Champaign","base_url":"https://www.ideals.illinois.edu/oai-pmh"},"display":{"title":"Reducing the costs of bounded-exhaustive testing","abstract":"Bounded-exhaustive testing is an automated testing methodology that checks the code under test for all inputs within given bounds: first the user describes a set of test inputs and provides test oracles that can check test outputs; then a tool generates all the test inputs, executes them on the code under test, and checks the test outputs; finally the user inspects the failing tests to submit bug reports. The costs of bounded-exhaustive testing include machine time for test generation and execution (which translates into human time waitingfor these results) and human time for inspection of results. We propose and evaluate three orthogonal techniques that reduce these costs. Sparse Test Generation skips the generation of some test inputs to reduce the time taken to reach the first failing test. Structural Test Merging generates a smaller number of larger test inputs (rather than a larger number of smaller test inputs) to reduce test generation and execution time. Oracle-based Test Clustering groups failing tests to reduce the inspection time. Results obtained from the bounded-exhaustive testing of the Eclipse refactoring engine show that these three techniques can substantially reduce the costs without significantly sacrificing fault-detection capability.","abstract_html":"Bounded-exhaustive testing is an automated testing methodology that checks the code under test for all inputs within given bounds: first the user describes a set of test inputs and provides test oracles that can check test outputs; then a tool generates all the test inputs, executes them on the code under test, and checks the test outputs; finally the user inspects the failing tests to submit bug reports. The costs of bounded-exhaustive testing include machine time for test generation and execution (which translates into human time waitingfor these results) and human time for inspection of results. We propose and evaluate three orthogonal techniques that reduce these costs. Sparse Test Generation skips the generation of some test inputs to reduce the time taken to reach the first failing test. Structural Test Merging generates a smaller number of larger test inputs (rather than a larger number of smaller test inputs) to reduce test generation and execution time. Oracle-based Test Clustering groups failing tests to reduce the inspection time. Results obtained from the bounded-exhaustive testing of the Eclipse refactoring engine show that these three techniques can substantially reduce the costs without significantly sacrificing fault-detection capability.","abstract_has_math":false,"creators":["Bangalore Jagannath, Vilas Shekhar"],"institution":"University of Illinois at Urbana-Champaign","degree_name":"M.S.","degree_level":"Thesis","degree_discipline":"Computer Science","degree_department":null,"school":null,"contributors":["Agha, Gul A.","Marinov, Darko"],"advisors":[],"committee_chairs":[],"committee_members":[],"year":2010,"date_issued":"2010-08-20T18:00:17Z","date_published":"2010-08-20T18:00:17Z","updated_at":"2026-07-22T22:25:09Z","subjects":["bounded-exhaustive testing","test merging","test clustering","test selection","test generation","software testing"],"languages":["en"],"rights":["Copyright 2010 Vilas Shekhar Bangalore Jagannath"],"rights_urls":[],"identifier_entries":[]},"links":{"outbound_url":"http://hdl.handle.net/2142/16865","outbound_label":"Handle","outbound_source":"dc:identifier"},"metadata_groups":[{"id":"people","label":"People","entries":[{"key":"dc:contributor","label":"Contributor","values":["Agha, Gul A.","Marinov, Darko"]},{"key":"dc:creator","label":"Author","values":["Bangalore Jagannath, Vilas Shekhar"]}]},{"id":"academic_context","label":"Academic Context","entries":[{"key":"dc:date","label":"Dc Date","values":["2010-08-20T18:00:17Z","2010-08"]},{"key":"thesis:degree_discipline","label":"Discipline","values":["Computer Science"]},{"key":"thesis:degree_level","label":"Degree Level","values":["Thesis"]},{"key":"thesis:degree_name","label":"Degree Name","values":["M.S."]},{"key":"thesis:institution_name","label":"Thesis Institution Name","values":["University of Illinois at Urbana-Champaign"]}]},{"id":"subjects_keywords","label":"Subjects and Keywords","entries":[{"key":"dc:subject","label":"Dc Subject","values":["bounded-exhaustive testing","test merging","test clustering","test selection","test generation","software testing"]}]},{"id":"language_rights","label":"Language and Rights","entries":[{"key":"dc:language","label":"Dc Language","values":["en"]},{"key":"dc:rights","label":"Dc Rights","values":["Copyright 2010 Vilas Shekhar Bangalore Jagannath"]}]},{"id":"identifiers","label":"Identifiers","entries":[{"key":"dc:identifier","label":"Identifier","values":["http://hdl.handle.net/2142/16865"]}]},{"id":"additional","label":"Additional Metadata","entries":[{"key":"dc:description","label":"Description","values":["Bounded-exhaustive testing is an automated testing methodology that checks the code under test for all inputs within given bounds: first the user describes a set of test inputs and provides test oracles that can check test outputs; then a tool generates all the test inputs, executes them on the code under test, and checks the test outputs; finally the user inspects the failing tests to submit bug reports. The costs of bounded-exhaustive testing include machine time for test generation and execution (which translates into human time waitingfor these results) and human time for inspection of results. We propose and evaluate three orthogonal techniques that reduce these costs. Sparse Test Generation skips the generation of some test inputs to reduce the time taken to reach the first failing test. Structural Test Merging generates a smaller number of larger test inputs (rather than a larger number of smaller test inputs) to reduce test generation and execution time. Oracle-based Test Clustering groups failing tests to reduce the inspection time. Results obtained from the bounded-exhaustive testing of the Eclipse refactoring engine show that these three techniques can substantially reduce the costs without significantly sacrificing fault-detection capability.","Item withdrawn by Mark Zulauf (zulauf@illinois.edu) on 2010-07-19T15:13:34Z Item was in collections: University of Illinois Theses & Dissertations (ID: 1) No. of bitstreams: 1 BangaloreJagannath_VilasShekhar.pdf: 547243 bytes, checksum: acb67608590458082ebbbe235968edc0 (MD5)","Made available in DSpace on 2010-08-20T18:00:17Z (GMT). No. of bitstreams: 2 BangaloreJagannath_VilasShekhar.pdf: 547243 bytes, checksum: acb67608590458082ebbbe235968edc0 (MD5) license.txt: 4065 bytes, checksum: 1022a08d664d6aa9c4d5f2a69ef0ce22 (MD5)"]},{"key":"dc:title","label":"Title","values":["Reducing the costs of bounded-exhaustive testing"]}]}],"canonical_facts":{"dc:contributor":["Agha, Gul A.","Marinov, Darko"],"dc:creator":["Bangalore Jagannath, Vilas Shekhar"],"dc:date":["2010-08-20T18:00:17Z","2010-08"],"dc:description":["Bounded-exhaustive testing is an automated testing methodology that checks the code under test for all inputs within given bounds: first the user describes a set of test inputs and provides test oracles that can check test outputs; then a tool generates all the test inputs, executes them on the code under test, and checks the test outputs; finally the user inspects the failing tests to submit bug reports. The costs of bounded-exhaustive testing include machine time for test generation and execution (which translates into human time waitingfor these results) and human time for inspection of results. We propose and evaluate three orthogonal techniques that reduce these costs. Sparse Test Generation skips the generation of some test inputs to reduce the time taken to reach the first failing test. Structural Test Merging generates a smaller number of larger test inputs (rather than a larger number of smaller test inputs) to reduce test generation and execution time. Oracle-based Test Clustering groups failing tests to reduce the inspection time. Results obtained from the bounded-exhaustive testing of the Eclipse refactoring engine show that these three techniques can substantially reduce the costs without significantly sacrificing fault-detection capability.","Item withdrawn by Mark Zulauf (zulauf@illinois.edu) on 2010-07-19T15:13:34Z Item was in collections: University of Illinois Theses & Dissertations (ID: 1) No. of bitstreams: 1 BangaloreJagannath_VilasShekhar.pdf: 547243 bytes, checksum: acb67608590458082ebbbe235968edc0 (MD5)","Made available in DSpace on 2010-08-20T18:00:17Z (GMT). No. of bitstreams: 2 BangaloreJagannath_VilasShekhar.pdf: 547243 bytes, checksum: acb67608590458082ebbbe235968edc0 (MD5) license.txt: 4065 bytes, checksum: 1022a08d664d6aa9c4d5f2a69ef0ce22 (MD5)"],"dc:identifier":["http://hdl.handle.net/2142/16865"],"dc:language":["en"],"dc:rights":["Copyright 2010 Vilas Shekhar Bangalore Jagannath"],"dc:subject":["bounded-exhaustive testing","test merging","test clustering","test selection","test generation","software testing"],"dc:title":["Reducing the costs of bounded-exhaustive testing"],"thesis:degree_discipline":["Computer Science"],"thesis:degree_level":["Thesis"],"thesis:degree_name":["M.S."],"thesis:institution_name":["University of Illinois at Urbana-Champaign"]},"updated_at":"2026-07-22T22:25:09Z"}