DETAILED ACTION
Claims 1-20 are pending. Claims 1, 7 and 14 have been amended.
The present application, filed on or after March 16, 2013, is being examined under the first inventor to file provisions of the AIA .
This non-final office action is in response to the applicant’s response received on 07/13/2026, for the final office action mailed on 02/13/2026.
Examiner’s Notes
Examiner has cited particular columns and line numbers, paragraph numbers, or figures 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 from the applicant, in preparing the responses, to fully consider the references in 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.
Continued Examination Under 37 CFR 1.114
A request for continued examination under 37 CFR 1.114, including the fee set forth in 37 CFR 1.17(e), was filed in this application after final rejection. Since this application is eligible for continued examination under 37 CFR 1.114, and the fee set forth in 37 CFR 1.17(e) has been timely paid, the finality of the previous Office action has been withdrawn pursuant to 37 CFR 1.114. Applicant's submission filed on 07/13/2026 has been entered.
Response to Arguments
Applicant's arguments filed 07/13/2026 regarding rejection made under 35 U.S.C. § 103 have been fully considered but they are moot in view of new ground(s) rejection.
Claim Rejections - 35 USC § 103
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 (i.e., changing from AIA to pre-AIA ) 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.
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.
Claim(s) 1-3 are rejected under 35 U.S.C. 103 as being unpatentable over Merritt (US-PAT-NO: 11,868,242 B1), in further view of Klafter et al. (US-PGPUB-NO: 2025/0156634 A1) hereinafter Klafter, Lin et al. (US-PGPUB-NO: 2025/0245131 A1) hereinafter Lin, Singh et al. (US-PAT-NO: 11,899,566 B1) hereinafter Singh and Bhat et al. (US-PGPUB-NO: 2020/0097388 A1) hereinafter Bhat.
As per claim 1, Merritt teaches a system for using machine learning to predict tests for testing application programming interface updates, the system comprising: one or more processors; and one or more memories configured to store instructions that when executed by the one or more processors perform operations comprising (see Merritt [column 9,lines 17-21], “The apparatus 200 may include a processor 204, a memory 202, input/output circuitry 206, communications circuitry 208, API test selection circuitry 210, API test execution circuitry 212, and API test prediction circuitry 214”): receiving a prediction request to predict one or more tests for testing a candidate update to an application programming interface, wherein the prediction request comprises at least one identifier of the application programming interface (see Merritt [column 11, lines 18-20], “API test prediction circuitry 214 includes hardware configured to predict, based upon learned components of an input API, the most effective tests to execute on the API”); determining, using at least the one identifier of the application programming interface, a plurality of parameters associated with the application programming interface, wherein the plurality of parameters is obtained from one or more parameter sources (see Merritt [column 12, lines 32-40], “The API exploratory bot 302 automatically discovers and/or documents API specifications as shown in step 314. For example, the API exploratory bot 302 is configured to act as a crawler through the provided API (e.g., through the executable API file), to find and learn API descriptions. API descriptions include elements that describe the API and its functionality, such as endpoints and parameters used in operations (e.g., requests and responses) involving the endpoints”); obtain a prediction of a plurality of tests to be executed for the candidate update to the application programming interface, (see Merritt [column 12, lines 20-29], “Once the source file is provided to BigML, the BigML platform is configured to prepare a plurality of datasets that BigML will use to create a predictive model. Datasets are transformed raw data from the source file that is ready to be used by the BigML platform. In an example embodiment, test heuristics/patterns may be replaced with more recent information, thereby increasing the level of test effectiveness and efficiency. Thus, the test heuristics/patterns may be periodically updated to reflect the recent predictive modeling changes”); determining, a first subset of the plurality of tests enabled to be executed without user input (see Merritt [column 15, lines 12-14], “In some example embodiments, the test heuristics/pattern repository 116 may provide test patterns and test heuristics automatically”) and a second subset of the plurality of tests that are not enabled to be executed without the user input (see Merritt [column 15, lines 14-17], “Alternatively or additionally, a test engineer 304, via client devices, may choose specific test heuristics and patterns to import to the predictive API evaluation system 114”); and executing the first subset of the plurality of tests without the user input (see Merritt [column 15-16, lines 64-5], “In an instance when a hypothesis is contradicted, the predictive API evaluation system 114 automatically assess one or more of API calls used during execution of the test suite, inputs, operations, actual results, expected results, performance metrics, and test heuristics used and/or output to determine and provide information about the contradicted hypothesis which, in turn, is learned and used as a basis for focused testing to identify other bugs or vulnerabilities”).
Merritt does not explicitly teach retrieving, by querying a retrieval-augmented generation (RAG) system using at least one of the plurality of parameters. However, Klafter teaches retrieving, by querying a retrieval-augmented generation (RAG) system using at least one of the plurality of parameters (see Klafter paragraph [0115-0116], “Automated web search: some embodiments may be integrated with, interface with or otherwise access a web search engine (such as for example the Google engine) and may, e.g., scrape or collect content or results associated with keywords provided in the prompt. [0116] Client database: some embodiments may include a Retrieval-Augmented Generation (RAG) process to collect knowledge from client databases”).
Merritt and Klafter are analogous art because they are in the same field of endeavor of software development. Therefore, it would have been obvious to one of ordinary skills in the art before the effective filing date of the claimed invention to modify Merritt’s teaching of selecting a test suite for an API for predictive API test suite selection with Klafter’s teaching of generating and extracting data from machine learning model outputs to incorporate the use of a retrieval augmented generator in order to provide more context to the machine learning model aside from the input parameters to receive a more thorough response/output.
Merritt modified with Klafter do not explicitly teach structured data identifying dependency relationships between the application programming interface and one or more services or application programming interfaces; inputting (a) the plurality of paramters and (b) the structured data identifying the dependency relationships between the application programming interface and the one or more services or the application programming interfaces retrieved by the RAG system as structured features into a machine learning model. However, Lin teaches structured data identifying dependency relationships between the application programming interface and one or more services or application programming interfaces (see Lin paragraph [0071], “The generation module 1062 is configured to generate the test case based on the API dependency relationship. For example, the generation module 1062 generates the API execution sequence based on the API dependency relationship, and mutates the API execution sequence with reference to a mutation strategy, including mutating one or more of an API execution sequence, an API parameter, and an API structure (oracle) in the API execution sequence, to obtain a plurality of test cases”); inputting (a) the plurality of paramters and (b) the structured data identifying the dependency relationships between the application programming interface and the one or more services or the application programming interfaces retrieved by the RAG system as structured features into a machine learning model (see Lin paragraph [0072], “In some embodiments, the intelligent generation subsystem 106 may further include an analysis module 1066 (also referred to as an analysis engine), and the analysis module 1066 is configured to analyze the response result and coverage code, to obtain an analysis result. Correspondingly, the generation module 1062 may further update the API dependency relationship and the mutation strategy through an AI model such as a reinforcement learning model or a Bayesian model based on the analysis result, where the updated API dependency relationship and the updated mutation strategy are used to generate a test case of a next round of test”).
Merritt, Klafter and Lin are analogous art because they are in the same field of endeavor of software development. Therefore, it would have been obvious to one of ordinary skills in the art before the effective filing date of the claimed invention to modify Merritt’s teaching of selecting a test suite for an API for predictive API test suite selection and Klafter’s teaching of generating and extracting data from machine learning model outputs with Lin’s teaching of cloud service test method and related device to incorporate the use of generating test case using API dependency relationship and using analysis module through an AI model to use updated API dependency relationships and mutation strategy to generate test case.
Merritt modified with Klafter and Lin do not explicitly teach wherein the machine learning model has been trained to predict, based on the plurality of parameters embedded into an embedding space of the machine learning model, the prediction of the plurality of tests; receiving, from the machine learning model, the plurality of tests as an output. However, Singh teaches wherein the machine learning model has been trained to predict, based on the plurality of parameters embedded into an embedding space of the machine learning model, the prediction of the plurality of tests (see Singh [column 12, lines 1-16], “The policy engine 254 acts as a reinforcement learning (RL) agent and interacts with the policy network 285, which can be a neural network model that is trained to approximate the policy by which the policy engine 254 acts. The policy engine 254 processes the base source code embedding(s) 202 and the target source code embedding(s) 204, using the policy network, and generates predicted test input(s) 205. For example, the policy engine 254 can utilize the currently trained parameter(s) of the policy network 285 to generate predicted test input(s) 205 that are contingent on those trained parameter(s) and the base source code embedding(s) 202 and the target source code embedding(s) 204. From the RL perspective, the base source code embedding(s) 202 and the target source code embedding(s) 204 form the state space, and the action taken by the policy engine 254 is the prediction of particular predicted test input(s) 205”) receiving, from the machine learning model, the plurality of tests as an output (see Singh [column 9, lines 5-15], “A code embedding-to-test embedding engine 154 processes the code unit embedding(s) 102 using code embedding-to-test embedding model 185, to generate predicted unit test embedding(s) 103. The code embedding-to-test embedding model 185 can be, for example, a transformer neural network model, an encoder-decoder neural network model, and/or other neural network model. In various implementations, the predicted unit test embedding(s) 103 are also in the latent space. Accordingly, in those implementations the input space and the output space, of the code embedding-to-test embedding model 185, are of the same dimension”).
Merritt, Klafter, Lin and Singh are analogous art because they are in the same field of endeavor of software development. Therefore, it would have been obvious to one of ordinary skills in the art before the effective filing date of the claimed invention to modify Merritt’s teaching of selecting a test suite for an API for predictive API test suite selection, Klafter’s teaching of generating and extracting data from machine learning model outputs and Lin’s teaching of cloud service test method and related device with Singh’s teaching of training machine learning models to automatically generate test cases for source code to incorporate the use of code embeddings to machine learning models in order to train them for predicting and generating proper test cases to use for APIs.
Merritt modified with Klafter, Lin and Singh do not explicitly teach based on run-time parameters of each test of the plurality of tests and wherein each run-time parameter is related to execution of a corresponding test of the plurality of tests. However, Bhat teaches based on run-time parameters of each test of the plurality of tests (see Bhat paragraph [0032], “In some examples, the tests can be run automatically based on the order of priority or criticality (e.g., risk level) that is predicted for each test. In instances where the prediction information includes a predicted number of defects, the particular tests to be run automatically, the number of tests to be run, the duration of the automated testing to be performed, and/or other testing aspects may be determined automatically based on the predicted number of defects” and wherein each run-time parameter is related to execution of a corresponding test of the plurality of tests (see Bhat paragraph [0032], “For example, if the prediction information predicts that there will be N defects in the software, and less than N defects are found during a typical testing pass after a predetermined period of testing time, the automated system may run additional tests, and/or run the tests for a longer period of time, until at least the predicted number of defects are identified in the software”).
Merritt, Klafter, Lin Singh and Bhat are analogous art because they are in the same field of endeavor of software development. Therefore, it would have been obvious to one of ordinary skills in the art before the effective filing date of the claimed invention to modify Merritt’s teaching of selecting a test suite for an API for predictive API test suite selection, Klafter’s teaching of generating and extracting data from machine learning model outputs, Lin’s teaching of cloud service test method and related device and Singh’s teaching of training machine learning models to automatically generate test cases for source code with Bhat’s teaching of learning based metrics predictions for software development to incorporate the use of the duration of the automated testing being performed to predict outcomes for each test, see Bhat paragraph [0032], “In some implementations, particular action(s) are performed automatically in response to the generation of the prediction information and/or based on the particular predictions (predicted metrics) that are generated by the model(s). For example, the prediction information can be automatically provided as input to a testing framework that controls automated testing of the software produced by the software development project. Such a testing framework may operate as part of a build process to automatically test one or more built software modules. In instances where the prediction information includes a test bucket (e.g., a collection of tests to be executed against the software), the tests in the test bucket may be executed automatically after the test bucket is generated by the model(s).”
As per claim 2, Merritt modified with Klafter, Lin, Singh and Bhat teaches wherein the instructions for determining the plurality of parameters associated with the application programming interface further cause the one or more processors to perform operations comprising: receiving computer code of the application programming interface (see Singh [column 8, lines 27-29], “The code-to-embedding engine 152 processes the ground truth source code unit 101, using code-to-embedding model 180”); generating, using an embedding model trained to embed the computer code into the embedding space of the machine learning model, an embedding representing the application programming interface (see Singh [column 8, lines 29-34], “to generate code unit embedding(s) 102. For example, a single code unit embedding can be generated that embeds the entirety of the code unit or, alternatively, multiple code unit embeddings can be generated and can collectively embed the entirety of the code (while individually embedding a portion of the code)”); and adding the embedding as a parameter of the plurality of parameters (see Singh [column 10, lines 5-19], “In some implementations, the unit test embedding-to-unit test engine 158 can, in generating one or more of the predicted unit test(s), process the predicted unit test embedding(s) 113 using a neural network model trained to for use in generating predicted unit tests from predicted unit test embeddings. For example, the neural network model 190 can be trained on training instances that each include, as training instance input, an embedding of a corresponding unit test and, as training instance output, the corresponding unit test. Through training, the neural network model 190 can generate robust and accurate unit tests on the fly, including those that may not have been included in the training sets and those that are not included in the pre-stored unit tests 195 (described below)”).
As per claim 3, Merritt modified with Klafter, Lin, Singh and Bhat teaches wherein the instructions for inputting the plurality of parameters into the machine learning model to obtain the prediction of the plurality of tests further cause the one or more processors to input the embedding into the machine learning model (see Singh [column 10, lines 5-19], “In some implementations, the unit test embedding-to-unit test engine 158 can, in generating one or more of the predicted unit test(s), process the predicted unit test embedding(s) 113 using a neural network model trained to for use in generating predicted unit tests from predicted unit test embeddings. For example, the neural network model 190 can be trained on training instances that each include, as training instance input, an embedding of a corresponding unit test and, as training instance output, the corresponding unit test. Through training, the neural network model 190 can generate robust and accurate unit tests on the fly, including those that may not have been included in the training sets and those that are not included in the pre-stored unit tests 195 (described below)”).
Claim(s) 4 is rejected under 35 U.S.C. 103 as being unpatentable over Merritt (US-PAT-NO: 11,868,242 B1), Klafter (US-PGPUB-NO: 2025/0156634 A1), Lin (US-PGPUB-NO: 2025/0245131 A1), Singh (US-PAT-NO: 11,899,566 B1) and Bhat (US-PGPUB-NO: 2020/0097388 A1), in further view Khurana et al. (US-PUG-NO: 2021/0216904 A1) hereinafter Khurana.
As per claim 4, Merritt modified with Klafter, Lin, Singh and Bhat teaches generating, using an embedding model trained to embed computer code into the embedding space of the machine learning model, a plurality of embeddings representing the plurality of application programming interfaces (see Singh [column 8, lines 29-34], “to generate code unit embedding(s) 102. For example, a single code unit embedding can be generated that embeds the entirety of the code unit or, alternatively, multiple code unit embeddings can be generated and can collectively embed the entirety of the code (while individually embedding a portion of the code)”); and adding the embedding as a parameter of the plurality of parameters (see Singh [column 10, lines 5-19], “In some implementations, the unit test embedding-to-unit test engine 158 can, in generating one or more of the predicted unit test(s), process the predicted unit test embedding(s) 113 using a neural network model trained to for use in generating predicted unit tests from predicted unit test embeddings. For example, the neural network model 190 can be trained on training instances that each include, as training instance input, an embedding of a corresponding unit test and, as training instance output, the corresponding unit test. Through training, the neural network model 190 can generate robust and accurate unit tests on the fly, including those that may not have been included in the training sets and those that are not included in the pre-stored unit tests 195 (described below)”).
Merritt modified with Klafter, Lin, Singh and Bhat do not explicitly teach retrieving, from a development database, a first training dataset comprising a first plurality of tests associated with a plurality of application programming interfaces, and, from a repository, a second training dataset comprising a second plurality of tests associated with the plurality of application programming interfaces; and training the machine learning model using a training dataset comprising the first training dataset, the second training dataset, and the plurality of embeddings. However, Khurana teaches retrieving, from a development database, a first training dataset comprising a first plurality of tests associated with a plurality of application programming interfaces, and, from a repository (see Khurana paragraph [0040], “Each of the APIs may be implemented in one or more languages and interface specifications. API.sub.0 (312) provides functional support to identify and select a ML model with respect to a corresponding dataset; API.sub.1 (322) provides functional support to identify one or more features in the corresponding dataset, e.g. first dataset or training dataset”), a second training dataset comprising a second plurality of tests associated with the plurality of application programming interfaces (see Khurana paragraph [0040], “API.sub.2 (332) provides functional support for assessing a second dataset and selectively augmenting the first dataset with one or more features identified from the assessment of the second dataset”); and training the machine learning model using a training dataset comprising the first training dataset, the second training dataset, and the plurality of embeddings (see Khurana paragraph [0043], “A training machine learning (ML) model with a learning program, e.g. neural model, is identified from a library of learning programs (404). More specifically, the first structured dataset is identified for the corresponding learning task. For example, with respect to animal classification, an ML classifier may be utilized to identify and match a ML model that performs well for the corresponding classification task. Based on the ML model selection and alignment, one or more features in the first structured dataset related to performance of the selected model are identified (406). It is understood that the first structured dataset includes a plurality of data, in which some of the data may be significant or pertinent to the output generated by the selected ML model. Identifying those features in the training set directed at performance may facilitate identification and significance of data subject to assessment in a second dataset prior to augmenting the training set. Performance of the model is measured based on the composition of input in the training set (408). Accordingly, the selected model and corresponding performance is measured based upon the training set”).
Merritt, Klafter, Lin, Singh, Bhat and Khurana are analogous art because they are in the same field of software development. Therefore, it would have been obvious to one of ordinary skills in the art before the effective filing date of the claimed invention to modify Merritt’s teaching of selecting a test suite for an API for predictive API test suite selection, Klafter’s teaching of generating and extracting data from machine learning model outputs, Lin’s teaching of cloud service test method and related device, Singh’s teaching of training machine learning models to automatically generate test cases for source code and Bhat’s teaching of learning based metrics predictions for software development with Khurana’s teaching of artificial intelligence platform to improve accuracy of machine learning model outputs to incorporate the use of multiple datasets to in order to improve machine learning model output which will provide better predicted test case as taught in Merritt.
Claim(s) 5 is rejected under 35 U.S.C. 103 as being unpatentable over Merritt (US-PAT-NO: 11,868,242 B1), Klafter (US-PGPUB-NO: 2025/0156634 A1), Lin (US-PGPUB-NO: 2025/0245131 A1), Singh (US-PAT-NO: 11,899,566 B1) and Bhat (US-PGPUB-NO: 2020/0097388 A1), in further view Schaefer et al. (US-PUG-NO: 2024/0311582 A1) hereinafter Schaefer.
As per claim 5, Merritt modified with Klafter, Lin, Singh and Bhat teaches wherein the instructions further cause the one or more processors to perform operations comprising: retrieving, for a plurality of application programming interfaces, a corresponding plurality of tests, wherein each corresponding plurality of tests were performed on a corresponding application programming interface (see Merritt [column 5, lines 11-21], “For example, the server 122 may be operable to receive heuristics, APIs, and/or evaluation requests and/or selections thereof provided by the client devices 102-104. The server 122 may facilitate the prediction and selection of tests for a given API. The server 122 may include an API Prediction Module 108 for predicting the most effective tests to execute on an API, an API test Selection Module 110 for selecting a suite of tests based upon knowledge gained by the API Prediction Module 108, and an API test execution module 112 for executing any of the selected tests on the given API”).
Merritt modified with Klafter, Lin, Singh and Bhat do not explicitly teach generating a first portion of a prompt for the machine learning model that includes a command to use the plurality of application programming interfaces and each corresponding plurality of tests to inform a response from the machine learning model, wherein the machine learning model is a large language model; generating a second portion of the prompt for the machine learning model based on the application programming interface; and inputting the prompt into the large language model. However, Shaefer teaches generating a first portion of a prompt for the machine learning model that includes a command to use the plurality of application programming interfaces and each corresponding plurality of tests to inform a response from the machine learning model (see Schaefer paragraph [0028], “The first prompt 208 contains Question #1 202 which contains a description of the task and the changes from the pull request 220. Question #1 202 includes a question that asks if the change is testworthy 222 and includes a format of the answer”), wherein the machine learning model is a large language model (see Shaefer paragraph [0028], “FIG. 2 is an illustration of an exemplary conversation with the large language model for the generation of unit tests to test changes in a pull request”); generating a second portion of the prompt for the machine learning model based on the application programming interface; and inputting the prompt into the large language model (see Shaefer paragraph [0029], “The next prompt, prompt #2 210, includes Question #2 204 and prompt #1 208. Question #2 204 contains a description of the task and the structure of the repository associated with the changed file 226 and a question that asks the model where to place the tests given the directory structure with an answer format 228. The large language model responds with FILE.JS 230”).
Merritt, Klafter, Singh, Bhat and Schaefer are analogous art because they are in the same field of software development. Therefore, it would have been obvious to one of ordinary skills in the art before the effective filing date of the claimed invention to modify Merritt’s teaching of selecting a test suite for an API for predictive API test suite selection, Klafter’s teaching of generating and extracting data from machine learning model outputs, Lin’s teaching of cloud service test method and related device, Singh’s teaching of training machine learning models to automatically generate test cases for source code and Bhat’s teaching of learning based metrics predictions for software development with Shaefer’s teaching of conversational unit test generation using large language model to incorporate the use of large language models to generate unit tests for a change to a file in a pull request of a code repository to simply testing using natural language and prompting.
Claim(s) 6 is rejected under 35 U.S.C. 103 as being unpatentable over Merritt (US-PAT-NO: 11,868,242 B1), Klafter (US-PGPUB-NO: 2025/0156634 A1), Lin (US-PGPUB-NO: 2025/0245131 A1), Singh (US-PAT-NO: 11,899,566 B1) and Bhat (US-PGPUB-NO: 2020/0097388 A1), in further view Kolagatla et al. (US-PUG-NO: 2017/0293548 A1) hereinafter Kolagatla.
As per claim 6, Merritt modified with Klafter, Lin, Singh and Bhat teaches wherein the instructions further cause the one or more processors to perform operations comprising: generating an updated plurality of tests based on adding the test that is missing to the plurality of tests; generating an updated embedding from the application programming interface; and inputting the updated embedding and the updated plurality of tests into a training routine of the machine learning model to improve the machine learning model (see Merritt [column 13, lines 16-30], “For example, if an operation to get a petID comes after an operation that posts a petObject having the petID, the predictive model hypotheses or classifies a positive test run according to previous test heuristics/patterns using classification algorithms in machine learning. Should the test run provide a negative outcome, the API Exploratory Bot 302 may provide feedback that the petID should have been found from the post operation in the previous request. As will be appreciated the test suite is updated based on the learning by the predicative model and the feedback provided by the API Exploratory Bot 302. For example, based on the negative outcome in the get petID test, the test suite will run through other getID operations having a variety of data values. With time and usage, the system keeps learning and the test suite is updated”).
Merritt modified with Klafter, Lin, Singh and Bhat does not explicitly teach receiving a message indicating that a test is missing from the prediction of the plurality of tests. However, Kolagatla teaches receiving a message indicating that a test is missing from the prediction of the plurality of tests (see Kolagatla paragraph [0035], “In an example, missed test identifier engine 302 causes a display of the missing test recommendation or alert via a GUI, e.g., a dashboard display GUI or any other GUI. In an example, missed test identifier engine 302 causes a display of the missing test recommendation or alert via the GUI that is provided by display engine 202 and utilized to cause the display of the set of test application evaluation factors, and that is utilized by evaluation data engine 204 to receive the user-assigned ratings for the test application evaluation factors”).
Merritt, Klafter, Li, Singh, Bhat and Kolagatla are analogous art because they are in the same field of software development. Therefore, it would have been obvious to one of ordinary skills in the art before the effective filing date of the claimed invention to modify Merritt’s teaching of selecting a test suite for an API for predictive API test suite selection, Lin’s teaching of cloud service test method and related device, Singh’s teaching of training machine learning models to automatically generate test cases for source code and Bhat’s teaching of learning based metrics predictions for software development with Kolagatla’s teaching of software testing to determine test application effectiveness to incorporate giving a user an alert if a test is missing in order to produce more robust test cases that will have more coverage.
Claim(s) 7-10 and 14-17 are rejected under 35 U.S.C. 103 as being unpatentable over Merritt (US-PAT-NO: 11,868,242 B1), in further view of Klafter (US-PGPUB-NO: 2025/0156634 A1), Lin (US-PGPUB-NO: 2025/0245131 A1), Singh et al. (US-PAT-NO: 11,899,566 B1) hereinafter Singh, Bhat (US-PGPUB-NO: 2020/0097388 A1) and Drozhak et al. (US-PGPUB-NO: 2023/0004486 A1) hereinafter Drozhak.
As per claim 7, Merritt teaches a method for using machine learning to predict tests for testing application programming interface updates, the method comprising: receiving a prediction request to predict one or more tests for testing a candidate update to an application programming interface, wherein the prediction request comprises at least one identifier of the application programming interface (see Merritt [column 11, lines 18-20], “API test prediction circuitry 214 includes hardware configured to predict, based upon learned components of an input API, the most effective tests to execute on the API”); determining, using at least one identifier of the application programming interface, a plurality of parameters associated with the application programming interface (see Merritt [column 12, lines 32-40], “The API exploratory bot 302 automatically discovers and/or documents API specifications as shown in step 314. For example, the API exploratory bot 302 is configured to act as a crawler through the provided API (e.g., through the executable API file), to find and learn API descriptions. API descriptions include elements that describe the API and its functionality, such as endpoints and parameters used in operations (e.g., requests and responses) involving the endpoints”); obtain a prediction of a plurality of tests to be executed for the candidate update to the application programming interface, (see Merritt [column 12, lines 20-29], “Once the source file is provided to BigML, the BigML platform is configured to prepare a plurality of datasets that BigML will use to create a predictive model. Datasets are transformed raw data from the source file that is ready to be used by the BigML platform. In an example embodiment, test heuristics/patterns may be replaced with more recent information, thereby increasing the level of test effectiveness and efficiency. Thus, the test heuristics/patterns may be periodically updated to reflect the recent predictive modeling changes”); determining, a first subset of the plurality of tests enabled to be executed without user input (see Merritt [column 15, lines 12-14], “In some example embodiments, the test heuristics/pattern repository 116 may provide test patterns and test heuristics automatically”); determining, a second subset of the plurality of tests that are not enabled to be executed without user input (see Merritt [column 15, lines 14-17], “Alternatively or additionally, a test engineer 304, via client devices, may choose specific test heuristics and patterns to import to the predictive API evaluation system 114”) and executing the first subset of the plurality of tests without the user input (see Merritt [column 15-16, lines 64-5], “In an instance when a hypothesis is contradicted, the predictive API evaluation system 114 automatically assess one or more of API calls used during execution of the test suite, inputs, operations, actual results, expected results, performance metrics, and test heuristics used and/or output to determine and provide information about the contradicted hypothesis which, in turn, is learned and used as a basis for focused testing to identify other bugs or vulnerabilities”).
Merritt does not explicitly teach retrieving, by querying a retrieval-augmented generation (RAG) system using at least one of the plurality of parameters. However, Klafter teaches retrieving, by querying a retrieval-augmented generation (RAG) system using at least one of the plurality of parameters (see Klafter paragraph [0115-0116], “Automated web search: some embodiments may be integrated with, interface with or otherwise access a web search engine (such as for example the Google engine) and may, e.g., scrape or collect content or results associated with keywords provided in the prompt. [0116] Client database: some embodiments may include a Retrieval-Augmented Generation (RAG) process to collect knowledge from client databases”).
Merritt and Klafter are analogous art because they are in the same field of endeavor of software development. Therefore, it would have been obvious to one of ordinary skills in the art before the effective filing date of the claimed invention to modify Merritt’s teaching of selecting a test suite for an API for predictive API test suite selection with Klafter’s teaching of generating and extracting data from machine learning model outputs to incorporate the use of a retrieval augmented generator in order to provide more context to the machine learning model aside from the input parameters to receive a more thorough response/output.
Merritt modified with Klafter do not explicitly teach structured data identifying dependency relationships between the application programming interface and one or more services or application programming interfaces; inputting (a) the plurality of paramters and (b) the structured data identifying the dependency relationships between the application programming interface and the one or more services or the application programming interfaces retrieved by the RAG system as structured features into a machine learning model. However, Lin teaches structured data identifying dependency relationships between the application programming interface and one or more services or application programming interfaces (see Lin paragraph [0071], “The generation module 1062 is configured to generate the test case based on the API dependency relationship. For example, the generation module 1062 generates the API execution sequence based on the API dependency relationship, and mutates the API execution sequence with reference to a mutation strategy, including mutating one or more of an API execution sequence, an API parameter, and an API structure (oracle) in the API execution sequence, to obtain a plurality of test cases”); inputting (a) the plurality of paramters and (b) the structured data identifying the dependency relationships between the application programming interface and the one or more services or the application programming interfaces retrieved by the RAG system as structured features into a machine learning model (see Lin paragraph [0072], “In some embodiments, the intelligent generation subsystem 106 may further include an analysis module 1066 (also referred to as an analysis engine), and the analysis module 1066 is configured to analyze the response result and coverage code, to obtain an analysis result. Correspondingly, the generation module 1062 may further update the API dependency relationship and the mutation strategy through an AI model such as a reinforcement learning model or a Bayesian model based on the analysis result, where the updated API dependency relationship and the updated mutation strategy are used to generate a test case of a next round of test”).
Merritt, Klafter and Lin are analogous art because they are in the same field of endeavor of software development. Therefore, it would have been obvious to one of ordinary skills in the art before the effective filing date of the claimed invention to modify Merritt’s teaching of selecting a test suite for an API for predictive API test suite selection and Klafter’s teaching of generating and extracting data from machine learning model outputs with Lin’s teaching of cloud service test method and related device to incorporate the use of generating test case using API dependency relationship and using analysis module through an AI model to use updated API dependency relationships and mutation strategy to generate test case.
Merritt modified with Klafter and Lin do not explicitly teach wherein the machine learning model has been trained to predict, based on the plurality of parameters embedded into an embedding space of the machine learning model, the prediction of the plurality of tests; receiving, from the machine learning model, the plurality of tests as an output. However, Singh teaches wherein the machine learning model has been trained to predict, based on the plurality of parameters embedded into an embedding space of the machine learning model, the prediction of the plurality of tests (see Singh [column 12, lines 1-16], “The policy engine 254 acts as a reinforcement learning (RL) agent and interacts with the policy network 285, which can be a neural network model that is trained to approximate the policy by which the policy engine 254 acts. The policy engine 254 processes the base source code embedding(s) 202 and the target source code embedding(s) 204, using the policy network, and generates predicted test input(s) 205. For example, the policy engine 254 can utilize the currently trained parameter(s) of the policy network 285 to generate predicted test input(s) 205 that are contingent on those trained parameter(s) and the base source code embedding(s) 202 and the target source code embedding(s) 204. From the RL perspective, the base source code embedding(s) 202 and the target source code embedding(s) 204 form the state space, and the action taken by the policy engine 254 is the prediction of particular predicted test input(s) 205”) receiving, from the machine learning model, the plurality of tests as an output (see Singh [column 9, lines 5-15], “A code embedding-to-test embedding engine 154 processes the code unit embedding(s) 102 using code embedding-to-test embedding model 185, to generate predicted unit test embedding(s) 103. The code embedding-to-test embedding model 185 can be, for example, a transformer neural network model, an encoder-decoder neural network model, and/or other neural network model. In various implementations, the predicted unit test embedding(s) 103 are also in the latent space. Accordingly, in those implementations the input space and the output space, of the code embedding-to-test embedding model 185, are of the same dimension”).
Merritt, Klafter, Lin and Singh are analogous art because they are in the same field of endeavor of software development. Therefore, it would have been obvious to one of ordinary skills in the art before the effective filing date of the claimed invention to modify Merritt’s teaching of selecting a test suite for an API for predictive API test suite selection, Klafter’s teaching of generating and extracting data from machine learning model outputs and Lin’s teaching of cloud service test method and related device with Singh’s teaching of training machine learning models to automatically generate test cases for source code to incorporate the use of code embeddings to machine learning models in order to train them for predicting and generating proper test cases to use for APIs.
Merritt modified with Klafter, Lin and Singh do not explicitly teach based on run-time parameters of each test of the plurality of tests and wherein each run-time parameter is related to execution of a corresponding test of the plurality of tests. However, Bhat teaches based on run-time parameters of each test of the plurality of tests (see Bhat paragraph [0032], “In some examples, the tests can be run automatically based on the order of priority or criticality (e.g., risk level) that is predicted for each test. In instances where the prediction information includes a predicted number of defects, the particular tests to be run automatically, the number of tests to be run, the duration of the automated testing to be performed, and/or other testing aspects may be determined automatically based on the predicted number of defects” and wherein each run-time parameter is related to execution of a corresponding test of the plurality of tests (see Bhat paragraph [0032], “For example, if the prediction information predicts that there will be N defects in the software, and less than N defects are found during a typical testing pass after a predetermined period of testing time, the automated system may run additional tests, and/or run the tests for a longer period of time, until at least the predicted number of defects are identified in the software”).
Merritt, Klafter, Lin Singh and Bhat are analogous art because they are in the same field of endeavor of software development. Therefore, it would have been obvious to one of ordinary skills in the art before the effective filing date of the claimed invention to modify Merritt’s teaching of selecting a test suite for an API for predictive API test suite selection, Klafter’s teaching of generating and extracting data from machine learning model outputs, Lin’s teaching of cloud service test method and related device and Singh’s teaching of training machine learning models to automatically generate test cases for source code with Bhat’s teaching of learning based metrics predictions for software development to incorporate the use of the duration of the automated testing being performed to predict outcomes for each test, see Bhat paragraph [0032], “In some implementations, particular action(s) are performed automatically in response to the generation of the prediction information and/or based on the particular predictions (predicted metrics) that are generated by the model(s). For example, the prediction information can be automatically provided as input to a testing framework that controls automated testing of the software produced by the software development project. Such a testing framework may operate as part of a build process to automatically test one or more built software modules. In instances where the prediction information includes a test bucket (e.g., a collection of tests to be executed against the software), the tests in the test bucket may be executed automatically after the test bucket is generated by the model(s).”
Merritt modified with Lin, Singh and Bhat do not explicitly teach notifying one or more users of the second subset of the plurality of sets. However, Drozhak teaches notifying one or more users of the second subset of the plurality of sets (see Drozhak paragraph [0112], “The test selector 530 received predictions and insights sent from the AI model 528 for determining either deployment or selecting a test. In some embodiments, the test selector 530 automatically sends an alert to a developer (e.g., an engineer 510) regarding the decision for a test (e.g., whether a test is predicted to pass or fail, and/or whether the system recommends performing the test, automatically deploying the test, or skipping the test) according to the prediction of the test”).
Merritt, Klafter, Lin, Singh, Bhat and Drozhak are analogous art because they are in the same field of endeavor of software development. Therefore, it would have been obvious to one of ordinary skills in the art before the effective filing date of the claimed invention to modify Merritt’s teaching of selecting a test suite for an API for predictive API test suite selection, Klafter’s teaching of generating and extracting data from machine learning model outputs, Lin’s teaching of cloud service test method and related device , Singh’s teaching of training machine learning models to automatically generate test cases for source code and Bhat’s teaching of learning based metrics predictions for software development with Drozkah’s teaching of improved software testing systems to incorporate the use of an alert to alert developers about testing sets in order to reduce testing times.
As per claim 8, Merritt modified with Klafter, Lin, Singh, Bhat and Drozhak teaches wherein the plurality of parameters is embedded into an embedding space of the machine learning model using an embedding model (see Singh [column 8, lines 43-53], “The unit embedding(s) 102 and the unit test embedding(s) 105 are both in the same latent space, which can be a reduced-dimensionality (relative to the source code and unit test) space. The code-to-embedding model 180 can be trained to process source code and generate a lower-dimensional embedding thereof such that, for example, embeddings for functionally and/or semantically similar source code pairs will be close (distance-wise) to one another in the latent space while embeddings for dissimilar instances of source code pairs will be farther away from one another in the latent space”).
As per claim 9, Merritt modified with Klafter, Lin, Singh, Bhat and Drozhak teaches wherein the instructions for determining the plurality of parameters associated with the application programming interface further cause the one or more processors to perform operations comprising: receiving computer code of the application programming interface (see Singh [column 8, lines 27-29], “The code-to-embedding engine 152 processes the ground truth source code unit 101, using code-to-embedding model 180”); generating, using an embedding model trained to embed the computer code into the embedding space of the machine learning model, an embedding representing the application programming interface (see Singh [column 8, lines 29-34], “to generate code unit embedding(s) 102. For example, a single code unit embedding can be generated that embeds the entirety of the code unit or, alternatively, multiple code unit embeddings can be generated and can collectively embed the entirety of the code (while individually embedding a portion of the code)”); and adding the embedding as a parameter of the plurality of parameters (see Singh [column 10, lines 5-19], “In some implementations, the unit test embedding-to-unit test engine 158 can, in generating one or more of the predicted unit test(s), process the predicted unit test embedding(s) 113 using a neural network model trained to for use in generating predicted unit tests from predicted unit test embeddings. For example, the neural network model 190 can be trained on training instances that each include, as training instance input, an embedding of a corresponding unit test and, as training instance output, the corresponding unit test. Through training, the neural network model 190 can generate robust and accurate unit tests on the fly, including those that may not have been included in the training sets and those that are not included in the pre-stored unit tests 195 (described below)”).
As per claim 10, Merritt modified with Klafter, Lin, Singh, Bhat and Drozhak teaches wherein the instructions for inputting the plurality of parameters into the machine learning model to obtain the prediction of the plurality of tests further cause the one or more processors to input the embedding into the machine learning model (see Singh [column 10, lines 5-19], “In some implementations, the unit test embedding-to-unit test engine 158 can, in generating one or more of the predicted unit test(s), process the predicted unit test embedding(s) 113 using a neural network model trained to for use in generating predicted unit tests from predicted unit test embeddings. For example, the neural network model 190 can be trained on training instances that each include, as training instance input, an embedding of a corresponding unit test and, as training instance output, the corresponding unit test. Through training, the neural network model 190 can generate robust and accurate unit tests on the fly, including those that may not have been included in the training sets and those that are not included in the pre-stored unit tests 195 (described below)”).
As per claim 14-17, these are the computer-readable media claims to method claims 7-10, respectively. Therefore, they are rejected for the same reasons as above.
Claim(s) 11 and 18 are rejected under 35 U.S.C. 103 as being unpatentable over Merritt (US-PAT-NO: 11,868,242 B1), Klafter (US-PGPUB-NO: 2025/0156634 A1), Lin (US-PGPUB-NO: 2025/0245131 A1), Singh (US-PAT-NO: 11,899,566 B1), Bhat (US-PGPUB-NO: 2020/0097388 A1) and Drozhak (US-PGPUB-NO: 2023/0004486 A1), in further view Khurana et al. (US-PUG-NO: 2021/0216904 A1) hereinafter Khurana.
As per claim 11, Merritt modified with Klafter, Lin, Singh, Bhat and Drozhak teaches generating, using an embedding model trained to embed computer code into the embedding space of the machine learning model, a plurality of embeddings representing the plurality of application programming interfaces (see Singh [column 8, lines 29-34], “to generate code unit embedding(s) 102. For example, a single code unit embedding can be generated that embeds the entirety of the code unit or, alternatively, multiple code unit embeddings can be generated and can collectively embed the entirety of the code (while individually embedding a portion of the code)”); and adding the embedding as a parameter of the plurality of parameters (see Singh [column 10, lines 5-19], “In some implementations, the unit test embedding-to-unit test engine 158 can, in generating one or more of the predicted unit test(s), process the predicted unit test embedding(s) 113 using a neural network model trained to for use in generating predicted unit tests from predicted unit test embeddings. For example, the neural network model 190 can be trained on training instances that each include, as training instance input, an embedding of a corresponding unit test and, as training instance output, the corresponding unit test. Through training, the neural network model 190 can generate robust and accurate unit tests on the fly, including those that may not have been included in the training sets and those that are not included in the pre-stored unit tests 195 (described below)”).
Merritt modified with Klafter, Lin, Singh, Bhat and Drozhak do not explicitly teach retrieving, from a development database, a first training dataset comprising a first plurality of tests associated with a plurality of application programming interfaces, and, from a repository, a second training dataset comprising a second plurality of tests associated with the plurality of application programming interfaces; and training the machine learning model using a training dataset comprising the first training dataset, the second training dataset, and the plurality of embeddings. However, Khurana teaches retrieving, from a development database, a first training dataset comprising a first plurality of tests associated with a plurality of application programming interfaces, and, from a repository (see Khurana paragraph [0040], “Each of the APIs may be implemented in one or more languages and interface specifications. API.sub.0 (312) provides functional support to identify and select a ML model with respect to a corresponding dataset; API.sub.1 (322) provides functional support to identify one or more features in the corresponding dataset, e.g. first dataset or training dataset”), a second training dataset comprising a second plurality of tests associated with the plurality of application programming interfaces (see Khurana paragraph [0040], “API.sub.2 (332) provides functional support for assessing a second dataset and selectively augmenting the first dataset with one or more features identified from the assessment of the second dataset”); and training the machine learning model using a training dataset comprising the first training dataset, the second training dataset, and the plurality of embeddings (see Khurana paragraph [0043], “A training machine learning (ML) model with a learning program, e.g. neural model, is identified from a library of learning programs (404). More specifically, the first structured dataset is identified for the corresponding learning task. For example, with respect to animal classification, an ML classifier may be utilized to identify and match a ML model that performs well for the corresponding classification task. Based on the ML model selection and alignment, one or more features in the first structured dataset related to performance of the selected model are identified (406). It is understood that the first structured dataset includes a plurality of data, in which some of the data may be significant or pertinent to the output generated by the selected ML model. Identifying those features in the training set directed at performance may facilitate identification and significance of data subject to assessment in a second dataset prior to augmenting the training set. Performance of the model is measured based on the composition of input in the training set (408). Accordingly, the selected model and corresponding performance is measured based upon the training set”).
Merritt, Klafter, Singh, Bhat, Drozhak and Khurana are analogous art because they are in the same field of software development. Therefore, it would have been obvious to one of ordinary skills in the art before the effective filing date of the claimed invention to modify Merritt’s teaching of selecting a test suite for an API for predictive API test suite selection, Klafter’s teaching of generating and extracting data from machine learning model outputs, Lin’s teaching of cloud service test method and related device, Singh’s teaching of training machine learning models to automatically generate test cases for source code, Bhat’s teaching of learning based metrics predictions for software development and Drozkah’s teaching of improved software testing systems with Khurana’s teaching of artificial intelligence platform to improve accuracy of machine learning model outputs to incorporate the use of multiple datasets to in order to improve machine learning model output which will provide better predicted test case as taught in Merritt.
As per claim 18, this is the computer-readable media claim to system claim 4. Therefore, it is rejected for the same reasons as above.
Claim(s) 12 and 19 are rejected under 35 U.S.C. 103 as being unpatentable over Merritt (US-PAT-NO: 11,868,242 B1), Klafter (US-PGPUB-NO: 2025/0156634 A1), Lin (US-PGPUB-NO: 2025/0245131 A1), Singh (US-PAT-NO: 11,899,566 B1), Bhat (US-PGPUB-NO: 2020/0097388 A1) and Drozhak et al. (US-PGPUB-NO: 2023/0004486 A1), in further view Schaefer et al. (US-PUG-NO: 2024/0311582 A1) hereinafter Schaefer.
As per claim 12, Merritt modified with Klafter, Lin, Singh, Bhat and Drozhak teaches wherein the instructions further cause the one or more processors to perform operations comprising: retrieving, for a plurality of application programming interfaces, a corresponding plurality of tests, wherein each corresponding plurality of tests were performed on a corresponding application programming interface (see Merritt [column 5, lines 11-21], “For example, the server 122 may be operable to receive heuristics, APIs, and/or evaluation requests and/or selections thereof provided by the client devices 102-104. The server 122 may facilitate the prediction and selection of tests for a given API. The server 122 may include an API Prediction Module 108 for predicting the most effective tests to execute on an API, an API test Selection Module 110 for selecting a suite of tests based upon knowledge gained by the API Prediction Module 108, and an API test execution module 112 for executing any of the selected tests on the given API”).
Merritt modified with Klafter, Lin, Singh, Bhat and Drozhak do not explicitly teach generating a first portion of a prompt for the machine learning model that includes a command to use the plurality of application programming interfaces and each corresponding plurality of tests to inform a response from the machine learning model, wherein the machine learning model is a large language model; generating a second portion of the prompt for the machine learning model based on the application programming interface; and inputting the prompt into the large language model. However, Shaefer teaches generating a first portion of a prompt for the machine learning model that includes a command to use the plurality of application programming interfaces and each corresponding plurality of tests to inform a response from the machine learning model (see Schaefer paragraph [0028], “The first prompt 208 contains Question #1 202 which contains a description of the task and the changes from the pull request 220. Question #1 202 includes a question that asks if the change is testworthy 222 and includes a format of the answer”), wherein the machine learning model is a large language model (see Shaefer paragraph [0028], “FIG. 2 is an illustration of an exemplary conversation with the large language model for the generation of unit tests to test changes in a pull request”); generating a second portion of the prompt for the machine learning model based on the application programming interface; and inputting the prompt into the large language model (see Shaefer paragraph [0029], “The next prompt, prompt #2 210, includes Question #2 204 and prompt #1 208. Question #2 204 contains a description of the task and the structure of the repository associated with the changed file 226 and a question that asks the model where to place the tests given the directory structure with an answer format 228. The large language model responds with FILE.JS 230”).
Merritt, Klafter, Lin, Singh, Bhat, Drozhak and Schaefer are analogous art because they are in the same field of software development. Therefore, it would have been obvious to one of ordinary skills in the art before the effective filing date of the claimed invention to modify Merritt’s teaching of selecting a test suite for an API for predictive API test suite selection, Klafter’s teaching of generating and extracting data from machine learning model outputs, Lin’s teaching of cloud service test method and related device, Singh’s teaching of training machine learning models to automatically generate test cases for source code, Bhat’s teaching of learning based metrics predictions for software development and Drozkah’s teaching of improved software testing systems with Shaefer’s teaching of conversational unit test generation using large language model to incorporate the use of large language models to generate unit tests for a change to a file in a pull request of a code repository to simply testing using natural language and prompting.
As per claim 19, this is the computer-readable media claim to system claim 5. Therefore, it is rejected for the same reasons as above.
Claim(s) 13 and 20 are rejected under 35 U.S.C. 103 as being unpatentable over Merritt (US-PAT-NO: 11,868,242 B1), Klafter (US-PGPUB-NO: 2025/0156634 A1), Lin (US-PGPUB-NO: 2025/0245131 A1), Singh (US-PAT-NO: 11,899,566 B1), Bhat (US-PGPUB-NO: 2020/0097388 A1) and Drozhak (US-PGPUB-NO: 2023/0004486 A1), in further view Kolagatla et al. (US-PUG-NO: 2017/0293548 A1) hereinafter Kolagatla.
As per claim 13, Merritt modified with Klafter, Lin, Singh, Bhat and Drozhak teaches wherein the instructions further cause the one or more processors to perform operations comprising: generating an updated plurality of tests based on adding the test that is missing to the plurality of tests; generating an updated embedding from the application programming interface; and inputting the updated embedding and the updated plurality of tests into a training routine of the machine learning model to improve the machine learning model (see Merritt [column 13, lines 16-30], “For example, if an operation to get a petID comes after an operation that posts a petObject having the petID, the predictive model hypotheses or classifies a positive test run according to previous test heuristics/patterns using classification algorithms in machine learning. Should the test run provide a negative outcome, the API Exploratory Bot 302 may provide feedback that the petID should have been found from the post operation in the previous request. As will be appreciated the test suite is updated based on the learning by the predicative model and the feedback provided by the API Exploratory Bot 302. For example, based on the negative outcome in the get petID test, the test suite will run through other getID operations having a variety of data values. With time and usage, the system keeps learning and the test suite is updated”).
Merritt modified with Klafter, Lin, Singh, Bhat and Drozhak does not explicitly teach receiving a message indicating that a test is missing from the prediction of the plurality of tests. However, Kolagatla teaches receiving a message indicating that a test is missing from the prediction of the plurality of tests (see Kolagatla paragraph [0035], “In an example, missed test identifier engine 302 causes a display of the missing test recommendation or alert via a GUI, e.g., a dashboard display GUI or any other GUI. In an example, missed test identifier engine 302 causes a display of the missing test recommendation or alert via the GUI that is provided by display engine 202 and utilized to cause the display of the set of test application evaluation factors, and that is utilized by evaluation data engine 204 to receive the user-assigned ratings for the test application evaluation factors”).
Merritt, Klafter, Lin, Singh, Bhat, Drozhak and Kolagatla are analogous art because they are in the same field of software development. Therefore, it would have been obvious to one of ordinary skills in the art before the effective filing date of the claimed invention to modify Merritt’s teaching of selecting a test suite for an API for predictive API test suite selection, Klafter’s teaching of generating and extracting data from machine learning model outputs, Lin’s teaching of cloud service test method and related device, Singh’s teaching of training machine learning models to automatically generate test cases for source code, Bhat’s teaching of learning based metrics predictions for software development and Drozkah’s teaching of improved software testing systems with Kolagatla’s teaching of software testing to determine test application effectiveness to incorporate giving a user an alert if a test is missing in order to produce more robust test cases that will have more coverage.
As per claim 20, this is the computer-readable media claim to system claim 6. Therefore, it is rejected for the same reasons as above.
Conclusion
The prior art made of record and not relied upon is considered pertinent to applicant's disclosure.
Liu et al. (US-PGPUB-NO: 2023/0185701 A1) teaches regression testing for web applications.
Ramanjani et al. (US-PGPUB-NO: 2023/0118407 A1) teaches autonomous testing of computer applications.
Tyler et al. (US-PAT-NO: 10,437,712 B1) teaches API functional-test generation.
Chen et al. (“API Completion Recommendation Algorithm Based on Programming Site Context,” 2024) teaches API completion recommendation.
Mirabella et al. (“Deep Learning Based Prediction of Test Input Validity for RESTful APIs,” 2021) teaches automated test case generation for RESTful web APIs.
Madisetti et al. (US-PAT-NO: 12,405,977 B1) teaches optimizing use of retrieval augmented generation pipelines in generative artificial intelligence applicant.
Any inquiry concerning this communication or earlier communications from the examiner should be directed to LENIN PAULINO whose telephone number is (571)270-1734. The examiner can normally be reached Week 1: Mon-Thu 7:30am - 5:00pm Week 2: Mon-Thu 7:30am - 5:00pm and Fri 7:30am - 4:00pm 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, Bradley Teets can be reached on (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.
/LENIN PAULINO/Examiner, Art Unit 2197
Prosecution Insights