DETAILED ACTION
Remarks
Applicant presents a communication dated 19 May 2026 in response to the 18 February 2026 final rejection (the “Previous Action”).
Claims 1, 12 and 19 are amended. Claim 20 is cancelled. New claim 21 is added.
Claim 1-19 and 21 are pending. Claims 1, 12 and 19 are the independent claims.
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 .
Examiner Notes
Examiner cites particular columns, paragraphs, figures and line numbers in the references as applied to the claims below for the convenience of the applicant. Although the specified citations are representative of the teachings in the art and are applied to the specific limitations within the individual claim, other passages and figures may apply as well. It is respectfully requested that, in preparing responses, the applicant fully consider the references in their entirety as potentially teaching all or part of the claimed invention, as well as the context of the passage as taught by the prior art or disclosed by the examiner.
In the event the determination of the status of the application as subject to AIA 35 U.S.C. 102 and 103 (or as subject to pre-AIA 35 U.S.C. 102 and 103) is incorrect, any correction of the statutory basis for the rejection will not be considered a new ground of rejection if the prior art relied upon, and the rationale supporting the rejection, would be the same under either status.
Response to Arguments
Applicant requests withdrawal of the 101 rejections in light of the amendments but provides no further explanation. (Remarks, p. 8 last par. – p. 9 par. 1). The rejections are accordingly maintained.
Applicant’s remaining arguments are moot in view of the new ground(s) of rejection below.
Claim Objections
Claim 19 is objected to because of the following informalities:
Claim 19 refers to “providing” at line 15, which appears to be a typographical error that should perhaps read -provide- instead.
Claim Rejections - 35 USC § 101
35 U.S.C. 101 reads as follows:
Whoever invents or discovers any new and useful process, machine, manufacture, or composition of matter, or any new and useful improvement thereof, may obtain a patent therefor, subject to the conditions and requirements of this title.
Claims 1-6, 8-10, 12-17, 19 and 21 are rejected under 35 U.S.C. 101 because the claimed invention is directed to a judicial exception without significantly more.
As to claim 1, the claim recites:
a method, comprising:
receiving natural language content describing interactions with software under test;
identifying natural language instructions in the natural language content based on the interactions;
converting the natural language instructions into programming language-specific instructions that, when executed by a software testing tool, perform testing of the software under test, where the programming language-specific instructions are formatted in a programming language-specific language of the software testing tool and include operative information comprising key-value pairs for performing user interface element interactions for the software under test, wherein the key-value pairs specify how the user interface element interactions are to be performed; and
storing the programming language-specific instructions as a sequence of actions for testing the software under test.
performing, by the software testing tool, the sequence of actions on the software under test; and
providing a result of performing the sequence of actions on the software under test.
Under the broadest reasonable interpretation in light of the specification the above underlined elements recite a mental process because the elements are performable by the human mind with aid of pen and paper. For example, the human mind is capable of converting natural language instructions written on paper into programming language specific instructions also written on paper. The claim therefore recites an abstract idea.
None of the additional elements integrate the judicial exception into a practical application.
The “storing…”, “performing…” and “providing…” steps are insignificant post-solution activity at least because they only appear to be nominal or tangential additions to the claim, See M.P.E.P. § 2106.05(g). Note that performing the sequence of actions as claimed does not necessarily entail executing any of the claimed programming language instructions.
Looking at the claim limitations as an ordered combination yields the same conclusion as that reached when looking at the elements individually. Their collective function is merely to apply the abstract idea in a generic computer along with insignificant post-solution activity.
The claim does not include additional elements that amount to significantly more than the judicial exception either, for substantially the same reasons discussed above with respect to a practical application. Note that reevaluation of the extra-solution activity per step 2B does not indicate that this element is anything more than what is well-understood, routine and conventional in the field. With regard to the “storing…”, courts have recognized that electronic recordkeeping and storing information in memory are well-understood, routine and conventional. See M.P.E.P. § 2106.05(d). With regard to the “performing…” and “providing…”, performing actions against software using a software testing tool and providing a result of those actions is well-understood, routine and conventional as evidenced by the incorporation of those activities in a commercial product, Selenium. (See Paiva et al. “Test case generation based on mutations over user execution traces”, p. 1176 last par. – p. 1177 par. 1).
As to claims 2-6, the features of this claim do not add any additional elements integrating the abstract idea into a practical application or amounting to significantly more because generating the recited prompt only describes the abstract idea itself and because inputting a prompt to an artificial intelligence model and receiving output only amounts to using a generic computer to implement the abstract idea. Reference to an artificial intelligence model external to the software testing tool in claim 6 also only limits the abstract idea to a particular technological environment or field of use. See M.P.E.P. § 2106.05(h).
As to claim 8, the features of this claim do not add any additional elements integrating the abstract idea into a practical application or amounting to significantly more because they only further describe the abstract idea itself.
As to claim 9, the features of this claim does not add any additional elements integrating the abstract idea into a practical application or amounting to significantly more at least because the addition of a messaging interface merely amounts to implementing the abstract idea on a generic computer.
As to claim 10, the features of this claim does not add any additional elements integrating the abstract idea into a practical application or amounting to significantly more at least because these features only appear to be nominal or tangential additions to the claimed invention and because courts have recognized that electronic recordkeeping and storing information in memory are well-understood, routine and conventional.
As to claim 12, the claim recites:
[a] computing system, comprising:
a processing system; and
memory storing instructions that, when executed, cause the computing system to perform operations comprising:
receiving natural language content from a natural language source describing testing a software under test;
identifying, in the natural language content, natural language instructions that describe actions that can be performed against the software under test;
converting the identified natural language instructions into programming language- specific instructions that a software testing tool can perform against the software under test in a sequence, wherein the programming language-specific instructions are formatted in a programming language of the software testing tool and include operative information comprising key-value pairs for performing user interface element interactions for the software under test, wherein the key-value pairs specify how the user interface element interactions are to be performed;
storing the programming language-specific instructions as an action sequence;
performing, by the software testing tool, the sequence of actions on the software under test; and
providing a result of performing the sequence of actions on the software under test.
Similar to claim 1, the underlined elements recite a mental process because the elements are performable by the human mind with aid of pen and paper. The claim therefore recites an abstract idea.
None of the additional elements integrate the judicial exception into a practical application.
The addition of “memory storing instructions that, when executed, cause the computing system to perform” the operations amounts to mere instructions to apply the abstract idea on a generic computer. See M.P.E.P. § 2106.05(f).
The “storing…”, “performing…” and “providing…” steps are insignificant post-solution activity at least because they only appear to be nominal or tangential additions to the claim, See M.P.E.P. § 2106.05(g). Note that performing the sequence of actions as claimed does not necessarily entail executing any of the claimed programming language instructions.
Looking at the claim limitations as an ordered combination yields the same conclusion as that reached when looking at the elements individually. Their collective function is merely to apply the abstract idea in a generic computer along with insignificant post-solution activity.
The claim does not include additional elements that amount to significantly more than the judicial exception either, for substantially the same reasons discussed above with respect to a practical application. Note that reevaluation of the extra-solution activity per step 2B does not indicate that this element is anything more than what is well-understood, routine and conventional in the field. With regard to the “storing…”, courts have recognized that electronic recordkeeping and storing information in memory are well-understood, routine and conventional. See M.P.E.P. § 2106.05(d). With regard to the “performing…” and “providing…”, performing actions against software using a software testing tool and providing a result of those actions is well-understood, routine and conventional as evidenced by its incorporation in a commercial product, Selenium. (See Paiva et al. “Test case generation based on mutations over user execution traces”, p. 1176 last par. – p. 1177 par. 1).
As to claim 13, the features of this claim do not add any additional elements integrating the abstract idea into a practical application or amounting to significantly more because they only further describe the abstract idea itself.
As to claims 14-17, the features of this claim do not add any additional elements integrating the abstract idea into a practical application or amounting to significantly more because generating the recited information and converting of instructions only describes the abstract idea itself and because inputting information to an artificial intelligence model and receiving output only amounts to using a generic computer component to implement the abstract idea.
As to claim 19, the claim recites:
[a] software testing tool, comprising:
a processing system; and
memory storing instructions that, when executed, cause the software testing tool to:
receive natural language content describing interactions with a software under test;
identify, using natural language processing, natural language instructions in the natural language content based on the described interactions; and
convert the natural language instructions into programming language-specific instructions, wherein the programming language-specific instructions are formatted in a programming language of the software testing tool and include operative information comprising key-value pairs comprising operative information for performing user interface element interactions for the software under test, wherein the key-value pairs specify how the user interface element interactions are to be performed;
test the software under test by performing the sequence of actions; and
providing a result of performing the sequence of actions on the software under test.
Similar to claim 1, the underlined element recite a mental process because the elements are performable by the human mind with aid of pen and paper. The claim therefore recites an abstract idea.
None of the additional elements integrate the judicial exception into a practical application.
The addition of a “testing tool”, “processing system” and “memory stoting instructions that, when executed, cause the software testing tool to” perform the operations amounts to mere instructions to apply the abstract idea on a generic computer. See M.P.E.P. § 2106.05(f).
The “testing…” and “providing” steps are insignificant post-solution activity at least because they only appear to be nominal or tangential additions to the claim, See M.P.E.P. § 2106.05(g). Note that testing as claimed does not necessarily entail executing any the programming language instructions.
Looking at the claim limitations as an ordered combination yields the same conclusion as that reached when looking at the elements individually. Their collective function is merely to apply the abstract idea in a generic computer along with insignificant post-solution activity.
The claim does not include additional elements that amount to significantly more than the judicial exception either, for substantially the same reasons discussed above with respect to a practical application. Note that reevaluation of the extra-solution activity per step 2B does not indicate that this element is anything more than what is well-understood, routine and conventional in the field. Testing by performing a sequence of actions using a software testing tool and providing a result of those actions is well-understood, routine and conventional as evidenced by its incorporation in a commercial product, Selenium. (See Paiva et al. “Test case generation based on mutations over user execution traces”, p. 1176 last par. – p. 1177 par. 1).
As to claim 21, the features of this claim do not add any additional elements integrating the abstract idea into a practical application or amounting to significantly more because they only further describe the abstract idea itself.
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 1-3, 8-9, 12-15, 17, 19 and 21 are rejected under 35 U.S.C. 103 as being unpatentable over Srivastava et al. (US 2024/0419578) (art made of record – hereinafter Srivastava) in view of Paiva et al., “Test case generation based on mutations over user execution traces” (art made of record – hereinafter Paiva).
As to claim 1, Srivastava discloses a method, comprising:
receiving natural language content describing interactions with software under test; (e.g., Srivastava, par. [0034]: the natural language request to perform the testing action for the application; par. [0061]: such requests are typically requests to perform a testing action in a user interface of an application; abstract: intents in the request; par. [0055]: intents such as field entry, button press, and the like)
identifying, natural language instructions in the natural language content based on the interactions; (e.g., Srivastava, abstract: a natural language processing model can recognize intents in the request [which is natural language, see above]; par. [0055]: intents such as field entry, button press, and the like)
converting the natural language instructions into programming language-specific instructions that, when executed by a software testing tool, perform testing of the software under test, (e.g., Srivastava, par. [0099]: a machine learning model to generate predictions based on input testing requests. An intent and user interface control indications can be predicted. The predictions are used to generate executable code to carry out the request; par. [0050]: the request can comprise multiple testing actions, and the executable code can perform multiple testing actions; abstract: to execute executable code to perform the requested testing actions; par. [0253]: instructions for the software [testing tool] implementing one or more innovations described herein) where the programming instructions are formatted in a programming language-specific language of the software testing tool; (e.g., Srivastava, par. [0150]: examples of executable statements are shown with reference to python and selenium statements; par. [0154]: in practice, other languages can be used. In embodiments generating scripts, the script can be in any number of languages) and
storing the programming language-specific instructions as a sequence of actions for testing the software under test (e.g., Srivastava; par. [0091]: statements that are subsequently executed, either immediately or stored for later execution; par. [0050]: the executable code can perform the multiple testing actions; par. [0145]: the fourth example involves multiple step execution (“Create Sales Order…and click Save”)
performing, by the software tool, the sequence of actions on the software under test; (e.g., Srivastava, par. [0034]: tool 170 executes executable code 180 to carry out the natural language request to perform the testing action [or sequence of actions, see above]; par. [0061]: to perform a testing action in a user interface of an application; par. [0094]: the technologies allow a tester to immediately begin testing an application) and
providing a result of performing the sequence of actions on the software under test (e.g., Srivastava, par. [0021]: results of testing can then be shared after execution of the requested actions)
Srivastava does not explicitly disclose wherein the programming language-specific instructions include operative information comprising key-value pairs for performing user interface elements interactions for the software under test, wherein the key-value pairs specify how user interface element interactions are performed.
However, in an analogous art, Paiva discloses:
wherein the programming language-specific instructions include operative information comprising key-value pairs for performing user interface elements interactions for the software under test, wherein the key-value pairs specify how the user interface element interactions are to be performed (e.g., Paiva, p. 1176 Listing 1, p. 1175 last par: each test case was stored as a JSON file as an array of JSON objects [programming specific instrictions]—each one representing a single step [interaction]. These steps are actions performed by the user on a web element [user interface element] and contain the necessary information to reproduce it. Listing 1 shows the structure of one such JSON file [see Listing, it comprises key-value pairs. The text before each colon of each line is a key, the text after it is the value]; p. 1176 par. 3: in the drag and drop action, the value contains the Xpath of the second object. This object corresponds to the place where the first object (pointed to by the path field) will be dropped; p. 1176 par. 2: to execute each test case, we developed a script that is capable of taking the test cases and transform them into Java files that—together with the Selenium Framework—are capable of executing the test steps in a browser; p. 1175 par. 7: these test cases are converted into test scripts for being executed over the web application under test).
It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify the language-specific instructions of Srivastava to include key-value pairs comprising operative information for performing user interface elements interactions for the software under test, wherein the key-value pairs specify how the user interface element interactions are to be performed as taught by Paiva, as Paiva would provide the advantages of a means of providing a test format that is less fragile and easier to read and maintain. (See, e.g., US 2011/0258600 at par. [0015] and [0028]).
As to claim 2, Srivastava/Paiva discloses the method of claim 1 (see rejection of claim 1 above), Srivastava further discloses wherein identifying the natural language instructions comprises:
generating a prompt including the natural language content and a request to identify actions that can be performed against the software under test; (e.g., Srivastava, abstract: a user can specify a request for one or more testing actions. A natural language processing model can recognize intents in the request; par. [0034]: the natural language request) and
providing the prompt as input to an artificial intelligence model (e.g., Srivastava, par. [0046]: inputting the request to the natural language processing model; par. [0042]: a natural language processing model with deep learning).
As to claim 3, Srivastava/Paiva discloses the method of claim 2 (see rejection of claim 2 above), Srivastava further discloses further comprising, including, in the prompt, at least one of:
examples of the actions that can be performed against the software under test; or
natural language metadata that describe the actions that can be performed against the software under test (e.g., Srivastava, par. [0061]: requests to perform a testing action in a user interface of an application; abstract: a natural language processing model can recognize intents in the request; par. [0055]: intents such as field entry, button press, check value and the like can be supported)
As to claim 8, Srivastava/Paiva discloses the method of claim 1 (see rejection of claim 1 above), Srivastava further discloses wherein receiving the natural language content comprises at least one of:
receiving a code update submission corresponding to a change made to source code of the software under test;
receiving a comment included in the source code;
receiving manually-authored instructions for testing the software under test;
a design document for the software under test; or
receiving a project management specification for the software under test (e.g., Srivastava, par. [0034]: a user interface control indicator appearing in the request 140).
As to claim 9, Srivastava/Paiva discloses the method of claim 1 (see rejection of claim 1 above), Srivastava further discloses:
wherein receiving the natural language content comprises receiving a message via a messaging interface (e.g., Srivastava, par. [0031]: a user interface of a digital assistant that receives the request 140)
As to claim 12, Srivastava discloses:
a computing system, comprising: a processing system; (e.g., Srivastava, Fig. 11 and associated text) and
memory storing instructions that, when executed, cause the computing system to perform operations (e.g., Srivastava, par. [0251]: the memory 1120, 1125 stores software 1180 implementing one or more innovation described herein, in the form of instructions suitable for execution by processing unit(s) 1110, 1115)
receiving natural language content from a natural language source describing testing a software under test; (e.g., Srivastava, par. [0034]: the natural language request to perform the testing action for the application; par. [0061]: such requests are typically requests to perform a testing action in a user interface of an application; abstract: intents in the request; par. [0055]: intents such as field entry, button press, and the like)
identifying, in the natural language content, natural language instructions that describe actions that can be performed against the software under test; (e.g., Srivastava, abstract: a natural language processing model can recognize intents in the request [which is natural language, see above]; par. [0055]: intents such as field entry, button press, and the like; par. [0061]: such requests are typically requests to perform a testing action in a user interface of an application)
converting the identified natural language instructions into programming language-specific instructions that a software testing tool can perform against the software under test (e.g., Srivastava, par. [0099]: a machine learning model to generate predictions based on input testing requests. An intent and user interface control indications can be predicted. The predictions are used to generate executable code to carry out the request; par. [0050]: the request can comprise multiple testing actions, and the executable code can perform multiple testing actions; abstract: to execute executable code to perform the requested testing actions; par. [0253]: instructions for the software [testing tool] implementing one or more innovations described herein) in a sequence, par. [0050]: the executable code can perform the multiple testing actions; par. [0145]: the fourth example involves multiple step execution (“Create Sales Order…and click Save”) wherein the programming language-specific instructions are formatted in a programming language of the software testing tool; (e.g., Srivastava, par. [0150]: examples of executable statements are shown with reference to python and selenium statements; par. [0154]: in practice, other languages can be used. In embodiments generating scripts, the script can be in any number of languages) and
storing the programming language-specific instructions as an action sequence (e.g., Srivastava; par. [0091]: statements that are subsequently executed, either immediately or stored for later execution; par. [0050]: the executable code can perform the multiple testing actions; par. [0145]: the fourth example involves multiple step execution (“Create Sales Order…and click Save”)
performing by the software tool, the sequence of actions on the software under test; (e.g., Srivastava, par. [0034]: tool 170 executes executable code 180 to carry out the natural language request to perform the testing action [or sequence of actions, see above]; par. [0061]: to perform a testing action in a user interface of an application; par. [0094]: the technologies allow a tester to immediately begin testing an application) and
providing a result of performing the sequence of actions on the software under test; (e.g., Srivastava, par. [0021]: results of testing can then be shared after execution of the requested actions).
Strivastava does not explicitly disclose wherein the programming language-specific instructions include operative information comprising key-value pairs for performing user interface element interactions for the software under test, wherein the key-value pairs specify how the user interface element interactions are to be performed.
However, in an analogous art, Paiva discloses:
wherein the programming language-specific instructions include operative information comprising key-value pairs for performing user interface element interactions for the software under test wherein the key-value pairs specify how the user interface element interactions are to be performed (e.g., Paiva, p. 1176 Listing 1, p. 1175 last par: each test case was stored as a JSON file as an array of JSON objects [programming specific instructions]—each one representing a single step [interaction]. These steps are actions performed by the user on a web element [user interface element] and contain the necessary information to reproduce it. Listing 1 shows the structure of one such JSON file [see Listing, it comprises key-value pairs. The text before each colon of each line is a key, the text after it is the value]; p. 1176 par. 3: in the drag and drop action, the value contains the Xpath of the second object. This object corresponds to the place where the first object (pointed to by the path field) will be dropped; p. 1176 par. 2: to execute each test case, we developed a script that is capable of taking the test cases and transform them into Java files that—together with the Selenium Framework—are capable of executing the test steps in a browser; p. 1175 par. 7: these test cases are converted into test scripts for being executed over the web application under test).
It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify the language-specific instructions of Srivastava to include key-value pairs comprising operative information for performing user interface elements interactions for the software under test, wherein the key-value pairs specify how the user interface element interactions are to be performed as taught by Paiva, as Paiva would provide the advantages of a means of providing a test format that is less fragile and easier to read and maintain. (See, e.g., US 2011/0258600 at par. [0015] and [0028]).
As to claim 13, Srivastava/Paiva discloses the computing system of claim 12 (see rejection of claim 12 above), Srivastava further discloses wherein the natural language source includes at least one of: a message; (e.g., Srivastava, par. [0031]: a user interface of a digital assistant that receives the request 140)
a code update submission corresponding to a change made to source code of the software under test;
a comment included in the source code;
manually-authored instructions for testing the software under test;
a project management specification for the software under test; or
a design document.
As to claim 14, Srivastava/Paiva discloses the computing system of claim 12 (see rejection of claim 12 above), Srivastava further discloses wherein identifying the natural language instructions that describe actions that can be performed against the software under test comprises generating an input for an artificial intelligence model, wherein the input includes the natural language content and a request for the artificial intelligence model to identify the natural language instructions describing the actions that can be performed against the software under test (e.g., Srivastava, par. [0034]: the natural language request; abstract: a user can specify a request for one or more testing actions. A natural language processing model [artificial intelligence model] can recognize intents in the request; par. [0045]: intent identifiers are output from the natural language processing model based on the request; par. [0055]: intents such as field entry, button press, and the like; par. [0061]: to perform a testing action in a user interface of an application [software under test]).
As to claim 15, Srivastava/Paiva discloses the computing system of claim 14 (see rejection of claim 14 above), Srivastava further discloses wherein the input further comprises:
examples of the actions that can be performed against the software under test; (e.g., Srivastava, par. [0141]: FIG. 10 us a walkthrough of different natural language request; par. [0145]: the fourth example involves multi step execution (“Create Sales Order with Customer 103001, Order Type OR, one Material TG0011 with quantity 10 and Plant 1010, and click Save”). There are multiple intents, First, for an “appname” intent, “Create Sales Order” is recognized as an object (application name). The application “Create Sales Order” can be launched or given focus. Next, a variety of values for fields are provided. Finally, for “click Save”, the intent is recognized as “button” and the value is “Save” (control indication) [launching or giving focus to an application, entering values into fields and clicking buttons being actions]) and
natural language metadata that describe the actions (see above, the name of the application, values to enter and button to click describe the actions noted).
As to claim 17, Srivastava/Paiva discloses the computing system of claim 14 (see rejection of claim 14 above), Srivastava further discloses the operations further comprising:
providing the input to the artificial intelligence model; (e.g., Srivastava, par. [0031]: a user can submit a natural language testing action request 140 to the model 150)
in response to the input, receiving an output from the artificial intelligence model, wherein the output includes the identified natural language instructions; (e.g., Srivastava, a natural language processing model [artificial intelligence model] can recognize intents in the request; par. [0045]: intent identifiers are output from the natural language processing model based on the request; par. [0055]: intents such as field entry, button press, check value, and the like can be supported) and
converting the identified natural language instructions into the programming language-specific instructions (e.g., Srivastava, par. [0034]: the intent identifiers 160 are accepted by the code generation tool 170, which executes executable code 180 to carry out the request to perform the testing action; par. [0150]: choosing an executable statement type based on the intent identifier).
As to claim 19, Srivastava discloses: a software testing tool, (e.g., Srivastava, par. [0251]: software 1180 [a software testing tool] implementing one or more innovation described herein, in the form of instructions) comprising:
a processing system; (e.g., Srivastava, Fig. 11 and associated text) and
memory storing instructions that, when executed, cause the software testing tool (e.g., Srivastava, par. [0251]: the memory 1120, 1125 stores software 1180 implementing one or in the form of instructions suitable for execution by processing unit(s) 1110, 1115) to:
receive natural language content describing interactions with a software under test; (e.g., Srivastava, par. [0034]: the natural language request to perform the testing action for the application; par. [0061]: such requests are typically requests to perform a testing action in a user interface of an application; abstract: intents in the request; par. [0055]: intents such as field entry, button press, and the like)
identify, using natural language processing, natural language instructions in the natural language content based on the described interactions; (e.g., Srivastava, abstract: a natural language processing model can recognize intents in the request [which is natural language, see above]; par. [0055]: intents such as field entry, button press, and the like) and
convert the natural language instructions into programming language-specific instructions, wherein the programming language-specific instructions are formatted in a programming language of the software testing tool (e.g., Srivastava, par. [0099]: a machine learning model to generate predictions based on input testing requests. An intent and user interface control indications can be predicted. The predictions are used to generate executable code to carry out the request; par. [0050]: the request can comprise multiple testing actions, and the executable code can perform multiple testing actions; abstract: to execute executable code to perform the requested testing actions; par. [0253]: instructions for the software [testing tool] implementing one or more innovations described herein)
test the software under test by performing the sequence of actions; (e.g., Srivastava, par. [0034]: tool 170 executes executable code 180 to carry out the natural language request to perform the testing action [or sequence of actions, see above]; par. [0061]: to perform a testing action in a user interface of an application; par. [0094]: the technologies allow a tester to immediately begin testing an application) and
providing a result of performing the sequence of actions on the software under test (e.g., Srivastava, par. [0021]: results of testing can then be shared after execution of the requested actions).
Srivastava does not explicitly disclose: the programming language-specific instruction include operative information comprising key-value pairs comprising operative information for performing user interface element interactions for the software under test, wherein the key-value pairs specify how the user interface element interactions are to be performed.
However, in an analogous art, Paiva discloses:
the programming language-specific instruction include operative information comprising key-value pairs comprising operative information for performing user interface element interactions for the software under test, wherein the key-value pairs specify how the user interface element interactions are to be performed (e.g., Paiva, p. 1176 Listing 1, p. 1175 last par: each test case was stored as a JSON file as an array of JSON objects [programming specific instrictions]—each one representing a single step [interaction]. These steps are actions performed by the user on a web element [user interface element] and contain the necessary information to reproduce it. Listing 1 shows the structure of one such JSON file [see Listing, it comprises key-value pairs. The text before each colon of each line is a key, the text after it is the value]; p. 1176 par. 3: in the drag and drop action, the value contains the Xpath of the second object. This object corresponds to the place where the first object (pointed to by the path field) will be dropped; p. 1176 par. 2: to execute each test case, we developed a script that is capable of taking the test cases and transform them into Java files that—together with the Selenium Framework—are capable of executing the test steps in a browser; p. 1175 par. 7: these test cases are converted into test scripts for being executed over the web application under test).
It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify the programming language-specific instructions of Srivastava to include key-value pairs comprising operative information for performing user interface elements interactions for the software under test, wherein the key-value pairs specify how the user interface element interactions are to be performed as taught by Paiva, as Paiva would provide the advantages of a means of providing a test format that is less fragile and easier to read and maintain. (See, e.g., US 2011/0258600 at par. [0015] and [0028]).
As to claim 21, Srivastava/Paiva discloses the method of claim 1 (see rejection of claim 1 above) but Srivastava does not explicitly disclose wherein the key-value pairs comprise: a first key-value pair relating to a first action of a first interaction of the user interface element interactions and a second key-value pair specifying a second action of the first interaction.
However, in an analogous art, Paiva discloses wherein the key-value pairs comprise:
a first key-value pair relating to a first action of a first interaction of the user interface element interactions; (e.g., Paiva, p. 1175 last par.: each test case was recorded as a sequence of steps performed by the user and stored as JSON file as an array of JSON objects—each one representing a single step; p. 1176 Listing 1: JSON structure of a test case containing two steps: an input and a click which represents a simple search on the website; p. 1176 par. 3: in the drag and drop action, the value field [key] contains the Xpath [value] of the second object. This object corresponds to the place where the first object (pointed to by the path field [second key, i.e., of a second key-value pair]) will be dropped) and
a second key-value pair specifying a second action of the first interaction (see immediately above).
It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify the programming language-specific instructions of Srivastava to include key-value pairs comprising a first key-value pair relating to a first action of a first interaction of the user interface element interactions and a second key-value pair specifying a second action of the first interaction, as taught by Paiva, as Paiva would provide the advantages of a means of providing a test format that is less fragile and easier to read and maintain (see, e.g., US 2011/0258600 at par. [0015] and [0028]) and a means of recording behaviors such as drag and drop in such a format. (See Paiva, p. 1176 par. 3).
Claim 4 is rejected under 35 U.S.C. 103 as being unpatentable over Srivastava (US 2024/0419578) in view of Paiva (“Test case generation based on mutations over user execution traces”) in further view of Hecking-Harbusch et al. (US 2025/0130928) (art of record – hereinafter Harbusch).
As to claim 4, Srivastava/Paiva discloses the method of claim 2 (see rejection of claim 2 above) but does not explicitly disclose wherein the prompt further includes a request to convert the identified natural language instructions into the programming language-specific instructions.
However, in an analogous art, Harbusch discloses:
wherein the prompt further includes a request to convert the identified natural language instructions into the programming language-specific instructions (e.g., Harbusch, par. [0030]: the last least test case 40 can comprise a natural language text. The test case [identified natural language instructions] can describe the scenario of how the code or the software is to be tested; par. [0050]: the test code [programming language-specific instructions] can be written in the same programming language as the code; par. [0036]: the prompt can comprise an instruction to the large language model (LLM) directed to generating at least one test case and at least one test code; par. [0058]: generating, via a machine learning model 31, a test code 50 [programming language specific instructions] based on the at least one test case 40 [identified natural language instructions]; par. [0003]: a test code can implement the test cases and thus makes them executable).
It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify the prompting of an artificial intelligence model and converting of identified natural language instructions into programming instructions of Srivastava/Paiva such that the prompt further includes a request to convert the identified natural language instructions into the programming language-specific instructions, as taught by Harbusch, as Harbusch would provide the advantage of a means of generating the code using the machine learning model, which can learn to generate better results over time. (See Harbusch, par. [0018]). Performing the conversion using a machine learning model would also avoid also the need for pre-written templates or statements to perform the request actions.
Claim 5 is rejected under 35 U.S.C. 103 as being unpatentable over Srivastava (US 2024/0419578) in view of Paiva (“Test case generation based on mutations over user execution traces”) in further view of Trummer (US 2024/028122) (art of record – hereinafter Trummer).
As to claim 5, Srivastava/Paiva discloses the method of claim 2 (see rejection of claim 2 above), but does not explicitly disclose wherein the prompt further includes examples of the programming language-specific instructions that correspond to the natural language instructions.
However, in an analogous art, Trummer discloses:
wherein the prompt further includes examples of the programming language-specific instructions that correspond to the natural language (e.g., Trummer, par. [0056]: receiving natural language input in association with a database query; par. [0057]: to decompose the at least one database query into a sequence of steps formulated using natural language; par. [0058]: system 102 generates one or more prompts for application to the AI system 110 by interleaving the processing steps with user-provided instructions of the natural language input; par. [0059]: applying the prompts to the AI system 110 for generation of the database code therefrom; par. [0116]: at run time, a specified number of samples is randomly selected and included in the prompt; par. [0170]: those samples consist of the prompt previously provided as well as the code generated in response to that prompt; par. [0073]: embodiments are configured to generate database code in various types of programming languages).
It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify the prompt of Srivastava to include examples of the programming language-specific instructions that correspond to the natural language as taught by Trummer, as Trummer would provide the advantage of a means of generating the code using an AI model and increasing the probability of doing so successfully. (See Trummer, pars. [0115-0116]). Using an AI model to generate the code would avoid also avoid the need for pre-written executable code statements or templates.
Claim 6 is rejected under 35 U.S.C. 103 as being unpatentable over Srivastava (US 2024/0419578) in view of Paiva (“Test case generation based on mutations over user execution traces”) in further view of Guttridge et al. (US 2025/0077682) (art of record – hereinafter Guttridge) and Harbusch (US 2025/0130928).
As to claim 6, Srivastava/Paiva discloses the method of claim 2 (see rejection of claim 2 above), but does not explicitly disclose wherein: generating the prompt comprises generating a first prompt; and converting the identified natural language instructions into the programming language instructions comprises: providing the first input prompt as a first input into a first artificial intelligence model that is external to the software testing tool, in response to the first input, receiving a first output from the first artificial intelligence model, wherein the first output includes identified natural language instructions; generating a second prompt; including, in the second prompt, the identified natural language instructions and a request to convert the identified natural language instructions into the programming language-specific instructions; providing the second prompt as a second input for a second artificial intelligence model; and in response to the second input, receiving a second output from the second artificial intelligence model, wherein the second output includes the programming language-specific instructions.
However, in an analogous art, Harbusch discloses wherein:
generating the prompt comprises generating a first prompt; (e.g., Harbusch, par. [0036]: the prompt 20 [necessarily generated]) and
converting the identified natural language instructions into the programming language-specific instructions (see below) comprises:
providing the first prompt as a first input into a first artificial intelligence model (e.g., Harbusch, par. [0036]: the prompt 20 can comprise a natural language instruction to the machine learning model 30)
in response to the first input, receiving a first output from the first artificial intelligence model, wherein the first output includes identified natural language instructions; (e.g., Harbusch, par. [0036]: the prompt can comprise a linguistic instruction to the large language model (LLM) directed to generating the at least one test case; par. [0039]: one or more test cases can be generated at least based on the prompt; par. [0030]: the last least test case 40 can comprise a natural language text. The test case can describe the scenario of how the code or the software is to be tested)
generating a second prompt; (e.g., Harbusch, par. [0058]: a further prompt 21)
including, in the second prompt, the identified natural language instructions and a request to convert the identified natural language instructions into the programming language-specific instructions; (e.g., Harbusch, par. [0060]: the further prompt can comprise a linguistic instruction to generate one or more test codes based on the at least one test case [natural language instructions]; par. [0050]: the at least one predetermined test code can be written in the same programming language as the code)
providing the second prompt as a second input for a second artificial intelligence model; (e.g., Harbusch, par. [0097]: machine learning model 30 and/or the further machine learning model 31 [second artificial intelligence model]; par. [0060]: the further prompt 21[second prompt] can comprise or be a natural language instruction to the machine learning model 31)
in response to the second input, receiving a second output from the second artificial intelligence model, wherein the second output includes the programming language-specific instructions (e.g., Harbusch, par [0060]: the further prompt can comprise a linguistic instruction to the large language model (LLM) directed to generate one or more test codes for testing the code; par. [0050]: the test code can be written in the same programming language as the code).
It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify the prompting of an artificial intelligence model and converting of identified natural language instructions into programming instructions of Srivastava/Paiva to include generating a first prompt; providing the first prompt as a first input into a first artificial intelligence model; in response to the first input, receiving a first output from the first artificial intelligence model, wherein the first output includes identified natural language instructions; generating a second prompt; including, in the second prompt, the identified natural language instructions and a request to convert the identified natural language instructions into the programming language-specific instructions; providing the second prompt as a second input for a second artificial intelligence model; and in response to the second input, receiving a second output from the second artificial intelligence model, wherein the second output includes the programming language-specific instructions, as taught by Harbusch, as Harbusch would provide the advantage of a means of performing the identification of natural language instructions and conversion using models specifically adapted to those applications. (See Harbusch, par. [0085]). Performing the conversion using a machine learning model would avoid also the need for pre-written templates or statements to perform the request actions.
Further, in an analogous art, Guttridge discloses:
a first artificial intelligence model that is external to the software testing tool; (e.g., Guttridge, Fig. 2 and associated text AI engine 222 may retrieve the model from the repository 223 and deploy the model within a live runtime environment; Fig. 5A and associated text [see figure, GenAI model 524 is external to testing software 522]; Fig. 1A and associated text [see figure, GenAI model 120 is external to test execution service 130 and frameworks 141-144]).
It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify the first artificial intelligence model and software testing tool of Srivastava/Paiva/Harbusch such that it is external to the software testing tool, as taught by Guttridge, as Guttridge would provide the advantage of a means of utilizing different models or test frameworks. (See Guttridge, par. [0055]).
Claim 7, 10-11 and 18 are rejected under 35 U.S.C. 103 as being unpatentable over Srivastava (US 2024/0419578) in view of Paiva (“Test case generation based on mutations over user execution traces”) in further view of Guttridge (US 2025/0077682).
As to claim 7, Srivastava/Paiva discloses the method of claim 1 (see rejection of claim 1 above) but does not explicitly disclose wherein an artificial intelligence model is trained on training data including recorded actions performed against the software under test, the training data comprising: respective programming language-specific instructions for each recorded action; and natural language metadata describing the recorded action.
However, in an analogous art, Guttridge discloses:
wherein an artificial intelligence model is trained on training data including recorded actions performed against the software under test, the training data comprising: respective programming language-specific instructions for each recorded action; and natural language metadata describing the recorded action (e.g., Guttridge, par. [0032]: creating tests from natural language descriptions; par. [0070]: a user may input a software test description, such as the requirements; par. [0082]: the requirements may include a description of activities to be performed to carry out the test [natural language metadata]; par. [0083]: the GenAI model 524 may generate a sequence of steps [recorded actions]; par. [0092]: the steps may be used to build an automation script; par. [0091]: a generative artificial intelligence (GenAI) model 624 capable of generating an automation script [programming-language specific instructions for each recorded action] for execution of the software test based on inputs; par. [0063]: the training process may use results that have already been generated/output by the GenAI model [i.e., the automation script and steps] in a live environment to retrain the model; par. [0058]: the log may include an identifier of the input [the natural language metadata above]. This information may be used to subsequently retrain the model).
It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify the artificial intelligence model of Srivastava such that it is trained on training data including recorded actions performed against the software under test, the training data comprising: respective programming language-specific instructions for each recorded action; and natural language metadata describing the recorded action, as taught by Guttridge, as Guttridge would provide the advantages of a means for the artificial intelligence model to learn to generate the executable code (see Guttridge, par. [0038]) and a means for the model to learn from past results. (See Guttridge, par. [0058]). Using an AI model to generate the code would also avoid the need for pre-written executable code statements or templates.
As to claim 10, Srivastava/Paiva discloses the method of claim 1 (see rejection of claim 1 above), but does not explicitly disclose further comprising in response to performing the sequence of actions on the software under test, receiving action telemetry data recorded about each action in the sequence of actions performed against the software under test, the action telemetry data including: respective programming language-specific instructions for each recorded action; and natural language metadata describing each recorded action.
However, in an analogous art, Guttridge discloses further comprising:
performing the sequence of actions against the software under test; (e.g., Guttridge, par. [0082]: activities to be performed to carry out the test; par. [0088]: automation script 564, which automates execution of the software test on the software program; par. [0094]: a step 642, a step 644, which are to be performed by the script [and those steps include actions, see figure]) and
in response to performing the sequence of actions on the software under test, receiving action telemetry data recorded about each action in the sequence of actions performed against the software under test, (see below) the action telemetry data including:
respective programming language-specific instructions for each recorded action; (e.g., Guttridge, par. [0048]: the GenAI model may generate automation scripts; par. [0129]: generating the automation script in the predefined programming language; par. [0110]: the testing software 822 may log the testing results in a log; par. [0058]: the output provided by the model. The log may include an identifier of the output. This information may be used to subsequently retrain the model; par. [0066]: the script 326 may input the additional training data sets into the GenAI model to continue to train the model [so the model receives the output as training data, and the output includes programming language-specific instructions that perform actions. This is in response to performing the actions, because the retraining occurs after execution (i.e., performing actions, see immediately above)]) and
natural language metadata describing each recorded action (e.g., Guttridge par. [0070]: a user may input a software test description, such as the requirements; par. par. 0074]: For example, if the query is “Describe the Requirements of the Test” and the response is “The test should check to make sure that the 16-digit input field on the GUOI can only accept 16 digits” [i.e., the requirements are natural language and describe the actions of the test]’ par. [0058]: the log may include an identifier of the input. This information may be used to subsequently retrain the model; par. [0066]: the script 326 may input the additional training data sets into the GenAI model to continue to train the model [so the model receives the input as training data, and the input includes natural language metadata describing the recorded action]).
It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify the artificial intelligence model of Srivastava/Paiva to include performing the sequence of actions against the software under test and in response to that performing, receiving action telemetry data recorded about each action in the sequence of actions performed against the software under test, the action telemetry data including respective programming language-specific instructions for each recorded action and natural language metadata describing each recorded action, as taught by Guttridge, as Guttridge would provide the advantages of a means of acquiring additional data for training the artificial intelligence model. (see Guttridge, par. [0058]) and a means of training the model to generate the executable code. (See Guttridge, par. [0038]). Using an AI model to generate the code would also avoid the need for pre-written executable code statements or templates.
As to claim 11, Srivastava/Paiva/Guttridge discloses the method of claim 10 (see rejection of claim 10 above), but Srivastava/Paiva does not explicitly disclose further comprising using the action telemetry data as training data for an artificial intelligence model.
However, in an analogous art, Guttridge discloses:
further comprising using the action telemetry data as training data for an artificial intelligence model e.g., Guttridge, par. [0063]: the training process may use results that have already been generated by the GenAI model [i.e., the automation script noted above with respect to claim 10] in a live environment to retrain the model; par. [0058]: the log may include an identifier of the input [the natural language metadata noted above with respect to claim 10]. This information may be used to subsequently retrain the model).
It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify the artificial intelligence model of Srivastava/Paiva to include using action telemetry data as training data for the artificial intelligence model, as taught by Guttridge, as Guttridge would provide the advantages of a means for the artificial intelligence model to learn to generate the tests (see Guttridge, par. [0038]) and a means for the artificial intelligence model to learn from test results. (See Guttridge, par. [0063]).
As to claim 18, Srivastava/Paiva discloses the computing system of claim 12 (see rejection of claim 12 above), but does not explicitly disclose further comprising: receiving, in response to executing the programming language-specific instructions against the software under test, action telemetry data recorded for each action in the action sequence, the action telemetry data including: respective programming language-specific instructions for each recorded action; and natural language metadata describing each recorded action; and training an artificial intelligence model to identify the natural language instructions that describe the actions that can be performed against the software under test using training data including the action telemetry data.
However, in an analogous art, Guttridge discloses further comprising:
receiving, in response to executing the programming language-specific instructions against the software under test, action telemetry data recorded for each action in the action sequence, (e.g., Guttridge, par. [0082]: activities to be performed to carry out the test; par. [0137]: executing tests on a software application; par. [0058]: information may be added to the results of execution and stored within a log 22. The log may include an identifier of the input, an identifier of the output. This information may be used to subsequently retrain the model; par. [0063]: the training process may use results that have already been generated/output by the GenAI model in a live environment to retrain the model; par. [0066]: the script may input the training data sets into the GenAI model 322).
the action telemetry data including:
respective programming language-specific instructions for each recorded action; (e.g., Guttridge, par. [0092]: the steps may be used to build an automation script [programming-language specific instructions for each recorded action]; par. [0091]: a generative artificial intelligence (GenAI) model 624 capable of generating an automation script [i.e., the script is output of the model, which is used to retrain it after executing the tests as noted above]) and
natural language metadata describing each recorded action; (e.g., Guttridge, par. [0070]: a user may input a software test description, such as the requirements; par. [0082]: the requirements may include a description of activities to be performed to carry out the test [natural language metadata]; par. [0058]: the log may include an identifier of the input. This information may be used to subsequently retrain the model) and
training an artificial intelligence model to identify the natural language instructions that describe the actions that can be performed against the software under test using training data including the action telemetry data (e.g., Guttridge, par. [0066]: the script may input the training data sets [which includes the telemetry data, see above] into the GenAI model 322; Fig. 5B and associated text, par. [0083]: the GenAI model 524 may generate a sequence of steps, including steps 542, 544, 546 and 548 [see figure, the steps are actions performed against the software under test]).
It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify the artificial intelligence model of Srtivastava/Paiva to include receiving, in response to executing the programming language-specific instructions against the software under test, action telemetry data recorded for each action in the action sequence, the action telemetry data including: respective programming language-specific instructions for each recorded action; and natural language metadata describing each recorded action; and training the artificial intelligence model to identify the natural language instructions that describe the actions that can be performed against the software under test using training data including the action telemetry data, as taught by Guttridge, as Guttridge would provide the advantages of a means for the artificial intelligence model to learn to generate the programming language-specific instructions (see Guttridge, par. [0038]) and a means for the artificial intelligence model to learn from test results. (See Guttridge, par. [0058]). Using an AI model to generate the code would also avoid the need for pre-written executable code statements or templates.
Claim 16 is rejected under 35 U.S.C. 103 as being unpatentable over Srivastava (US 2024/0419578) in view of Paiva (“Test case generation based on mutations over user execution traces”) in further view of Harbusch (US 2025/0130928) and Trummer (US 2024/028122).
As to claim 16, Srivastava/Paiva discloses the computing system of claim 15 (see rejection of claim 15 above), but does not explicitly disclose wherein the input further comprises: a request to convert the identified natural language instructions into the programming language-specific instructions; and example programming language-specific instructions that correspond to the natural language metadata.
However, in an analogous art, Harbusch discloses wherein the input further comprises:
a request to convert the identified natural language instructions into the programming language-specific instructions; (e.g., Harbusch, par. [0030]: the last least test case 40 can comprise a natural language text. The test case [identified natural language instructions] can describe the scenario of how the code or the software is to be tested; par. [0050]: the test code [programming language-specific instructions] can be written in the same programming language as the code; par. [0036]: the prompt can comprise an instruction to the large language model (LLM) directed to generating at least one test case and at least one test code; par. [0058]: generating, via a machine learning model 31, a test code 50 [programming language specific instructions] based on the at least one test case 40 [identified natural language instructions]; par. [0003]: a test code can implement the test cases and thus makes them executable).
It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify the prompting of an artificial intelligence model and converting of identified natural language instructions into programming instructions of Srivastava/Paiva such that the prompt further includes a request to convert the identified natural language instructions into the programming language-specific instructions, as taught by Harbusch, as Harbusch would provide the advantage of a means of generating the code using the machine learning model, which can learn to generate better results over time. (See Harbusch, par. [0018]). Performing the conversion using a machine learning model would also avoid also the need for pre-written templates or statements to perform the request actions.
Further, in an analogous art, Trummer discloses wherein the input further comprises:
example programming language-specific instructions that correspond to the natural language metadata (e.g., Trummer, par. [0056]: receiving natural language input in association with a database query; par. [0057]: to decompose the at least one database query into a sequence of steps formulated using natural language; par. [0058]: system 102 generates one or more prompts for application to the AI system 110 by interleaving the processing steps with user-provided instructions of the natural language input; par. [0059]: applying the prompts to the AI system 110 for generation of the database code therefrom; par. [0116]: at run time, a specified number of samples is randomly selected and included in the prompt; par. [0170]: those samples consist of the prompt previously provided as well as the code generated in response to that prompt; par. [0073]: embodiments are configured to generate database code in various types of programming languages).
It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify the prompt of Srivastava/Paiva/Harbusch to include example programming language-specific instructions that correspond to the natural language metadata as taught by Trummer, as Trummer would provide the advantage of a means of increasing the probability of successfully generating code. (See Trummer, pars. [0115-0116]).
Conclusion
Any inquiry concerning this communication or earlier communications from the examiner should be directed to TODD AGUILERA whose telephone number is (571)270-5186. The examiner can normally be reached M-F 11AM - 7:30PM EST.
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, Hyung S Sough can be reached at (571)272-6799. 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.
/TODD AGUILERA/Primary Examiner, Art Unit 2192
Prosecution Insights