Systems, devices and methods are provided for testing a terminal application. For example, a test component is implanted into a source code program of a terminal application to be tested; one or more preset debugging codes are written into the source code program of the terminal application; one or more function addresses of the debugging codes in the source code program of the terminal application are acquired and registered; compiling and executing the source code program; an application test page is generated on a terminal user interface; and in response to a test execution instruction being triggered by a client on the application test page, the debugging codes is called via the function addresses in the test component to test the terminal application.

A method translates the native machine codes that do not allocate memory for metadata, do not store, and do not propagate metadata by augmenting them with extra instructions to allocate memory for metadata, to store, and to populate metadata such that metadata are readily available at run time for checking programming errors.

A software-development tool can present telemetry data with associated source code. For example, a computing device can identify, by a text editor, source code of a software application that is associated with telemetry data of performance metrics associated with running the source code. The computing device can display, by the text editor, an icon with the source code. The icon can indicate the source code is associated with the telemetry data. The computing device can receive an interaction with the icon. In response to receiving the interaction, the computing device can retrieve, by the text editor, the telemetry data from a telemetry-data repository for display in the text editor.

For a program of interest represented as a sequence of states comprising variables and flags wherein controls transition the program from state to state, and wherein the program includes tests at prescribed locations in the program that are applied upon specific states and generate observables, a method includes inserting at different points in the program hooks that capture program runtime behaviors constituting classification features. The method further includes flattening the program states, commands and tests along a program run-time timeline, and identifying a root cause of a program failure by backtrack analyzing a stream of input states and commands and output consequent states, commands and test results to detect causal correlations between variables, states and commands. The step of backtrack analyzing includes determining joint conditional probabilities and identifying candidate failure root causes that maximize conditional probabilities.

Systems and methods may be used to provide and implement a state machine in a display software user interface environment, and used to handle events and actions associated with the state machine. In one example embodiment, a virtual display environment provided by an engine is interfaced with a state machine that is configured to interpret various state machine definitions corresponding to states occurring in the virtual display environment. The state machine definitions may be used to determine how a particular state of a virtual item in the display environment may be represented, interacted with, and transitioned into another state. Use of the state machine definitions may enable representation of complex scenarios for virtual objects and events in the display environment in a unified definition format, without requiring specialized programming or scripting commands to implement the scenarios.

This disclosure describes techniques to compile source code corresponding to a portion of a software program. The techniques include generating first object code by processing the source code. Based at least in part on processing the source code, generating second object code, wherein the second object code, when executed by one or more processors, causes the one or more processors to perform an operation unconditionally bound to a unique identifier of the operation. The described techniques further include generating an indication of a mapping of the unique identifier to the portion of the software program.

A code testing system determines mistyped identifiers in computer language code. For identifiers of objects in the code, such as variables and functions, the instances of the identifiers are identified in the code and recorded in an occurrence table. Uses of an identifier may be identified as copies of one another based on a hash value of the instance and its location in a function. Hash values for an identifier that are not unique may not be recorded in the instance table. For identifiers that are associated with a single occurrence or a single group of copies, these identifiers are identified as candidates for correction. Suggested corrections are determined based on a comparison with other identifiers in the occurrence table to determine similar identifiers in the occurrence table. If so, the candidate identifier may be identified as likely mistyped and the similar identifier is suggested as a correction.

Disclosed herein are systems and method for detecting coroutines. A method may include: identifying an application running on a computing device, wherein the application includes a plurality of coroutines; determining an address of a common entry point for coroutines, wherein the common entry point is found in a memory of the application; identifying, using an injected code, at least one stack trace entry for the common entry point; detecting coroutine context data based on the at least one stack trace entry; adding an identifier of a coroutine associated with the coroutine context data to a list of detected coroutines; and storing the list of detected coroutines in target process memory associated with the application.

According to an example, an instruction to run a kernel of an application on an apparatus having a first processing unit integrated with a second processing unit may be received. In addition, an application profile for the application at a runtime of the application kernel on the second processing unit may be created, in which the application profile identifies an affinity of the application kernel to be run on either the first processing unit or the second processing unit, and identifies a characterization of an input data set of the application. The application profile may also be stored in a data store.

Periodicity similarity between two different tracer objectives may be used to identify additional input parameters to sample. The tracer objectives may be individual portions of a large tracer operation, and each of the tracer objectives may have separate set of input objects for which data may be collected. After collecting data for a tracer objective, other tracer objectives with similar periodicities may be identified. The input objects from the other tracer objectives may be added to a tracer objective and the tracer objective may be executed to determine a statistical significance of the newly added objective. An iterative process may traverse multiple input objects until exhausting possible input objects and a statistically significant set of input objects are identified.