DETAILED ACTION
Notice of Pre-AIA or AIA Status
The present application, filed on or after March 16, 2013, is being examined under the first inventor to file provisions of the AIA .
This Office Action is in response to Request for Continued Examination filed on November 19, 2025.
Claims 9 and 12-16 are pending.
Claims 9, 14 and 15 have been amended.
Claims 10-11 has been canceled.
Response to Amendment
Claim Rejections - 35 USC § 103
The following is a quotation of 35 U.S.C. 103 which forms the basis for all obviousness rejections set forth in this Office action:
A patent for a claimed invention may not be obtained, notwithstanding that the claimed invention is not identically disclosed as set forth in section 102, if the differences between the claimed invention and the prior art are such that the claimed invention as a whole would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to which the claimed invention pertains. Patentability shall not be negated by the manner in which the invention was made.
Claims 9 and 13-16 are rejected under 35 U.S.C. 103 as being unpatentable over Christian Holler et al. (“Fuzzing with Code Fragments”, 2012) in view of Fugate et al. (US 2020/0356468) in view of Gustavo Grieco et al. (“QuickFuzz: An Automatic Random Fuzzer for Common File Formats”, 2016) and in further view of Eddington et al. (US 2015/0309914).
With respect to Claim 9, Christian Holler et al. disclose:
carrying out multiple test runs, in each test run of the multiple test runs: (running multiple tests within a single shell and multiple tests executed in a row, 4.3 Running Tests, Paragraph 3, lines 4-13)
selecting a base test input from a set of base test inputs that are predefined for the test run, (given a code base (set of base test inputs), selecting a combination of code fragments to generate a new program (selecting base test input), 1 Introduction, Paragraph 4, lines 7-14) each base test input specifying a composition of computer program modules; (LangFuzz will use and recombine fragments of the provided test suite (each base test input specifying a composition of computer program modules) to generate new programs, 1. Introduction, Paragraph 4, lines 7-14)
changing the base test input for a test input [randomly]; (randomly pick some of the fragments during parsing and replace them with other fragments of the same type, 3.1 Code mutation, Paragraph 1, lines 15-17)
[generating] the program code of the computer program to form a version of the computer program in a composition made up of the computer program modules that is given by the changed test input; (LangFuzz will use and recombine fragments of the provided test suite to generate new programs wherein several fragments of the new program (mutated test) are randomly selected for replacement (changed test input), 1. Introduction, Paragraph 4, lines 7-14 and 4 The LangFuzz Implementation, Paragraph 3, lines 2-10)
testing the version of the computer program; (the mutated test is executed and its result is checked, 4 The LangFuzz Implementation, Paragraph 3, lines 10-11)
ascertaining an increase in a value of a [test metric] that is achieved by the test of the version of the computer program; (detecting a problematic input from executing the mutated test such as memory corruptions (e.g. garbage collection problems) (an increase in value of a test metric), 4.3 Running Tests, Paragraph 3, lines 1-13)
and adding the changed test input as a base test input to the set of base test inputs for subsequent test runs, as a function of the increase in the value of the [test metric]. (LangFuzz reuses previously failed/problematic programs to generate new programs by reusing and recombining fragments from the code base (adding the changed test input as a base test input) and by a recombination of previously problematic inputs, there is a higher chance that new problems are identified, 1 Introduction, Paragraph 4, lines 8-14)
Christian Holler et al. do not explicitly disclose:
specifying a composition of computer program modules by setting one or more of precompiler switches, macros, or inline functions in program code of the computer program
[test metric] is a test coverage metric, wherein the test coverage metric is a test coverage that has been achieved by the carried out test runs of the multiple test runs
[randomly] is a function of an output of a random number generator
[generating] is compiling
However, Fugate et al. disclose:
specifying a composition of computer program modules by setting one or more of precompiler switches, macros, or inline functions in program code of the computer program (the variants of the computer program contain the same features as the original computer program. However, the variants may contain additional instructions, different instructions, or the same instructions in a different location within the computer program (one or more of precompiler switches, macros, or inline functions in program code), Paragraph 19; custom decorators may be added to the source code of the original program to limit or restrict the application of transformations to specific regions of the computer program (one or more of precompiler switches, macros, or inline functions in program code), Paragraph 49)
[test metric] is a test coverage metric, wherein the test coverage metric is a test coverage that has been achieved by the carried out test runs of the multiple test runs (As additional tests are run and as additional variants are tested, code coverage will tend to increase until either all code is covered, a prescribed proportion of the code is covered by the tests, or performing additional tests against additional variants does not increase code coverage (test coverage) above a minimum amount of increase on a per test or per variant prescribed amount (test coverage metric/test coverage), Paragraph 24)
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teaching of Fugate et al. into the teaching of Christian Holler et al. to include specifying a composition of computer program modules by setting one or more of precompiler switches, macros, or inline functions in program code of the computer program and [test metric] is a test coverage metric, wherein the test coverage metric is a test coverage that has been achieved by the carried out test runs of the multiple test runs in order to help uncover unknown or unreachable defects in the computer program such as race conditions, use-before-initialization, use-after-free, pointer mis-use and reflection defects. (Fugate et al., Paragraph 19)
Christian Holler et al. and Fugate et al. do not disclose:
[randomly] is a function of an output of a random number generator
[generating] is compiling
However, Gustavo Grieco et al. disclose:
[randomly] is a function of an output of a random number generator (constructing randomized structured data using a random number generator, 2.1 High-Level Fuzzing, Paragraph 1, lines 5)
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teaching of Gustavo Grieco et al. into the teaching of Christian Holler et al. and Fugate et al.to include [randomly] is a function of an output of a random number generator in order to help construct randomized structured data compositionally and/or allows for the creation of unique, nonuniform and random data. (Gustavo Grieco et al., 2.1 High-Level Fuzzing, Paragraph 1, lines 5)
Christian Holler et al., Fugate et al. and Gustavo Grieco et al. do not disclose:
[generating] is compiling
However, Eddington et al. disclose:
[generating] is compiling (generating a third code segment (fuzzed code segment) by compiling code into an executable file, Paragraph 118, Claim 17)
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teaching of Eddington et al. into the teaching of Christian Holler et al., Fugate et al. and Gustavo Grieco et al.to include [generating] is compiling in order to generate machine code from source code which can be executed by a computer.
With respect to Claim 13, all the limitations of Claim 9 have been addressed above; and Christian Holler et al. further disclose:
wherein the testing of the version of the computer program includes multiple test runs using random or pseudorandom test inputs. (LangFuzz runs multiple tests within a single shell and multiple test executed in a row, 4.3 Running Tests, Paragraph 3, lines 4-13; LangFuzz utilizes both generative and mutative fuzz testing wherein mutative involves new testing inputs derived from existing data by randomly modifying it (random or pseudorandom test inputs), 3 How LangFuzz Works, Paragraph 1, lines 1-5)
With respect to Claim 14, Christian Holler et al. disclose:
the test system including one or more multiple computers and being configured to: (using LangFuzz allows for black-box fuzz testing implemented on a Mozilla JavaScript interpreter (one or more multiple computers), Abstract)
carry out multiple test runs, in each test run of the multiple test runs: (running multiple tests within a single shell and multiple tests executed in a row, 4.3 Running Tests, Paragraph 3, lines 4-13)
select a base test input from a set of base test inputs that are predefined for the test run, (given a code base (set of base test inputs), selecting a combination of code fragments to generate a new program (selecting base test input), 1 Introduction, Paragraph 4, lines 7-14) each base test input specifying a composition of computer program modules; (LangFuzz will use and recombine fragments of the provided test suite (each base test input specifying a composition of computer program modules) to generate new programs, 1. Introduction, Paragraph 4, lines 7-14)
change the base test input for a test input [randomly]; (randomly pick some of the fragments during parsing and replace them with other fragments of the same type, 3.1 Code mutation, Paragraph 1, lines 15-17)
[generate] the program code of the computer program to form a version of the computer program in a composition made up of the computer program modules that is given by the changed test input, (LangFuzz will use and recombine fragments of the provided test suite to generate new programs wherein several fragments of the new program (mutated test) are randomly selected for replacement (changed test input), 1. Introduction, Paragraph 4, lines 7-14 and 4 The LangFuzz Implementation, Paragraph 3, lines 2-10) wherein the base test inputs specify from which computer program modules the version of the computer program is compiled; (code fragments are selected from a given/provided code base/suite of failed programs (specify from which computer program module) to generate new programs (version of the computer program is compiled), 1 Introduction, Paragraph 4, lines 7-14)
test the version of the computer program; (the mutated test is executed and its result is checked, 4 The LangFuzz Implementation, Paragraph 3, lines 10-11)
ascertain an increase in a value of a [test metric] that is achieved by the test of the version of the computer program; (detecting a problematic input from executing the mutated test such as memory corruptions (e.g. garbage collection problems) (an increase in value of a test metric), 4.3 Running Tests, Paragraph 3, lines 1-13)
and add the changed test input as a base test input to the set of base test inputs for subsequent test runs, as a function of the increase in the value of the [test metric]. (LangFuzz reuses previously failed/problematic programs to generate new programs by reusing and recombining fragments from the code base (adding the changed test input as a base test input) and by a recombination of previously problematic inputs, there is a higher chance that new problems are identified, 1 Introduction, Paragraph 4, lines 8-14)
Christian Holler et al. do not explicitly disclose:
specifying a composition of computer program modules by setting one or more of precompiler switches, macros, or inline functions in program code of the computer program
[test metric] is a test coverage metric, wherein the test coverage metric is a test coverage that has been achieved by the carried out test runs of the multiple test runs
[randomly] is a function of an output of a random number generator
[generate] is compile
However, Fugate et al. disclose:
specifying a composition of computer program modules by setting one or more of precompiler switches, macros, or inline functions in program code of the computer program (the variants of the computer program contain the same features as the original computer program. However, the variants may contain additional instructions, different instructions, or the same instructions in a different location within the computer program (one or more of precompiler switches, macros, or inline functions in program code), Paragraph 19; custom decorators may be added to the source code of the original program to limit or restrict the application of transformations to specific regions of the computer program (one or more of precompiler switches, macros, or inline functions in program code), Paragraph 49)
[test metric] is a test coverage metric, wherein the test coverage metric is a test coverage that has been achieved by the carried out test runs of the multiple test runs (As additional tests are run and as additional variants are tested, code coverage will tend to increase until either all code is covered, a prescribed proportion of the code is covered by the tests, or performing additional tests against additional variants does not increase code coverage (test coverage) above a minimum amount of increase on a per test or per variant prescribed amount (test coverage metric/test coverage), Paragraph 24)
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teaching of Fugate et al. into the teaching of Christian Holler et al. to include specifying a composition of computer program modules by setting one or more of precompiler switches, macros, or inline functions in program code of the computer program and [test metric] is a test coverage metric, wherein the test coverage metric is a test coverage that has been achieved by the carried out test runs of the multiple test runs in order to help uncover unknown or unreachable defects in the computer program such as race conditions, use-before-initialization, use-after-free, pointer mis-use and reflection defects. (Fugate et al., Paragraph 19)
Christian Holler et al. and Fugate et al. do not disclose:
[randomly] is a function of an output of a random number generator
[generate] is compile
However, Gustavo Grieco et al. disclose:
[randomly] is a function of an output of a random number generator (constructing randomized structured data using a random number generator, 2.1 High-Level Fuzzing, Paragraph 1, lines 5)
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teaching of Gustavo Grieco et al. into the teaching of Christian Holler et al. and Fugate et al.to include [randomly] is a function of an output of a random number generator in order to help construct randomized structured data compositionally and/or allows for the creation of unique, nonuniform and random data. (Gustavo Grieco et al., 2.1 High-Level Fuzzing, Paragraph 1, lines 5)
Christian Holler et al., Fugate et al. and Gustavo Grieco et al. do not disclose:
[generate] is compile
However, Eddington et al. disclose:
[generate] is compile (generating a third code segment (fuzzed code segment) by compiling code into an executable file, Paragraph 118, Claim 17)
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teaching of Eddington et al. into the teaching of Christian Holler et al., Fugate et al. and Gustavo Grieco et al.to include [generate] is compile in order to generate machine code from source code which can be executed by a computer.
With respect to Claim 15, Christian Holler et al. disclose:
carrying out multiple test runs, in each test run of the multiple test runs: (running multiple tests within a single shell and multiple tests executed in a row, 4.3 Running Tests, Paragraph 3, lines 4-13)
selecting a base test input from a set of base test inputs that are predefined for the test run, (given a code base (set of base test inputs), selecting a combination of code fragments to generate a new program (selecting base test input), 1 Introduction, Paragraph 4, lines 7-14) each base test input specifying a composition of computer program modules; (LangFuzz will use and recombine fragments of the provided test suite (each base test input specifying a composition of computer program modules) to generate new programs, 1. Introduction, Paragraph 4, lines 7-14)
changing the base test input for a test input [randomly]; (randomly pick some of the fragments during parsing and replace them with other fragments of the same type, 3.1 Code mutation, Paragraph 1, lines 15-17)
[generating] the program code of the computer program to form a version of the computer program in a composition made up of the computer program modules that is given by the changed test input, (LangFuzz will use and recombine fragments of the provided test suite to generate new programs wherein several fragments of the new program (mutated test) are randomly selected for replacement (changed test input), 1. Introduction, Paragraph 4, lines 7-14 and 4 The LangFuzz Implementation, Paragraph 3, lines 2-10) wherein the base test inputs specify from which computer program modules the version of the computer program is compiled; (code fragments are selected from a given/provided code base/suite of failed programs (specify from which computer program module) to generate new programs (version of the computer program is compiled), 1 Introduction, Paragraph 4, lines 7-14)
testing the version of the computer program; (the mutated test is executed and its result is checked, 4 The LangFuzz Implementation, Paragraph 3, lines 10-11)
ascertaining an increase in a value of a [test metric] that is achieved by the testing the version of the computer program; (detecting a problematic input from executing the mutated test such as memory corruptions (e.g. garbage collection problems) (an increase in value of a test metric), 4.3 Running Tests, Paragraph 3, lines 1-13)
and adding the changed test input as a base test input to the set of base test inputs for subsequent test runs, as a function of the increase the value of the [test metric]. (LangFuzz reuses previously failed/problematic programs to generate new programs by reusing and recombining fragments from the code base (adding the changed test input as a base test input) and by a recombination of previously problematic inputs, there is a higher chance that new problems are identified, 1 Introduction, Paragraph 4, lines 8-14)
Christian Holler et al. do not explicitly disclose:
specifying a composition of computer program modules by setting one or more of precompiler switches, macros, or inline functions in program code of the computer program
[test metric] is a test coverage metric, wherein the test coverage metric is a test coverage that has been achieved by the carried out test runs of the multiple test runs
[randomly] is a function of an output of a random number generator
[generating] is compiling
However, Fugate et al. disclose:
specifying a composition of computer program modules by setting one or more of precompiler switches, macros, or inline functions in program code of the computer program (the variants of the computer program contain the same features as the original computer program. However, the variants may contain additional instructions, different instructions, or the same instructions in a different location within the computer program (one or more of precompiler switches, macros, or inline functions in program code), Paragraph 19; custom decorators may be added to the source code of the original program to limit or restrict the application of transformations to specific regions of the computer program (one or more of precompiler switches, macros, or inline functions in program code), Paragraph 49)
[test metric] is a test coverage metric, wherein the test coverage metric is a test coverage that has been achieved by the carried out test runs of the multiple test runs (As additional tests are run and as additional variants are tested, code coverage will tend to increase until either all code is covered, a prescribed proportion of the code is covered by the tests, or performing additional tests against additional variants does not increase code coverage (test coverage) above a minimum amount of increase on a per test or per variant prescribed amount (test coverage metric/test coverage), Paragraph 24)
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teaching of Fugate et al. into the teaching of Christian Holler et al. to include specifying a composition of computer program modules by setting one or more of precompiler switches, macros, or inline functions in program code of the computer program and [test metric] is a test coverage metric, wherein the test coverage metric is a test coverage that has been achieved by the carried out test runs of the multiple test runs in order to help uncover unknown or unreachable defects in the computer program such as race conditions, use-before-initialization, use-after-free, pointer mis-use and reflection defects. (Fugate et al., Paragraph 19)
Christian Holler et al. and Fugate et al. do not disclose:
[randomly] is a function of an output of a random number generator
[generating] is compiling
However, Gustavo Grieco et al. disclose:
[randomly] is a function of an output of a random number generator (constructing randomized structured data using a random number generator, 2.1 High-Level Fuzzing, Paragraph 1, lines 5)
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teaching of Gustavo Grieco et al. into the teaching of Christian Holler et al. and Fugate et al.to include [randomly] is a function of an output of a random number generator in order to help construct randomized structured data compositionally and/or allows for the creation of unique, nonuniform and random data. (Gustavo Grieco et al., 2.1 High-Level Fuzzing, Paragraph 1, lines 5)
Christian Holler et al., Fugate et al. and Gustavo Grieco et al. do not disclose:
[generating] is compiling
However, Eddington et al. disclose:
[generating] is compiling (generating a third code segment (fuzzed code segment) by compiling code into an executable file, Paragraph 118, Claim 17)
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teaching of Eddington et al. into the teaching of Christian Holler et al., Fugate et al. and Gustavo Grieco et al.to include [generating] is compiling in order to generate machine code from source code which can be executed by a computer.
With respect to Claim 16, all the limitations of Claim 9 have been addressed above; and Christian Holler et al. further disclose:
wherein the base test inputs specify from which computer program modules the version of the computer program is compiled. (code fragments are selected from a given/provided code base/suite of failed programs (specify from which computer program module) to generate new programs (version of the computer program is compiled), 1 Introduction, Paragraph 4, lines 7-14)
Claim 12 is rejected under 35 U.S.C. 103 as being unpatentable over Christian Holler et al. (“Fuzzing with Code Fragments”, 2012) in view of Fugate et al. (US 2020/0356468) in view of Gustavo Grieco et al. (“QuickFuzz: An Automatic Random Fuzzer for Common File Formats”, 2016) in view of Eddington et al. (US 2015/0309914) in view of Liu et al. (US 2020/0183814) and in further view of Dickenson et al. (US 2008/0052695).
With respect to Claim 12, all the limitations of Claim 9 have been addressed above; and Christian Holler et al., Fugate et al., Gustavo Grieco et al. and Eddington et al. do not disclose:
wherein a registration is performed if for a changed base test input, the program code of the computer program cannot be compiled to form a version of the computer program in a composition made up of computer program modules that is given by the changed test input, and a search is made for a version of the computer program in a composition, made up of a fewest possible computer program modules and/or a least possible program code, that is compiled and that is error-free.
However, Liu et al. disclose:
wherein a registration is performed if for a changed base test input, the program code of the computer program cannot be compiled to form a version of the computer program in a composition made up of computer program modules that is given by the changed test input, (after identifying a program P and modifying and mutating the inputs to convert the program to P’ (changed base test input), compilation errors are detected such as “Compiling Error on legal input program” and presented for review (registration), Paragraph 37)
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teaching of Liu et al. into the teaching of Christian Holler et al., Fugate et al., Gustavo Grieco et al. and Eddington et al. to include wherein a registration is performed if for a changed base test input, the program code of the computer program cannot be compiled to form a version of the computer program in a composition made up of computer program modules that is given by the changed test input in order to perform fuzz testing which can provide in-depth testing capability to capture bugs that would crash or paralyze a server or other hardware. (Liu et al., Paragraph 37, lines 15-18)
Christian Holler et al., Fugate et al., Gustavo Grieco et al., Eddington et al. and Liu et al. do not disclose:
a search is made for a version of the computer program in a composition, made up of a fewest possible computer program modules and/or a least possible program code, that is compiled and that is error-free
However, Dickenson et al. disclose:
a search is made for a version of the computer program in a composition, made up of a fewest possible computer program modules and/or a least possible program code, that is compiled and that is error-free. (after a compiler error is detected, source code modifier identifies suspect code and the source code is change to edit/remove the suspect code (fewest possible computer program modules and/or the least possible program code) and the compiler successfully recompiles the code (error-free), Paragraphs 29-30)
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate the teaching of Dickenson et al. into the teaching of Christian Holler et al., Fugate et al., Gustavo Grieco et al., Eddington et al. and Liu et al. to include a search is made for a version of the computer program in a composition, made up of a fewest possible computer program modules and/or a least possible program code, that is compiled and that is error-free in order to isolate an error and perform error correction upon detecting a compilation error. (Dickenson et al., Paragraph 2)
Response to Arguments
Applicant’s arguments with respect to claim(s) 9 and 12-16 have been considered but are moot because the new ground of rejection does not rely on any reference applied in the prior rejection of record for any teaching or matter specifically challenged in the argument.
Conclusion
Any inquiry concerning this communication or earlier communications from the examiner should be directed to LANNY N UNG whose telephone number is (571)270-7708. The examiner can normally be reached Mon-Thurs 6am-4pm.
Examiner interviews are available via telephone, in-person, and video conferencing using a USPTO supplied web-based collaboration tool. To schedule an interview, applicant is encouraged to use the USPTO Automated Interview Request (AIR) at http://www.uspto.gov/interviewpractice.
If attempts to reach the examiner by telephone are unsuccessful, the examiner’s supervisor, Bradley Teets can be reached at 571-272-3338. The fax phone number for the organization where this application or proceeding is assigned is 571-273-8300.
Information regarding the status of published or unpublished applications may be obtained from Patent Center. Unpublished application information in Patent Center is available to registered users. To file and manage patent submissions in Patent Center, visit: https://patentcenter.uspto.gov. Visit https://www.uspto.gov/patents/apply/patent-center for more information about Patent Center and https://www.uspto.gov/patents/docx for information about filing in DOCX format. For additional questions, contact the Electronic Business Center (EBC) at 866-217-9197 (toll-free). If you would like assistance from a USPTO Customer Service Representative, call 800-786-9199 (IN USA OR CANADA) or 571-272-1000.
/LANNY N UNG/Examiner, Art Unit 2197