| Entries |
| Document | Title | Date |
|---|
| 20080209406 | History-based call stack construction - In a computing system environment, methods and apparatus relate to constructing a call stack for a software program based upon a comprehensive recording of an execution history of the software program. Upon defining procedure calls and returns in the execution history, a call stack is constructed for the procedure calls having no corresponding returns, but without reading or otherwise examining allocated stack memory or registers, such as return addresses. In this manner, an accurate call stack can be constructed despite stack memory or registers being erased or corrupted or despite various compiler optimizations eliminating convenience or otherwise complicating the construction. Nuances for defining procedure calls and returns as well as stack pointer values for same are also contemplated. Still other embodiments relate to stand-alone computer program products (on computer-readable media or as a download, or other) or those working in conjunction with other programs. | 08-28-2008 |
| 20080256520 | METHOD FOR ANALYZING FFECTS OF PERFORMANCE CHARACTERISTICS OF AN APPLICATION BASED ON COMPLEX CONFIGURATION MODELS - A method is provided for analyzing performance of a software application that is configured to contain a number of objects, wherein the application defines operations that include respective objects and relationships corresponding thereto. Performance costs are assigned to respective objects and to their corresponding relationships, and a total cost is computed for each of the operations from the assigned performance costs. Notice is provided when the cost of a particular operation exceeds a pre-specified performance threshold. | 10-16-2008 |
| 20080263525 | METHOD AND SYSTEM FOR DETECTING VULNERABILITIES IN SOURCE CODE - A method and system of detecting vulnerabilities in source code. Source code is parsed into an intermediate representation. Models (e.g., in the form of lattices) are derived for the variables in the code and for the variables and/or expressions used in conjunction with routine calls. The models are then analyzed in conjunction with pre-specified rules about the routines to determine if the routine call posses one or more of pre-selected vulnerabilities. | 10-23-2008 |
| 20080270997 | Automatic data manipulation to influence code paths - Software development and testing systems use adaptive feedback to construct an input dataset for a target program. The target's operation is monitored to identify significant events that correlate with the input dataset. Critical events are detected and reported to a user. Various methods of implementing the adaptive feedback, and systems that can be tested using these methods, are also described. | 10-30-2008 |
| 20080270998 | Application integration testing - Application testing is disclosed. A definition of a test to be performed on a subject application is received in a generic form not specific to the subject application. The test is performed by exchanging data with the subject application, as required to perform the test, using a test connector application associated with the subject application to do at least one of (1) convert an input data to be supplied to the subject application during the test from a generic data format not specific to the subject application into an application-specific data format associated with the subject application, if the application-specific data format is different than the generic data format and (2) normalize an output data received from the subject application in the application-specific data format into the generic data format not specific to the subject application, if the application-specific data format is different than the generic data format. | 10-30-2008 |
| 20080276228 | SYSTEM AND METHOD FOR STATIC ANALYSIS USING FAULT PATHS - A system and method for analyzing a program includes determining possible bug paths in a program based on statistical analysis of test cases. A static analysis is then performed only on the possible bug paths. The bugs are then located in the program. | 11-06-2008 |
| 20080282235 | Facilitating Assessment Of A Test Suite Of A Software Product - Facilitating assessment of a test suite of a software product. In an embodiment, an inventory is maintained containing the features of the software product and one or more execution flows operative when a feature is provided by the software product. Information related to execution flows for which test scripts are present (in the test suite) is also indicated in the inventory. Various test metrics and views are provided to a user facilitating the user to assess the test suite of the software product. | 11-13-2008 |
| 20080307397 | Program Analysis by Partial Emulation - Program code is statically analyzed (without actually executing the code) by “virtually” executing the code with a virtual processor or emulator that steps through the code. The analysis includes locating entry and exit points, identifying branch points, analyzing one or more code paths from a branch, noting calls to external functions (e.g., libraries), etc. Programming logic errors can be located, such as calls that never return or isolated code that can never be reached. Analysis can include dynamic analysis of code when emulation is combined with a debugger, for example. | 12-11-2008 |
| 20090007078 | Computer-Implemented Systems And Methods For Software Application Testing - Computer-implemented systems and methods for testing one or more software applications. For example, a system and method can be configured to perform a comparison between test data results and benchmark test data in order to determine test result differences between the received test data results and the retrieved benchmark test data. Testing criteria is applied to the determined test result differences in order to identify test deviations from the benchmark test data. | 01-01-2009 |
| 20090044177 | METHOD AND APPARATUS FOR PROFILE ENHANCED SOURCE CODE ANALYZER RESULTS - A computer implemented method, apparatus, and computer program product for generating enhanced source code analyzer results. The process receives a plurality of results generated by a static code analysis for a computer program. Profile data associated with the computer program is received. A priority for each result in the plurality of results is identified to form prioritized results. A prioritized static analysis report is generated using the prioritized results. The prioritized static analysis report indicates the priority for each result in the plurality of results. | 02-12-2009 |
| 20090055806 | Techniques for Employing Aspect Advice Based on an Object State - A technique of employing advice with base code includes parsing an object state filter in an advice pointcut of the advice and generating a subroutine to evaluate whether an object state meets the object state filter. The subroutine, one or more bound aspect parameters, and an advice body of the advice is then weaved with the base code. | 02-26-2009 |
| 20090094585 | METHOD AND APPARATUS FOR ANALYZING EXPLOIT CODE IN NONEXECUTABLE FILE USING VIRTUAL ENVIRONMENT - Provided is a method and apparatus for analyzing an exploit code included in a nonexecutable file using a target program with vulnerability in a virtual environment. The method includes the steps of: loading a nonexecutable file including the exploit code by a target program, the target program being executed in a virtual environment and includes vulnerability; analyzing a register value of the target program and determining if the register value of the target program indicates a normal code region; storing log information on operation of the target program when the register value indicates a region other than the normal code region; and extracting and analyzing the exploit code included in the nonexecutable file based on the stored log information. In this method, the exploit code is analyzed in the virtual environment, thereby preventing damage caused by execution of the exploit code. | 04-09-2009 |
| 20090100415 | APPARATUS FOR AND METHOD OF IMPLEMENTING FEEDBACK DIRECTED DEPENDENCY ANALYSIS OF SOFTWARE APPLICATIONS - A novel and useful mechanism for optimizing the detection of dependencies in a software system via feedback between static and dynamic engines. The present invention enables dynamic analysis to be more effective by using the results of static analysis to identify sections that need to be traced during dynamic analysis. The method also increases the accuracy of static analysis by using dynamic values as inputs to static analysis. Dynamic values used as inputs for static analysis are a result of dynamic analysis. The mechanism first executes a static analysis, then executes a dynamic analysis targeting the sections identified by the static analysis and finally executes a static analysis using the dynamic values identified during the dynamic analysis in order to detect dependencies. The present invention also provides a mechanism to analyze a specific section of a software system by first executing a dynamic analysis targeting the specific section and then executing a static analysis using the dynamic values identified during the dynamic analysis. | 04-16-2009 |
| 20090106742 | Framework for Testing API of a Software Application - A test executor for testing an application programming interface of a software application includes a plurality of invokers, a mapper/converter, and a comparer. The plurality of invokers includes a software application invoker and a database application invoker. The software application invoker is adapted to communicate with a software application through an application programming interface of the software application while the database application invoker is adapted to communicate with a database application through an application programming interface of the database application. The mapper/converter is in communication with the plurality of invokers. The mapper/converter converts results from at least one of the software application invoker and the database application invoker into a common data format. The comparer is in communication with the mapper/converter and compares the results in the common data format to assess the functionality of the application programming interface of the software application. | 04-23-2009 |
| 20090119648 | APPARATUS AND METHOD FOR ANALYZING SOURCE CODE USING MEMORY OPERATION EVALUATION AND BOOLEAN SATISFIABILITY - A computer readable storage medium includes executable instructions to identify a memory operation in target source code. A set of constraints associated with the memory operation are developed. The constraints are converted into a Boolean expression. The Boolean expression is processed with a Boolean satisfiability engine to determine whether the memory operation is potentially unsafe. | 05-07-2009 |
| 20090119649 | STATIC ANALYSIS DEFECT DETECTION IN THE PRESENCE OF VIRTUAL FUNCTION CALLS - A computer-implemented error detection mechanism for detecting programming errors in a computer program. The computer-implemented error detection method described herein can make use of a Function Behaviour Knowledge Base (FBKB) to approximate how a virtual function changes state of the program execution for all methods that can be called at each specific invocation point. The FBKB is used to select what implementation of a virtual function should be called in order to give rise to a programming defect. By dropping implementations that do not lead to a programming defect, the set of possible object runtime types is reduced. If this set is empty by the end of the analysis, then a defect is not possible, otherwise the set of object runtime types will contain types that may cause a defect. | 05-07-2009 |
| 20090125891 | METHOD AND SYSTEM FOR MONITORING CODE CHANGE IMPACT ON SOFTWARE PERFORMANCE - Method and system for detection and notification of performance changes in program code. In one aspect, stored previous routine test results and current routine test results are accessed, indicating a previous and current time of execution of the program code, the current routine test performed later than the previous routine test. The previous and current times of execution are automatically compared and a change in performance of the program code is determined. Users are notified of the change in performance, where each user is notified after the change in performance is determined to be significant enough to the particular user according to associated predetermined criteria. | 05-14-2009 |
| 20090138859 | SAMPLING BASED RUNTIME OPTIMIZER FOR EFFICIENT DEBUGGING OF APPLICATIONS - A method of reproducing runtime environment for debugging an application is disclosed. The method includes reading an optimizer file from a non-volatile storage medium. The optimizer file includes a runtime environment, application definition information, and a log. The log includes summaries of a plurality of events, the plurality of actions, and a time mark of occurrence for each of the plurality of actions. A runtime environment for debugging the application is then defined and the application runtime is set up using the application definition information in the optimizer file. Further, the method includes running the application and attaching an optimizer, then triggering each of the plurality of actions to occur at each time mark of occurrence associated with the each of the plurality of actions, and analyzing each of the plurality of actions and the plurality of events associated with the each of the plurality of actions, the analyzing includes comparing the events produced by running the application with the plurality of events in the optimizer file. If a fault is produced by the triggering, a debugger is invoked to analyze the fault. | 05-28-2009 |
| 20090138860 | PROGRAM ANALYSIS METHOD AMD APPARATUS - A program analysis method includes: analyzing, for each program, correlation between plural property values of properties including a property concerning a cost and the accumulated number of failures; calculating a failure forecast value for each program, based on the analysis result and the plural property values of the properties including the property concerning the cost; calculating a latent risk value for each program based on the accumulated number of failures, the failure forecast value, an assumed damage degree per one failure; and selecting a program to be processed based on the latent risk values. Thus, it becomes possible to identify a program for which the maintenance should be carried out, based on the latent risk. | 05-28-2009 |
| 20090158259 | DETERMINISTIC PSEUDO-RANDOM FAULT EVENT RECORDATION AND INJECTION TOOL - A method is presented for recording and injecting a fault event during execution of a computer program. The method may include detecting a method call event during execution of the program, incrementing a counter to produce a counter value, and determining, based on a program execution state, a fault event to be generated. The fault event may be associated with a fault event type. The fault event type and the counter value may be stored, and the fault event may be generated. A second method call event may be detected during execution of the program and a second counter may be incremented, producing a second counter value. A previously-generated fault event associated with a counter value matching the second counter value may be identified, and the previously-generated fault event may be generated. | 06-18-2009 |
| 20090204952 | METHOD OF SECURING A COMPUTER PROGRAM. AND CORRESPONDING DEVICE, METHOD OF UPDATING AND UPDATE SERVER - A method for securing use of a primary computer program driving at least one data receiving and delivery device. The method implements a secondary computer checking program, different from the primary program and capable of delivering the same output data as at least a portion of the primary program, referred to as the critical portion, in the presence of identical input data. The following steps are performed when at least one of the critical portions of the primary program is activated: executing the critical portion, delivering first output data based on input data; executing the checking program, delivering second output data based on the input data; comparing the first and second output data and generating anomaly information, if the first and second output data are different; transmitting the anomaly information to a remote server; and continuing the primary program, based on the first and second output data. | 08-13-2009 |
| 20090217247 | Program performance analysis apparatus - To provide a program performance analysis apparatus that can present to a user whether tuning made to a program operating on a predetermined hardware is either good or bad, a performance information acquisition unit for obtaining the performance information of a program, a difference information generation unit for generating difference information by making a comparison between the performance information of a first program and that of a second program obtained by making a change to the first program, and a change evaluation unit for evaluating whether the change is either good or bad are comprised. | 08-27-2009 |
| 20090249307 | PROGRAM ANALYSIS APPARATUS, PROGRAM ANALYSIS METHOD, AND PROGRAM STORAGE MEDIUM - There is provided with an apparatus which includes: an inputting unit which inputs a target program and address definition data, a first analyzer which generates definition-reference data associating a line number of a statement, an address of a definition variable and an address of a reference variable; a second analyzer which generates address dependency data that associates the address of the definition variable, the line number of a statement containing the definition variable, and the line number of a statement containing a reference variable of same address as the definition variable; a third analyzer which generates control dependency data that associates the line number of a control statement and the line number of a controlled-object statement; and an extracting unit which extracts a slice as a set of statements reached based on the control dependency data and the address dependency data starting from the statement of a desired line number. | 10-01-2009 |
| 20090259995 | Apparatus and Method for Standardizing Textual Elements of an Unstructured Text - In one embodiment the present invention includes a method for standardizing certain textual elements of an unstructured text to enhance the use of the unstructured text as a data source for an analytical processing tool. In accordance with one or more user-defined pre-processing directives, a pre-processing logic identifies textual elements of a certain type, and converts the underlying textual elements to conform to user-defined standards for the particular type. The converted textual element is then inserted into the unstructured text, or an index based on the unstructured text, thereby improving the use of the unstructured text as a data source for conventional analytical processing (e.g., querying) tools. | 10-15-2009 |
| 20090265693 | METHOD AND SYSTEM FOR TEST RUN PRIORITIZATION FOR SOFTWARE CODE TESTING IN AUTOMATED TEST EXECUTION - A method and system for software code testing for an automated test execution environment is provided. Testing involves importing test case information into a tooling environment based on code coverage and targeted testing, the test information including test name and code coverage data including classes and methods exercised by the code; generating a test hierarchy by analyzing the individual test case information; selecting tests including one or more of: all tests for a full regression run, a subset of tests for basic quality assurance or testing a particular area of functionality, and tests that exercise a recently changed class; executing selected tests to generate a pass/fail result for each test and correlating the test results; performing test run prioritization to recommend which remaining tests to execute. | 10-22-2009 |
| 20090265694 | METHOD AND SYSTEM FOR TEST FAILURE ANALYSIS PRIORITIZATION FOR SOFTWARE CODE TESTING IN AUTOMATED TEST EXECUTION - A method and system for software code testing for an automated test execution environment is provided. Testing involves importing test case information into a tooling environment based on code coverage and targeted testing, the test information including test name and code coverage data including classes and methods exercised by the code; generating a test hierarchy by analyzing the individual test case information; selecting tests including one or more of: all tests for a full regression run, a subset of tests for basic quality assurance or testing a particular area of functionality, and tests that exercise a recently changed class; executing selected tests to generate a pass/fail result for each test and correlating the test results; performing test failure analysis prioritization to prioritize any failures. | 10-22-2009 |
| 20090265695 | METHOD AND APPARATUS FOR ANALYZING PROGRAM EXECUTION PATH - An apparatus that analyzes execution paths of a target program includes a setting unit, a detecting unit, a determining unit, and a plurality of buffers. The setting unit stores a condition for determining whether or not to record events caused by execution of the target program. The detecting unit detects input and output data and events which are caused by execution of the target program. The determining unit determines whether or not to record the events based on the condition. The plurality of buffers store the events correlated with the input and output data if the determining unit determines to record the events. | 10-22-2009 |
| 20090282392 | METHOD AND SYSTEM FOR DEBUGGING DATA INTEGRATION APPLICATIONS WITH REUSABLE SYNTHETIC DATA VALUES - A method and system for debugging data integration applications with reusable synthetic data values. The method includes receiving a specification for a data integration application comprising transformation rules, receiving synthetic data values to use as test values for the inputs of the transformation rules, and using the synthetic data values for testing the functionality of the transformation rules. | 11-12-2009 |
| 20090288072 | Automatic Tests of Product Documentation - A computer implemented method of software product documentation review involves importing a description of a structure of the product documentation for use in determining locations in the product documentation from which to extract code and/or command portions of the product documentation for testing and providing pre-defined test case stub files for the product documentation into which are inserted extracted portions of the product documentation for testing. The test case stub files are run with the code and/or command portions inserted to determine whether or not they are runnable which is indicative of whether or not an error is present in the documentation. | 11-19-2009 |
| 20090293044 | Graphical Program Code Coverage - System and method for analyzing a graphical program. A graphical program is provided that includes a plurality of interconnected nodes that visually indicate functionality of the program. The graphical program includes a plurality of block diagrams arranged in a hierarchical manner, including a top-level block diagram and one or more sub-block diagrams, where each block diagram includes a respective subset of the plurality of interconnected nodes. At least one of the block diagrams includes a node that includes at least one of the sub-block diagrams. When a block diagram executes, all the respective nodes of the block diagram execute. Each node in the plurality of interconnected nodes is configured to provide graphical code coverage information when executed. The graphical program is executed, thereby generating graphical code coverage information for the graphical program indicating which nodes executed, which is then stored. | 11-26-2009 |
| 20090300588 | METHOD AND APPARATUS FOR ACQUIRING DEFINITIONS OF DEBUG CODE OF BASIC INPUT/OUTPUT SYSTEM - An apparatus for acquiring information on debug codes of BIOS includes an information memory module, a detecting module, a control module, and an information display module. The information memory module is capable of storing POST codes and information corresponding to the POST codes. The detecting module is capable of real-time scanning address port of a bus of, for example, a motherboard, and transforming data from the address port to POST codes. The control module is capable of receiving the detected POST codes from the detecting module, and comparing the detected POST codes with the stored POST codes in the information memory module to look up information corresponding to the detected POST codes. An information display module is controlled by the control module and capable of displaying the detected POST codes and the information corresponding to the detected POST codes. | 12-03-2009 |
| 20090320002 | METHOD AND SYSTEM FOR TESTING AND ANALYZING USER INTERFACES - A system and method is described in which the state of the art in automated software applications is significantly improved. According to some approaches, interface testing is implemented and based upon a verification language and a verification environment. The system and method support the concepts of constrained random test generation, coverage, constrained random generation, and dynamic checks. | 12-24-2009 |
| 20100011346 | CONTROL CHART TECHNIQUE FOR ANALYZING SOFTWARE ENGINEERING ACTIVITIES AFFECTED BY INTRINSIC PROCESS VARIATION AND STATISTICAL FLUCTUATIONS - In software engineering, the performance or efficiency of individual process steps is typically defined as some sort of rate such as the number of detected defects divided by the effort spent for review or testing. In this situation, the variation in tie data always reflects a mixture of intrinsic process variation caused by, for example, human factors such as the experience of reviewers or the variable quality of the review objects, and purely statistical variation due to the effects of Poisson statistics when defects are counted. Due to this mixture of causes of variation no conventional statistical process control chart holds for the constraints of typical software engineering processes. A new statistical process control (SPC) approach (method and system) is presented to overcome the mentioned problems. | 01-14-2010 |
| 20100058299 | METHOD OF ARRAY INTERCEPTION USING DATA-FLOW ANALYSIS - An apparatus and a method for Java array interception using bytecode manipulation and data flow analysis. In one embodiment, a user-provided object class is identified. An array access operation of the user-provided object class is intercepted. The intercepted array access operation is translated with an emulator class of a native Java array. The translated array access operation is sent to an emulator class to determine whether to dispatch to the native Java array or an alternate data source. | 03-04-2010 |
| 20100058300 | TEST COVERAGE ANALYSIS METHOD AND APPARATUS - A test coverage analysis method and corresponding apparatus are disclosed, wherein, by executing the program under test using one or more test cases, generating one or more heapdump files containing the call stack information of the program under test, and analyzing the call stack information in the one or more heapdump files, the coverage information of the one or more test cases in terms of functions in the program under test is obtained. | 03-04-2010 |
| 20100100874 | COMPLEXITY DEPENDENCY CHANGE IMPACT SYSTEM AND METHOD - A complexity dependency change impact system and method is disclosed. In one embodiment, a method of determining an efficient software testing scheme based on a dependency structure matrix (DSM) analysis includes generating a compressed DSM based on cyclic blocks associated with modules of a software application, tagging and levelling the modules of the software application based on the compressed DSM, and generating at least one compressed partition matrix based on the tagged and levelled modules. The method further includes generating at least one expanded partition matrix based on the at least one compressed partition matrix, generating value threads using the at least one compressed partition matrix and obtaining a new scheduling table and performing a path analysis using the value threads to determine the efficient software testing scheme. | 04-22-2010 |
| 20100107145 | Software Performance Analysis Using Data Mining - A system, method, and computer program for analyzing code execution and software performance characteristics are disclosed. Samples of code during run-time or from crash logs can be displayed as both a top-down tree of calls from a particular function and a bottom-up tree of calls to the particular function. Data mining techniques, including filtering and focusing, remove code that is not of interest and display code that is more relevant to performance analysis. In particular, functions contained in libraries such as system libraries can be stripped from view. The cost associated with an excluded function can be propagated to a calling function, in either the top-down or bottom-up tree. | 04-29-2010 |
| 20100122239 | METHOD AND APPARATUS FOR MONITORING RUNTIME OF PERSISTENCE APPLICATIONS - A monitoring method and apparatus monitors a runtime application to collect and display static and dynamic data concerning software entities and database operations in a runtime environment. In one embodiment, monitoring classes are used to collect monitoring data from at least one PersistenceUnit (PU) and at least one PersistenceContext (PC) associated with the PU of an application the uses an in implementation of a Java Persistence Application Programming Interface (JPA). A Java Management Extension (JMX) MBean communicates with the monitoring classes to expose monitoring data outside the runtime environment. | 05-13-2010 |
| 20100122240 | Method and apparatus for analyzing application - An application analyzing method includes extracting a variable corresponding to a particular input data item and information regarding a value of the variable by analyzing a plurality of source programs constituting an application, record information of a database used by the application, and execution control information of the application, and outputting, based on the variable and the information regarding the value of the variable extracted in the extracting, information regarding a presumed value with respect to the input data item as presumed requirement information. | 05-13-2010 |
| 20100138812 | SYSTEM AND METHOD FOR ANALYZING PERFORMANCE OF A SOFTWARE TESTING SYSTEM - A system and method for analyzing performance of a software testing system is disclosed. In one embodiment, a method of analyzing performance of a software testing system associated with a software system having multiple modules includes performing a computer-based complexity analysis of the software system, performing a computer-based impact analysis of information related to an impact of a defect on a module of the software system, and generating a computer-based distribution of effort across an impacted module of the software system based on the complexity analysis and the impact analysis to enhance the software testing system performance. The information may include reported defects from a working environment associated with the software system. The method may also include utilizing output data associated with the complexity analysis as input data to the impact analysis. | 06-03-2010 |
| 20100138813 | METHOD AND APPARATUS FOR TESTING ONLINE PERFORMANCE ON CLIENT/SERVER ARCHITECTURE - An apparatus for testing online performance on a client/server architecture, includes: a client group connected to a server group; and a server group for providing the online service to the client group and capturing packet information based on communication with the client group. Further, the apparatus for testing online performance on a client/server architecture includes a central management unit for carrying out analysis, edition, and scripting for the captured packet information to overall manage an online performance test between the client group and the server group; and a load generation unit for generating a virtual client in accordance with the scripting result of the central management unit to regenerate a load in the server group. | 06-03-2010 |
| 20100146490 | METHOD FOR TESTING A COMPUTER PROGRAM - The invention relates to a method for testing a computer program after changing a first version of the computer program into a second version of the computer program due to a revision of the computer program. The method comprises the steps of | 06-10-2010 |
| 20100180262 | OVERLAY IDENTIFICATION OF DATA PROCESSING TARGET STRUCTURE - A method, system, and computer program product for identifying an overlay of a data processing target structure in a computing environment is provided. At least one of examining a mapping macro for the target structure with a set of valid ranges, comparing the set of valid ranges with the target structure to identify a string of at least one first invalid value and a last invalid value and locate invalid regions of the target structure, and examining executable code associated with the target structure, comparing at least one unchanged module against at least one additional module exhibiting an overlay characteristic to identify the string of the at least one first invalid value and the last invalid value and locate invalid regions of the target structure, is performed. | 07-15-2010 |
| 20100186004 | DATA ANALYSIS SYSTEM AND METHOD - A method, computer program product, and system for collecting technical support data associated with at least one of a plurality of products, thus generating collected technical support data. The collected technical support data is analyzed to identify one or more product issues within the collected data. One or more product recommendations is generated concerning potential solutions to the one or more identified issues in response to the analysis of the collected technical data. | 07-22-2010 |
| 20100223600 | THREAD EXECUTION ANALYZER - A thread execution analyzer analyzes blocking events of threads in a program using execution data and callstacks collected at the blocking events. The thread execution analyzer attempts to identify an application programming interface (API) responsible for each blocking event and provides blocking analysis information to a user. The blocking analysis information may be used by a developer of the program to understand the causes of blocking events that occur for threads of the program. | 09-02-2010 |
| 20100242028 | SYSTEM AND METHOD FOR PERFORMING CODE PROVENANCE REVIEW IN A SOFTWARE DUE DILIGENCE SYSTEM - A system and method is provided for performing code provenance review in a software due diligence system. In particular, performing code provenance review may include sub-dividing source code under review and third-party source into logical fragments using a language-independent text fracturing algorithm. For example, the fracturing algorithm may include a set of heuristic rules that account for variations in coding style to create logical fragments that are as large as possible without being independently copyrightable. Unique fingerprints may then be generated for the logical fragments using a fingerprint algorithm that features arithmetic computation. As such, potentially related source code may be identified if sub-dividing the source code under review and the third-party source code produces one or more logical fragments that have identical fingerprints. | 09-23-2010 |
| 20100251221 | COMBINATION MAY-MUST CODE ANALYSIS - A method of analyzing a computer application is disclosed. The method may break an application into components and the method may determine if the components have already been analyzed for errors, either through static analysis or by a code analysis. If the component has already been analyzed, the previous analysis may be used and the method may move on to the next code section. If the component has not been analyzed, it may be determined if the component may be reached from a given starting point. If the component cannot be reached from a given starting point, the component may not be analyzed. Both static and code testing tools may be used to determine if errors exist. The fined-grained coupling and alternation of may (universal) and must (existential) summaries allow the method to easily navigate through these code fragments while traditional may-only, must-only or non-compositional may-must al-gorithms are stuck in their specific analyses. | 09-30-2010 |
| 20100313186 | DEVELOPER-MANAGED DEBUGGER DATA RECORDS - A developer analysis record supports debugging. One developer analysis record contains a copy of a debuggee source code expression including one or more variables. An expression location in the record specifies the location of the expression within debuggee source code, and an expression scope specifies the scope of the expression within the source code. Developer comments about the expression may be stored in the record, distinct from source code and free from programming language syntax restrictions. The developer analysis record can be stored by a developer during one debugger session and then retrieved by the same or another developer during a later debugger session. The developer analysis record can be displayed and updated in a floating window, such as a tear-off floating datatip window. | 12-09-2010 |
| 20100313187 | METHOD AND SYSTEM FOR DETECTING INFEASIBLE PATHS - A method of testing a software program comprises obtaining path properties of an infeasible path, selecting a path from the software program and obtaining path properties of the selected path, wherein the method further comprises comparing path properties of the selected path to the path properties of the infeasible path to identify a target path and determine infeasibility of the target path. | 12-09-2010 |
| 20100333073 | SYSTEMS AND METHODS FOR AUTOMATED GENERATION OF SOFTWARE TESTS BASED ON MODELING THE SOFTWARE TEST DOMAIN - Systems and methods for automatically generating test procedures for a software application. In an example method a user creates a test case model based on requirements associated with the software application under test. The user then generates an interface control document. The interface control document includes associations of information between the requirements and the test case model. Next, a processing device automatically generates test procedures for the software application under test based on the interface control document, the requirements and the test case model. The processor automatically creates a local copy of the test case model based on the interface control document. | 12-30-2010 |
| 20110016456 | GENERATING ADDITIONAL USER INPUTS FOR FAULT DETECTION AND LOCALIZATION IN DYNAMIC SOFTWARE APPLICATIONS - The present invention provides a system, computer program product and a computer implemented method for prioritizing code fragments based on the use of a software oracle and on a correlation between the executed code fragments and the output they produce. Also described is a computer-implemented method generates additional user inputs based on execution information associated with path constraints and based on information from the oracle. Advantageously, the embodiment is useful in a test generation tool that generated many similar inputs when a failure-inducing input is found, in order to enhance fault localization. Further, described is a computer-implemented flow for extending the existing idea of concolic testing to applications that interact with persistent state. | 01-20-2011 |
| 20110016457 | FAULT DETECTION AND LOCALIZATION IN DYNAMIC SOFTWARE APPLICATIONS REQUIRING USER INPUTS AND PERSISTENT STATES - The present invention provides a system, computer program product and a computer implemented method for prioritizing code fragments based on the use of a software oracle and on a correlation between the executed code fragments and the output they produce. Also described is a computer-implemented method generates additional user inputs based on execution information associated with path constraints and based on information from the oracle. Advantageously, the embodiment is useful in a test generation tool that generated many similar inputs when a failure-inducing input is found, in order to enhance fault localization. Further, described is a computer-implemented flow for extending the existing idea of concolic testing to applications that interact with persistent state. | 01-20-2011 |
| 20110029959 | TECHNIQUES FOR DISCOVERING DATABASE CONNECTIVITY LEAKS - Techniques for discovering database connectivity leaks are presented. Each connection made by an application to a database is monitored. When the application is shut down, if information regarding a particular connection remains in memory, then that connection is reported as a potential database connectivity leak. | 02-03-2011 |
| 20110061043 | Devices, Methods And Computer Program Products For Reverse Execution Of A Simulation - Devices, methods, and software program products for reverse execution of a simulation and/or tracing a value are provided. A state of a preceding checkpoint may be restored and a simulation may be run forward. Break points or watch points may be noted and the state of the last occurring breakpoint or watch point preceding the current simulation position may be restored. If no breakpoint or watch point occurred, an earlier checkpoint may be loaded and the previous steps may be repeated. | 03-10-2011 |
| 20110078665 | COMPUTING A SYMBOLIC BOUND FOR A PROCEDURE - A system that facilitates computing a symbolic bound with respect to a procedure that is executable by a processor on a computing device is described herein. The system includes a transition system generator component that receives the procedure and computes a disjunctive transition system for a control location in the procedure. A compute bound component computes a bound for the transition system, wherein the bound is expressed in terms of inputs to the transition system. The system further includes a translator component that translates the bound computed by the compute bound component such that the bound is expressed in terms of inputs to the procedure. | 03-31-2011 |
| 20110078666 | System and Method for Reproducing Device Program Execution - Provided are a system and method for precisely reproducing a device program execution, such as reproducing a software program executed on a computer for example. The method provides a solution to a class of diagnosis methods known as “record/replay” or “deterministic replay”, where information related to a program execution is recorded for later replay, often for diagnostic purposes to reproduce errors in device function such as software bugs and other anomalous behavior. In contrast with other methods in this class, the invention provides a method for low-overhead recording and high-precision replay of programs possibly utilizing multiple processor cores, and also low-overhead recording and high-precision replay of programs that perform input and/or output operations at high data rates, and further provides a system and method provide a solution with substantially few hardware requirements beyond that of a modern electronic device, such as a personal computer, or a laptop computer, or other electronic device controlled by one or more processors. Taken together, these features enable efficient and cost-effective execution replay of modern multiprocessor and networked software. | 03-31-2011 |
| 20110088018 | METHODS AND APPARATUS FOR TESTING USER INTERFACES - Methods and apparatus for testing user interfaces are disclosed herein. An example method includes extracting object data from a file associated with a user interface; storing a plurality of object definitions corresponding to the extracted object data in a computer readable storage medium; and generating, at a computer having a tangible memory, a test script for the user interface using the object definitions, wherein the test script is to be generated based on one or more test definitions defining one or more attributes of the object definitions to be tested in the test script, and wherein the test script is to be generated based on one or more automation rules defining how the object definitions are to be tested. | 04-14-2011 |
| 20110131554 | APPLICATION GENERATION SYSTEM, METHOD, AND PROGRAM PRODUCT - A method, system and computer program product for optimizing performance of an application running on a hybrid system. The method includes the steps of: selecting a first user defined operator from a library component within the application; determining at least one available hardware resource; generating at least one execution pattern for the first user defined operator based on the available hardware resource; compiling the execution pattern; measuring the execution speed of the execution pattern on the available hardware resource; and storing the execution speed and the execution pattern in an optimization table; where at least one of the steps is carried out using a computer device so that performance of said application is optimized on the hybrid system. | 06-02-2011 |
| 20110161937 | PROCESSING PREDICATES INCLUDING POINTER INFORMATION - A system is described for processing predicates in the course of analyzing a program, based on a general-purpose theory of pointers. The system converts location expressions in the predicates into logical formulae that are interpretable by a theorem prover module, producing converted predicates. This conversion associates the location expressions with location objects. More specifically, the conversion represents variables as explicitly-specified location objects, and location terms (such as a field-type access terms and dereference-type terms) as constructor-specified location objects. The theory of pointers is also expressed by a set of axioms which constrain the operation of the theorem prover module. | 06-30-2011 |
| 20110161938 | INCLUDING DEFECT CONTENT IN SOURCE CODE AND PRODUCING QUALITY REPORTS FROM THE SAME - Defect content for a computer program product can be stored with source code of the computer program product. A computer program product analysis tool having a graphical user interface can be provided. Search criteria for defect content for the computer program product can be specified by a user via the graphical user interface. The stored defect content of the source code of the computer program product can be searched based on the search criteria. A computer program product quality report can be produced for the computer program product based on results of the searching of the stored defect content. | 06-30-2011 |
| 20110167413 | COVERAGE APPARATUS AND METHOD FOR TESTING MULTI-THREAD ENVIRONMENT - A coverage apparatus and method for testing a multi-thread environment is provided. The coverage apparatus and method analyzes an application to search for synchronization blocks, forcedly schedules an execution order of a plurality of threads including the detected synchronization blocks in such a manner as to induce execution conflicts of the synchronization blocks, and then executes the threads in the scheduled order to perform coverage of the corresponding application. | 07-07-2011 |
| 20110173592 | Architectural Support for Automated Assertion Checking - A mechanism is provided for automatic detection of assertion violations. An application may write assertion tuples to the assertion checking mechanism. An assertion tuple forms a Boolean expression (predicate or invariant) that the developer of the application wishes to check. If the assertion defined by the tuple remains true, then the application does not violate the assertion. For any instruction that stores a value to a memory location or register at a target address, the assertion checking mechanism compares the target address to the addresses specified in the assertion tuples. If the target address matches one of the tuple addresses, then the assertion checking mechanism reads a value from the other address in the tuple. The assertion checking mechanism then recomputes the assertion using the retrieved value along with the value to be stored. If the assertion checking mechanism detects an assertion violation, the assertion checking mechanism raises an exception. | 07-14-2011 |
| 20110179399 | ESTABLISHING A USEFUL DEBUGGING STATE FOR MULTITHREADED COMPUTER PROGRAM - A facility for supporting the analysis of a multithreaded program is described. For each of a number of threads of the multithreaded program, the facility identifies a semantically meaningful point in the execution of the thread. The facility interrupts the execution of each thread at the point identified for the thread. | 07-21-2011 |
| 20110209126 | INTER-PROCEDURAL ANALYSIS OF COMPUTER PROGRAMS - This invention concerns inter-procedural analysis of computer programs. The need for inter-procedural analysis arises, for instance, where information is to be passed across the boundaries between functions; for example, by passing a pointer of variables to another function. The pointer needs to identify a valid memory location when used by a calling function. In one aspect the invention is a method and in another aspect the invention is a computer programmed to perform the method. The heart of the method involves the use of computational tree logic (CTL) model checking each sub-structure of the code to iteratively check alternately whether guarantees associated with the code are true, false or undetermined for each external assumption, and whether the internal assumptions are consistent with the guarantees of the caller sub-structures. | 08-25-2011 |
| 20110231828 | EVALUATING AND ENFORCING SOFTWARE DESIGN QUALITY - Evaluation and enforcement of software design quality, in which a system applies design quality rules to a design of a software application to detect violations and provides output describing one or more violations of the design quality rules detected. Based on the output, the system receives user input to address the one or more violations of the design quality rules and, subsequent to receiving the user input, evaluates code developed for the software application for violations of the design quality rules to assess quality of the code being developed for the software application based on the design of the software application. | 09-22-2011 |
| 20110252408 | PERFORMANCE OPTIMIZATION BASED ON DATA ACCESSES DURING CRITICAL SECTIONS - Detecting optimization opportunities is enabled by utilizing a trace of a target concurrent computer program and determining a relation between data objects accessed during the tracked execution. The relation may be stored in a Temporal Relation Graph (TRG), in an extended-TRG or another data structure. The relation may be affected by temporally-adjacent accesses to data objects. The relation may further be affected by accesses to data objects performed during critical sections of the target program. | 10-13-2011 |
| 20110265065 | DEFECT PREDICATE EXPRESSION EXTRACTION - A defect predicate expression extraction device. The device extracts, as candidates for predicate expressions representing defects, predicate expressions occurring in the neighborhood of predicate modifying expressions representing suddenness or predicate modifying expressions representing repeatability. The defect predicate expression extraction device further extracts, as predicate expressions representing normality, predicate expressions occurring in the neighborhood of predicate modifying expressions representing normality and extracts predicate expressions representing defects by removing the predicate expressions representing normality from a list of the candidates for predicate expressions representing defects. | 10-27-2011 |
| 20110276949 | MEMORY LEAK DETECTION - Embodiments of the invention provide systems and methods for detecting an analyzing memory leaks. According to one embodiment, a method of detecting a memory leak can comprise collecting instance count data for a number of instances of a plurality of classes in a memory heap. A correlation coefficient can be calculated for each of the plurality of classes in the memory heap. The correlation coefficient can represent a relevance of the class to a growth of the memory heap. Classes contributing to the growth of the memory heap can then be identified based on the correlation coefficient. | 11-10-2011 |
| 20110289488 | Generating Test Sets Using Intelligent Variable Selection and Test Set Compaction - In one embodiment, constructing one or more sets of variables corresponding to one or more input variables of a software module respectively; for each one of the sets of variables, computing an average branching depth that is affected by the set of variables; selecting a first one of the sets of variables that has the smallest average branching depth; assigning a first symbolic value to the input variable of the first set of variables; symbolically executing the software module to generate a first set of test cases for the first set of variables; optionally compacting the first set of test cases by removing the redundant tests that do not increase test coverage and selecting a minimal subset of the first set of test cases that cover all the covered conditional branch points; and validating the software module using the first set of test cases. | 11-24-2011 |
| 20110296388 | STATIC ANALYSIS USING INTERACTIVE AND INTEGRATION TOOLS - Systems, methods, and computer storage media having computer-executable instructions embodied thereon that facilitate static software program analysis using an interactive tool and/or a disassembly integration tool are provided. An interactive tool enables a user to view alternative error paths in association with an error such that the user can identify any valid errors within program code. A disassembly integration tool provides source code that is interleaved with an intermediate representation of such source code. | 12-01-2011 |
| 20110314454 | INCREMENTAL COMPOSITIONAL DYNAMIC TEST GENERATION - Concepts and technologies are described herein for incremental compositional dynamic test generation. The concepts and technologies described herein are used to increase the code coverage and security vulnerability identification abilities of testing applications and devices, without significantly increasing, and in some cases decreasing, computational and time costs associated with the testing. Test summaries that describe how code is tested by a test engine are generated and stored during testing of code. These test summaries can be evaluated when additional iterations or versions of the code are tested. If functions corresponding to the test summaries are unchanged from, or logically equivalent to, a version of the function previously tested, the test summary may be used when testing the new version of the code. | 12-22-2011 |
| 20120030658 | SOFTWARE DEVELOPMENT ASSISTANT METHOD AND SYSTEM - The present invention provides a software development method, system and computer program product. Generally, a computer program product for software development assistance includes a computer readable storage medium having computer readable program code embodied therewith such that the computer readable program receives from a server over a computer communications network both a software update for software installed in an end user device, and also test cases and a testing tool. The test cases are loaded in memory of the end user device and executed in the end user device with the execution tool with respect to the software update. Execution information produced by the execution of the test cases is collected and transmitted back to the server from the end user device. Optionally, a new test case for the software update can be created within the memory of the end user device the new test case can be executed along with the received test cases with the execution tool in the end user device. Consequently, the new test case can be transmitted to the server along with the collected execution information. | 02-02-2012 |
| 20120084760 | TRANSACTIONAL DEBUGGER FOR A TRANSACTIONAL MEMORY SYSTEM - Various technologies and techniques are disclosed for providing a debugger for programs running under a transactional memory system. When running a particular program using the debugger, the system detects when a conflict occurs on at least one conflictpoint that was set in the particular program. A graphical user interface is provided that displays information related to the detected conflict. The graphical user interface can display transactional state and/or other details independently of a conflict. A conflictpoint can be assigned to one or more regions of source code in one or more transactions in the particular program. A conflictpoint can also be assigned to a particular variable in the particular program. When running the particular program in a debug mode, execution is stopped if a conflict occurs on any of the conflictpoints. | 04-05-2012 |
| 20120096442 | COVERAGE APPARATUS AND METHOD FOR TESTING MULTITHREADING ENVIRONMENT - A coverage technique for testing a multithreading environment is provided. The coverage technique schedules the execution order of mutually exclusive synchronization block pairs, wherein the mutually exclusive synchronization block pairs are defined by associating synchronization blocks that are detected from a plurality of threads each including synchronization blocks and can be simultaneously executed, to induce execution conflictions of the mutually exclusive synchronization blocks, thereby efficiently testing the corresponding multi-threaded application. | 04-19-2012 |
| 20120137275 | Tracking Information Flow - This invention provides a technique for tracking information flow in a computer program or system, dynamically marking variables as high or low to indicate whether there has possibly been direct flow to that variable from the data initially marked high. Each conditional and loop test is classified as high or low, based only on low data. An assignment of an expression to a variable marks the variable high if the expression contains a variable marked high, or if the assignment occurs during execution of the body of a test that was classified as high; otherwise the assignment marks the variable low. Program execution aborts if the classifying expression for a test depends on the value of a high variable, or if the test is classified low, the test includes a high variable, and the test evaluates to false. | 05-31-2012 |
| 20120151454 | GENERATING INPUTS FOR CLIENT-SERVER PROGRAMS FOR FAULT DETECTION AND LOCALIZATION - The present invention provides a system, computer program product, and a computer implemented method for analyzing a set of two or more communicating applications. The method begins with receiving a first second application that communicates with each other during execution. Next, an initial input for executing the first application and the second application is received. The initial input is added to a set of inputs. An iterative execution loop is performed at least once. The loop begins with selecting inputs out of the set of inputs for execution. Next, using the selected inputs, the first and/or the second application is executed while information regarding the execution and information communicated to the other application are recorded. A set of one or more new application inputs for either applications is generated based the second application recorded information and the first application information. These new inputs are added to the set of inputs. | 06-14-2012 |
| 20120159457 | VALIDATING RUN-TIME REFERENCES - Identifying conflicting declared invalid runtime references of overlaid data structures of a shared memory area as declared in a program listing. The identifying includes identifying a first data structure and a first parameter list in the program listing. A first routine call and a sequential flow of execution of the first routine call through the program listing in order to write data to the shared memory area are identified. A second data structure and a second parameter list in the program listing are identified. A second routine call and a second sequential flow of execution of the second routine call through the program listing in order to write data to the shared memory area are identified. It is determined whether the second routine call is attempting to overwrite data of the first routine call with the data of the second routine call in the shared memory area. | 06-21-2012 |
| 20120167059 | Evaluating Coverage of a Software Test - Evaluating the coverage of a test, the evaluating including using an apparatus that includes a storage component, an analysis component, and an output component. The storage component is for storing log data of a plurality of tests. The log data includes a plurality of input values that are input to a specified input field on a specified screen and transmitted to a server in each of the plurality of tests that use the specified screen displayed on a client device. The analysis component is for performing analysis that includes analyzing to what extent the plurality of input values included in the log data stored in the storage component cover values that should be input to the specified input field in the plurality of tests. The output component is for outputting a result of the analyzing from the analysis component. | 06-28-2012 |
| 20120174078 | SMART CACHE FOR A SERVER TEST ENVIRONMENT IN AN APPLICATION DEVELOPMENT TOOL - Embodiments of the present invention provide a method, system and computer program product for a smart cache for server testing in an application development tool. In an embodiment of the invention, method of smart caching of service data during application testing in a development tool for a service invoking application is provided. The method includes loading source code for a computer program into a development tool executing in memory of a computing system. The method further includes executing the source code from the development tool. In this regard, the execution of the source code invokes a service responsive to a directive to invoke the service disposed in the source code. Finally, the method includes invoking the service in a container instance in response to a first invocation of the service from the computer program. However, a data set for the service is located in a cache and returned the data set to the computer program in lieu of invoking the service in the container instance for all other invocations of the service. | 07-05-2012 |
| 20120185832 | Testing Software Applications with Progress Tracking - Methods for testing a software application by providing one or more test units. Each test unit is adapted to verify a feature of the software application. A weight is assigned to each test unit. A theoretical sequence of execution of the test units is determined for the assigned weights and the test units are executed for the theoretical sequence. | 07-19-2012 |
| 20120192161 | DISTRIBUTED STATIC ANALYSIS OF COMPUTER SOFTWARE APPLICATIONS - A method for distributed static analysis of computer software applications, includes: statically analyzing instructions of a computer software application; identifying at least one entry point in the computer software application; assigning a primary agent to statically analyze the computer software application from the entry point; assigning a secondary agent to statically analyze a call site encountered by the primary agent and produce a static analysis summary of the call site; and presenting results of any of the static analyses via a computer-controlled output device. | 07-26-2012 |
| 20120216177 | Generating Sound and Minimal Security Reports Based on Static Analysis of a Program - A method is disclosed that includes, using a static analysis, analyzing a software program to determine a number of paths from sources accepting information to sinks using that information or a modified version of that information and to determine multiple paths from the number of paths. The determined multiple paths have a same transition from an application portion of the software program to a library portion of the software program and require a same downgrading action to address a vulnerability associated with source-sink pairs in the multiple paths. The analyzing includes determining the multiple paths using a path-sensitive analysis. The method includes, for the determined multiple paths, grouping the determined multiple paths into a single representative indication of the determined multiple paths. The method includes outputting the single representative indication. Computer program products and apparatus are also disclosed. | 08-23-2012 |
| 20120222018 | METHODS, CIRCUITS, APPARATUS, SYSTEMS AND ASSOCIATED SOFTWARE MODULES FOR EVALUATING CODE BEHAVIOR - Disclosed are methods, circuits, apparatus, systems and associated software modules for dynamically evaluating code behavior in runtime. There is provided a code testing platform and/or framework which may include: (1) a code execution environment instancing module (CEEIM), (2) code execution resources, (3) executed code isolation logic, and (4) code call response logic. The CEEIM may instance, on a computing platform, a code execution environment (CEE) which is at least partially isolated from external resources functionally associated with the computing platform. The CEE may include code execution resources adapted to execute code whose behavior is to be evaluated, wherein a resource call generated from code execution may be analyzed by the code isolation logic and may under certain conditions be routed to the code call response logic. | 08-30-2012 |
| 20120266145 | APPARATUS AND METHOD FOR AUTOMATICALLY ANALYZING THE USAGE OF AN APPLICATION'S USER INTERFACE - An apparatus (D) is dedicated to analyzing the use by at least one user of at least one user interface (IG) associated with an application (AP). This apparatus (D) comprises analysis means (MA) operative to compare first data representative of first actions performed by the user by means of that user interface (IG) in order to carry out tasks required by the associated application (AP), with second data, representative of second actions that that user should have performed by means of that user interface (IG) in order to carry out those required tasks, and third data, representative of the way in which that user should have performed those second actions, in order to determine any differences representative of shortcomings of that user interface (IG). | 10-18-2012 |
| 20120278792 | Automatic Verification and Synthesis for Weak Memory Models - Techniques are provided for automatic verification and inference of memory fences in concurrent programs that can bound the store buffers that are used to model relaxed memory models. A method is provided for determining whether a program employing a relaxed memory model satisfies a safety specification. An abstract memory model is obtained of the relaxed memory model. The abstract memory model represents concrete program states of the program as a finite number of abstract states. The safety specification is evaluated for the program on the abstract memory model having the finite number of abstract states. Fence positions at one or more locations can be determined to ensure that the safety specification is satisfied. | 11-01-2012 |
| 20120297372 | Static Analysis Of Validator Routines - A method includes accessing a validator routine having an input string and one or more return points, each return point returning a return value having two possible values; finding the return points in the validator routine; for each of the return points, performing a backwards traversal from a return point through a code section and determining constraints on the input string based at least on one or both of the two possible return values for the return point; using the determined constraints for the input string, determining whether all of the return values returned from the one or more return points meet validation constraints; and outputting one or more indications of whether all of the returned values returned from the return points meet the validation constraints for the one or both of the two possible return values. Apparatus and computer program products are also disclosed. | 11-22-2012 |
| 20120304156 | REDUCING NETWORK TRIPS FOR REMOTE EXPRESSION EVALUATION - An expression can be evaluated in a remote debugging environment with one single round trip across the network. An expression evaluator on a local machine can compile the expression into a language-independent intermediate language (IL) that encodes all the information needed to evaluate the expression in the absence of a symbol table. The IL can include instructions that manipulate state inside the debuggee process, as well as logical operations needed to process the information. The IL language can be turing complete so that any computation needed to determine the state to read and write and how the information gathered is to be combined can be performed. The IL can be sent to the remote computer and can be interpreted on the remote computer. The IL can be interpreted on the remote computer using a stack based mechanism, without the need to access symbolic information on the local computer. | 11-29-2012 |
| 20120304157 | METHOD FOR TESTING OPERATION OF SOFTWARE - A method for processing test results from testing operation of software. A test result of pass, fail status, or unperformed is received for each test case of a test performed for each release of the software. A group to which each test belongs is ascertained. A test result stability index is calculated for each test case as being proportional to a total number of consecutive releases that include and are prior to the last release of the software such that the test result for each of the consecutive releases denotes a pass. A module stability index is calculated for each test case as being a summation over a product of a weight at each release and a binary stability indicator of 0 at each release for which the test result is changed from that of the immediately prior release and 1 at every other release. | 11-29-2012 |
| 20120317554 | IDENTIFYING AND TRIAGING SOFTWARE BUGS THROUGH BACKWARD PROPAGATION OF UNDER-APPROXIMATED VALUES AND EMPIRIC TECHNIQUES - A software testing tool may use static verification analysis techniques to locate points (lines/events) in computer code at which an error may be present and points (lines/events) in the computer code that may be the underlying cause of the located error points. In one implementation, a device may perform a static verification analysis of computer code to locate a point in the code that causes an error in the execution of the computer code. The static analysis may be performed by analyzing a first set of possible execution paths of the computer code based on an over-approximation of states. The device may back-propagate, from the located point, through a second set of possible execution paths, where the second set of possible execution paths is obtained based on an under-approximation of the states that were over-approximated. Based on the back-propagation, the device may determine potential causes of the error. Additionally, in some implementations, empiric analysis techniques, based on semantic information for the computer code, may also be performed. The empiric analysis techniques may be used to assist in classifying the potential causes of the error. | 12-13-2012 |
| 20130014089 | AUTOMATED TESTING OF APPLICATION PROGRAM INTERFACES USING GENETIC ALGORITHMS - Various embodiments enable automated testing of Application Program Interfaces (APIs) by abstracting API call signatures and processing the abstracted API call signatures utilizing one or more genetic algorithms. Utilizing the inventive approach, test cases are built and then analyzed using a genetic algorithm. This can be done to both identify problems, such as bugs, associated with the APIs, and/or to identify quality improvements. | 01-10-2013 |
| 20130024847 | SOFTWARE TEST AUTOMATION SYSTEMS AND METHODS - Described are a system and method for performing an automated quality assessment on a software program under test. A test automation system executes a test on a software program Data related to the test is automatically collected. The data includes first information determined by the test automation system in response to executing the test. The data further includes second information related to the test and received from a source other than the test automation system. The first information is analyzed. A quality assessment of the software program is generated from the analyzed first information and from the second information. | 01-24-2013 |
| 20130036405 | AUTOMATED TEST FAILURE TROUBLESHOOTER - A test controller performs a test of a test-target component of a test-target system so as to generate at least one fail event indicating a possible fault in the test-target component. A trouble-shooting and analysis tool probes the test controller and/or hardware of the test-target system to investigate potential causes of the fail event other than a fault of said software component. The trouble-shooting and analysis tool then analyzes fail data including probe data to evaluate potential causes of the fail event. | 02-07-2013 |
| 20130055218 | Automating Software Testing - A system and method of automating software testing is provided. The system and method may determine whether some of a plurality of anchor points within application instructions is triggered in response to input from a current operation within operation instructions. If some of the plurality of anchor points is triggered, one of the triggered anchor points may be selected. Instructions may be generated that configure a given processor to pause after the current operation until the selected one of the triggered anchor points completes. | 02-28-2013 |
| 20130055219 | OVERLAY IDENTIFICATION OF DATA PROCESSING TARGET STRUCTURE - A method, system, and computer program product for identifying an overlay of a data processing target structure in a computing environment is provided. At least one of examining a mapping macro for the target structure with a set of valid ranges, comparing the set of valid ranges with the target structure to identify a string of at least one first invalid value and a last invalid value and locate invalid regions of the target structure, and examining executable code associated with the target structure, comparing at least one unchanged module against at least one additional module exhibiting an overlay characteristic to identify the string of the at least one first invalid value and the last invalid value and locate invalid regions of the target structure, is performed. | 02-28-2013 |
| 20130086560 | PROCESSING AUTOMATION SCRIPTS OF SOFTWARE - Processing automation scripts used for testing pages includes running the automation scripts using a processor, searching for an element on the page according to locating information in an instruction of the automation scripts, collecting element-related information of the element in response to finding of the element on the page according to the locating information, and associating the collected element-related information of the element with the instruction of the automation scripts. The element-related information associated with the instruction is saved. | 04-04-2013 |
| 20130091495 | FEEDBACK-DIRECTED RANDOM CLASS UNIT TEST GENERATION USING SYMBOLIC EXECUTION - Methods and systems for generating software analysis test inputs include generating a path query to cover a target branch of a program by executing a symbolic test driver concretely and partially symbolically, where at least one symbolic expression is partially concretized with concrete values; determining whether it is feasible to execute the target branch based on whether the generated path query is satisfiable or unsatisfiable using a constraint solver; if the target branch is feasible, generating a new test driver by replacing symbolic values in the symbolic test driver with generated solution values; and if the target branch is not feasible, analyzing an unsatisfiable core to determine whether unsatisfiability is due to a concretization performed during generation of the path query. | 04-11-2013 |
| 20130139130 | SYSTEM AND METHOD FOR PERFORMANCE ASSURANCE OF APPLICATIONS - A method for assuring performance of applications is described herein. According to an implementation, the method includes obtaining at least one performance requirement associated with an application in a pre-development phase of a development lifecycle of the application. The performance requirement is mapped with one or more of functional requirements associated with the application and the performance requirement is analyzed based at least on an operational load expected to be handled by the application during operation. Further, the application is developed based on the performance requirement and the mapping. At least one performance characteristic associated with the application is determined, to compare against the performance requirement assuring performance of the application during operation. | 05-30-2013 |
| 20130139131 | SOURCE CODE PROCESSING METHOD, SYSTEM AND PROGRAM - A method, system, and computer readable article of manufacture to enable parallel execution of a divided source code in a multiprocessor system. The method includes the steps of: inputting an original source code by an input device into the computing apparatus; finding a critical path in the original source code by a critical path cut module; cutting the critical path in the original source code into a plurality of process block groups by the critical path cut module; and dividing the plurality of process block groups among a plurality of processors in the multiprocessor system by a CPU assignment code generation module to produce the divided source code. The system includes an input device; a critical path cut module; and a CPU assignment code generation unit to produce the divided source code. The computer readable article of manufacture includes instructions to implement the method. | 05-30-2013 |
| 20130152055 | REDUCING FALSE ALARMS FOR STATIC ANALYSIS OF CONCURRENT PROGRAMS - The claimed subject matter provides a method for performing a static analysis of concurrent programs. The method includes determining that a static analysis of the first concurrent program generates a warning for an input. The method also includes determining whether a static analysis of the second concurrent program generates the warning for the input. The method further includes removing the warning if the static analysis of the second concurrent program generates the warning. | 06-13-2013 |
| 20130152056 | SYSTEM AND METHOD FOR DATA COLLECTION AND ANALYSIS OF INFORMATION RELATING TO MOBILE APPLICATIONS - A system and method are provided for data collection and analysis of information related to applications. Specifically, the developer of the application may install analytic software, which may be embodied as a software development kit (SDK), on an integrated development environment (“IDE”) associated with the developer, wherein the analytic software may be installed with a wizard-like interface having a series of easy to follow instructions. Once installed, the application, with the analytic software incorporated therein, may be provided and installed on a plurality of end user devices. Thereafter, the analytic software may work in conjunction with analytic processing logic to assist the developer in obtaining pertinent information related to bugs associated with the application that is being executed on an end user device. | 06-13-2013 |
| 20130198724 | CONFIDENCE-BASED STATIC ANALYSIS - Systems, methods and program products are provided for confidence-based static analysis, including initiating a static analysis of computer software, associating a confidence value with a first element of the static analysis, determining a current state of the static analysis, calculating an adjusted confidence value in accordance with a confidence adjustment function as applied to the current state and the confidence value associated with the first element, associating the adjusted confidence value with a second element of the static analysis resulting from a transition from the first element, and eliminating the second element from the static analysis if the adjusted confidence value meets elimination criteria. | 08-01-2013 |
| 20130212565 | APPLICATION ANALYSIS METHOD, ANALYSIS SYSTEM AND RECORDING MEDIUM - Disclosed is a method for analyzing a program that includes database operation statements, said method including: a first procedure for analyzing control flow of a program and data used in the program, on the basis of the program and the execution result of the program; a second procedure for analyzing the dependency relationship among a plurality of database operation statements, in accordance with the analysis result of the first procedure and the operation details of the plurality of database operation statements; a third procedure for analyzing the propagation path of the incorrect operation in the opposite direction to the control flow, on the basis of the analysis result of the first procedure and the analysis result of the second procedure and taking as a starting point for analysis a predetermined program location which is operating incorrectly; and a fourth procedure for displaying program statements on the propagation path obtained by the third procedure. | 08-15-2013 |
| 20130219374 | SYSTEM AND METHOD FOR AUTOMATED AND OBJECTIVE ASSESSMENT OF PROGRAMMING LANGUAGE CODE - A system and method of evaluating a software program is disclosed. Information of a proposed problem is received from a user via the user interface and a problem profile associated with the proposed problem is created. A master software solution associated with the proposed problem is processed to identify one or more attributes, such as a first identified attribute. One or more first test cases associated with the first identified attribute in the master software solution are generated. An evaluation program including at least the one or more generated first test cases is generated. The generated evaluation program is configured to be applied to at least one submitted software program that is to be evaluated. At least the one or more first test cases is configured to be applied as one or more test inputs to a corresponding attributes in the submitted software program. | 08-22-2013 |
| 20130219375 | METHOD AND SYSTEM FOR PROBLEM NOTIFICATION AND PROCESSING - A notification of a problem associated with an application may be received. A difference may be determined between a problem version of the application and an operational version of the application to identify a change associated with the problem. A person associated with the change may be determined. A task of resolving the problem may be assigned to the person associated with the change. A person may be notified of the problem and of the assigning of the task based on the identified change. A modification may be performed to resolve the problem associated with the change based on the determining of the difference. | 08-22-2013 |
| 20130239097 | DISTRIBUTED STATIC ANALYSIS OF COMPUTER SOFTWARE APPLICATIONS - A method for distributed static analysis of computer software applications, includes: statically analyzing instructions of a computer software application; identifying at least one entry point in the computer software application; assigning a primary agent to statically analyze the computer software application from the entry point; assigning a secondary agent to statically analyze a call site encountered by the primary agent and produce a static analysis summary of the call site; and presenting results of any of the static analyses via a computer-controlled output device. | 09-12-2013 |
| 20130268920 | SYSTEM AND METHOD FOR MOVING ENTERPRISE SOFTWARE APPLICATION COMPONENTS ACROSS ENVIRONMENTS - A system and method for application lifecycle management, including moving enterprise software application components, such as Oracle Fusion Application components, across different environments. In accordance with an embodiment, the task of moving the application components from a first/source environment to another second/target environment is simplified by movement tools, including a user interface for use by an administrator in moving component binaries and configuration information. The system can be used to minimize the amount of work that would otherwise be required to reapply customization and configuration changes that were made in the source environment, to the target environment. Various types of movement scenarios are also described. | 10-10-2013 |
| 20130275953 | TEST COVERAGE ANALYSIS - A test coverage analysis method and corresponding apparatus are disclosed, wherein, by executing the program under test using one or more test cases, generating one or more heapdump files containing the call stack information of the program under test, and analyzing the call stack information in the one or more heapdump files, the coverage information of the one or more test cases in terms of functions in the program under test is obtained. | 10-17-2013 |
| 20130305228 | REDUCING APPLICATION STARTUP TIME THROUGH ALGORITHM VALIDATION AND SELECTION - An application developer is able to select from a library only those algorithms or functions that are needed. When the application starts on a device, only those algorithms will perform a self-test thereby significantly reducing application start-up time. This is in lieu of the conventional practice of having all the algorithms in library perform a self-test at application runtime. The application developer, by changing parameters to certain functions in the library, can add and remove algorithms as the application changes. The service provider providing the library can still make a generic offering of the full library to its customers and, through the new functionality, facilitate application developer selection of algorithms that are needed. This reduction of start-up time is particularly beneficial on mobile devices where processing power may be limited. | 11-14-2013 |
| 20130332910 | DYNAMIC LIVELOCK ANALYSIS OF MULTI-THREADED PROGRAMS - A system for analyzing a multi-threaded program includes a processor and a data storage device coupled to the processor to store a multi-threaded program execution and code for detecting one or more lock cycle conditions from the executed trace to identify one or more livelock or deadlock potentials, and code to confirm the livelock or deadlock potentials in a controlled re-execution. | 12-12-2013 |
| 20130339933 | SYSTEMS AND METHODS FOR QUALITY ASSURANCE AUTOMATION - A method and a system for quality assurance automation are described. A system comprises a requirements service to generate requirements artifacts from one or more sources. The requirement artifacts are of a standardized format that is referenced in tested software code. A data provider service standardizes and distributes various types of common test data across multiple business disciplines. An execution service manages test executions across and multiple environments where test software code is installed. An evaluation service analyzes data resulting from the test executions. A reporting service reports the analyzed data. | 12-19-2013 |
| 20140033183 | DEBUGGING METHOD USING PROGRAM INSPECTORS TO DEBUG PROGRAMS DEVELOPED USING FRAMEWORKS AND LIBRARIES - A debugging method for use with computer programs that may include a number of program components such as objects within a software framework. The debugging method includes providing a debugging environment with a debugger that generates debugging information, including runtime state information, for each of the program components. The method includes identifying one of the program components for inspection within the debugging environment. The method includes using an inspector selection module to select a set of program inspectors to perform the inspection of the identified program component, e.g., by first determining the type of object or program component that has been identified or based upon a type of issue being debugged. The method includes performing the inspection with these program inspectors or scripts that each define a particular potential user error or nonstandard usage of an object, and outputting a report of the programming issues identified by the program inspectors. | 01-30-2014 |
| 20140040867 | SYSTEM TEST SCOPE AND PLAN OPTIMIZATION - Various embodiments include at least one or systems, methods, and software providing abilities to automatically generate a test plan that mitigates risk involved in testing less than an entirety of a software system following modification. Some embodiments operate to allow a user to influence the scope of an optimized test plan while also reducing a number of tests and test execution effort involved. Such embodiments may identify portions of the software system to test and portions of the software system that will not be tested in a manner that reduces a total testing effort involved. Reductions in testing effort are performed in generation of the test plan in view of testing preferences which are utilized not only to reduce the total effort in executing a test plan, but also does so to optimize the test plan. | 02-06-2014 |
| 20140040868 | AUTOMATIC REPAIR OF SCRIPTS - A method and associated system for repairing a script. A missed object is detected among one or more objects of the running script, the missed object being unrecognized from an original object of a previous running of the script. A change type of the detected missed object is determined. The script is repaired based on the change type. | 02-06-2014 |
| 20140053139 | SYMBOLIC TESTING OF SOFTWARE USING CONCRETE SOFTWARE EXECUTION - A method of testing software may include accessing software that includes multiple execution paths that each include one or more branching points. The method may also include concretely executing the software using multiple concrete inputs to traverse at least two of the execution paths of the software. The method may also include capturing concrete execution results produced from executing the software using the concrete inputs. The method may also include symbolically executing the software using one or more symbolic inputs based on the concrete execution results. | 02-20-2014 |
| 20140053140 | STATIC ANALYSIS OF VALIDATOR ROUTINES - A method includes accessing a validator routine having an input string and one or more return points, each return point returning a return value having two possible values; finding the return points in the validator routine; for each of the return points, performing a backwards traversal from a return point through a code section and determining constraints on the input string based at least on one or both of the two possible return values for the return point; using the determined constraints for the input string, determining whether all of the return values returned from the one or more return points meet validation constraints; and outputting one or more indications of whether all of the returned values returned from the return points meet the validation constraints for the one or both of the two possible return values. Apparatus and computer program products are also disclosed. | 02-20-2014 |
| 20140075419 | Sequentially Constructive Model of Computation - System and method for validating a program under a specified model of computation. The model of computation may be related to the synchronous statechart model of computation. A program may be received that specifies a plurality of operations using a variable within a logical tick such that the variable has multiple values within the logical tick. The program may be statically analyzed according to a specified model of computation that specifies program execution based on logical ticks, which may include determining that the program has deterministic semantics that specify deterministic results for each logical tick during execution of the program, including specifying deterministic results of the plurality of operations performed within the logical tick. The program may be validated in accordance with the specified model of computation in response to the determining. Such techniques may allow validation of a larger set of programs than conventional models while maintaining deterministic results. | 03-13-2014 |
| 20140089903 | Sampling Based Runtime Optimizer for Efficient Debugging of Applications - A method of reproducing runtime environment for debugging an application is disclosed. The method includes accessing an optimizer file from a non-volatile storage medium. The optimizer file includes a runtime environment, application definition information, and a log. The log includes summaries of a plurality of events, the plurality of actions, and a time mark of occurrence for each of the plurality of actions. A runtime environment for debugging the application is then defined and the application runtime is set up using the application definition information in the optimizer file. Further, the method includes running the application and attaching an optimizer, then triggering each of the plurality of actions to occur at each time mark of occurrence associated with the each of the plurality of actions, and analyzing each of the plurality of actions and the plurality of events associated with the each of the plurality of actions, the analyzing includes comparing the events produced by running the application with the plurality of events in the optimizer file. If a fault is produced by the triggering, a debugger is invoked to analyze the fault. | 03-27-2014 |
| 20140109066 | TESTING FRAMEWORK FOR APPLICATIONS - An application distribution server may be operable to select a plurality of data processing devices which are capable of receiving application updates. One or more experimental versions of an application may be communicated by the application distribution server to each of the selected plurality of data processing devices during an update process of the application. The application distribution server may cause collection of performance information associated with the one or more experimental versions. The application distribution server may then cause communication of the collected performance information to a developer of the application for analysis. When a particular experimental version is uninstalled from a particular data processing device or when feedback and/or rating information on the particular experimental version is communicated from the particular data processing device, the application distribution server may communicate, to the particular data processing device, a message indicating an experiment and options to opt-out of future experiments. | 04-17-2014 |
| 20140123117 | AUTOMATIC TESTING APPARATUS FOR EMBEDDED SOFTWARE, AUTOMATIC TESTING METHOD THEREOF AND TEST SCENARIO COMPOSING METHOD - An automatic test apparatus for embedded software, an automatic testing method thereof and a test scenario composing method may be used to detect an unpredictable problem as well as a predictable problem that may occur under user's conditions and reproduce various events. The automatic testing apparatus may include a keyword composer which extracts a keyword from status information output by executing the embedded software, and composes a keyword list using the extracted keywords, an output analyzer which analyzes the output from the execution of the embedded software based on the composed keyword list, a control command generator which loads at least one scenario previously stored in accordance with the analysis results, and generates an instruction list corresponding to a predetermined event status, and a test processor which processes the embedded software to reproduce the event status based on the generated instruction list. | 05-01-2014 |
| 20140130019 | Hybrid Program Analysis - A hybrid program analysis method includes initiating a static program analysis of an application, generating, by a static program analyzer, a query to a dynamic program analyzer upon determining a code construct of the application requiring dynamic analysis, resolving, by the dynamic program analyzer, the query into a set of arguments with which to invoke the code construct of the application, generating, by the dynamic program analyzer, the set of arguments, invoking, by the dynamic program analyzer, the code construct of the application using set of arguments, answering, by the dynamic program analyzer, the query, and continuing the static program analysis of the application. | 05-08-2014 |
| 20140130020 | STATIC ANALYSIS OF COMPUTER CODE TO DETERMINE IMPACT OF CHANGE TO A CODE COMPONENT UPON A DEPENDENT CODE COMPONENT - A method is provided method to evaluate impact of a change in code of a depended upon component of a system stored in a non-transitory computer readable storage device, upon a dependent component of the system, the method comprising: identifying a dependency relationship between a first component stored in a storage device and a second component stored in the storage device; in response to a determination that the second component depends upon the first component, configuring a computer system to obtain a first property evaluation corresponding to the first component; and in response to obtaining the first property evaluation corresponding to the first component, configuring the computer system to associate the first property evaluation with the second component, and determine a second property evaluation corresponding to the second component, is the second component being associated with the first property evaluation. | 05-08-2014 |
| 20140157241 | CODE-FREE TESTING FRAMEWORK - A method, system and computer program product for testing software comprises discovering, by an agent executing on a computer, testable code configured to execute on the computer; receiving, by the agent, a request related to testing the testable code from a requestor; in response to the request, sending the requestor a property of the testable code; receiving, by the agent, data related to the property; activating; by the agent, the testable code wherein the received data is associated with the property in order to produce a result from the activated testable code; and returning, by the agent, the result to the requestor. | 06-05-2014 |
| 20140157242 | DEFERRED EVALUATION AND PRESENTATION OF A CUSTOM DIAGNOSTIC ANALYSIS - A device receives code generated via a technical computing environment (TCE), performs a test on the code to generate a test result, and generates test information based on the performance of the test on the code. The device outputs or stores the test result, and receives, based on the test result, a request for a diagnostic analysis of the code. The device performs, based on the request, the test information, and at least one diagnostic, a diagnostic analysis of the code to generate a diagnostic result, and outputs or stores the diagnostic result. | 06-05-2014 |
| 20140173572 | CONSTRAINT DERIVATION IN CONTEXT FOLLOWING FOR USE WITH OBJECT CODE INSERTION - A method of creating constraints for use with object code insertion technology can include deriving an A-representation and a B-representation of values produced by execution of instructions of a portion of object code, wherein prior to object code insertion the A-representation and the B-representation of a value produced by same instruction(s) are equivalent. The method further can include identifying equalities between A-representations of values produced by different instructions and determining constraints from the identified equalities using B-representations, where the constraints are observed after object code insertion. | 06-19-2014 |
| 20140201721 | FRAMEWORK AND REPOSITORY FOR ANALYSIS OF SOFTWARE PRODUCTS - Tacit knowledge associated with software development problems may be shared by providing a framework configured to pre-process raw service data of a software product for identification of data elements. Pre-processing operations may be applied to the raw service data to extract data elements. An identified operating problem in the service data may be efficiently analyzed by referring to a repository of stored records that include previously performed user actions when facing the identified operating problem. | 07-17-2014 |
| 20140237455 | DETECTION OF REPETITION AREAS DURING TESTING IN AN EVENT DRIVEN, MULTICHANNEL ARCHITECTURE - Approaches for application testing are provided. An approach includes recording a test case of an application running on a mobile device. The approach also includes generating an expected layout based on object data received from the mobile device during the recording. The approach additionally includes receiving playback object data based on the test case being played back on the mobile device or a different mobile device. The approach further includes comparing the playback object data to the expected layout data. | 08-21-2014 |
| 20140258992 | Scalable and Precise String Analysis Using Index-Sensitive Static String Abstractions - A disclosed method includes accessing one or more seeding specifications and a program including computer-readable code and applying the one or more seeding specifications to the program to identify for analysis seeds including strings for corresponding identified string variables. The method includes tracking flows emanating from the identified seeds. The tracking includes computing an integral offset into a tracked string variable for any statements causing such a computation. The tracking also includes providing a string representation based on the computed integral offset, wherein the provided string representation comprises a value of the integral offset and an indication of the corresponding tracked string variable. The tracking further includes modeling string manipulations of the tracked string variables using the string representations. Apparatus and program products are also disclosed. | 09-11-2014 |
| 20140282432 | ANALYZING INCOMPLETE SOFTWARE - A method of analyzing an incomplete software program may include receiving high-level software code of a software program that includes multiple functions. The multiple functions may include at least one incomplete function and at least one complete function. The method may further include compiling at least a portion of the high-level software code to generate low-level software code by compiling the complete function and passing over the incomplete function. The method may further include modifying the low-level software code to account for a call to the incomplete function in the low-level software code and symbolically executing the low-level software code. | 09-18-2014 |
| 20140282433 | TESTING FUNCTIONAL CORRECTNESS AND IDEMPOTENCE OF SOFTWARE AUTOMATION SCRIPTS - Various embodiments automatically test software automation scripts. In one embodiment, at least one software automation script is obtained. The software automation script is configured to automatically place a computing system into a target state. A plurality of test cases for the software automation script is executed. Each of the plurality of test cases is a separate instance of the software automation script configured based at least on one or more different states of the computing system. The software automation script is determined to be one of idempotent and non-idempotent and/or one of convergent and non-convergent based on executing the plurality of test cases. | 09-18-2014 |
| 20140282434 | TESTING FUNCTIONAL CORRECTNESS AND IDEMPOTENCE OF SOFTWARE AUTOMATION SCRIPTS - Various embodiments automatically test software automation scripts. In one embodiment, at least one software automation script is obtained. The software automation script is configured to automatically place a computing system into a target state. A plurality of test cases for the software automation script is executed. Each of the plurality of test cases is a separate instance of the software automation script configured based at least on one or more different states of the computing system. The software automation script is determined to be one of idempotent and non-idempotent and/or one of convergent and non-convergent based on executing the plurality of test cases. | 09-18-2014 |
| 20140282435 | PERFORMANCE PROFILING APPARATUS AND PERFORMANCE PROFILING METHOD - A performance profiling apparatus includes: a plurality of counters provided for a routine included in a program; a storage section configured to store an instruction of the program and an identification information indicating the routine of the program; a processor configured to read the instruction from the storage section and to execute a process according to the instruction; and a counter controller configured to, at the time of reading the instruction of the processor, receive the identification information of the instruction which is output from the storage section with the instruction and to instruct a first counter designated by the identification information to count up. | 09-18-2014 |
| 20140310694 | USING APPLICATION STATE DATA AND ADDITIONAL CODE TO RESOLVE DEADLOCKS - A computer captures a thread state data of a first program. The computer generates a second program by applying a first program patch to the first program. The computer inserts additional code into a source code of the second program. The computer executes a first performance test using the second program and the inserted additional code. The computer monitors a first status of the second program and the inserted additional code that are under the first performance test. The computer determines a degree that a first deadlock state was prevented during the first performance test. The computer generates a first message based, at least in part, on the determined degree that the first deadlock state was prevented during the first performance test. | 10-16-2014 |
| 20140325490 | Classifying Source Code Using an Expertise Model - A technique to classify source code based on skill level. Features may be extracted from the source code. The source code may be classified based on the extracted features using an expertise model. | 10-30-2014 |
| 20140331211 | METHOD AND SYSTEM FOR DETECTING CONCURRENCY PROGRAMMING ERRORS IN KERNEL MODULES AND DEVICE DRIVERS - The existence of errors and bugs in device drivers and other software operating in kernel space may be difficult to find and eliminate. A system and method for debugging computer programs may involve the use of several different modules. Running in the kernel space is an event monitor. Running in the user space is an event collector, an event player, and a concurrency error detector. This setup allows one to debug device driver software and other software that executes in kernel space using existing user space error detectors. | 11-06-2014 |
| 20140331212 | COMPUTER IMPLEMENTED SYSTEM AND METHOD FOR INDEXING AND ANNOTATING USE CASES AND GENERATING TEST SCENARIOS THEREFROM - A system and method for indexing and annotating use cases and generating test scenarios using in-memory processing from the corresponding use case model includes a use case model creator to create/build an in-memory use case model for the use cases created by a user; a predetermined structural format, according to which the steps of the use cases are organized by an editor; an indexer to appropriately index the steps of the use case(s) in the use case model; a generator which facilitates extraction of the indexed steps from the use case and identification of at least one ordered set in which the indexed steps can be assembled; and a test scenario generator to generate a test scenario having the indexed steps arranged according to the ordered set identified by an identifier and being validated by a validator according to pre-determined validation criteria. | 11-06-2014 |
| 20140359584 | APPLICATION ANALYTICS REPORTING - Systems and methods for application analytics reporting include comparing metrics regarding the use of the application to a usage model for the application. The usage model indicates an expected set of states of the application and transitions between the states during execution of the application. A determined difference between the metrics and the expected states and transitions indicated by the usage model that exceeds a predetermined threshold is provided as analytics data. | 12-04-2014 |
| 20140372988 | Using a Static Analysis for Configuring a Follow-On Dynamic Analysis for the Evaluation of Program Code - The use of a static analysis for configuring a follow-on dynamic analysis for the evaluation of program code is provided. A request may be received for configuring a static analysis session for the evaluation of the program code. The static analysis may be executed and an output may be produced therefrom. The output may be analyzed to determine whether a dynamic analysis is needed for resolving code ambiguities in the program code. If it determined that the dynamic analysis is needed, then the dynamic analysis of the program code is initiated. | 12-18-2014 |
| 20140372989 | IDENTIFICATION OF A FAILED CODE CHANGE - A method to identify a failed code change in a deployment pipeline with a plurality of code changes. The plurality of code changes are tested by running a set of tests on the plurality of code changes until a subset of the plurality of code changes pass the set of tests. Each time the subset fails the set of tests, at least one of the plurality of code changes is removed from the subset. The failed code change is determined based on the subset that passes the set of tests. | 12-18-2014 |
| 20150033212 | TESTING PROGRAM, TESTING METHOD, AND TESTING DEVICE - A non-transitory computer-readable recording medium having stored therein a test program that causes a computer to execute a process comprising: starting a test of a test-target program containing a plurality of modules by executing a plurality of individual tests, the plurality of individual tests being associated with the plurality of modules, respectively; generating test-relationships information that includes relationships between the plurality of individual tests based on module-relationships information including relationships of the plurality of modules; and in cases in which results of the plurality of individual tests include one or a plurality of specific results fulfilling a specific condition, specifying one or a plurality of additionally executing tests based on the one or plurality of specific results and the test-relationships information. | 01-29-2015 |
| 20150040107 | SOLVING AN OPTIMIZATION PROBLEM USING A CONSTRAINTS SOLVER - Systems and techniques are described for solving an optimization problem using a constraints solver. A set of constraints that correspond to the optimization problem can be generated. Next, a set of upper bound constraints can be added to the set of constraints, wherein the set of upper bound constraints imposes an upper bound on one or more variables that are used in an objective function of the optimization problem. Next, the embodiments can iteratively perform the following set of operations on a computer: (a) solve the set of constraints using the constraints solver; (b) responsive to the constraints solver returning a solution, decrease the upper bound; and (c) responsive to the constraints solver indicating that no solutions exist or that the constraints solver timed out, increase the upper bound. The solution with the lowest upper bound value can be outputted as the optimal solution for the optimization problem. | 02-05-2015 |
| 20150040108 | PARALLEL PROGRAM ANALYSIS AND BRANCH PREDICTION - Systems and methods for predicting execution paths of at least one target program of a plurality of programs that are run in parallel are described. In one method, execution flows of programs are generated by conducting a static analysis. In addition, the programs are executed to obtain debug logs from the programs. Further, communication messages transmitted between the execution flows are identified from the debug logs. A deduction that at least one conditional branch was taken in at least one given execution flow of the first execution flows by the target program is made based on the communication messages that are identified in the debug logs. Based on the deduction, at least one conditional branch that was not taken is removed from the given execution flow. In addition, modified execution flows that were modified in accordance with the removal are output to indicate predicted execution paths of the target program. | 02-05-2015 |
| 20150046909 | System, Method, and Apparatus for Automatic Recording and Replaying of Application Executions - A method comprises receiving data pertaining to a recorded interaction between a test device operating system and an application on a test device, the recorded interaction being based on a user input; compiling the data pertaining to the recorded interaction in a script compiler, the data comprising human-readable action-description language; sending the compiled data comprising human-readable action-description language from the script compiler of the server to a developer device; receiving modified data from the developer device; and sending the modified data from the developer device to the test device. | 02-12-2015 |
| 20150052505 | IDENTIFYING AND TRIAGING SOFTWARE BUGS THROUGH BACKWARD PROPAGATION OF UNDER-APPROXIMATED VALUES AND EMPIRIC TECHNIQUES - A software testing tool may use static verification analysis techniques to locate points (lines/events) in computer code at which an error may be present and points (lines/events) in the computer code that may be the underlying cause of the located error points. In one implementation, a device may perform a static verification analysis of computer code to locate a point in the code that causes an error in the execution of the computer code. The static analysis may be performed by analyzing a first set of possible execution paths of the computer code based on an over-approximation of states. The device may back-propagate, from the located point, through a second set of possible execution paths, where the second set of possible execution paths is obtained based on an under-approximation of the states that were over-approximated. Based on the back-propagation, the device may determine potential causes of the error. Additionally, in some implementations, empiric analysis techniques, based on semantic information for the computer code, may also be performed. The empiric analysis techniques may be used to assist in classifying the potential causes of the error. | 02-19-2015 |
| 20150082287 | SCENARIO BASED TEST DESIGN - The present subject matter relates to software testing. The method comprises obtaining user requirements from a user, the user requirements being indicative of functionalities and features to be incorporated in a software application. Based on the user requirements, at least one test scenario for testing the software application may be identified. The at least one test scenario may include at least one step. Further, based on a first approval received from the user, one or more test cases may be associated with each step of the software application. The first approval is indicative of validity of the at least one test scenario. The one or more test cases may be executed for testing the software, based on a second approval received from the user. The second approval is indicative of validity of the one or more test cases. | 03-19-2015 |
| 20150121348 | METHOD AND DEVICE FOR ANALYZING APPLICATION - A method and device for analyzing an application are provided. The method includes obtaining the application, obtaining at least one of environment information, which is information about an environment where the application is executed, and execution information, which is information about operations of components of the application, obtaining code data to analyze from the application, based on at least one of the environment information and the execution information, obtaining function information, and analyzing the code data, based on the obtained function information. | 04-30-2015 |
| 20150135168 | Software Metrics Assessment System - An apparatus of one embodiment evaluates a software change and includes an interface, a memory, and a processor. The interface is operable to communicate through a network with a mainframe and a database. The memory is operable to store metrics information. The processor is operable to determine that a job has executed on the mainframe, the job including a program on the mainframe that utilizes the software change and causes first database queries to he sent from the mainframe to the database. The processor is also operable to send a message identifying the job to the mainframe, receive job information associated with the first database queries from the mainframe, generate second database queries based on the job information, send the second database queries to the database, receive metrics associated with the first database queries, and determine whether the metrics information meets one or more compliance standards. | 05-14-2015 |
| 20150135169 | TESTING DEVICE AND TESTING METHOD THEREOF - A testing device and a testing method thereof are provided. The testing device is connected to a terminal device running a graphical user interface (GUI). The testing device runs a testing program to start a recording procedure to execute the following steps: detecting a plurality of actions generated in response to operations on the terminal device; detecting a foreground application of the GUI; reading a plurality of pieces of object information of the foreground application; and determining the actions to record an object property operation of the foreground application and a call command. The testing device further stops the recording procedure to generate and store a script file and a reference log file. The script file includes the object property operation and the call command. | 05-14-2015 |
| 20150143345 | APPLICATION VERSION RELEASE MANAGEMENT - Implementations of the disclosed subject matter provide systems and methods for providing one or more versions of an application to one or more subsets of users based on measured performance of the one or more versions of the application. A method may include providing a first version of an application to a first subset of users of the application. Next, performance of the first version of the application may be measured and a second subset of users of the application may be selected based on the performance of the first version of the application. As a result, a second version of the application may be provided to the second subset of users of the application. | 05-21-2015 |
| 20150143346 | Constructing test-centric model of application - A test-centric model of an application is constructed. Each resource specified by each test governing an application is added to the test-centric model. The test or tests specifying an resource are linked to the resource within the test-centric model. A composition of the application is defined using the one or more tests, as the resources specified by the one or more tests, within the test-centric model of the application. | 05-21-2015 |
| 20150149985 | TESTING OF INACTIVE DESIGN-TIME ARTIFACTS - A system includes reception of an instruction to commit a design-time artifact of a database server application to a repository of a database server, storage of the design-time artifact in the repository of the database server in association with an inactive flag, reception of a request from a user to access the design-time artifact associated with the inactive flag, and, in response to the request, generation of a private runtime representation of the design-time artifact associated with the inactive flag, and deployment of the private runtime representation of the design-time artifact for exclusive use by the user. | 05-28-2015 |
| 20150293834 | Methods, Apparatus, and Computer Readable Media for Providing a Governance Framework for Declarative Rule Based Programming - A governance framework may be used to for developing software that may use a business process management platform (BPM), such as BPM software by Pega Systems. The governance framework may help to prevent software bugs. For example, the governance framework may prevent developers from checking in code that may have violations, bugs, and/or errors. The governance framework may ensure that code adhere to guardrails, for example, by monitoring developer activity and identifying potential issues. The governance framework may reduce defect rates for a software program that may be developed. For example, the governance framework may improve the quality of a software product while decreasing development time by catching potential defects. The governance framework may ensure that a development team creates software efficiently, for example, by providing a velocity report for the development team. The velocity report may show the performance of the development team. | 10-15-2015 |
| 20150301922 | ANALYZING COMPUTER PROGRAMS TO IDENTIFY ERRORS - A method of analyzing a computer program under test (CPUT) using a system comprising a processor and a memory can include performing, by the processor, static analysis upon the CPUT and runtime analysis upon at least a portion of the CPUT. A static analysis result and a runtime analysis result can be stored within the memory. Portions of the CPUT analyzed by static analysis and not by runtime analysis can be determined as candidate portions of the CPUT. The candidate portions of the CPUT can be output. | 10-22-2015 |
| 20150309921 | SYSTEM AND METHOD FOR MANAGING ELECTRONIC ASSETS - An asset management system is provided which comprises one or more controllers, which operate as main servers and can be located at the headquarters of an electronic device manufacturer to remotely control their operations at any global location. The controller can communicate remotely over the Internet or other network to control one or more secondary or remote servers, herein referred to as appliances. The appliances can be situated at different manufacturing, testing or distribution sites. The controller and appliances comprise hardware security modules (HSMs) to perform sensitive and high trust computations, store sensitive information such as private keys, perform other cryptographic operations, and establish secure connections between components. The HSMs are used to create secure end-points between the controller and the appliance and between the appliance and the secure point of trust in an asset control core embedded in a device. | 10-29-2015 |
| 20150317236 | STATIC ANALYSIS OF COMPUTER CODE TO DETERMINE IMPACT OF CHANGE TO A CODE COMPONENT UPON A DEPENDENT CODE COMPONENT - A method is provided method to evaluate impact of a change in code of a depended upon component of a system stored in a non-transitory computer readable storage device, upon a dependent component of the system, the method comprising: identifying a dependency relationship between a first component stored in a storage device and a second component stored in the storage device; in response to a determination that the second component depends upon the first component, configuring a computer system to obtain a first property evaluation corresponding to the first component; and in response to obtaining the first property evaluation corresponding to the first component, configuring the computer system to associate the first property evaluation with the second component, and determine a second property evaluation corresponding to the second component, is the second component being associated with the first property evaluation. | 11-05-2015 |
| 20150324272 | SYSTEM AND METHOD FOR PROVIDING ADDITIONAL FUNCTIONALITY TO DEVELOPER SIDE APPLICATION IN AN INTEGRATED DEVELOPMENT ENVIRONMENT - A developer analytic module executing on an integrated development environment provides location tracing of a software development toolkit and automatic updated of the SDK. The developer analytic module further provides data container transfer functionality to ensure that analytic logic has access to necessary data containers to perform symbolication and/or error detection. | 11-12-2015 |
| 20150331780 | DEFECT ANALYSIS SYSTEM FOR ERROR IMPACT REDUCTION - A first set of data associated with a plurality of data sources is analyzed to determine a plurality of relationships among the first set of data. First rules are generated first rules based, at least in part, on the first set of data, wherein a first of the first rules indicates a first software defect and a cause of the first software defect, wherein a second of the first rules indicates a solution to the first software defect. Determining that the solution to the first software detect is a possible solution to a second software defect is made based, at least in part, on the first and second of the first rules. An indication that first set of data has been modified is received. A relationship between the first set of data and a second set of data associated with the plurality of data sources is determined. | 11-19-2015 |
| 20150363192 | COMPUTER-IMPLEMENTED TOOLS AND METHODS FOR EXTRACTING INFORMATION ABOUT THE STRUCTURE OF A LARGE COMPUTER SOFTWARE SYSTEM, EXPLORING ITS STRUCTURE, DISCOVERING PROBLEMS IN ITS DESIGN, AND ENABLING REFACTORING - An interrelated set of tools and methods are disclosed for recording the identity of software components responsible for creating files, recording the identity of software components that access software files, reasoning about the dependency relationships between software components, identifying and reporting undesirable dependencies between them, and reporting other useful information about a large-scale software architecture by instrumenting a software build process or test process. | 12-17-2015 |
| 20150363303 | MOBILE AND REMOTE RUNTIME INTEGRATION - An application program may be analyzed to identify candidate classes or methods that may be executed using a remote computing node. Candidate classes or methods may be translocated to the remote computing node based on performance characteristics of the device on which the application program is running, the environment in which the device operates, and on the performance and availability of the remote computing node. An application program publisher may be assigned instances of virtual machines that may be dedicated to hosting translocated classes and methods. | 12-17-2015 |
| 20150378861 | IDENTIFICATION OF SOFTWARE PHASES USING MACHINE LEARNING - Technologies for application performance analysis include a computing device capable of executing an application having a number of phases. The computing device collects performance data indicative of a number of performance attributes of the computing device during execution of the application. The computing device may merge data collected from a processor performance monitoring unit with data collected from an operating system of the computing device. The computing device partitions the performance data into a number of clusters using an unsupervised clustering algorithm such as K-means clustering, forming a cluster model. The computing device may partition the performance data into a number of cluster models, apply a classification algorithm such as regularized discriminant analysis to each cluster model, and select the cluster model with the lowest misclassification rate. The computing associates each cluster of the cluster model to a phase of the software application. Other embodiments are described and claimed. | 12-31-2015 |
| 20160004517 | SOFTWARE DEVELOPMENT IMPROVEMENT TOOL - iREVIEW - Aspects of the disclosure relate to providing a tool for detecting defects in iSeries source code. The tool addresses a requirement of a software development team to review code requirements while developing a software/program. There may be strict coding guidelines if not followed properly, increase likelihood of a programming defect. The tool may scan code written by the software development team to ensure compliance with the coding guidelines and generate a list of defects/warnings in a text file format. The tool may transmit the list of defects/warnings, such as by email, to a manager of the software development team. The tool may measure productivity of the software development team based on the number of defects/warnings reported. The tool may include a control table. The control table may maintain the coding guidelines as rules which may be easily amendable by a user of the tool. | 01-07-2016 |
| 20160026555 | AUTOMATED MOBILE APPLICATION VERIFICATION - Disclosed are various embodiments for automatically testing and verifying mobile applications. A mobile application is obtained from a source entity. The mobile application is automatically installed in different mobile computing devices in a testing environment. Execution of the mobile application is automatically initiated in the different mobile computing devices. Whether the mobile application meets performance criteria is automatically verified for each of the different mobile computing devices. | 01-28-2016 |
| 20160034375 | DETERMINING TEST CASE PRIORITIES BASED ON TAGGED EXECUTION PATHS - Test case priorities are automatically determined based on the execution path of a software application that includes priority tags. By embedding the priority tags in the source code of the software application, the consistency and reliability of the test case priorities is improved compared to conventional, primarily manual approaches to determining test case priorities. Further, efficiency is increased by providing run-time feedback regarding test cases that facilitates identification of the highest priority test cases and corresponding test suite optimizations. | 02-04-2016 |
| 20160034383 | APPLICATION TEST ACROSS PLATFORMS - A method and a system for testing an application across platforms. Application testing for checking functionality of an application is carried out to insure that same applications have the same behavior on different platforms. Such platforms include function, user interface (UI), and generated data. One embodiment of the present invention provides a method for cross-platform application testing. A first response to an action is determined on a first platform. The action is triggered on a second platform, the second platform being different from the first platform. Then, a second response is determined to the action on the second platform. Finally, the first response and the second response are compared to test consistency of the application on the first platform and the second platform. A corresponding system for testing an application across platforms is also provided. | 02-04-2016 |
| 20160055074 | PROGRAM ANALYSIS DEVICE, PROGRAM ANALYSIS METHOD, AND PROGRAM ANALYSIS PROGRAM - An application list reading part | 02-25-2016 |
| 20160055078 | DECREASING USER MANAGEMENT OF AN APPLIANCE - In a method for decreasing user management of a pre-configured hyper-converged computing device, software updates of installed software on an underlying hardware platform of said pre-configured hyper-converged computing device are tested by a first party, wherein the installed software is provided by the first party. The software updates are provided by the first party for updating the installed software on the pre-configured hyper-converged computing device. Installation of the software updates is enabled on the pre-configured hyper-converged computing device such that user management of the pre-configured hyper-converged computing device is decreased based on the software updates previously tested on the underlying hardware platform. | 02-25-2016 |
| 20160062873 | CENTRALIZED DISPATCHING OF APPLICATION ANALYTICS - A method may include, in a computing device comprising at least one processor and a memory, generating at least one information beacon from each of a plurality of applications installed on the computing device. Each information beacon may include application analytics data associated with a corresponding application while the corresponding application is running on the computing device. The at least one information beacon from each of the plurality of applications may be stored in a common location in the computing device. The stored at least one information beacon may be dispatched from each of the plurality of applications to a network device communicatively coupled to the computing device. The generating may be triggered by beacon generation code implemented in each of the plurality of applications installed on the computing device. | 03-03-2016 |
| 20160077831 | ACCURATE AND PERFORMANT CODE DESIGN USING MEMOIZATION - Methods, systems, and computer program products are provided that enable intelligent assistance functions to be performed on program code over multiple contexts associated with the program code. An intelligent assistance function may be performed on the program code for a first context associated with the program code to generate results for the first context that do not cover all of the program code. The intelligent assistance function is iterated for one or more additional contexts associated with the program code, with each iteration being performed on portions of the program code that were not able to be analyzed under the prior context iterations, until the program code is covered in its entirety. In this manner, results may be generated for the entirety of the program code that cover all of the associated contexts. | 03-17-2016 |
| 20160077950 | METHODS, CIRCUITS, APPARATUS, SYSTEMS AND ASSOCIATED SOFTWARE MODULES FOR EVALUATING CODE BEHAVIOR - Disclosed are methods, circuits, apparatus, systems and associated software modules for dynamically evaluating code behavior in runtime. There is provided a code testing platform and/or framework which may include: (1) a code execution environment instancing module (CEEIM), (2) code execution resources, (3) executed code isolation logic, and (4) code call response logic. The CEEIM may instance, on a computing platform, a code execution environment (CEE) which is at least partially isolated from external resources functionally associated with the computing platform. The CEE may include code execution resources adapted to execute code whose behavior is to be evaluated, wherein a resource call generated from code execution may be analyzed by the code isolation logic and may under certain conditions be routed to the code call response logic. | 03-17-2016 |
| 20160092340 | METHOD AND SYSTEM FOR REVIEWING OF CLUSTERED-CODE ANALYSIS WARNINGS - A system and method for reviewing of warning generated during static analysis of a clustered software code by identifying, common point warnings and unique warnings from warnings associated with a software code, and further identifying, a top of must overlapped function for each of the common point warnings. Generating, one or more groups of the common point warnings based on the top of must overlapped function, and assigning, the top of must overlapped function as a constraint for corresponding group of common point warnings. Eliminating, warnings from each of the one or more groups using a review output wherein the review output is identified by reviewing a common point warning from the one or more group under the constraint such that the review of the common point warning under the constraint satisfy for review of all remaining for reviews of all remaining common point warnings of the group. | 03-31-2016 |
| 20160092349 | CORRELATING OUT-OF-BAND PROCESS DATA DURING MOBILE TEST AUTOMATION - Methods and arrangements for testing mobile applications. A mobile application for testing is input at a mobile device. The mobile application is automatically tested using a test script, wherein the testing requires data from an out-of-band channel. The testing includes: invoking a listener module based on the mobile application; using the listener module to automatically obtain data from an out-of-band channel; and communicating the automatically obtained data to the mobile application. Other variants and embodiments are broadly contemplated herein. | 03-31-2016 |
| 20160098342 | SYSTEMS AND PROCESSES FOR COMPUTER LOG ANALYSIS - Existing program code, which is executable on one or more computers forming part of a distributed computer system, is analyzed. The analysis identifies log output instructions present in the program code. Log output instructions are those statements or other code that generate log messages related to service requests processed by the program code. A log model is generated using the analysis. The log model is representative of causal relationships among service requests defined by the program code. The log model can then be applied to logs containing log messages generated by execution of the program code, during its normal operation, to group log messages for improved analysis, including visualization, of the performance and behaviour of the distributed computer system. | 04-07-2016 |
| 20160103755 | Sequentially Constructive Model of Computation - System and method for validating a program under a specified model of computation. The model of computation may be related to the synchronous statechart model of computation. A program may be received that specifies a plurality of operations using a variable within a logical tick such that the variable has multiple values within the logical tick. The program may be statically analyzed according to a specified model of computation that specifies program execution based on logical ticks, which may include determining that the program has deterministic semantics that specify deterministic results for each logical tick during execution of the program, including specifying deterministic results of the plurality of operations performed within the logical tick. The program may be validated in accordance with the specified model of computation in response to the determining. Such techniques may allow validation of a larger set of programs than conventional models while maintaining deterministic results. | 04-14-2016 |
| 20160103760 | Sequentially Constructive Model of Computation - System and method for validating a program under a specified model of computation. The model of computation may be related to the synchronous statechart model of computation. A program may be received that specifies a plurality of operations using a variable within a logical tick such that the variable has multiple values within the logical tick. The program may be statically analyzed according to a specified model of computation that specifies program execution based on logical ticks, which may include determining that the program has deterministic semantics that specify deterministic results for each logical tick during execution of the program, including specifying deterministic results of the plurality of operations performed within the logical tick. The program may be validated in accordance with the specified model of computation in response to the determining. Such techniques may allow validation of a larger set of programs than conventional models while maintaining deterministic results. | 04-14-2016 |
| 20160124836 | APPLICATION TESTING - A method includes analyzing, by a processor, a first version of a computer program. The analyzing includes identifying a first data processing element included in the first version of the computer program. The first data processing element references a first data source external to the first version of the computer program. The method includes generating a data source element that represents a second data source different from the first data source. The method includes generating a second version of the computer program. The second version of the computer program includes the generated data source element and a second data processing element that is based on the first data processing element. In the second version of the computer program, the second data processing element references the generated data source element. | 05-05-2016 |
| 20160132421 | ADAPTATION OF AUTOMATED TEST SCRIPTS - Embodiments provide a computerized method for adapting automating test scripts, said method including: utilizing at least one processor to execute computer code that performs the steps of: receiving, at an input device, an original test script created to test an application; utilizing the original test script to test, using the processor, a variant of the application; identifying, using the processor, failures in the original test script when the variant of the application is being tested; and modifying, using the processor, the original test script to overcome the identified failures. | 05-12-2016 |
| 20160147644 | METHOD FOR TESTING MOBILE APPLICATION AND ASSOCIATED APPARATUS AND SYSTEM - The application testing system and method provide an efficient and effective way to test multiple application variants of an application on at least one mobile device. The application testing system may cause a first application variant selection indication to be transmitted to at least one mobile device having the application. The first application variant selection indication may be configured to cause the mobile device to interact with the application according to a first application variant of the plurality of application variants. The application testing system may analyze data corresponding to the usage of the first application variant by the at least one mobile device, and cause a second application variant selection indication to be transmitted to the mobile device, wherein the second application variant selection indication is configured to cause the mobile device to interact with the application according to a second application variant of the plurality of application variants. | 05-26-2016 |
| 20160154725 | METHODS, CIRCUITS, APPARATUS, SYSTEMS AND ASSOCIATED SOFTWARE MODULES FOR EVALUATING CODE BEHAVIOR | 06-02-2016 |
| 20160154730 | USING LINKED DATA TO DETERMINE PACKAGE QUALITY | 06-02-2016 |
| 20160162390 | ORTHOGONAL EXPERIMENTATION IN A COMPUTING ENVIRONMENT - Various embodiments include at least one of systems, methods, and software to receive input configuring tests within a computing environment to expose users to standard application or website experiences or test experiences. In some embodiments, multiple tests may be configured to run orthogonally within user experiences without affecting the results of one another. Some such embodiments preserve the ability to execute certain tests in anon-orthogonal manner while other tests are allowed to execute orthogonally. | 06-09-2016 |
| 20160170863 | SOFTWARE TEST AUTOMATION | 06-16-2016 |
| 20160188437 | TESTING FUNCTIONAL CORRECTNESS AND IDEMPOTENCE OF SOFTWARE AUTOMATION SCRIPTS - Various embodiments automatically test software automation scripts. In one embodiment, at least one software automation script is obtained. The software automation script is configured to automatically place a computing system into a target state. A plurality of test cases for the software automation script is executed. Each of the plurality of test cases is a separate instance of the software automation script configured based at least on one or more different states of the computing system. The software automation script is determined to be one of idempotent and non-idempotent and/or one of convergent and non-convergent based on executing the plurality of test cases. | 06-30-2016 |
| 20160188438 | TESTING FUNCTIONAL CORRECTNESS AND IDEMPOTENCE OF SOFTWARE AUTOMATION SCRIPTS - Various embodiments automatically test software automation scripts. In one embodiment, at least one software automation script is obtained. The software automation script is configured to automatically place a computing system into a target state. A plurality of test cases for the software automation script is executed. Each of the plurality of test cases is a separate instance of the software automation script configured based at least on one or more different states of the computing system. The software automation script is determined to be one of idempotent and non-idempotent and/or one of convergent and non-convergent based on executing the plurality of test cases. | 06-30-2016 |
| 20160188449 | SOFTWARE AGING TEST SYSTEM, SOFTWARE AGING TEST METHOD, AND PROGRAM FOR SOFTWARE AGING TEST - Load test is executed with an appropriate frequency which does not lead to a decrease in software development efficiency and a decrease in the precision of software aging detection. Load test of a version of software under test is executed in accordance with an execution criterion, presence or absence of a software aging problem is detected by comparing a test result of the load test with a test result of load test of a previous version of the software to be compared, and frequency of execution of subsequent load test is adjusted by changing the execution criterion based on a result of the detection. | 06-30-2016 |
| 20160196203 | EXTRACTION OF PROBLEM DIAGNOSTIC KNOWLEDGE FROM TEST CASES | 07-07-2016 |
| 20160378638 | TESTING FUNCTIONAL CORRECTNESS AND IDEMPOTENCE OF SOFTWARE AUTOMATION SCRIPTS - Various embodiments automatically test software automation scripts. In one embodiment, at least one software automation script is obtained. The software automation script is configured to automatically place a computing system into a target state. A plurality of test cases for the software automation script is executed. Each of the plurality of test cases is a separate instance of the software automation script configured based at least on one or more different states of the computing system. The software automation script is determined to be one of idempotent and non-idempotent and/or one of convergent and non-convergent based on executing the plurality of test cases. | 12-29-2016 |
| 20160378649 | TESTING FUNCTIONAL CORRECTNESS AND IDEMPOTENCE OF SOFTWARE AUTOMATION SCRIPTS - Various embodiments automatically test software automation scripts. In one embodiment, at least one software automation script is obtained. The software automation script is configured to automatically place a computing system into a target state. A plurality of test cases for the software automation script is executed. Each of the plurality of test cases is a separate instance of the software automation script configured based at least on one or more different states of the computing system. The software automation script is determined to be one of idempotent and non-idempotent and/or one of convergent and non-convergent based on executing the plurality of test cases. | 12-29-2016 |
| 20170235663 | SERVICE DEMAND BASED PERFORMANCE PREDICTION USING A SINGLE WORKLOAD | 08-17-2017 |
| 20190146897 | STATIC PROGRAM ANALYSIS OF A PARTIAL SOFTWARE PROGRAM | 05-16-2019 |
