Abstract: A method for objective code branch verification executes code branch annotations to assess developer-specified pass conditions for each code branch that are indicative of whether or not the code branch is functioning as originally intended by the author of the code. The method includes maintaining and dynamically updating both a counter value and a pass indicator status in association with each of multiple annotated code branches defined within a code body during execution of the code body. The counter value for each annotated code branch represents a number of times the annotated code branch has executed within a current run-time environment, and the pass indicator status indicates satisfaction or non-satisfaction of a pass condition identified within the code branch that is determined based on the counter value for the associated code branch.

Abstract: Methods and systems generating real-time notifications of software application importance based on current processing requirements. The method includes receiving a first dataset, wherein the first dataset comprises recovery time estimates for processing requirements. The method includes receiving a second dataset, wherein the second dataset comprises second recovery time estimates for applications. The method includes receiving a third dataset, wherein the third dataset comprises dependencies between processing requirements and applications. The method determines many-to-many relationships between the processing requirements and applications based on the dependencies. The method inputs the many-to-many relationships into a machine learning model to identify importance metrics for each application. The method generates, for display on a user interface, a ranking of the applications in order of importance metric.

Abstract: Provided is a method for recognizing a weak point in an original program using a test program, the original program being configured to perform a predetermined function on input data when executed in a predetermined runtime environment and the test program being configured to execute the same predetermined function on the input data when executed in the predetermined runtime environment, including: executing the original program and the test program in parallel on identical input data in the predetermined runtime environment; obtaining a test information characterizing the execution of the test program; and determining whether the original program has a weak point based on a comparison of the test information with a predetermined weak point information indicating conditions for recognizing weak points. Weak points of a program can be determined dynamically, without having to perform a time consuming testing in an artificial test environment.

Abstract: Aspects of the present disclosure involve systems, methods, devices, and the like for generating an unobtrusive and discrete barcode used for debugging. In one embodiment, a system is introduced that enables the tracking of application interactions on a user device. The tracking can include the generation of a debug id which can include a discrete string used to describe locations, preferences, and interactions with a user device application. The string may then be converted into a corresponding barcode which can be discretely displayed on the user interface of the application. In another embodiment, the barcode may be captured and/or retrieved for use in debugging the application, in an instance where an application malfunction is encountered.

Abstract: Cloud simulation or validation system allows for the simulation of a future node that may be deployed on a piece of hardware. The system may attempt to simulate the operating system for node-A on top of the hardware for node-A, including basic network connectivity. When a host is booted up with the simulated configuration, validation scripts may be run to verify that the site is correctly prepped for cloud deployment. With its pre-staged RAM-based OS temporarily loaded into the host's RAM memory, any set of OS-based scripts, tools or binaries, may be executed for simulation and validation based upon the intended role of the host onto which the cloud simulation or validation system configuration is loaded.

Abstract: Systems and methods for managing tenant code for a multi-tenant system. Instrumentation code may be added to the tenant code and track its performance. The tenant code may be disabled when it is determined based on information from the instrumentation code that the tenant code is misbehaving. An approximate clock may be used to determine if the running time of the tenant code exceeds a threshold.

Abstract: System, methods, and other embodiments described herein relate to improving control flow in a program for safety-related functions. In one embodiment, a method includes identifying a safety-related function of the program. The safety-related function is associated with functionality performed by the program that effects whether an associated device operates according to a functional safety standard. The method includes integrating a fault tree for the safety-related function into associated portions of a control flow graph of the program. The control flow graph identifies at least procedural control flows within the program, and the fault tree indicates combinations of conditions in the program that produce faults by the program. The method includes providing the control flow graph as an electronic output to improve the control flow of the program.

Abstract: A method of rendering a graphical user interface (GUI) comprising an application topology graph for a microservice architecture comprises generating a plurality of traces from a first plurality of spans generated by instrumented services in the architecture and generating generate a second plurality of spans for uninstrumented services using information extracted from the first plurality of spans. The method further comprises grouping the second plurality of spans with the plurality of traces. Subsequently, the method comprises traversing the traces and collecting a plurality of span pairs from the plurality of traces, wherein each pair of the span pairs is associated with a call between two services. The method also comprises aggregating information across the plurality of span pairs to reduce duplicative information associated with multiple occurrences of a same span pair from the plurality of span pairs.

Abstract: An error notification system includes a plurality of data production systems in communication with a monitoring server. Each data production system has a data processor configured to receive input data from a first set of data production systems, process the input data to produce output data, and make the output data accessible to a second set of data production systems. The monitoring server is configured to monitor data transmissions between the data production systems and to identify, for each data transmission, originating and receiving systems. The monitoring server is further configured to map data flow from each originating source system to identify all downstream data production systems. Upon identification of a data error in the originating source system, the monitoring server obtains data error information, assembles a data error notification, and transmits the data error notification to data production systems meeting system notification criteria.

Abstract: A method is provided comprising: executing a first set of files, and collecting a first set of performance data; updating the first set of files to produce a second set of files; executing the second set of files and collecting a second set of performance data; identifying a first subset of the first set of performance data; identifying a second subset of the first set of performance data; calculating a score based on the first subset and the second subset, the score indicating a difference in resource consumption between one or more first thread instances that are instantiated using the first set of files and one or more second thread instances that are instantiated using the second set of files; and generating and outputting a debugging message based on the score, wherein the first thread instances and the second thread instances have the same entry function and the same opcode.

Abstract: Systems, methods, and computer-readable media are described for associating regression test cases with corresponding test fingerprints via a translation table or other suitable storage mechanism. A test fingerprint indicates a collection of breakpoints encountered as part of traversal of a code path during execution of a test case, and thus, provides an indication of an extent of code coverage of the test case. Test fingerprints can be evaluated to determine cumulative code coverage of sets of test cases. Specific sets of test cases can be selected based on the cumulative code coverage they provide. Sets of test cases that provide greater cumulative code coverage and/or that target specific areas of interest can be prioritized for execution particularly when having to adhere to execution constraints.

Abstract: The present invention is directed to a method and system for testing, during runtime, the correctness of a computer program (such as a hypervisor, an operating system or an interpreter) that controls a system and has one or more software modules. Accordingly, a reflexive code of a reflex function is integrated into the software modules or into a virtual infrastructure that executes the computer program. Whenever desired, the reflexive code is activated by an input and its corresponding output is processed. Then, the correctness of the one or more software modules or of the computer program is determined according to the processing results.

Abstract: Systems and methods for evaluating and presenting software testing project status indicators. An example method may comprise: determining, by a computer system, a plurality of project status indicators comprising one or more average test execution rates, a required test execution rate, a test execution schedule variance, an actual test completion ratio, and/or a test completion schedule variance; and causing one or more project status indicators to be displayed in a visual relation to each other, to a timeline, and/or to another project's status indicators.

Abstract: System and method of compiling a program having a mixture of host code and device code to enable Profile Guided Optimization (PGO) for device code execution. An exemplary integrated compiler can compile source code programmed to be executed by a host processor (e.g., CPU) and a co-processor (e.g., a GPU) concurrently. The compilation can generate an instrumented executable code which includes: profile instrumentation counters for the device functions; and instructions for the host processor to allocate and initialize device memory for the counters and to retrieve collected profile information from the device memory to generate instrumentation output. The output is fed back to the compiler for compiling the source code a second time to generate optimized executable code for the device functions defined in the source code.

Abstract: Systems and methods for visualizing and/or analyzing trace data collected during execution of a computer system are described. Algorithms and user interface elements are disclosed for providing user interfaces, data summarization technologies, and/or underlying file structures to facilitate such visualization and/or analysis. Trace data history summarization algorithms are also disclosed. Various combinations of the disclosed systems and methods may be employed, depending on the particular requirements of each implementation.

Abstract: In an embodiment, a computer-implemented method for improving computer processing efficiency comprises using a main processing thread, in response to detecting an error in one or more function calls, tracing the one or more function calls at runtime and collecting stack trace data; and using a background processing thread, generating and displaying a function call tree based on the stack trace data.

Abstract: A method for permitting a program to be analyzed and tuned includes the steps of receiving a program which itself includes a plurality of stages, where execution of the program follows a plurality of distinct paths, each of the distinct paths including one or more of the stages. The method further includes determining unique paths of the program and determining execution boundaries of the program. In addition, the method includes persisting the unique paths and the execution boundaries in a database, and changing an execution of the program based on the persisted unique paths and execution boundaries.

Abstract: A method that supports multithreading/concurrent programming debugging includes the following steps: setting breakpoints of program sections of multithreading; converting the breakpoints into context switch points; executing a planned execution sequence of an interleaving execution path, to start a specified thread to execute a program section thereof till a first execution environment change point; clicking a next thread of the interleaving execution path one after another, and executing the clicked next thread till a next context switch point; and recording and storing the interleaving execution path.

Abstract: A system includes a multi-process application that runs. A multi-process application runs on primary hosts and is checkpointed by a checkpointer comprised of at least one of a kernel-mode checkpointer module and one or more user-space interceptors providing at least one of barrier synchronization, checkpointing thread, resource flushing, and an application virtualization space. Checkpoints may be written to storage and the application restored from said stored checkpoint at a later time. Checkpointing may be incremental using Page Table Entry (PTE) pages and Virtual Memory Areas (VMA) information. Checkpointing is transparent to the application and requires no modification to the application, operating system, networking stack or libraries. In an alternate embodiment the kernel-mode checkpointer is built into the kernel.

Abstract: An approach is provided for generating diagnostic data. In response to a determination that an error condition occurs in a first node executing a first process which restarts based on the error condition occurring, a first message is received, where the first message is broadcast from the first node to a second node and other node(s). In response to the first message, in-memory collections of diagnostic data are started in the nodes. Subsequent to receiving the first message, the error condition occurs in the second node. Based on the error condition occurring in the second node, a second message is broadcast from the second node to the first node and the other node(s) which causes the first node, the second node, and the other node(s) to dump the in-memory collections of diagnostic data at a predefined location.

Abstract: A device may instrument a codebase associated with a software application. The device may execute a test on the instrumented codebase as the instrumented codebase executes, wherein the instrumented codebase generates test data based on the test being executed. The device may generate, based on the test data, a live graphical model of the codebase from a composite graphical model of the codebase, wherein the composite graphical model includes historical information, associated with the codebase, mapped to a graphical model of the codebase. The device may generate an extended reality rendered view of the live graphical model. The device may provide, to an extended reality device, the extended reality rendered view of the live graphical model for display by the extended reality device.

Abstract: An apparatus is disclosed in which the apparatus may include a plurality of cores, including a first core, a second core and a third core, and circuitry coupled to the first core. The first core may be configured to process a plurality of instructions. The circuitry may be may be configured to detect that the first core stopped committing a subset of the plurality of instructions, and to send an indication to the second core that the first core stopped committing the subset. The second core may be configured to disable the first core from further processing instructions of the subset responsive to receiving the indication, and to copy data from the first core to a third core responsive to disabling the first core. The third core may be configured to resume processing the subset dependent upon the data.

Abstract: Systems and methods for visualizing and/or analyzing trace data collected during execution of a computer system are described. Algorithms and user interface elements are disclosed for providing user interfaces, data summarization technologies, and/or underlying file structures to facilitate such visualization and/or analysis. Trace data history summarization algorithms are also disclosed. Various combinations of the disclosed systems and methods may be employed, depending on the particular requirements of each implementation.

Abstract: A computer-implemented software development diagnostic tool which implements a state machine comprising at least three different states of software developer activity. A method of collecting software development diagnostic data, in which a computer-implemented software development diagnostic tool is used to receive state-detection information and record time data for each of a plurality of predefined states of software developer activity. A method of detecting inefficiencies in software development, comprising producing diagnostic data using a computer-implemented software development diagnostic tool, displaying the diagnostic data, and detecting in the diagnostic data a problem pattern of developer activity.

Abstract: A method of producing a white-box implementation of a cryptographic function, including: creating, by a processor, a white-box implementation of a cryptographic function using a network of two dimensional lookup tables; identifying two dimensional lookup tables using a common index; and rewriting the identified two dimensional lookup tables as a three dimensional table.

Abstract: The invention relates to a capture tool that remotely captures client-side performance data comprising: an interactive interface that receives user input; a computer processor, coupled to a memory component and the interactive interface, programmed to: receive, via a command line interface, a test command that comprises a path to a test script; launch, via a test runner component, a browser, at a remote client device, to execute a test in response to the test command; capture trace data from the browser launching at the remote client device; save the trace data at a local storage as snapshot files; and generate, via the interactive interface, performance data based on the trace data.

Abstract: A method, computer program product, and system is described. A continuous integration environment is identified. A first software test associated with the continuous integration environment is identified. A probationary status for the first software test is determined, the probationary status indicating, at least in part, a potential lack of reliability for the first software test.

Abstract: A system includes: at least one processor running instances of two or more services. Instances of a first service are dependent upon instances of a second service. A fault-injection manager, based on data in a service directory indicative of dependencies of services of the system, determines a fault-inducing condition to inject into the system and injects the fault-inducing condition into the system. A health monitoring manager detects failures in the system and identifies the first service as vulnerable to the fault-inducing condition when the fault-inducing condition causes an instance of the second service to fail.

Abstract: The present disclosure relates to a method and system for generating and transforming test data. The one embodiment, a user query is received in natural language and parsed to generate keywords using lemmatization. Based on the generated keywords and filter conditions in the user query, a data source specific executable query suitable for data sources is generated and executed against each data source to generate test data. The method determines if there are any missing test data in the generated test data and creates missing test data based on the data type, number of records required. The method also automatically transforms the generated test data into corresponding test data suitable to the requirements of a target system. Thus, the system generates test data specific to different data sources based on query provided in natural language and transforms the generated test data to comply with the requirements of the target system.

Abstract: Embodiments of the present invention are directed to a total cost of ownership method and system for technology components, applications or business units. The system provides financial reporting costs in information technology terms in order to build a bridge between technology and finance organizations. The method and system utilize data from systems of record for assets and charges, extract this data and deliver output reports and visualizations on the data processing and analysis in order to drive a Total Cost of Ownership for technology components, applications or business units. The method includes bringing data from disparate sources into the computer processor accessing at least one storage medium, validating the data by a Data Quality Engine, processing the data by matching the at least one charge to the at least one asset and performing data analytics and reporting on the Total Cost of Ownership.

Abstract: Example implementations relate to composing future tests. Some implementations may include a data capture engine to capture data points during test executions of the application under test. The data points may include, for example, test action data and application action data. Additionally, some implementations may include a data correlation engine to correlate each of the data points with a particular test execution of the test executions, and each of the data points may be correlated based on a sequence of events that occurred during the particular test execution. Furthermore, some implementations may also include a test composition engine to compose, based on an interaction with a visualization of results of a verification query of the correlated data points, a future test of the application under test.

Abstract: A device may receive testing instructions, for testing a computer program product, in a first format. The testing instructions may include testing data and a testing script. The testing data and the testing script may be associated with the first format. The device may identify a set of commands in the first format. The device may extract the set of commands from the first format. The device may convert the testing instructions from the first format to a second format based on extracting the set of commands. The device may execute the testing instructions based on the second format.

Abstract: In an approach to detection of potential merge errors when merging source code, a computer detects a source code merge process start. The computer compares at least one change made to a main stream of source code to a child stream. The computer determines whether one or more of the at least one change made to the main stream are not included in the child stream. Responsive to determining one or more of the at least one change made to the main stream are not included in the child stream, the computer determines the one or more of the at least one change made to the main stream that are not included in the child stream were removed from the child stream during a software development activity. The computer flags one or more files of the child stream corresponding to the one or more of the at least one change.

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

Abstract: Systems and methods for visualizing and/or analyzing trace data collected during execution of a computer system are described. Algorithms and user interface elements are disclosed for providing user interfaces, data summarization technologies, and/or underlying file structures to facilitate such visualization and/or analysis. Trace data history summarization algorithms are also disclosed. Various combinations of the disclosed systems and methods may be employed, depending on the particular requirements of each implementation.

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

Abstract: A method and system of a method of tracing a data element for flow analysis includes receiving an input of a data element to be traced, tagging the data element to be traced and selecting one or more tiers of an application to trace the flow of the tagged data element. The selected one or more tiers of the application are parsed through a plugin associated with a software programming language and an entry is recorded at the plugin associated with a software programming language, when an instance of traced data element is encountered. A database entry is created for every encounter of the tagged data element. Further, a data flow graph is generated to trace the data element across the at least one application tier.

Abstract: In some examples, a method to interactively repair a software program using one or more automatically generated tests with human-provided test oracles may include identifying a fault location in a software program, generating a potential repair at the fault location based on a repair candidate, automatically generating a first test to test the potential repair, and generating a first query for a first test oracle based on the first test. The method may also include obtaining a response to the first query from a human, generating a first human-provided test oracle based on the first query and the obtained response to the first query, augmenting a test suite to include the first automatically generated test with the first human-provided test oracle, and testing the potential repair using the augmented test suite including the first automatically generated test with the first human-provided test oracle.

Abstract: A method and system is provided for automated generation of the functional test cases for testing a software system. In an embodiment, the invention provides an expressive decision table (EDT), a requirement specification notation designed to reduce translation efforts. It implements a novel scalable row-guided random algorithm with fuzzing (RGRaF) (pronounced R-graph) to generate test cases. The invention also implements two new coverage criteria targeted at requirements and requirement interactions. The invention also provides fuzzing at time boundaries to achieve scalability. According to an embodiment, the invention also provides the feature of generating error in case the generated functional test case corresponds to system property violation of the software system. According to another embodiment, the system can also reject the functional test case if there is an improbable condition of the software system.

Abstract: Multi-user collaborative software applications may synchronize data between multiple users or multiple devices. There are multiple existing ways to synchronize data. Some of these synchronization methods, such as file locking, are easy to implement but have performance or functionality drawbacks. Operational transformation (OT) is a high performance synchronization method, but difficult and time-consuming to implement in many cases, and cannot be partially implemented throughout a system. Methods and systems provide for blending operational transformation with other synchronization methods in the same collaborative software application, allowing operational transformation to be used in situations where it cannot be implemented throughout a system.

Abstract: A method of debugging software code in an information handling system (IHS) is disclosed. The method includes establishing communications between a debug computer and a target computer and triggering the target computer to collect and transmit a plurality of symptom and root cause (SARC) values associated with the software code. The SARC values are compared to SARC reference values associated with the software code. The method further includes determining if the SARC values meet the requirements of the SARC reference values. In response to the SARC values not meeting the requirements of the SARC reference values, at least one process associated with the SARC values that do not meet the requirements of the SARC reference values is identified. Process data corresponding to the at least one process is collected and a SARC diagnosis report is generated for the software code based on the process data.

Abstract: A method for generating an automated test configured to test a system under test. The system under test includes a plurality of operational states and executable actions. The method includes: providing a model of the system under test, the model including a plurality of model states and selectable model actions, wherein one or more of the model states are representative of operational states of the system under test and each model action is associated with one or more executable actions on the system under test; and generating an automated test. The automated test is generated by selecting a sequence of model actions; and defining, based on the selected sequence of model actions, an automated test configured to execute a sequence of executable actions on the system under test. The selection of model actions is dependent upon the previous selection of model actions in the current and/or previous automated tests.

Abstract: A grading system and method for grading a user solution to a computing assignment are presented. The method includes receiving a program code submitted by a user, wherein the received program code is the user solution to the computing assignment; activating at least one code processing engine, wherein each code processing engine is a secured isolated execution environment; executing the program code in the at least one activated code processing engine to produce an answer; determining a grade for the answer based on an expected answer and an approximate grading function, wherein the approximate grading function is determined based on a type of the computing assignment; and returning the grade to the user.

Abstract: Systems and methods for visualizing and/or analyzing trace data collected during execution of a computer system are described. Algorithms and user interface elements are disclosed for providing user interfaces, data summarization technologies, and/or underlying file structures to facilitate such visualization and/or analysis. Trace data history summarization algorithms are also disclosed. Various combinations of the disclosed systems and methods may be employed, depending on the particular requirements of each implementation.

Abstract: Mechanisms for exception resolution in a software development session are provided. An exception is detected during a software development session. Information regarding the exception is provided to a central exception repository computing device. The information includes exception information that identifies the exception and a first user identifier that identifies the first user. A second user identifier that identifies a second user who has encountered a same exception is received from the central exception repository computing device. Information is presented to the first user that identifies the second user. A communication session between the first user and the second user is facilitated.

Abstract: A new feature can be defined for an application. Data pertaining to layer information, service information, feature information and dependency information for the application can be processed and, based on the processing, an identification can be made of a highest layer of a plurality of layers of the application containing at least one service or at least a second feature upon which the new feature is dependent. A recommendation can be rendered. The recommendation can indicate to place the new feature in the highest layer of the plurality of layers containing the at least one service or at least the second feature upon which the new feature is dependent.

Abstract: A method is provided in one example embodiment and includes receiving at a first network node a request to obtain data from a second network node, wherein the first and second network nodes are connected via n access networks; partitioning the request into n subrequests proportionally based on relative throughputs of the n access networks; and transmitting each of the n subrequests to the second network node via a respective one of the n access networks.

Abstract: The method includes capturing an execution scenario associated with a real-time execution of an application, determining at least one scenario variable based on the execution scenario, generating a test case based on a code template, the execution scenario and the at least one scenario variable, and updating a test suite using the test case, the test suite configured to define a quality test of the application.

Abstract: For resolving an initialization order of static objects located in a plurality of object files using a processor device, for each object file, the objects in the object file are categorized as defined static objects or undefined objects. A directed graph is created of the plurality of object files. Then, topological sorting is applied to the directed graph to yield the order of the plurality of object files that ensures a correct initialization of the static objects.

Abstract: Technology is described for executing program code in a service provider environment. Program code to be interpreted in the service provider environment may be identified. A symbol may be detected in the program code during execution of the program code. A data store in the service provider environment may be accessed to fetch a value corresponding to the symbol in the program code. The data store may include a plurality of symbols and corresponding values. The program code may be interpreted using the value fetched from the data store.