Abstract: Testing a system under test includes intercepting, within a proxy system, a request from a client system sent to the system under test. The request is analyzed within the proxy system and sent to the system under test. Within the proxy system, a response from the system under test sent to the client system is intercepted. The response is instrumented creating a modified response indicating test coverage according to the request. The modified response is sent to the client system.

Abstract: A system and method for discovering fault conditions such as conflicts between applications and an operating system, driver, hardware, or a combination thereof, installed in mobile computing devices uses a mobile device running a diagnostic application. A list of applications that were launched or installed during a time period prior to an operational disruption is retrieved. A data table of combinations of incompatible programs and drivers is used to analyze the list of the applications that were launched or installed to create a list of potential fault-causing interactions due to software incompatibilities of software installed in the mobile computing device. A knowledge database is updated with data identifying at least one of the potential fault-causing interactions.

Abstract: The technology disclosed relates to implementing a novel architecture of a finite state machine (abbreviated FSM) that can be used for testing. In particular, it can be used for testing communications devices and communication protocol behaviors.

Abstract: Techniques for testing one or more applications running on a handheld device include: receiving, by a tester system, an error state corresponding to the one or more applications; retrieving, by the tester system, one or more tests script parameters corresponding to the error state from a database, wherein the one or more test script parameters corresponding to the error state are stored in the database; providing, by the tester system, the one or more test script parameters to an input subsystem, wherein the input subsystem is connected to the handheld device; notifying a user to provide one or more inputs corresponding to the error state, wherein the one or more test script parameters are not stored in the database; receiving, by the tester system, the one or more inputs from the user; and providing, by the tester system, the one or more inputs to the input subsystem.

Abstract: A first computer receives a first and a second test sample. The first computer executes the first and second test sample. The first computer determines that the value exposed by a first parameter in the second test sample is different from the value exposed by the first parameter in first test sample. The first computer creates a first value driven equivalence class. The first computer determines the value exposed by the second parameter in the second test sample is different from the value exposed by the second parameter in the first test sample and the value exposed by the second parameter in the second test sample is equivalent to the value exposed by the first parameter in the second test sample. The first computer adds the second parameter to the first value driven equivalence class and creates a generalized test case, including at least the first value driven equivalence class.

Abstract: An approach is provided to utilize experiences of a user community to identify software problems and communicate resolutions to such problems. Error reports are received from installed software systems in the user community. From these reports, a set of problematic usage patterns are generated, with each of the usage patterns having a confidence factor that is increased based on the number of problem reports that match the usage pattern. The problematic usage patterns are matched to sections of code corresponding to the installed software system with sections of code being identified with problematic usage patterns having confidence factors greater than a given threshold.

Abstract: A mechanism for utilizing a virtual machine cloud for automated test system deployment is disclosed. A method of embodiments of the invention includes selecting a master image used to initialize one or more virtual machines (VMs), providing a list of repository definitions and test packages to the one or more VMs, and receiving test results from executing the test packages on a computer system of the VM defined by the master image, wherein the computer system includes an operating system and one or more software applications.

Abstract: A system for automated testing of functionally complex systems, comprising a test manager module operating on a server computer, a test data storage subsystem coupled to the test manager module and adapted to store at least test results, a test execution module operating on a server computer, and a test analysis module operating on a server computer and adapted to receive test data from the test data storage subsystem. The test manager module causes tests to be executed by the test execution engine, and on detection of an anomalous test result, the test manager module at least causes additional testing to be performed and causes the test analysis module to analyze the results of at least some of the additional testing in order to isolate at least one component exhibiting anomalous behavior.

Abstract: Techniques for managing a fused processing element are described. Embodiments receive streaming data to be processed by a plurality of processing elements. Additionally, an operator graph of the plurality of processing elements is established. The operator graph defines at least one execution path and wherein at least one of the processing elements of the operator graph is configured to receive data from at least one upstream processing element and transmit data to at least one downstream processing element. Embodiments detect an error condition has been satisfied at a first one of the plurality of processing elements, wherein the first processing element contains a plurality of fused operators. At least one of the plurality of fused operators is selected for removal from the first processing element. Embodiments then remove the selected at least one fused operator from the first processing element.

Abstract: An exemplary system may include debug capabilities. In one embodiment, the system obtains a debug address. For a process associated with the system, the system determines whether a memory page used by the process includes the debug address. Upon determining that the memory page used by the process includes the debug address, the system marks the memory page for debug and sends the memory page to a swap area.

Abstract: Embodiments of the invention relate to the conversion and execution of functional tests. In one embodiment, a current test step of a manual functional test is executed. The test includes a set of test steps each including at least one action and one target of the action. The test is associated with an application that includes a plurality of objects to be tested. At least two of the objects are determined to be associated with the target of the test step. A user is prompted to provide a selection of one of the at least objects for association with the target of the test step. A new test step is generated. The new test step associates the object selected by the user with the target of the current test step. The new test step is designated for automatic execution in place of the current test step for subsequent executions thereof.

Abstract: Method for automatically reloading software characterized in that it comprises: a step of detecting corruption (E101) of at least one part of a software package of an on-board programmable device (10-1, 10-2, 10-n); and, in response to signaling, a step of reloading (E103) a non-corrupt version of the said at least one corrupt part of the software in order to replace the said at least one corrupt part of the software.

Abstract: A fault restoration technique for use in a virtual environment is provided. The fault restoration technique includes monitoring fault state values of a plurality of domains, detecting a faulty domain, if any, from the plurality of, and restoring the faulty domain by reloading the OS of the faulty domain.

Abstract: During a debug mode of operation of a data processor it is determined whether a data access request is to a stack of the data processor. If not, a data trace message based on the data access request is generated for transmission to a debugger so long as an address being accessed by data access request meets a predefined address range criteria. Otherwise, if the data access request is to the stack of the data processor, a data trace message based on the data access request is prevented from being generated for transmission to the debugger regardless the predefined address range criteria.

Abstract: The present disclosure is directed to a control system for a machine. The control system has an electronic module containing at least one programmable controller. The at least one programmable controller stores a plurality of code modules, and be configured to identify from the plurality of code modules a module that contains a code fault. The at least one programmable controller identifies the code fault by executing, with the at least one programmable controller, the code module, writing a code execution status to a designated memory location on the electronic module, and identifying, based on the code module execution status, the code module that contains the code fault.

Abstract: The disclosure discloses a method and a system for detecting an abnormality of a network processor. The method comprises the following steps: an abnormality detection operation code is added into an execution flow of each thread in a network processor, and the network processor sets a flag bit corresponding to a current thread in an abnormality protection flag data area in a shared memory to a first flag when executing the abnormality detection operation code in the current thread; and when a period of a timer is expire, a coprocessor detects all the flag bits in the abnormality protection flag data area in the shared memory, determines that a thread corresponding to a flag bit which is not the first flag is abnormal when detecting that not all the flag bits are the first flag, and sets all the flag bits to a second flag when detecting that all the flag bits are the first flag.

Abstract: A computer-implemented method of debugging computer code includes: obtaining state information corresponding to a first machine at a checkpoint initiated during execution of the computer code on the first machine; and configuring the second machine to a same operating state as the first machine at the checkpoint to create a mirrored version of the first machine. The method also includes receiving a notification that execution of the program on a first machine has failed, and in response to receiving the notification: triggering a processor of the second machine to initiate execution of a copy of the code from a specific code execution point at which the checkpoint was; activating a debugger module to run concurrently with the execution of the program on the second machine and collect and store the debug data as corresponding to execution failure of the computer code at the first machine.

Abstract: A method for generating a replayable testing script for iterative use by an automated testing utility may include recording a plurality of scripts, each script relating to a separate iteration of a transaction between a user and a tested application performed by an operator. The method may also include comparing the recorded scripts to identify a location of a data item by finding different values in a pair of corresponding locations in the recorded scripts, indicative of a dynamic data item. The method may further include generating the replayable testing script comprising one of the recorded scripts and having a variable parameter at the identified location of the dynamic data item.

Abstract: Various embodiments monitor a distributed software system. In one embodiment, at least one monitoring policy associated with a distributed software system is selected. A policy type associated with the monitoring policy is identified. An installer is selected based on the policy type associated with the monitoring policy. Monitoring software is installed in a computing environment utilizing the installer. The monitoring software is configured to monitor the distributed software system based on the monitoring policy.

Abstract: Methods, apparatus, and systems for electronic device recovery are disclosed. An example method includes determining that a software request received from a computing device includes an indication of a repair mode of an electronic device, determining a characteristic of the electronic device, determining software to be provided to the electronic device based on the characteristic, and in response to determining that the software request includes the indication of the repair mode, transmitting location information for the software to the computing device.

Abstract: A system includes a client system comprising a memory and a processor configured to execute a debugging tool. The debugging tool is communicatively coupled to an OPC Unified Architecture (UA) server. Furthermore, the debugging tool is configured to monitor and control, from the client system, debugging of an application executing on the OPC UA server.

Abstract: A method of managing code-tracing data in a target program is described. The method comprises the steps of: identifying when an exception occurs in the target program; accessing a stack trace of a call stack to identify a module in the target program that threw the exception; and activating code-tracing at a high detail level in that module.

Abstract: A method for debugging an application includes obtaining first and second fusible operation requests; if there is a break point between the first and the second operation request, generating a first set of compute kernels including programs corresponding to the first operation request, but not to the second operation request; and generating a second set of compute kernels including programs corresponding the second operation request, but not to the first operation request; if there is no break point between the first and the second operation request, generating a third set of compute kernels which include programs corresponding to a merge of the first and second operation requests; and arranging for execution of either the first and second, or the third set of compute kernels, further including debugging the first or second set of compute kernels when there is a break point set between the first and second operation requests.

Abstract: The present disclosure describes methods, systems, and computer program products for measuring strength of a unit test. One computer-implemented method includes receiving software unit source code associated with a unit test, analyzing a line of the software unit source code for removability, initiating, by operation of a computer, modification of the software unit source code to remove the line of the software unit source code and create a modified software unit, initiating execution of the modified software unit using the unit test, determining success or failure of a unit test execution, and analyzing a next line of the software unit source code for removability.

Abstract: A computer-implemented method detects a stability change in a computer system, and identifies a first set of at least one capability of the computer system that is affected by the stability change. In response to detecting the stability change, the method identifies a software application that was installed prior to the stability change, and identifies a second set of at least one capability of the computer system that is utilized by the identified software application. The method compares the first and second capability sets to determine a degree of similarity, and compares the time that the stability change was detected to the time that the identified software application was installed to determine a temporal proximity. The method then identifies the likelihood that the identified software application is the cause of the stability change, wherein the identified likelihood is a function of the degree of similarity and the temporal proximity.

Abstract: A computer program product includes computer usable program code for: detecting a stability change in a computer system; identifying a first set of at least one capability of the computer system that is affected by the stability change; identifying, in response to detecting the stability change, a software application that was installed or updated prior to the stability change; identifying a second set of at least one capability that is utilized by the identified software application; comparing the first set to the second set to determine a degree of similarity; comparing a first time that the stability change was detected to a second time that the identified software application was installed or updated to determine a temporal proximity; and identifying the likelihood that the identified software application is the cause of the stability change, wherein the identified likelihood is a function of the degree of similarity and the temporal proximity.

Abstract: A method, computer program product, and system for transforming unit tests is described. A unit test associated with one or more software units is identified. A first input parameter of the unit test is identified. A substitute parameter value is determined, wherein the substitute parameter value is associated with a security test for the one or more software units. A value of the first input parameter in the unit test is replaced with the substitute parameter value. The unit test including the substitute parameter value is implemented for the one or more software units. A first security issue associated with the one or more software units is identified, based upon, at least in part, replacing the first input parameter of the unit test with the substitute parameter value and implementing the unit test including the substitute parameter value.

Abstract: An execution of a target software program that causes a particular bug to manifest itself is generated. A target software program is received. A bug report generated by an execution of the target software program is received. The bug report describes a particular bug within the target software program. A bug type of the particular bug is received. A synthesized execution file is generated based on the target software program, the bug report, and the bug type. The synthesized execution file specifies an execution of the target software program that causes the particular bug to manifest itself.

Abstract: Embodiments of the invention provide a set of validators that can be used to determine whether an installation is operating within desired parameters and is in compliance with any requirements. The validators may be provided with a software application or release, for example, and may be run during and/or after installation to test the application operation. A set of self-healing operations may be triggered when faults are detected by the validators. This allows a software application to auto-diagnose and auto-self-heal any detected faults.

Abstract: Methods for invasive debug of a processor without processor execution of instructions are disclosed. As a part of a method, a memory mapped I/O of the processor is accessed using a debug bus and an operation is initiated that causes a debug port to gain access to registers of the processor using the memory mapped I/O. The invasive debug of the processor is executed from the debug port via registers of the processor.

Abstract: Embodiments of the present invention provide a computing system and method to profile a program for finding potential optimization in heap usage by reducing lag and drag in lifetimes of heap memory blocks. The process consists of three steps. First, an instrumentation engine analyzes a given program and inserts additional code at interesting locations to collect needed information. Second, when the instrumented program is executed on a set of test cases, runtime data is collected. Third, since this data is large for a complex and long running program, data is processed to present it to a user in useful ways so that a programmer improves the heap utilization in the program.

Abstract: An industrial controller module (13a) is provided with a routine of program instructions (29a) for storing a log of I/O table state changes (31) in a defined portion of memory (23). Upon the occurrence of a trigger event, a file of the state changes (37) is saved in the memory (23). Each entry (32) in the log of I/O table state changes (31) includes a timestamp (33) and values of each word of I/O state data (36) that changed at a time of the timestamp. Logs of state change data (16a), including timestamp data can also be saved for intelligent sensors and actuators (16) and uploaded with the log of controller processor state data (31) to a computer (20) with a diagnostic program (21a) for playing back the state changes and synchronizing changes of the intelligent sensors and actuators (16) with changes of the controller processor module (13a).

Abstract: An embedded software debug system with partial hardware acceleration includes a computer that executes a debug software stack. The debug software stack includes high level operations. The system also includes a remote microcontroller electronically connected to the computer. The system further includes an embedded processor electronically connected to the remote microcontroller. The remote microcontroller receives an applet from the computer and executes the applet in conjunction with the computer executing the debug software stack to debug the embedded processor. The applet includes low level protocol operations including performance critical tight-loops precompiled into machine code. The debug software stack may include a stub that replaces the tight-loops of the applet. The computer may send the applet to the remote microcontroller in response to executing the still).

Abstract: A method for detecting a software-race condition in a program includes copying a state of a transaction of the program from a first core of a multi-core processor to at least one additional core of the multi-core processor, running the transaction, redundantly, on the first core and the at least one additional core given the state, outputting a result of the first core and the at least one additional core, and detecting a difference in the results between the first core and the at least one additional core, wherein the difference indicates the software-race condition.

Abstract: A system, computer readable medium, and method for automatically testing computer objects affected by an update package. The exemplary method may compare computer objects/instances in an update package with those of the installed version of the computer application. A set of computer objects that have changed in the update package as compared to the installed version may be generated. The changes to each of the computer objects in the set of changed objects may be analyzed to determine if an automated test is related to the changed object. If an object has a related automated test assigned to it, the object may be placed in a separate list for testing. The automated tests of the changed objects in the separate list may be organized into a test plan. The automated tests may be executed according to the test plan. The system may have servers and computer processors to implement the method.

Abstract: A method and system for providing immunity to a computer system wherein the system includes an immunity module, a recovery module, a maintenance module, an assessment module, and a decision module, wherein the immunity module, the recovery module, the maintenance module and the assessment module are each linked to the decision module. The maintenance module monitors the system for errors and sends an error alert message to the assessment module, which determines the severity of the error and the type of package required to fix the error. The assessment module sends a request regarding the type of package required to fix the error to the recovery module. The recovery module sends the package required to fix the error to the maintenance module, which fixes the error in the system.

Abstract: A fault-based software testing method and system are provided. The fault-based software testing method includes: generating a plurality of error programs by injecting faults into a testing target program; grouping the generated error programs into a plurality of groups with respect to respective test data, and selecting representative error programs with respect to the respective groups; and when an error is detected in the execution result of the representative error programs with respect to the corresponding test data, determining that errors are detected in all the error programs of the corresponding group.

Abstract: A system for testing two or more applications associated with a computerized process may include a central repository, a user interface and a testing coordinator. The central repository may be used to store at least one test case each including a test data set and two or more sets of test scripts. The user interface may facilitate a selection of one or more test cases for use by the testing coordinator. The testing coordinator may be configured to test the operation of the computerized process by initiating testing of a first application by a first test tool using the test data set and a first set of scripts and initiating testing of the second application by the second test tool using the test data set and the second set of scripts from the selected test case. In some cases, the first test tool is incompatible with the second test tool.

Abstract: An automated software testing and validation system allows testing of a software application under test (SAUT) regardless of the dynamic nature of the SAUT. An abstracted set of hierarchal or linear objects model certain regions of the SAUT. Automated test scripts utilize theses regions to intuitively navigate and identify potions of the SAUT to automate. The scripts can also access specific SAUT elements contain within each defined region. These elements can then be used to invoke actions or verify outputs there from. The system uses a set of rich identification rules embodied in the system which allow the user to configure the identification of any element within the abstracted region. The rules are customizable to allow the user to configure the desired level of loose coupling between the automated scripts and the target element to adapt the scripts to the nature of the SAUT.

Abstract: Described herein is a technology for a dashboard used for visualizing data. In some implementations, a dashboard with one or more dashboard item is provided. Performance of the dashboard is evaluated to determine a load time of the dashboard. Possible suggestions for improving performance of the dashboard are provided if performance issues are determined from evaluating performance of the dashboard.

Abstract: A computational geometry technique is utilized to detect, diagnose, and/or mitigate fault detection during the execution of a software application. Runtime measurements are collected and processed to generate a geometric enclosure that represents the normal, non-failing, operating space of the application being monitored. When collected runtime measurements are classified as being inside or on the perimeter of the geometric enclosure, the application is considered to be in a normal, non-failing, state. When collected runtime measurements are classified as being outside of the geometric enclosure, the application is considered to be in an anomalous, failing, state. In an example embodiment, the geometric enclosure is a convex hull generated in N-dimensional Euclidean space. Appropriate action (e.g., restart the software, turn off access to a network port) can be taken depending on where the measurement values lie in the space.

Abstract: A method is disclosed for diagnosing programming errors for a data storage device, wherein a dump file is received from the data storage device comprising program execution data. The dump file is converted into a plurality of debug stop records, wherein each debug stop record comprises trace information related to a programming error. A first debug stop record is evaluated relative to a history of debug stop records stored in a history database. When the first debug stop record corresponds to a second debug stop record in the history database, the programming error is resolved for the first debug stop record using resolution information associated with the second debug stop record.

Abstract: A system includes a manager module that oversees execution of a business process by a test module. The business process includes a plurality of process steps, and the test module comprises a plurality of test cases, a plurality of software test tools, and a plurality of parameters. The test module is configured to permit a user to select a particular process step of the business process, to select a particular test case for the particular process step, to select a particular software test tool for the particular test case, and to select a particular parameter flow for the particular software test tool. The test module is also configured to execute the selected process step using the selected test case, the selected software test tool, and the selected parameter flow.

Abstract: Development of data services can be enhanced through the use of methods and systems that automate aspects of the build process. Particularly, software can be used to automatically generate test cases and incorporate test results into documentation as part of the build process based on an updated Application Programming Interface (API) specification to generate up-to-date and accurate Software Development Kit (SDK) artifacts. A method can comprise accessing data defining an API for a data service, such as Web Application Description Language (WADL) or Web Service Description Language (WSDL) data. The method can further comprise identifying a test case for a service call that can be made via the API based on the data defining the API, and generating test code, the test code configured to evaluate the test case by making the service call. The test code can be used for evaluating the test case(s) in order to ensure requests and/or responses are consistent with the API definition.

Abstract: Techniques for error report processing are described herein. Error reports, received by a developer due to program crashes, may be organized into a plurality of “buckets.” The buckets may be based in part on a name and a version of the application associated with a crash. Additionally, a call stack of the computer on which the crash occurred may be associated with each error report. The error reports may be “re-bucketed” into meta-buckets to provide additional information to programmers working to resolve software errors. The re-bucketing may be based in part on measuring similarity of call stacks of a plurality of error reports. The similarity of two call stacks—a measure of likelihood that two error reports were caused by a same error—may be based in part on functions in common, a distance of those functions from the crash point, and an offset distance between the common functions.

Abstract: A computer implemented method for configuring virtual internal networks for testing is provided, such that affects of testing are internally isolated. The method includes deploying a virtual firewall and deploying a public switch enabling access to an external local area network through a first interface of the virtual firewall. A private switch enabling access to a plurality of virtual machines through a second interface of the virtual firewall is provided. The plurality of virtual machines defines a private network behind the firewall. A network address is assigned to the virtual firewall and a private address is assigned to each of the virtual machines. The plurality of virtual machines is then tested through a test launcher in communication with the public switch.

Abstract: A computer implemented method, apparatus, and computer usable program code for returning a return code to an error hook in an application using a framework. An identifier and a pass-through are received from the error hook. The error hook is software code in the application. The pass-through is a set of parameters. If the identifier has an active status, a set of framework conditions is retrieved using the identifier. If the set of framework conditions is met, an inject callback is retrieved using the error identifier. The inject callback is called with the error identifier and the pass-through. An inject callback return code is received. If the inject callback return code is an execute return code, the execute return code is returned to the error hook.

Abstract: A method is provided for diagnosing failures in an object-oriented software system. The method comprises collecting runtime diagnostic information; maintaining a record of the diagnostic information in a storage buffer; and dynamically updating the record of the diagnostic information to include a group of the diagnostic information collected over a most recent occurrence of a predetermined interval. The diagnostic information includes at least one set of call stack information for at least one currently running application and at least one set of other information. Each of the at least one set of other information is selected from a set of memory access information, a set of data access information, and a set of paging information for each currently executing process.

Abstract: A method, computer program product, and system for transforming unit tests is described. A unit test associated with one or more software units is identified. A first input parameter of the unit test is identified. A substitute parameter value is determined, wherein the substitute parameter value is associated with a security test for the one or more software units. A value of the first input parameter in the unit test is replaced with the substitute parameter value. The unit test including the substitute parameter value is implemented for the one or more software units. A first security issue associated with the one or more software units is identified, based upon, at least in part, replacing the first input parameter of the unit test with the substitute parameter value and implementing the unit test including the substitute parameter value.

Abstract: Integrated fuzzing techniques are described. A fuzzing system may employ a container configured as a separate component that can host different target pages to implement fuzzing for an application. A hosted target file is loaded as a subcomponent of the container and parsed to recognize functionality of the application invoked by the file. In at least some embodiments, this involves building a document object model (DOM) for a browser page and determining DOM interfaces of a browser to call based on the page DOM. The container then operates to systematically invoke the recognized functionality to cause and detect failures. Additionally, the container may operate to perform iterative fuzzing with multiple test files in an automation mode. Log files may be created to describe the testing and enable both self-contained replaying of failures and coverage analysis for multiple test runs.