Abstract: A system and method for automatic coding out biases in applications, systems, and processes are disclosed. A processor operatively connected to a memory via a communication interface applies an intake process based on received inventory data to applications, systems, and processes and implements a machine learning model in response to applying the intake process. The processor also identifies areas of the potential bias data within the applications, systems, and processes by utilizing the machine learning model based on analyzing response data received during the intake process; generates output data that includes bias data and exceptions data identified for the applications, systems, and processes; and mitigates the bias data and exceptions data in response to the output data by implementing a mitigation process.

Abstract: A device may receive parameters to test modifications to an application associated with a product and/or a service, and may process data identifying the parameters and the application, with a machine learning model, to generate test applications for testing corresponding modifications to the application. The device may define test group sizes of test groups for testing the test applications, and may receive, from user devices, requests for accessing the application. The device may assign, based on the test group sizes, sets of the user devices to the test groups for testing the test applications, and may provide the test applications concurrently to the corresponding sets of the user devices based on the test groups. The device may receive, from the corresponding sets of the user devices, feedback associated with the test applications, and may perform one or more actions based on the feedback.

Abstract: Embodiments learn and visualize a software component and interface. Software code including a series of events can be received, where the series of events include calls to a software component and interface under test. Supplemental code can be injected into the received code. The software code with the injected supplemental code can be executed, where the executed supplemental code generates state data for the software component and interface. Based on the generated state data, a state diagram visualization can be generated that visualizes states and state transitions for the software component and interface under test given the series of events.

Abstract: Embodiments relate to a system, program product, and method for validating a system under test (SUT). The method includes selecting one or more random biases for one or more properties of the one or more API requests. The method also includes transmitting the one or more API requests to the SUT, transmitting an API response from the SUT for each of the one or more API requests, and validating each API response.

Abstract: A computer program is evaluated for security vulnerabilities by formulating a query in a query language and receiving into a memory of a computer source code of the computer program to be analyzed, preparing a data flow graph from the source code, and determining that the query is satisfied by an analysis of the data flow graph. Alternatively, the computer program is evaluated by collecting runtime events during an execution of binary code and determining that the query is satisfied by an analysis of the runtime events. In either case a security vulnerability is reported.

Abstract: Computing systems, database systems, and related methods are provided for providing visualizations of distributed package components. One exemplary method involves a server providing a graphical representation of a plurality of classes of a package, receiving a request to view a global class of the plurality of classes, obtaining previously compiled code associated with the global class of the from a database, filtering the code to include global source components of the global class while removing non-global source code components, and providing a graphical representation of the filtered code on the client device requesting presentation of the global class.

Abstract: A method of monitoring and assessing program variables of an industrial installation driven by a controller (C) by instructions programmed in a user program. Specific monitoring modules (MS1 to MSt) are implanted, as close as possible in time to the variable(s) (V1 to Vt) to be monitored to monitor evolution in real-time. During execution, each specific monitoring module (MSy) reads, in real-time, the logic state of each of variables which it monitors in an instantaneous cycle turn (TCi) of the controller (C), compares this logic state with the previously recorded logic state, and, only in the case of a state change, records the new logic state read as well as the real-time time-stamp of this event in a global memory unit (UM_G). The recorded metadata is analyzed in order to check behavior of the installation, use this production data and identify a possible malfunction of program and/or the installation.

Abstract: An apparatus for performing data processing in a single program multiple data fashion on a target data set is provided, having execution circuitry configured to execute multiple threads, thread schedule configuration storage configured to store information defining a plurality of thread schedule configurations, and thread scheduling circuitry configured to cause the execution circuitry to execute the multiple threads in a selected order defined by a selected thread schedule configuration. A method of operating the apparatus, as well as a method of compiling a source program for the apparatus are also provided.

Abstract: This disclosure describes methods, apparatuses, and systems for providing visualizations of workflows. Data associated with successes and failures of individual components of workflows can be collected and aggregated to provide an overview of the operation of workflows, as well as allowing a software developer to troubleshoot operations of the workflow. Status indications of steps can be visualized in a graphical user interface (GUI), for example, and faults can be identified and presented in the GUI. By aggregating workflow data across hundreds, thousands, or even millions of workflows, a user can quickly determine the overall operations of the workflow, as well as areas of the workflow that may need improvement.

Abstract: A method, system, and apparatus for debugging an application program from a workstation that is remote from a server on which the application program resides includes invoking the application program from the workstation via a network interface; displaying a user frame at the workstation that includes information generated by the application program; providing a debug view option at the workstation for generating a debug frame of the application program; and displaying the debug frame at the workstation when the debug view option is selected. When the debug view option is selected, the information for the user frame is saved and can be restored to regenerate the information on the user frame when the user view option is selected. The developer can view internal, public, and private code associated with the application program without compromising the security of other application programs on the server.

Abstract: Described is a tool for allowing developers to analyze objects in to process virtual address space. The system includes a technique for identifying references between objects within memory and refining these references with runtime metadata and analysis heuristics. These objects may then be displayed in the form of a graph that employs a progressive disclosure to more effectively allow a developer debug memory. For example, the graph may organize objects within a coordinate grid system that allows a developer to concentrate or expand reference paths as necessary when analyzing objects or detecting potentially leaked or abandoned sources of memory.

Abstract: A remote debugging technique provides anonymity of program variables and selective debugging capability by providing a registration facility by which program variables are registered locally with a debugging module. An external program then communicates with the debugging modules and observes and/or modifies the program variables by specifying either an index or a variable name. The need to publish symbols is thereby averted and only the variables that a developer is interested in observing need be registered.

Abstract: A method for generating control-code, where at least one function-block and/or function-block-connection is specified.

Abstract: Techniques are described herein that are capable of instantiating and executing in-process wrapped execution engine(s) for tooling a dynamic program across a process boundary. For instance, a dynamic language execution engine may be instantiated in a wrapper object that is hosted in a host process to provide a wrapped execution engine while the host process is running. The wrapped execution engine may be configured to provide information regarding execution of a targeted application of the host process to a requesting application. The wrapped execution engine may be isolated from other execution engine(s) that are included in the host process such that the targeted application does not have access to code that defines the wrapped execution engine. The targeted application may include one or more of the other execution engines.

Abstract: A method for constructing data structures and a method for describing running states of a computer and state transitions thereof are provided. The method for constructing the data structure, which describes the execution processes of computer codes, includes: when the computer is running, constructs the data structure using the code segment wherein lies a calling instruction as a node and using the calling relationship between the code segment initiating the calling instruction and the called code segment, which are both constructed by the calling instruction, as a calling path. The data structure includes every node and the calling path between every calling and called nodes. When a certain calling instruction is executed, it is possible to describe the running state of the computer when the calling instruction is executed with the data structure consisting of all nodes and calling paths before the calling instruction by constructing the above data structure.

Abstract: A dataflow of a distributed application is visualized in a locally simulated execution environment. A scheduler receives a job graph which includes a graph of computational vertices that are designed to be executed on multiple distributed computer systems. The scheduler queries a graph manager to determine which computational vertices of the job graph are ready for execution in a local execution environment. The scheduler queries a cluster manager to determine the organizational topology of the distributed computer systems to simulate the determined topology in the local execution environment. The scheduler queries a data manager to determine data storage locations for each of the computational vertices indicated as being ready for execution in the local execution environment. The scheduler also indicates an instance of each computational vertex to be spawned and executed in the local execution environment based on the organizational topology and indicated data storage locations.

Abstract: In one embodiment, a method for providing software problem solutions includes: obtaining a software problem of a questioning user; obtaining from other users multiple solutions for solving the software problem, each of the multiple solutions being provided as a recording script, and each of the recording scripts includes a user operation sequence and a corresponding semantic node sequence, wherein one or more semantic nodes in each of the semantic node sequences describes meanings of user operations; analyzing, by a computer processor, semantic node sequences in the recording scripts of the multiple solutions to determine recommendation degree information for the multiple solutions; and outputting the multiple solutions and the associated recommendation degree information.

Abstract: System and method implementing an integrated interface for multiple instruments for signal analysis, including two or more virtual instruments. The method includes a) receiving user input specifying an operation implementing at least a portion of a signal analysis function; b) performing the operation utilizing at least one of the instruments to perform the operation; c) displaying an icon comprising a graphical representation of the operation in response to the specifying; d) storing information specifying the operation; and repeating a)-d) multiple times to specify the function, thereby producing stored information representing the operations in the function, and after which multiple icons are displayed representing the operations and visually indicating the function. The operations in the function include 1) generating signals displayed in a graph, and/or 2) modifying one or more signals displayed in the graph.

Abstract: Coverage data may be collected for a model. The coverage data may include model coverage data and code coverage data for test cases input to the model. The coverage data may be presented to a user as data indicating a correspondence between coverage outcomes for the model and coverage outcomes for the code used to implement the model.

Abstract: Coverage data may be collected for a model. The coverage data may include model coverage data and code coverage data for test cases input to the model. The coverage data may be presented to a user as data indicating a correspondence between coverage outcomes for the model and coverage outcomes for the code used to implement the model.

Abstract: Embodiments of the present invention provide a method, system and computer program product for assertion management in a dynamically assembled programmatic environment. In an embodiment of the invention, a method for assertion management in a dynamically assembled programmatic environment can include dynamically assembling different execution units into a dynamically assembled computer program, applying an assertion to at least one of the different execution units through an introspection of the one of the different execution units, and generating an assertion result reporting a failure of the assertion responsive to the failure of the assertion.

Abstract: A software testing system and method provides full reuse of software tests and associated test data in a centralized shared repository, including enabling the full reuse of test assets including test actions, test scenarios, test data; and automation scripts. Reusable test components consisting of test steps and the type of test data needed by those test steps, are managed and maintained. These components are assembled into reusable components with no binding of test data until execution time, thereby treating the test data as a reusable asset. A reusable test is initially defined using only an indication of a type or category of data, and not bound to the actual data itself, until it is assembled into an executable immediately prior to automated or manual test execution.

Abstract: Error reporting software-based method where an error list for a currently-running version of some target software (or firmware) is compared to an error list for a previous versions. Helpful information can be gleaned from the comparison of error lists. For example, if it is known that the hardware configuration has not changed, as between the two lists, and there is an error on the current list that does not appear on the previous list, then this indicates that the error is in the software update and is not a hardware problem.

Abstract: Coverage data may be collected for a model. The coverage data may include model coverage data and code coverage data for test cases input to the model. The coverage data may be presented to a user as data indicating a correspondence between coverage outcomes for the model and coverage outcomes for the code used to implement the model.

Abstract: A method for debugging reconfigurable hardware is described. According to this method, all necessary debug information is written in each configuration cycle into a memory, which is then analyzed by the debugger.

Abstract: An operation of a processor in respect to transactions is checked by simulating an execution of a test program, and updating a transaction order graph to identify a cycle. The graph is updated based on a value read during an execution of a first transaction and a second transaction that is the configured to set the memory with the read value. The test program comprises information useful for identifying the second transaction.

Abstract: A system and method for identifying an application exception generated in response to a software application operating on a system is provided, wherein the method includes identifying an occurrence of an application exception, examining the application exception to identify characteristics of the application exception and processing the application exception, prior to the application exception being logged, responsive to the characteristics of the application exception. The processing includes determining whether application exception environment data is to be collected and if the application exception environment data is to be collected, logging the application exception environment data.

Abstract: Techniques for debugging applications are provided. Access to an application is controlled by a wrapper. The wrapper intercepts calls to the application and records the calls. The calls are then passed to the application for processing. The recorded calls form a log which may be analyzed or mined to detect error conditions or undesirable performance characteristics associated with the application independent of source associated with the application.

Abstract: In accordance with embodiments, there are provided mechanisms and methods for automated test case generation and scheduling. These mechanisms and methods for automated test case generation and scheduling can provide an automated manner of generating test cases and scheduling tests associated with such test cases. The ability to provide this automation can improve efficiency in a testing environment.

Abstract: According to aspects illustrated herein, there is provided a method, system, and computing device for identifying bugs in a software application. The method provides for hosting the software application on a cloud server and providing the software application to a group of users and monitors usage of the software application. Next, new usage patterns are identified by identifying current usage patterns based on the monitoring are identified and comparing the current usage patterns to stored usage patterns. After that, bugs are identified by: 1) automatically generating a set of new test matrices based on the new usage patterns; 2) automatically running the set of new test matrices on the software application, while the software application is being used; 3) recording error messages generated; and 4) correlating the error messages with the new usage patterns to identify the bugs. Then, a reporting message is generated to report the identified bugs.

Abstract: A method and system for testing complex machine control software A method of formally testing a complex machine control software program in order to determine defects within the software program is described. The software program to be tested (SUT) has a defined test boundary, encompassing the complete set of visible behaviour of the SUT, and at least one interface between the SUT and an external component, the at least one interface being defined in a formal, mathematically verified interface specification.

Abstract: Selectively presenting source code defect information within a source code editor. In the source code editor, a defect tracking identifier can be presented. The defect tracking identifier can be associated with a defect record contained in a defect tracking system. When a user selects the defect tracking identifier, defect information associated with the defect can be automatically retrieved from the defect tracking system. The defect information can be presented in the source code editor.

Abstract: In accordance with the teachings described herein, systems and methods are provided for an automated application interface. One or more wizards may be used to receive user input in order to perform one or more software interface operations to manipulate a first set of data between data analysis software and database software. Information associated with the user input may be captured and used to generate one or more template data stores. A user interface may be used to modify at least one template data store to identify a subsequent set of data. The template data stores may be automatically executed in an identified sequence to perform software interface and data analysis operations for the subsequent set of data.

Abstract: A computer storage medium having a computer-readable code segment for performing a method may be provided. The method may include receiving inputs from a user using an interface, the inputs define a test that is run against the application software; associating a resource with the test, the resource selected by the user using the interface; executing the test against the application software; comparing an outputted value of the application software with an expected value; and outputting a result.

Abstract: A debugger includes: a plurality of processor cores; and a scheduler configured to control an allocation of a plurality of basic modules to the processor cores based on an execution rule for enabling parallel execution of a program that is divided into the basic modules that are executable asynchronously with one another, the program being defined with the execution rule of the basic modules for executing the basic modules in time series, wherein the scheduler includes a break point setting module configured to set a group of break points that are designated through a graphical user interface.

Abstract: A method in a multithreaded computing environment for capturing diagnostic data, the method comprising the steps of: in response to a determination that the computing environment is in a predetermined invalid state, a first thread recording diagnostic data for the computing environment, wherein the determination includes a verification that the invalid state corresponds to a state other than a transient state of the computing environment corresponding to a transition of the computing environment by a second thread from a first valid state to a second valid state. An apparatus and computer program element for providing such diagnostic data capture are also provided.

Abstract: A method is implemented in a computer infrastructure having computer executable code tangibly embodied on a computer readable storage medium having programming instructions. The programming instructions are operable to receive a maturity level for an organization and select at least one defect analysis starter/defect reduction method (DAS/DRM) defect profile based on the maturity level. Additionally, the programming instructions are operable to determine a projection analysis for one or more stages of the life cycle of a software code project of the organization based on the at least one DAS/DRM defect profile.

Abstract: Some embodiments provide a system that executes a native code module. During operation, the system obtains the native code module. Next, the system loads the native code module into a secure runtime environment. Finally, the system safely executes the native code module in the secure runtime environment by using a set of software fault isolation (SFI) mechanisms that maintain control flow integrity for the native code module and constrain store instructions in the native code module by bounding a valid memory region of the native code module with one or more guard regions.

Abstract: 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.

Abstract: Described herein are systems and methods for managing testing functionalities. One such method includes receiving, from a test tool, data indicative of a user-created test script, being a data-bound test script in the present example. The data-bound test script is created for testing a target application, and is bound to a predetermined data set. This received data is then processed, thereby to define data indicative of an unbound test script. A user interface is provided for allowing a user to associate the unbound test script with one or more data sets selected from a repository of stored data sets. Responsive to a user command, data indicative of a new data-bound test scripts is defined based on the association of the unbound test script with the selected one or more data sets. This new defined data-bound test script is executable via the test tool. For example, instructions are provided to the test tool such that those scripts are executed for the testing of the target application.

Abstract: A detecting system for detecting functions of a driver includes a storage unit, a control unit, and an human machine interface (HMI). The control unit samples a plurality of functions of the driver to generate a plurality of sampled values at each preset sampling time. The control unit determines if the plurality of sampled values are normal according to a plurality of preset reference ranges for the plurality of functions stored in the storage unit. When one or more of the plurality of sampled values is abnormal, the control unit generates an alarm signal, and the HMI displays the plurality of sampled values.

Abstract: A system and method for correcting errors in downloading web pages provides a historic error resolving procedure and a common error resolving procedure. The historic error resolving procedure is for storing a download error and debugging solutions corresponding to the download error. The download error includes error positions and error types. The common error resolving procedure stores predefined error types and corresponding debugging solutions. If the download error of an error does not exist in the historic error resolving procedure, the common error resolving procedure is searched for the error types and corresponding debugging solutions. If the error type does not exist in the common error resolving procedure, an administrator is prompted to provide a new debugging solution to solve the error, and the new debugging solution is stored into the historic error resolving procedure.

Abstract: Content requests are debugged in accordance with a presence of a flag in a request to a publisher. A document received from the publisher contains a script to debug requests for content to a content provider. The requests are examined to determine the presence of informational, warning and error conditions. The conditions are written to a debugging user interface.

Abstract: A diagnosis apparatus is disclosed that is able to promote productivity of a diagnosis of the target program which may be for an image forming apparatus such as a printer, a copier, or a fax. The diagnosis apparatus uses a diagnosis program which acquires log information of a target program at runtime. The diagnosis program is sent to a situation where the diagnosis program is to be executed. Further, the diagnosis apparatus includes a memory unit configured to store correspondence data between the diagnosis program and program selection information, where the program selection information is used for selecting the diagnosis program. Also included is a selecting unit which selects the diagnosis program based on the correspondence data, a sending unit which sends the diagnosis program to the situation, and a receiving unit which receives the log information from the diagnosis program.

Abstract: A software engine has a base system in communication with service subsystems and test subsystems. The base system, the service subsystems, and the test subsystems are software applications that exchange data with one another while operating within the software engine. In one exemplary mode of operation, the base system receives outputs from the service subsystems. In another exemplary mode of operation, the base system receives outputs from the test subsystems that simulate the outputs generated by the service subsystems. An exemplary method of testing the software engine is also provided. Specifically, the illustrative method includes receiving an output during a service mode, switching from the service mode to a testing mode, and receiving the simulated output during the testing mode. The method steps may be performed by a computer executing instructions stored on a computer-readable medium.

Abstract: A protocol analyzer is provided including a monitoring state machine for tracking a communication protocol. A trigger mechanism triggers a trace by the analyzer when the state of the protocol differs from the monitoring state machine. The state of the protocol differs from the monitoring state machine when no state change occurs in a pre-defined time period, which may be defined for a given state change. The state of the protocol also differs from the monitoring state machine when a different state change takes place to that indicated by the monitoring state machine.