DETAILED ACTION
This action is responsive to application filed on February 22, 2024.
Claims 1-20 are pending and are presented to examination.
The present application, filed on or after March 16, 2013, is being examined under the first inventor to file provisions of the AIA .
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.
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.
Drawings
The drawings filed on February 22, 2024 are acceptable for examination purposes.
Information Disclosure Statement
As required by M.P.E.P. 609, the applicant’s submission of the Information Disclosure Statement dated April 24, 2024 is acknowledged by the examiner and the cited references have been considered in the examination of the claims now pending.
Claim Objections
Claims 1-20 are objected to because of the following informalities: For claims 2, 4-6 and 8-10, please incorporate the word “further” before “comprising:” for better claim structure formalism e.g., “The method of claim 1, further comprising:”. Claim 1 (and similar for claims 11 and 18) recites the limitation “identifying a step defined within the test case script, wherein the step includes one or more threads defined as rows within the testing spreadsheet;” in lines 6-8. Claim 10 recites “implementing a control panel for one or more test cases of the testing spreadsheet to override test control values, flow control values, step-level values, or thread- level values defined by the testing spreadsheet for the test cases, wherein a modification to the control panel modifies a test case without modifying values of steps or threads within the testing spreadsheet defined for the test case, and wherein the control panel is populated with a run threads field used to specify one or more threads in one or more steps to execute.”. For claims 12-17 replace “wherein the machine executable code causes the computing device to:” or only in claim 11 “wherein the machine executable code causes [[the]] a machine to:” Please amend the claim language as indicated in bold above. Appropriate correction is required.
Dependent claims 3, 7 and 19-20 do not overcome the deficiency of the base claim and, therefore, are objected for the same reasons as the base claim.
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-20 are rejected under 35 U.S.C. 101 because the claimed invention recites a judicial exception, is directed to that judicial exception, an abstract idea, as it has not been integrated into practical application and the claims further do not recite significantly more than the judicial exception. Examiner has evaluated the claims under the framework provided in the 2019 Patent Eligibility Guidance published in the Federal Register 01/07/2019 and has provided such analysis below.
Step 1: Claims 1-10 are directed to methods and fall within the statutory category of processes; Claims 11-17 are directed to devices and fall within the statutory category of machines; and Claims 18-20 are directed to media and fall withing the statutory category of manufactures. Therefore, “Are the claims to a process, machine, manufacture or composition of matter?” Yes.
In order to evaluate the Step 2A inquiry “Is the claim directed to a law of nature, a natural phenomenon or an abstract idea?” we must determine, at Step 2A Prong 1, whether the claim recites a law of nature, a natural phenomenon or an abstract idea and further whether the claim recites additional elements that integrate the judicial exception into a practical application.
Step 2A Prong 1:
Claims 1, 11 and 18 as drafted, recite a process that, under its broadest reasonable interpretation, covers steps that could reasonably be performed in the mind, including with the aid of pen and paper, but for the recitation of generic computer components. That is, the limitations: a) “parsing a testing spreadsheet, defining a test case script, to identify test data for performing a test within a computing environment and control flag cells with control values used to control a flow for executing the test using the test data;” – Mental processes (see MPEP 2106.04(a)(2), III), this limitation can be performed by a human using pen and paper, for example a person may read/analyze a spreadsheet document having cells/rows fill with values/parameters to be used as a mapping document.
b) “identifying a step defined within the test case script, wherein the step includes one or more threads defined as rows within the spreadsheet;” – Mental processes (see MPEP 2106.04(a)(2), III), this limitation can be performed by a human using pen and paper, for example a person could use the above mapping document to link these parameters/values with a test script/code/block wrote by a developer in paper. c) “determining whether calls associated with the one or more threads match calls within a resource listing file;” - Mental processes (see MPEP 2106.04(a)(2), III), this limitation can be performed by a human using pen and paper, for example a person may have another list listing resources in order to create a mapping relationship between the test script and the spreadsheet.
d) “”. That is, nothing in the claim elements precludes the step from practically being performed in the mind or with a pen and paper, (i.e., “parsing”, “identifying”, “determining”) can be performed in the human mind though observation, evaluation, judgment, opinion with the aid of pen and paper. Thus, these limitations fall within the “Mental Processes” grouping of abstract ideas.
Therefore, Yes, claims 1, 11 and 18 recite judicial exceptions.
The claims have been identified to recite judicial exceptions, Step 2A Prong 2 will evaluate whether the claims are directed to the judicial exception.
Step 2A Prong 2:
This judicial exception is not integrated into a practical application. The claims recite the following additional elements: “a memory”, “a processor”, “a computer device”, “a machine” and “a non-transitory machine readable medium”. The additional elements are merely instructions to implement an abstract idea on a computer, or merely using a generic computer or computer components as a tool to perform the abstract idea (see MPEP 2106.05(f)). Accordingly, the additional elements recited in the claims do not integrate the abstract idea into a practical application because it does not impose any meaningful limits on practicing the abstract idea, thus failing to integrate the abstract idea into a practical application.
The claims also include an additional element such as “in response to a call of a thread matching the resource listing file, utilizing the control values to execute the thread to perform the call using the test data as part of executing the test within the computing environment.”. Accordingly, this element does not integrate the abstract idea into a practical application because is just mere instructions to apply an exception (see MPEP 2106.05(f),2). This limitation invokes computers as a tool to perform the existing process.
Therefore, “Do the claims recite additional elements that integrate the judicial exception into a practical application? No, these additional elements do not integrate the abstract idea into a practical application and they do not impose any meaningful limits on practicing the abstract idea. The claim is directed to an abstract idea.
After having evaluating the inquires set forth in Steps 2A Prong 1 and 2, it has been concluded that claims 1, 11 and 18 not only recites a judicial exception but that the claim is directed to the judicial exception as the judicial exception has not been integrated into practical application.
Step 2B:
As discussed above with respect to integration of the abstract idea into a practical application, the additional elements “a memory”, “a processor”, “a computer device”, “a machine” and “a non-transitory machine readable medium” are generic computer components used as tools to perform the abstract idea. Accordingly, the additional elements recited in the claims cannot provide an inventive concept. In addition, after further evaluation the claim as a whole doesn’t improve any function of a computer or to any other technology or technical field. Thus, the claims are not patent eligible.
Therefore, “Do the claims recite additional elements that amount to significantly more than the judicial exception? No, these additional elements, alone or in combination, do not amount to significantly more than the judicial exception.
Having concluded analysis within the provided framework, Claims 1, 11 and 18 do not recite patent eligible subject matter under 35 U.S.C. § 101.
With regard to claims 6-7, 12-15 and 19 the claims are reciting further embellishment of the judicial exception. The claims do not offer something that can be considered to be a significantly more than the judicial exception since they are related to just descriptions to form a log output with data and what data may the steps in the spreadsheet may have, all of them lacking to mention any technical steps that integrate these claims into practical application or to amount significantly more.
With regards to claim 2, it recites “utilizing environment.” as drafted, is a process that, but for the recitation of generic computing components, under its broadest reasonable interpretation, covers performance of the limitation in the mind and/or using pen and paper. For example, a person using pen and paper can identify a key to be used as a validation to use data in a spreadsheet. Moreover, claim 2 does not recite any other additional elements and for the same reasons as above with regard to integration into practical application and whether additional elements amount to significantly more, claim 2 also fails both Step 2A prong 2, thus the claim is directed to the judicial exception as it has not been integrated into practical application, and fails Step 2B as not amounting to significantly more Therefore, Claim 2 does not recite patent eligible subject matter under 35 U.S.C. § 101. With regards to claim 3, it recites “wherein the call comprises an application programming interface (API) request, and wherein the method comprises: framing the API request with a payload and key/value pair within a cell of the testing spreadsheet to create a framed API; and comparing the framed API with the resource listing file to select an API as a destination.” as drafted, is a process that, but for the recitation of generic computing components, under its broadest reasonable interpretation, covers performance of the limitation in the mind and/or using pen and paper. For example, a person using pen and paper can map a document with data and compare it. Moreover, claim 3 does not recite any other additional elements and for the same reasons as above with regard to integration into practical application and whether additional elements amount to significantly more, claim 3 also fails both Step 2A prong 2, thus the claim is directed to the judicial exception as it has not been integrated into practical application, and fails Step 2B as not amounting to significantly more Therefore, Claim 3 does not recite patent eligible subject matter under 35 U.S.C. § 101.
With regards to claim 4, it recites “defining a first test case as a first sheet within the testing spreadsheet; defining a second test case as a second sheet within the testing spreadsheet; and defining a workbook of the spreadsheet as a group of test cases that include the first test case and the second test case.” as drafted, is a process that, but for the recitation of generic computing components, under its broadest reasonable interpretation, covers performance of the limitation in the mind and/or using pen and paper. For example, a person using pen and paper can define a plurality of tests using the spreadsheet. Moreover, claim 4 does not recite any other additional elements and for the same reasons as above with regard to integration into practical application and whether additional elements amount to significantly more, claim 4 also fails both Step 2A prong 2, thus the claim is directed to the judicial exception as it has not been integrated into practical application, and fails Step 2B as not amounting to significantly more Therefore, Claim 4 does not recite patent eligible subject matter under 35 U.S.C. § 101.
With regards to claim 5, it recites “implementing a default thread execution rule to execute the one or more threads as a single step; and in response to a serial mode control value being set for the step, overriding the default thread execution rule to serially execute the one or more threads.” as drafted, is a process that, but for the recitation of generic computing components, under its broadest reasonable interpretation, covers performance of the limitation in the mind and/or using pen and paper. For example, a person using pen and paper can implement a rule using the control value utilizing the spreadsheet. Moreover, claim 5 does not recite any other additional elements and for the same reasons as above with regard to integration into practical application and whether additional elements amount to significantly more, Claim 5 also fails both Step 2A prong 2, thus the claim is directed to the judicial exception as it has not been integrated into practical application, and fails Step 2B as not amounting to significantly more Therefore, Claim 5 does not recite patent eligible subject matter under 35 U.S.C. § 101.
With regards to claim 8, it recites “declaring and accessing a variable by assigning a prefix character to a variable name within the testing spreadsheet.” as drafted, is a process that, but for the recitation of generic computing components, under its broadest reasonable interpretation, covers performance of the limitation in the mind and/or using pen and paper. For example, a person using pen and paper can declare a variable and assigning a prefix to a variable name to be used together with the spreadsheet and other type of data. Moreover, claim 8 does not recite any other additional elements and for the same reasons as above with regard to integration into practical application and whether additional elements amount to significantly more,Claim 8 also fails both Step 2A prong 2, thus the claim is directed to the judicial exception as it has not been integrated into practical application, and fails Step 2B as not amounting to significantly more Therefore, Claim 8 does not recite patent eligible subject matter under 35 U.S.C. § 101.
With regards to claim 9, it recites “evaluating the testing spreadsheet to determine that a prefix character is assigned to at least one of a value within a cell of the testing spreadsheet to comment or exclude the value from the call, a method parameter to comment or exclude the method parameter from the call, or a sheet name to exclude or comment a corresponding test case; and in response to a value being assigned to a cell within a step number column, excluding or commenting a thread defined by a row that includes the cell.” as drafted, is a process that, but for the recitation of generic computing components, under its broadest reasonable interpretation, covers performance of the limitation in the mind and/or using pen and paper. For example, a person can evaluate the spreadsheet to identify values and mapping procedure with other data. Moreover, claim 9 does not recite any other additional elements and for the same reasons as above with regard to integration into practical application and whether additional elements amount to significantly more, claim 9 also fails both Step 2A prong 2, thus the claim is directed to the judicial exception as it has not been integrated into practical application, and fails Step 2B as not amounting to significantly more Therefore, Claim 9 does not recite patent eligible subject matter under 35 U.S.C. § 101.
With regards to claim 10, it recites “implementing a control panel for each test case of the testing spreadsheet to override test control values, flow control values, step-level values, or thread- level values defined by the testing spreadsheet for the test cases, wherein a modification to the control panel modifies a test case without modifying values of steps or threads within the testing spreadsheet defined for the test case, and wherein the control panel is populated with a run threads field used to specify one or more threads in one or more steps to execute.” as drafted, is mere instructions to apply an exception (e.g., utilizing and manipulation of spreadsheet data using a tool). Moreover, claim 10 does not recite any other additional elements and for the same reasons as above with regard to integration into practical application and whether additional elements amount to significantly more, claim 10 also fails both Step 2A prong 2, thus the claim is directed to the judicial exception as it has not been integrated into practical application, and fails Step 2B as not amounting to significantly more Therefore, Claim 10 does not recite patent eligible subject matter under 35 U.S.C. § 101.
With regards to claim 16, it recites “wherein the machine executable code causes the machine to: in response to determining that there is a mismatch with the expected status code and values, specify that the thread failed; and in response to determining that there is no mismatch with the expected status code and values, specify that the thread pass.” as drafted, is a process that, but for the recitation of generic computing components, under its broadest reasonable interpretation, covers performance of the limitation in the mind and/or using pen and paper. For example, a person can indicate identify an output result to classify the instruction as failed or pass. Moreover, claim 16 does not recite any other additional elements and for the same reasons as above with regard to integration into practical application and whether additional elements amount to significantly more, claim 16 also fails both Step 2A prong 2, thus the claim is directed to the judicial exception as it has not been integrated into practical application, and fails Step 2B as not amounting to significantly more Therefore, Claim 16 does not recite patent eligible subject matter under 35 U.S.C. § 101.
With regards to claim 17, it recites “wherein the machine executable code causes the machine to: in response to the call of the thread not matching the resource listing file, generate an error report than an API cannot be found.” as drafted, is a process that, but for the recitation of generic computing components, under its broadest reasonable interpretation, covers performance of the limitation in the mind and/or using pen and paper. For example, a person can generate an error report if there is not mapping available for a particular data. Moreover, claim 17 does not recite any other additional elements and for the same reasons as above with regard to integration into practical application and whether additional elements amount to significantly more, claim 17 also fails both Step 2A prong 2, thus the claim is directed to the judicial exception as it has not been integrated into practical application, and fails Step 2B as not amounting to significantly more Therefore, Claim 17 does not recite patent eligible subject matter under 35 U.S.C. § 101.
With regards to claim 20, it recites “wherein the instructions cause the machine to: utilize a command line parameter to alter a value of a variable within the testing spreadsheet for a test case at runtime, wherein the test case is run for different test scenarios using override values input through the command line parameter without modifying original values within the testing spreadsheet.” as drafted, is a process that, but for the recitation of generic computing components, under its broadest reasonable interpretation, covers performance of the limitation in the mind and/or using pen and paper. For example, a person can write command line instructions in paper to be used by a computer. Moreover, claim 20 does not recite any other additional elements and for the same reasons as above with regard to integration into practical application and whether additional elements amount to significantly more, claim 20 also fails both Step 2A prong 2, thus the claim is directed to the judicial exception as it has not been integrated into practical application, and fails Step 2B as not amounting to significantly more Therefore, Claim 20 does not recite patent eligible subject matter under 35 U.S.C. § 101. Therefore, Claims 1-20 do not recite patent eligible subject matter under 35 U.S.C. § 101.
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.
The factual inquiries for establishing a background for determining obviousness under 35 U.S.C. 103 are summarized as follows:
1. Determining the scope and contents of the prior art.
2. Ascertaining the differences between the prior art and the claims at issue.
3. Resolving the level of ordinary skill in the pertinent art.
4. Considering objective evidence present in the application indicating obviousness or nonobviousness.
Claims 1-6 and 11-18 are rejected under 35 U.S.C. 103 as being unpatentable over Arkadyev (US Pub. No. 2017/0185509) in view of Chilupuri et al. (US Pub. No. 2023/0047837 – hereinafter Chilupuri).
With respect to claim 1, Arkadyev teaches a method, comprising: parsing a testing spreadsheet, defining a test case script, to identify test data for performing a test within a computing environment and control flag cells with control values used to control a flow for executing the test using the test data (See abstract, paragraph [0006] and figure 2 (and related text), “In some aspects, parsing the set of instructions to determine the action to perform may comprise determining, in the set of instructions, a location of a trigger indicating the action to perform. Based on the location of the trigger indicating the action to perform, it may be determined that text in the set of instructions following the trigger comprises a name of the action to perform. Additionally or alternatively, parsing the set of instructions to determine the data to use for the action to perform may comprise determining, in the set of instructions, a location of a trigger indicating the data to use for the action to perform. Based on the location of the trigger indicating the data to use for the action to perform, it may be determined that text in the set of instructions following the trigger comprises a name or a location of a data sheet storing the data to use for the action to perform.”. See paragraph [0019], “In some aspects, an automation framework may receive one or more instruction (e.g., an instruction sheet, such as a spreadsheet information sheet) as input and extract from the instruction sheet specific information about the action to be performed by the framework and the data that may be used for the action. That is, the instruction sheet may define actions and input data for the functionalities of the application to be tested.”. See paragraphs [0026], [0029], “The application specific component 215 may comprise data sheets 227, which may be spreadsheets or other tables. The data sheets 227 may comprise the data to be used for test scenarios. For example, the data sheets 227 may define the relevant data to be used for each UI control in each test step. The test scenarios 264 and steps 266 may list the test cases to be executed, as will be described in further detail below.”. See paragraphs [0033], [0036], “The framework 205 may comprise one or more components that may process data after execution is performed by the framework core 207. For example, the framework 205 may comprise a keyword driver 230 that provides keywords for use by an instruction (e.g., data) sheet or file 232 (e.g., in a spreadsheet or table format). The instruction sheet 232 may be read, e.g., row by row, to identify test cases 234 listed in the instruction sheet. The steps 236 of each test case 234 may be processed. For each step 236, the framework 205 may extract information about the action to be executed and the data to be used for the action. That is, these pieces of information may be passed to the framework core 207 and/or application specific component 215 for processing. The information may be sent to the framework core 207 and/or application specific component 215 in a format that the framework understands. For example, the action information may be formatted as UIMap.Fill or UITable.Filter, and the data may be formatted as <DataSheetName, RowNumber/RowLabel>.”. See paragraphs [0059], [0062]-[0063], [0073], “A parser 260 may parse test steps to identify the text and their corresponding actions. In some aspects, the parser 260 and/or another parser may parse a set of instructions (e.g., a feature file) to determine an action to perform and to determine data to use for the action to perform.”. Furthermore, see figures 4-8 (and related text). Examiner notes: parser and spreadsheet defining a test via keywords in cells/rows).
identifying a step defined within the test case script, wherein the step includes one or more threads defined as rows within the spreadsheet (See abstract, paragraph [0006] and figure 2 (and related text), “In some aspects, parsing the set of instructions to determine the action to perform may comprise determining, in the set of instructions, a location of a trigger indicating the action to perform. Based on the location of the trigger indicating the action to perform, it may be determined that text in the set of instructions following the trigger comprises a name of the action to perform. Additionally or alternatively, parsing the set of instructions to determine the data to use for the action to perform may comprise determining, in the set of instructions, a location of a trigger indicating the data to use for the action to perform. Based on the location of the trigger indicating the data to use for the action to perform, it may be determined that text in the set of instructions following the trigger comprises a name or a location of a data sheet storing the data to use for the action to perform.”. See paragraph [0019], “In some aspects, an automation framework may receive one or more instruction (e.g., an instruction sheet, such as a spreadsheet information sheet) as input and extract from the instruction sheet specific information about the action to be performed by the framework and the data that may be used for the action. That is, the instruction sheet may define actions and input data for the functionalities of the application to be tested.”. See paragraphs [0026], [0029], “The application specific component 215 may comprise data sheets 227, which may be spreadsheets or other tables. The data sheets 227 may comprise the data to be used for test scenarios. For example, the data sheets 227 may define the relevant data to be used for each UI control in each test step. The test scenarios 264 and steps 266 may list the test cases to be executed, as will be described in further detail below.”. See paragraphs [0032]-[0036], “The framework 205 may comprise one or more components that may process data after execution is performed by the framework core 207. For example, the framework 205 may comprise a keyword driver 230 that provides keywords for use by an instruction (e.g., data) sheet or file 232 (e.g., in a spreadsheet or table format). The instruction sheet 232 may be read, e.g., row by row, to identify test cases 234 listed in the instruction sheet. The steps 236 of each test case 234 may be processed. For each step 236, the framework 205 may extract information about the action to be executed and the data to be used for the action. That is, these pieces of information may be passed to the framework core 207 and/or application specific component 215 for processing. The information may be sent to the framework core 207 and/or application specific component 215 in a format that the framework understands. For example, the action information may be formatted as UIMap.Fill or UITable.Filter, and the data may be formatted as <DataSheetName, RowNumber/RowLabel>.”. See paragraphs [0059], [0062]-[0063], [0073], “A parser 260 may parse test steps to identify the text and their corresponding actions. In some aspects, the parser 260 and/or another parser may parse a set of instructions (e.g., a feature file) to determine an action to perform and to determine data to use for the action to perform.”. Furthermore, see figure 1, steps 120, step definition 125, figure 2 steps 236, steps 266, steps definition 246, 248 and figures 4-8 (and related text). Examiner notes: steps in spreadsheet). Arkadyev is silent to disclose, however in an analogous art, Chilupuri teaches:
determining whether calls associated with the one or more threads match calls within a resource listing file (See paragraph [0023], “In embodiments, API specification 102 may include a specification for machine-readable interface files for describing, producing, consuming, and visualizing RESTful web services. A variety of tools may generate code, documentation and test cases given an interface file. Development of the OpenAPI Specification (“OAS”) is overseen by the Open API Initiative, an open source collaborative project of the Linux Foundation. According to an embodiment of the present invention, APIs have a specification, which may include an Open API Specification or Swagger contract. In embodiments, API specification 102 is implemented using the Swagger (JSON/YAML) format or the API Blueprint format.”. See paragraphs [0036], [0042]-[0043] and figures 1, 4-6 (and related text), “At 301, REST API specification 102 is parsed using a parser to extract the resource URL, the parameter names along with the parameter information, the response codes and the JSON payload for POST and PUT operations. This parsed information is provided and generated as an Excel file or any spreadsheet or other user readable format.”. Examiner notes: swagger file and list of resources) and in response to a call of a thread matching the resource listing file, utilizing the control values to execute the thread to perform the call using the test data as part of executing the test within the computing environment (See abstract, “Embodiments receive a REST API specification that provides information for a plurality of REST APIs and parse the REST API specification to extract, for each REST API, a corresponding Uniform Resource Locator (“URL”), and corresponding parameter names response codes and payloads. Embodiments convert the parsed REST API specification into a converted text file, the converting including parameter constraints and parameter default values. Embodiments then generate all possible combinations of test data for each REST API from the converted text file and perform one or more test operations on each of the combinations of test data.”. Furthermore, see figures 1, 3, 5 (and related text) and paragraphs [0019], [0033], [0036], [0043]-[0044], “Embodiments retrieve all of the paths mentioned in the REST API specification, along with the parameter details and response codes to generate a more easily understandable spreadsheet or “Excel” file (or any other type of human readable file). Based on the parameter type and the nature of the parameter, randomization of the test data is done. This test data is fed into combination generator tool 107 to generate test data combinations which help in identifying corner cases (i.e., cases outside of normally expected results).”. Therefore, it would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to modify Arkadyev’s teaching, which set forth a application code testing computing device receiving a set of instructions for testing one or more user interface pages of an application under test, by determining whether calls associated with the one or more threads match calls within a resource listing file and in response to a call of a thread matching the resource listing file, utilizing the control values to execute the thread to perform the call using the test data as part of executing the test within the computing environment as suggested by Chilupuri, as Chilupuri would provide an enhanced way to validate interfaces to the web services (see paragraph [0001]). With respect to claim 2, Arkadyev is silent to disclose, however in an analogous art, Chilupuri teaches utilizing an automation key server to get a key to decrypt an encrypted resource listing file to obtain the resource listing file and to decrypt a configuration spreadsheet to obtain setup configurations for executing the test; and utilizing the setup configurations for performing the test within the computing environment (See paragraph [0047], “An example of a parameter defaults.txt file 103 is as follows, which provides default values for the authorization key (which provides authorization to use the web service) and values for identities for hotels, hotel rooms, and activities:”. See paragraph [0051], “If the user has not provided any default values, the converter searches for the existence of a system generated defaults file 310 that is generated at 305, and if that also does not exist then it uses randomly generated values that are generated at 311 based on the parameter type (e.g., String, Boolean or Integer). The system generated defaults are generated by a parser at 305 as a result of the testing, and is then used as input for the next round of testing as an iterative process. At 305, if the GET operation response is successful, then the parser retrieves the data out of the GET operation response with the key value information and stores it in a text file. This data can be used during the next execution if the user does not pass any pre-defined data values 103.”).
Therefore, it would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to modify Arkadyev’s teaching, which set forth a application code testing computing device receiving a set of instructions for testing one or more user interface pages of an application under test, by utilizing an automation key server to get a key to decrypt an encrypted resource listing file to obtain the resource listing file and to decrypt a configuration spreadsheet to obtain setup configurations for executing the test; and utilizing the setup configurations for performing the test within the computing environment as suggested by Chilupuri, as Chilupuri would provide an enhanced way to validate interfaces to the web services (see paragraph [0001]). With respect to claim 3, Arkadyev is silent to disclose, however in an analogous art, Chilupuri teaches wherein the call comprises an application programming interface (API) request, and wherein the method comprises: framing the API request with a payload and key/value pair within a cell of the testing spreadsheet to create a framed API; and comparing the framed API with the resource listing file to select an API as a destination (See paragraph [0023], “In embodiments, API specification 102 may include a specification for machine-readable interface files for describing, producing, consuming, and visualizing RESTful web services. A variety of tools may generate code, documentation and test cases given an interface file. Development of the OpenAPI Specification (“OAS”) is overseen by the Open API Initiative, an open source collaborative project of the Linux Foundation. According to an embodiment of the present invention, APIs have a specification, which may include an Open API Specification or Swagger contract. In embodiments, API specification 102 is implemented using the Swagger (JSON/YAML) format or the API Blueprint format.”. See paragraphs [0036], [0042]-[0043] and figures 1, 4-6 (and related text), “At 301, REST API specification 102 is parsed using a parser to extract the resource URL, the parameter names along with the parameter information, the response codes and the JSON payload for POST and PUT operations. This parsed information is provided and generated as an Excel file or any spreadsheet or other user readable format.”. See abstract, “Embodiments receive a REST API specification that provides information for a plurality of REST APIs and parse the REST API specification to extract, for each REST API, a corresponding Uniform Resource Locator (“URL”), and corresponding parameter names response codes and payloads. Embodiments convert the parsed REST API specification into a converted text file, the converting including parameter constraints and parameter default values. Embodiments then generate all possible combinations of test data for each REST API from the converted text file and perform one or more test operations on each of the combinations of test data.”. Furthermore, see figures 1, 3, 5 (and related text) and paragraphs [0019], [0033], [0036], [0043]-[0044], “Embodiments retrieve all of the paths mentioned in the REST API specification, along with the parameter details and response codes to generate a more easily understandable spreadsheet or “Excel” file (or any other type of human readable file). Based on the parameter type and the nature of the parameter, randomization of the test data is done. This test data is fed into combination generator tool 107 to generate test data combinations which help in identifying corner cases (i.e., cases outside of normally expected results).”.
Therefore, it would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to modify Arkadyev’s teaching, which set forth a application code testing computing device receiving a set of instructions for testing one or more user interface pages of an application under test, by: framing the API request with a payload and key/value pair within a cell of the testing spreadsheet to create a framed API; and comparing the framed API with the resource listing file to select an API as a destination as suggested by Chilupuri, as Chilupuri would provide an enhanced way to validate interfaces to the web services (see paragraph [0001]). With respect to claim 4, Arkadyev teaches defining a first test case as a first sheet within the testing spreadsheet; defining a second test case as a second sheet within the testing spreadsheet; and defining a workbook of the spreadsheet as a group of test cases that include the first test case and the second test case (See figure 4, group of action data and paragraphs [0032], [0055], “The application specific component 215 may comprise reusable actions 217. The reusable actions 217 may business actions 219, such as DSL operations, and navigation operations 221. These actions may be implemented as separate groups of steps in instruction sheets of special type, and coding might not be needed.”. See figure 3 block 315 “Generate group of actions” and paragraph [0077[-[0083], “Each group action may be defined in a worksheet, which may comprise a group instruction sheet. Multiple group actions may be defined in the same worksheet depending on the categorization. For example, group actions on the admin module may be defined in a worksheet called AdminGroupinstructionSheet worksheet. Each group's actions may be separated by a blank line, as illustrated in FIG. 4. FIG. 4 illustrates examples of group action data 405 generated and transformed by computing devices in which various aspects of the disclosure may be implemented.”). With respect to claim 5, Arkadyev is silent to disclose, however in an analogous art, Chilupuri teaches implementing a default thread execution rule to execute the one or more threads as a single step; and in response to a serial mode control value being set for the step, overriding the default thread execution rule to serially execute the one or more threads (See abstract and paragraph [0005], “Embodiments convert the parsed REST API specification into a converted text file, the converting including parameter constraints and parameter default values. Embodiments then generate all possible combinations of test data for each REST API from the converted text file and perform one or more test operations on each of the combinations of test data.”. See paragraph [0046], “Referring again to FIG. 3, a converter 302, provided with parameter constraints 104, parameter defaults 103 and the spreadsheet file from 301, generates a text file at 320 suitable to be fed into combination generator 107. A user who is using the tool/embodiments can send the default values or the tool can generate the values automatically based on the parameter type (i.e., String/Boolean/Integer). The default values sent in the defaults.txt file determine the values for the parameters which the tool sends to the API call during the test execution.”. See paragraphs [0049]-[0051], [0053], “The constraints can be defined by the business which describes the dependency of one parameter to the other. For example, when a parameter such as “Completed” holds a value “true” then the parameter “EndDate” of a process cannot be anything after the currentDate. This is a condition which can be considered a constraint while defining various combinations of test data. Further, there may also be no constraints for the parameters. Therefore, even if some constraints are defined and the parameters in the constraints file are not valid for an API call then the constraints section would be empty in the text file that gets generated.”). Therefore, it would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to modify Arkadyev’s teaching, which set forth a application code testing computing device receiving a set of instructions for testing one or more user interface pages of an application under test, by implementing a default thread execution rule to execute the one or more threads as a single step and in response to a serial mode control value being set for the step, overriding the default thread execution rule to serially execute the one or more threads as suggested by Chilupuri, as Chilupuri would provide an enhanced way to validate interfaces to the web services (see paragraph [0001]).
With respect to claim 6, Arkadyev is silent to disclose, however in an analogous art, Chilupuri teaches performing the test to generate at least one of console logs, test logs in an HTML format, or debug logs in the HTML format (See paragraph [0057], “The HTML report 110 with test execution results is then generated. FIG. 9 illustrates an example of HTML report 110”). Therefore, it would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to modify Arkadyev’s teaching, which set forth a application code testing computing device receiving a set of instructions for testing one or more user interface pages of an application under test, by performing the test to generate at least one of console logs, test logs in an HTML format, or debug logs in the HTML format as suggested by Chilupuri, as Chilupuri would provide an enhanced way to validate interfaces to the web services (see paragraph [0001]). With respect to claims 11, the claim is directed to a computing device that corresponds to the method recited in claim 1, respectively (see the rejection of claim 1 above; wherein Arkadyev also teaches such a device in paragraph [0065]). With respect to claim 12, Arkadyev is silent to disclose, however in an analogous art, Chilupuri teaches generate, during execution of the test, console logs describing steps and threads that were executed, skipped steps and skipped threads that were not executed, and test results (See paragraph [0032], [0034], [0054], [0056], [0062], “generates test data automatically with varied combinations of data generated from combinations generator 107. Embodiments also incorporate automatic and more generic assertions to validate the execution of the APIs and generate reports.”). Therefore, it would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to modify Arkadyev’s teaching, which set forth a application code testing computing device receiving a set of instructions for testing one or more user interface pages of an application under test, by generating, during execution of the test, console logs describing steps and threads that were executed, skipped steps and skipped threads that were not executed, and test results as suggested by Chilupuri, as Chilupuri would provide an enhanced way to validate interfaces to the web services (see paragraph [0001]). With respect to claim 13, Arkadyev is silent to disclose, however in an analogous art, Chilupuri teaches wherein the machine executable code causes the machine to: implement, during execution of the test, a debugger to generate debug logs (See paragraph [0057], “The HTML report 110 with test execution results is then generated. FIG. 9 illustrates an example of HTML report 110”). Therefore, it would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to modify Arkadyev’s teaching, which set forth a application code testing computing device receiving a set of instructions for testing one or more user interface pages of an application under test, by implementing, during execution of the test, a debugger to generate debug logs as suggested by Chilupuri, as Chilupuri would provide an enhanced way to validate interfaces to the web services (see paragraph [0001]). With respect to claim 14, Arkadyev is silent to disclose, however in an analogous art, Chilupuri teaches wherein the machine executable code causes the machine to: form a test case that includes the thread, wherein the thread comprises an API path in a key/value pair, an API payload, and an expected status code and values expected from a response (See paragraph [0023], “In embodiments, API specification 102 may include a specification for machine-readable interface files for describing, producing, consuming, and visualizing RESTful web services. A variety of tools may generate code, documentation and test cases given an interface file. Development of the OpenAPI Specification (“OAS”) is overseen by the Open API Initiative, an open source collaborative project of the Linux Foundation. According to an embodiment of the present invention, APIs have a specification, which may include an Open API Specification or Swagger contract. In embodiments, API specification 102 is implemented using the Swagger (JSON/YAML) format or the API Blueprint format.”. See paragraphs [0036], [0042]-[0043] and figures 1, 4-6 (and related text), “At 301, REST API specification 102 is parsed using a parser to extract the resource URL, the parameter names along with the parameter information, the response codes and the JSON payload for POST and PUT operations. This parsed information is provided and generated as an Excel file or any spreadsheet or other user readable format.”. See abstract, “Embodiments receive a REST API specification that provides information for a plurality of REST APIs and parse the REST API specification to extract, for each REST API, a corresponding Uniform Resource Locator (“URL”), and corresponding parameter names response codes and payloads. Embodiments convert the parsed REST API specification into a converted text file, the converting including parameter constraints and parameter default values. Embodiments then generate all possible combinations of test data for each REST API from the converted text file and perform one or more test operations on each of the combinations of test data.”. Furthermore, see figures 1, 3, 5 (and related text) and paragraphs [0019], [0033], [0036], [0043]-[0044], “Embodiments retrieve all of the paths mentioned in the REST API specification, along with the parameter details and response codes to generate a more easily understandable spreadsheet or “Excel” file (or any other type of human readable file). Based on the parameter type and the nature of the parameter, randomization of the test data is done. This test data is fed into combination generator tool 107 to generate test data combinations which help in identifying corner cases (i.e., cases outside of normally expected results).”.
Therefore, it would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to modify Arkadyev’s teaching, which set forth a application code testing computing device receiving a set of instructions for testing one or more user interface pages of an application under test, by forming a test case that includes the thread, wherein the thread comprises an API path in a key/value pair, an API payload, and an expected status code and values expected from a response as suggested by Chilupuri, as Chilupuri would provide an enhanced way to validate interfaces to the web services (see paragraph [0001]). With respect to claim 15, Arkadyev is silent to disclose, however in an analogous art, Chilupuri teaches perform test execution for the thread by sending a framed API request with the API payload to the API path, receiving an API response, and checking the API response for the expected status code and values (See paragraph [0023], “In embodiments, API specification 102 may include a specification for machine-readable interface files for describing, producing, consuming, and visualizing RESTful web services. A variety of tools may generate code, documentation and test cases given an interface file. Development of the OpenAPI Specification (“OAS”) is overseen by the Open API Initiative, an open source collaborative project of the Linux Foundation. According to an embodiment of the present invention, APIs have a specification, which may include an Open API Specification or Swagger contract. In embodiments, API specification 102 is implemented using the Swagger (JSON/YAML) format or the API Blueprint format.”. See paragraphs [0036], [0042]-[0043] and figures 1, 4-6 (and related text), “At 301, REST API specification 102 is parsed using a parser to extract the resource URL, the parameter names along with the parameter information, the response codes and the JSON payload for POST and PUT operations. This parsed information is provided and generated as an Excel file or any spreadsheet or other user readable format.”. See abstract, “Embodiments receive a REST API specification that provides information for a plurality of REST APIs and parse the REST API specification to extract, for each REST API, a corresponding Uniform Resource Locator (“URL”), and corresponding parameter names response codes and payloads. Embodiments convert the parsed REST API specification into a converted text file, the converting including parameter constraints and parameter default values. Embodiments then generate all possible combinations of test data for each REST API from the converted text file and perform one or more test operations on each of the combinations of test data.”. Furthermore, see figures 1, 3, 5 (and related text) and paragraphs [0019], [0033], [0036], [0043]-[0044], “Embodiments retrieve all of the paths mentioned in the REST API specification, along with the parameter details and response codes to generate a more easily understandable spreadsheet or “Excel” file (or any other type of human readable file). Based on the parameter type and the nature of the parameter, randomization of the test data is done. This test data is fed into combination generator tool 107 to generate test data combinations which help in identifying corner cases (i.e., cases outside of normally expected results).”.
Therefore, it would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to modify Arkadyev’s teaching, which set forth a application code testing computing device receiving a set of instructions for testing one or more user interface pages of an application under test, by performing test execution for the thread by sending a framed API request with the API payload to the API path, receiving an API response, and checking the API response for the expected status code and values as suggested by Chilupuri, as Chilupuri would provide an enhanced way to validate interfaces to the web services (see paragraph [0001]). With respect to claim 16, Arkadyev is silent to disclose, however in an analogous art, Chilupuri teaches wherein the machine executable code causes the machine to: in response to determining that there is a mismatch with the expected status code and values, specify that the thread failed; and in response to determining that there is no mismatch with the expected status code and values, specify that the thread pass (see paragraph [0075], “Embodiments generate HTML reports for individual APIs. The HTML report 110 includes the PASS/FAIL status of the API call and in case of failure, the error code and the payload that was used in generating the failure scenario. This helps the user in regenerating the same scenario manually.”). Therefore, it would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to modify Arkadyev’s teaching, which set forth a application code testing computing device receiving a set of instructions for testing one or more user interface pages of an application under test, by specifying that the thread failed and specifying that the thread pass as suggested by Chilupuri, as Chilupuri would provide an enhanced way to validate interfaces to the web services (see paragraph [0001]).
With respect to claim 17, Arkadyev is silent to disclose, however in an analogous art, Chilupuri teaches wherein the machine executable code causes the machine to: in response to the call of the thread not matching the resource listing file, generate an error report than an API cannot be found (See paragraph [0059], “This will check the API server behavior when mandatory parameters are missing and expects an error in this case. Further, when the optional parameters are missing, there should not be any difference in the API server behavior.”). Therefore, it would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to modify Arkadyev’s teaching, which set forth a application code testing computing device receiving a set of instructions for testing one or more user interface pages of an application under test, by generating an error report than an API cannot be found as suggested by Chilupuri, as Chilupuri would provide an enhanced way to validate interfaces to the web services (see paragraph [0001]).
With respect to claims 18, the claim is directed to a non-transitory machine readable medium device that corresponds to the method recited in claim 1, respectively (see the rejection of claim 1 above; wherein Arkadyev also teaches such a device in paragraph [0457]).
Claim 7 is rejected under 35 U.S.C. 103 as being unpatentable over Arkadyev (US Pub. No. 2017/0185509) in view of Chilupuri et al. (US Pub. No. 2023/0047837 – hereinafter Chilupuri) and further in view of Chandrasekaran (US Pat. No. 9,021,440). With respect to claim 7, Arkadyev in view of Chilupuri is silent to disclose, however in an analogous art, Chandrasekaran teaches wherein the step comprises at least one of a volume create operation, a volume deletion operation, a backup operation, or a storage operation associated with storage of the computing environment (See column 6 lines 36-43 and figures 1-6 (and related text), “In an example that illustrates the difference between UC-APIs of the test script generator 200 and APIs 306 of the TAF 300, a test comprises four functions: Function 1 is creating a Raid 5 Volume using 5 drives in Ready state; Function 2 is creating a Raid 10 Volume using 2 drives in Ready state; Function 3 is delete the Volume created in Step 2; and Function 4 is running 10 using 10 Meter tool to the volume created in Function 1.”). Therefore, it would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to modify the combination of Arkadyev and Chilupuri, wherein a step comprises at least one of a volume create operation, a volume deletion operation, a backup operation, or a storage operation associated with storage of the computing environment as suggested by Chandrasekaran, as Chandrasekaran would provide an enhanced to automated test script generation for use in an automated product testing (see column 1 lines 6-7).
Claims 8-9 are rejected under 35 U.S.C. 103 as being unpatentable over Arkadyev (US Pub. No. 2017/0185509) in view of Chilupuri et al. (US Pub. No. 2023/0047837 – hereinafter Chilupuri) and further in view of Dunn et al. (US Pat. No. 9,111,030 – hereinafter Dunn).
With respect to claim 8, Arkadyev in view of Chilupuri is silent to disclose, however in an analogous art, Dunn teaches declaring and accessing a variable by assigning a prefix character to a variable name within the testing spreadsheet (See column 8 lines 5-16, “Automated testing software 111 may employ a naming convention for results files that associates the test cases with the corresponding result files. For example, as shown in FIG. 8, automated testing software 111 generates the string "31117+31118.20080619.103404 PASS.html" as the name for the results file corresponding to control file 114-1, e.g. results file 700. The file name includes the prefix "31117+31118," which represents the two test cases that were used to generate results file 700. The plus "+" character is used to concatenate each individual test case that was used to generate the results file.”. See column 9 lines 1-7, “In some embodiments, the naming convention also identifies certain components of software application 131 by using a prefix followed by an underscore "_" in the name of the results file. For example, software application 131 may include a "TestMatch" component. As shown in FIG. 7, the string "TestMatch" appears in the prefix of the name of results file 700.”). Therefore, it would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to modify the combination of Arkadyev and Chilupuri, by declaring and accessing a variable by assigning a prefix character to a variable name within the testing spreadsheet as suggested by Dunn, as Dunn would provide an enhanced way for testing software applications (see column 1 lines 15-17). With respect to claim 9, Arkadyev in view of Chilupuri is silent to disclose, however in an analogous art, Dunn teaches evaluating the testing spreadsheet to determine that a prefix character is assigned to at least one of a value within a cell of the testing spreadsheet to comment or exclude the value from the call, a method parameter to comment or exclude the method parameter from the call, or a sheet name to exclude or comment a corresponding test case; and in response to a value being assigned to a cell within a step number column, excluding or commenting a thread defined by a row that includes the cell (See column 8 lines 5-16, “Automated testing software 111 may employ a naming convention for results files that associates the test cases with the corresponding result files. For example, as shown in FIG. 8, automated testing software 111 generates the string "31117+31118.20080619.103404 PASS.html" as the name for the results file corresponding to control file 114-1, e.g. results file 700. The file name includes the prefix "31117+31118," which represents the two test cases that were used to generate results file 700. The plus "+" character is used to concatenate each individual test case that was used to generate the results file.”. See column 9 lines 1-7, “In some embodiments, the naming convention also identifies certain components of software application 131 by using a prefix followed by an underscore "_" in the name of the results file. For example, software application 131 may include a "TestMatch" component. As shown in FIG. 7, the string "TestMatch" appears in the prefix of the name of results file 700.”). Therefore, it would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to modify the combination of Arkadyev and Chilupuri, by evaluating the testing spreadsheet to determine that a prefix character is assigned to at least one of a value within a cell of the testing spreadsheet to comment or exclude the value from the call, a method parameter to comment or exclude the method parameter from the call, or a sheet name to exclude or comment a corresponding test case as suggested by Dunn, as Dunn would provide an enhanced way for testing software applications (see column 1 lines 15-17).
Claims 10 and 19 are rejected under 35 U.S.C. 103 as being unpatentable over Arkadyev (US Pub. No. 2017/0185509) in view of Chilupuri et al. (US Pub. No. 2023/0047837 – hereinafter Chilupuri) and further in view of Jafary (US Pub. No. 2017/0046251 – hereinafter Jafary). With respect to claim 10, Arkadyev in view of Chilupuri is silent to disclose, however in an analogous art, Jafary teaches implementing a control panel for each test case of the testing spreadsheet to override test control values, flow control values, step-level values, or thread- level values defined by the testing spreadsheet for the test cases, wherein a modification to the control panel modifies a test case without modifying values of steps or threads within the testing spreadsheet defined for the test case, and wherein the control panel is populated with a run threads field used to specify one or more threads in one or more steps to execute (see abstract and figure 2 (and related text)). Therefore, it would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to modify the combination of Arkadyev and Chilupuri, by implementing a control panel for each test case of the testing spreadsheet to override test control values, flow control values, step-level values, or thread- level values defined by the testing spreadsheet for the test cases, wherein a modification to the control panel modifies a test case without modifying values of steps or threads within the testing spreadsheet defined for the test case, and wherein the control panel is populated with a run threads field used to specify one or more threads in one or more steps to execute as suggested by Jafary, as Jafary would provide an enhanced step to use a test engine for reading the test suite spreadsheet and the test script configuration spreadsheets to execute the test scripts on any platform or browser specified by the test suite spreadsheet (see abstract).
With respect to claim 19, Arkadyev in view of Chilupuri is silent to disclose, however in an analogous art, Jafary teaches wherein the instructions cause the machine to: populate a control flag cell with at least one of a skip control value, a jump control value, an exit control value, pause control value, a thread control value, a batch control value, a test log control value, a status control value, a test verification control value, a serial mode flow control value, or a quick mode flow control value (see abstract and figure 2 (and related text)). Therefore, it would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to modify the combination of Arkadyev and Chilupuri, by populating a control flag cell with at least one of a skip control value, a jump control value, an exit control value, pause control value, a thread control value, a batch control value, a test log control value, a status control value, a test verification control value, a serial mode flow control value, or a quick mode flow control value as suggested by Jafary, as Jafary would provide an enhanced step to use a test engine for reading the test suite spreadsheet and the test script configuration spreadsheets to execute the test scripts on any platform or browser specified by the test suite spreadsheet (see abstract).
Claim 20 is rejected under 35 U.S.C. 103 as being unpatentable over Arkadyev (US Pub. No. 2017/0185509) in view of Chilupuri et al. (US Pub. No. 2023/0047837 – hereinafter Chilupuri) and further in view of Dolinina et al. (US Pub. No. 2014/0075242 – hereinafter Dolinina).
With respect to claim 20, Arkadyev in view of Chilupuri is silent to disclose, however in an analogous art, Dolinina teaches wherein the instructions cause the machine to: utilize a command line parameter to alter a value of a variable within the testing spreadsheet for a test case at runtime, wherein the test case is run for different test scenarios using override values input through the command line parameter without modifying original values within the testing spreadsheet (see paragraphs [0020], [0058] and figures 1-9 (and related text), “The user can insert a START_GROUP cell 702 and an END_GROUP cell 704 that define the boundaries of the group, so that the test runner 108 treats tests between the START_GROUP cell 702 and the END_GROUP cell 704 as a group. The test runner 108 executes or causes to be executed test actions 112 on the target test platform via a REST based engine, such as an API, a command line interface (CLI), or a software development kit (SDK). The test runner 108 can send all types of REST API requests, such as GET, PUT, POST, DELETE, TRACE, or CONNECT. The test runner 108 can receive feedback regarding the progress, success, failure, or other status of tests, which a results reporter 110 can output to a user. The results reporter 110 can report results via active messages, such as a pop-up in a graphical user interface, via email or text message, via an entry in a log, and so forth. The results reporter 110 can generate nested reports containing results of sub-tests. The results reporter 110 can also generate a single report summarizing the results of the test actions 112 for a particular product, product category, feature, test suite, unit test, and so forth. The test runner 108 can simultaneously execute multiple sets of test actions 112, which can be for the same API engine 114 or a set of different test interfaces.”). Therefore, it would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to modify the combination of Arkadyev and Chilupuri, by utilizing a command line parameter to alter a value of a variable within the testing spreadsheet for a test case at runtime, wherein the test case is run for different test scenarios using override values input through the command line parameter without modifying original values within the testing spreadsheet as suggested by Dolinina, as Dolinina would provide an enhanced step to automated testing of different products with different REST API formats (see paragraph [0001]).
Conclusion
The prior art made of record and not relied upon is considered pertinent to applicant's disclosure. S et al. (US Pat. No. 2024/0354238) discloses a method to retrieve for an automate for an application under test, the application under test including a user interface displaying at least one web object; execute the automate, wherein execution of the automate further comprises: identifying at least one Open Data Protocol (OData) call in the automate; mapping at least one test data value for the web object to a corresponding parameter in the OData call; and executing the at least one OData call with the mapped at least one test data value, wherein execution of the at least one OData call outputs a response. (see abstract).
Kambadahalli et al. (US Pat. No. 2024/0241816) discloses an automated test generation system including a processing system and a memory system in communication with the processing system. The memory system stores instructions of an automated test generator that when executed result in parsing a test input sheet to identify one or more inputs, outputs, and expressions that define software requirements in a logical form with respect to the inputs, accessing a data dictionary to determine limits of the inputs, applying test case generation rules to produce test cases to test whether a software configuration item under test meets the software requirements, and applying test script generation rules to produce test scripts that implement the test cases by setting values of the inputs to the software configuration item under test based on the limits and the expressions to verify the outputs. (see abstract).
Any inquiry concerning this communication or earlier communications from the examiner should be directed to ANIBAL RIVERACRUZ whose telephone number is (571)270-1200. The examiner can normally be reached Monday-Friday 9:30 AM-6:00 PM.
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 5712726799. 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.
/ANIBAL RIVERACRUZ/Primary Examiner, Art Unit 2192
Prosecution Insights