Abstract: In one aspect, there is provided a computer-implemented method. The method may including selecting an existing business object for extension in an extensibility integrated development system; generating, in the extensibility integrated development system, a page highlighting one or more nodes of the existing business object to allow selection of the one or more nodes for modification; selecting, in the extensibility integrated development system, at least one of the one or more nodes, when highlighted; modifying, in the extensibility integrated development system, the selected one or more nodes by adding at least one attribute to the at least one of the selected one or more nodes; and storing, in a repository, the modified node including the added at least one attribute. Related apparatus, systems, methods, and articles are also described.

Abstract: Systems and methods are disclosed for emotive healthcare software usability. A method to improve software usability is described, the method comprising presenting a software application to a user. The method also including logging activities of the user with respect to the software application, wherein the logging includes recording the user using the software application, and wherein the activities include user action with respect to the software application and mouse location on a user interface displaying the software application. The method also including interpreting user emotion from the recording, and tracking an emotive index based on a combination of user emotion and user action with respect to the software application and mouse location. The method also including providing feedback based on the emotive index.

Abstract: A method and system for an unattended installation of any type of a guest operating system (GOS) on a Virtual Machine (VM), or a nested VM. Proposed method and system allow users to create an executable script, which provides automation of any GOS or application installation on the VM. User actions, such as mouse clicks, gestures, touch commands and keyboard strokes, performed during GOS/application installation are recorded. The delays, time periods between clicks and strokes are recorded as well. All of this information is incorporated into an executable script. The script, when executed, simulates/reproduces GOS/application action sequence. This sequence reflects the behavior of GOS/application itself executed on a VM.

Abstract: A network interface includes a firmware module that generates a first message based on a first print macro call and a memory module that stores the first message. The first message comprises a subset of data indicative of the first print macro call.

Abstract: Analysis data from the execution of a computer program is collected. The analysis data may include samples of two different types of performance data from the execution of the computer program. Performance data may include sampled hardware performance counter data and sampled executing functions. The performance data is used to create a composite view of the data. The composite view may allow a user to efficiently correlate the different types of performance data by using a colored visual display.

Abstract: Methods, systems, and apparatuses for monitoring web applications are provided. An exemplary method for monitoring a web application includes executing a first test on a first browser residing on a server. The exemplary method also includes executing a second test on a second browser residing on the server. The first and second browsers are heterogeneous browsers and run in heterogeneous browser environments.

Abstract: An API testing component is provided that is configured to deploy test suites to one or more test virtual machine instances. The test suites include an API test. The API tests are periodically executed on the test virtual machine instances, and test results generated by the API tests are collected and stored. The API testing component also provides a user interface for viewing the test results using a user interface specification that defines a visual layout for presenting test results generated by one or more test suites. The API testing component might also generate one or more alarm messages utilizing the test results and an alarm specification.

Abstract: A source line simulator system determines a line of source code that corresponds to a virtual return address in response to executing a debugging command on the source code. The simulator system determines whether the line of source code that corresponds to the virtual return address is correct and can enable a simulator mode based on a determination that the line of source code that corresponds to the virtual return address is not correct. The simulator system can generate a debugging graphical user interface (GUI) that displays an indicator at a line of source code that is correct.

Abstract: An apparatus executes and tests software. The apparatus comprises: an execution hardware unit that executes software to be tested; an interface screen control hardware unit that causes a display device to display an interface screen by the software to be tested and receives a user's input operation using the interface screen; and a problem report management hardware unit that manages information on a problem that has occurred during a test of the software, wherein the problem report management hardware unit includes: a selection operation receiving hardware unit that receives a selection of a component part of the interface screen; an input receiving hardware unit that receives a user's input of information; and a report generating hardware unit that generates report information on the component part, based on information on the component part related to the selection received.

Abstract: A system and method to display an application server resource landscape in a hierarchical view and invoke an Enterprise JavaBeans business method with a complex object as an argument. In one embodiment, the hierarchical view permits user input to initialize attribute values for simple and complex arguments. A graphical user interface presents invoked business method execution results.

Abstract: Embodiments are directed towards testing mobile applications for a plurality of mobile computers. A server computer may be provided a mobile application, a test script, and mobile computer criteria. One or more mobile computers may be filtered from a larger set on the mobile computer criteria. The server computer may install the mobile application on each determined mobile computer. Next, each portion of the test script for the mobile application may be performed and/or executed on each determined mobile computer, wherein a result for each performed portion may be stored. During the test run at least one screenshot may be generated based on at least one performed portion of the test script, wherein the screenshots may be stored. The server computer may generate a displayable report that may include each screenshot and a result for each performed portion of the test script.

Abstract: A method of feature-driven testing by one or more computing devices includes determining a graphical user interface (GUI) model of an application, determining an application-independent feature of a platform, augmenting the GUI model to reflect the application-independent feature resulting in an augmented model, and determining a test case from the augmented model. The test case includes the application-independent feature. The application is to be executed on the platform. The GUI model includes states and transitions.

Abstract: A test device may include an application that accesses online content. In some examples, a test intermediary and/or a test user interface (UI) are downloaded to the test device in response to a request by the application for obtaining the content from a network location. The test intermediary may be positioned to receive communications between the application and the content during testing of the content and/or the application. For example, the test intermediary may intercept metrics and other callbacks passed between the content and the application during manual or automated testing. In some instances, the test intermediary may provide the metrics and/or other test outputs for display in the test user UI rendered on the test device. The content may be rendered to be functional within the test UI, and the existence of the test intermediary and/or the test UI may be transparent to the application and the content.

Abstract: The invention may provide “undo” (e.g., rollback) features, along with data management simplification features, to an update package model of software suite development/evolution. New functions, which may have disruption effects for customers, may be installed into the core configuration data with inactive switches. Upon activation, a switch status may change, and a query filter may use the activated function (e.g., as associated with the switch ID). Original functions may be maintained, giving the user the ability to deactivate an activated function, and thereby reverting the system back to the prior configuration status.

Abstract: Aspects of the subject matter described herein relate to software development. In aspects, code is deployed to a target and debugged. After the debugging has ended, instead of waiting for another version to be deployed to the target, the code is retracted from the target and warm up of the target is performed as needed potentially in parallel with other software development activities with respect to the code.

Abstract: The subject matter of this specification can be embodied in, among other things, a method that includes establishing a connection with one or more virtual machines using a debugger protocol configured to communicate debug commands to applications executed by the one or more virtual machines. The method also includes transmitting a request for a current state of the one or more virtual machines using the connection. Information associated with the current state includes state variables not controlled by an application receiving debug commands. The method includes outputting the current state of the one or more virtual machines for display to a user.

Abstract: A tracing system may perform cost analysis to identify burdensome or costly trace objectives. For a burdensome objective, two or more objectives may be created that can be executed independently. The cost analysis may include processing, storage, and network performance factors, which may be budgeted to collect data without undue performance or financial drains on the application under test. A larger objective may be recursively analyzed to break the larger objective into smaller objectives which may be independently deployed.

Abstract: Debugging of code of a computer program is facilitated by implementing a step-type operation using internal breakpoints to ensure debugger control of the code. During a debugging session, a step-type operation is implemented by setting active internal breakpoints on every line of code of every routine currently on the call stack referenced by the processor and on entry points of the code being debugged, and subsequently leaving in place, upon completion of the step-type operation, active internal breakpoints. Subsequent to implementing the step-type operation any active internal breakpoints encountered during execution of one or more other operations of the code and deemed unnecessary to completion of the other operation(s) are disabled, and the location of any internal breakpoints disabled during execution of the one or more other operations are tracked in a data structure(s) for subsequent use in reestablishing needed internal breakpoints for implementation of another step-type operation.

Abstract: A device can implement a stage view depicting a visual element for each of a plurality of components of an application under development. The device implements a code overlay showing whether code can be applied to the components and, for components to which code can be applied, a code status indicator. The status indicator may relate to procedural code or to a data member, such as an object or other variable. Different indicators can be used to show that code can be applied, code is applied correctly, incomplete code is applied, or code is applied but contains an error. Different colors or other visual effects can be used to indicate status. The indicators may be selectable to provide a code viewing or editing interface. A status indicator for code associated with a component can be positioned near the visual representation of the component, but may be repositionable.

Abstract: A computer-implemented method and system for debugging a program is disclosed. The method may include obtaining data on inter-component calls of a call chain of an execution run of the program between segments of Multilanguage software components of the program, the data relating to the identity of the Multilanguage software components in which these segments are included and an order in which the segments are called in the call chain. The method may further include obtaining a user selection relating to one of the segments of the Multilanguage software components that were called in the call chain. The method may also include invoking a debugger designed for debugging the software component of the Multilanguage software components that includes the selected segment and displaying a user interface of that debugger on a display device.

Abstract: A computer implemented method for debugging of a program may include parsing a code segment of the program, the code segment invoking one or a plurality of execution events during an execution of the program to derive a plurality of questions, each relating to an execution event of said one or a plurality of execution events, based on the parsing of the code segment and on information recorded during the execution of the program. The method may also include selecting one of the questions as a current question. The method may further include presenting in a user interface the current question with one or a plurality of causes related to the current question, and one or a plurality of other questions of said one or a plurality of questions for selection by the user.

Abstract: Method and systems of visually depicting instrumented and sampled data are provided. A first stream of instrumented data, the instrumented data collected via execution of code contained in a user-scriptable engine. Then a second stream of sampled data is received, the sampled data collected by monitoring execution of code contained in scripts executed by the user-scriptable engine. Then an aggregated version of a portion of the instrumented data and an aggregated version of a portion of the sampled data are simultaneously displayed in one or more viewing regions. Then user interaction with an object pertaining to the aggregated version of a portion of the instrumented data is received. In response to the receiving user interaction with the object pertaining to the aggregated version of a portion of the instrumented data, the aggregated version of the portion of the sampled data is caused to change to depict a different aggregated version of a portion of the sampled data.

Abstract: The present invention extends to methods, systems, and computer program products for stepping through JavaScript code in a debugger without landing on errors in library or open source code. A debugger receives user inputs designating one or more segments of the JavaScript code as library code. The debugger then performs debugging operations on the JavaScript code. The debugging operations including a stepping operation for stepping through the JavaScript code to identify errors only in user-generated segments of the JavaScript code, wherein the user-generated segments correspond to code that was not designated as library code.

Abstract: Among other things, a method includes, at a computer system on which one or more computer programs are executing, receiving a specification defining types of state information, receiving an indication that an event associated with at least one of the computer programs has occurred, the event associated with execution of a function of the computer program, collecting state information describing the state of the execution of the computer program when the event occurred, generating an entry corresponding to the event, the entry including elements of the collected state information, the elements of state information formatted according to the specification, and storing the entry. The log can be parsed to generate a visualization of computer program execution.

Abstract: Methods and apparatus for debuggers supporting method restart are described. A method comprises implementing a user interface (UI) enabling a user to submit a request, via a single interaction within a debugging session, to restart execution of an invocable operation of a program. The method further comprises, in response to a request to restart an invocable operation, designating, as the source code line whose corresponding executable code is to be executed next, the first line of source code of the particular invocable operation that corresponds to an executable operation. The method includes indicating that execution of the program is to be resumed at the first line, and resuming execution of the program at the first line.

Abstract: Systems and methods for detecting concurrency bugs are provided. In some embodiments, context-aware communication graphs that represent inter-thread communication are collected during test runs, and may be labeled according to whether the test run was correct or failed. Graph edges that are likely to be associated with failed behavior are determined, and probable reconstructions of failed behavior are constructed to assist in debugging. In some embodiments, software instrumentation is used to collect the communication graphs. In some embodiments, hardware configured to collect the communication graphs is provided.

Abstract: A debugger allows a programmer to select the granularity of a line step function. Using a debugger step statement, the programmer can specify line step, statement step, or automatic selection. When the user specifies line step in the debugger statement, the debugger functions in true line step mode, where a line of source code is executed for each step. When the user specifies statement step in the debugger statement, the debugger functions in statement step mode, where a statement is executed for each step. When the user specifies automatic selection in the debugger statement, the program is analyzed, and a decision regarding whether to use line step or statement step is made based on the characteristics of the program and based on user-specified selection criteria. In this manner the function of the debugger when line stepping can vary according to the programmer's needs.

Abstract: A relational model may be used to encode primitives for each of a plurality of threads in a multi-core processor. The primitives may include tasks and parameters, such as buffers. The relationships may be linked to particular tasks. The tasks with the coding, which indicates the relationships, may then be used upon user selection to display a visualization of the functional relationships between tasks.

Abstract: Various techniques for interacting with a test case via a graphical model are disclosed. For example, one method involves displaying a first icon, which represents a first testing activity within a test case; displaying a second icon, which represents a second testing activity within the test case; and displaying a connector, which couples the first icon and the second icon. An assertion (e.g., against test results obtained by performing the first testing activity) is associated with the connector.

Abstract: A method and system for graphing JAVA bytecode. JAVA bytecode is analyzed to identify blocks of bytecode that are consecutively executed without being targeted by branching instructions. The links in the form of branching instructions or target based breaks are also identified. The blocks and links are then graphed to facilitate the review and debugging of the program. The graph can be optimized to improve the readability of the graph.

Abstract: A method, system and program product for guiding correction of semantic errors in code in an integrated development environment. The method includes inputting, using a code editor, code being developed by a developer in an integrated development environment, identifying, using one or more collaboration records located for a node in a syntax tree constructed for the code inputted, any semantic errors pertaining to use of a third-party library in the code inputted by the developer and, displaying one or more suggestions associated with the one or more collaboration records located to correct the any semantic errors identified for the node, wherein the developer can choose a suggestion of the one or more suggestions displayed to guide correction of the any semantic errors.

Abstract: A debugger allows a programmer to select the granularity of a line step function. Using a debugger step statement, the programmer can specify line step, statement step, or automatic selection. When the user specifies line step in the debugger statement, the debugger functions in true line step mode, where a line of source code is executed for each step. When the user specifies statement step in the debugger statement, the debugger functions in statement step mode, where a statement is executed for each step. When the user specifies automatic selection in the debugger statement, the program is analyzed, and a decision regarding whether to use line step or statement step is made based on the characteristics of the program and based on user-specified selection criteria. In this manner the function of the debugger when line stepping can vary according to the programmer's needs.

Abstract: Presented is a method, system, computer readable instructions executable code and computer storage medium for testing compatibility between a computer application and a target computer platform. Configuration parameters of a computer application are provided to a computer system for comparison against a database to determine whether the configuration parameters of the computer application and the configuration parameters of a target computer platform are compatible or incompatible.

Abstract: A system and method for identifying optimal system architectures for a reference application are provided. The system and method comprise executing a reference application and a plurality of test applications on a current system architecture and sampling performance data for each of the applications. The performance data is used to compute an application signature for each application. A similarity element is derived from the application signatures that illustrates the similarity between each application and every other application. Using a similarity threshold and an algorithm, a subset of test applications that are similar to the reference application are derived.

Abstract: Embodiments provide call stacks for asynchronous programming. A set of all asynchronous call stacks is found by first identifying all threads and all outstanding tasks that have not yet been completed. Optionally, all outstanding continuation-delegates or lambdas that are in the windows queue waiting to be scheduled and/or all outstanding delegates or lambdas in a language-specific queue are also identified. Next, for each thread, identify whether it was invoked by a continuation-callback and, if so, find the corresponding task/promise. Next, given a task/promise, identify the logical parent task/promise. Optionally, given a delegate or lambda, identify its logical parent task/promise. The sequence of logical tasks/promises constitutes an asynchronous call stack in a program. Further information may optionally be retrieved to make the asynchronous call stack more useful. Finally, given a task/promise, identify the corresponding line number and location in source code.

Abstract: A design tool provides global resource conflict management. The design tool identifies a conflict in requested values of a global resource during development of an embedded application. The design tool further calculates new values of the global resource, and proposes the new values of the global resource as an alternative to the requested values to assist a user in resolution of the conflict.

Abstract: Methods, apparatus, and computer program products are disclosed for debugging a high performance computing program by gathering lists of addresses of calling instructions for a plurality of threads of execution of the program, assigning the threads to groups in dependence upon the addresses, and displaying the groups to identify defective threads.

Abstract: Customizing a target system. The target system may include a first device with a first programmable hardware element (PHE) and a second device with a second PHE. Synchronization modules may be provided for implementation on the first and second PHEs. The synchronization modules may provide a standard interface for interacting with other code. A user may specify user-created code for the first and second PHEs which utilizes the synchronization modules. The user-created code may interact with the synchronization modules using the standard interface. Accordingly, hardware descriptions may be generated for the first and second PHEs of the target system. Different modules may be used for different interconnects. Additionally, multiple synchronization modules may be used, e.g., dynamically, during operation of the target system.

Abstract: This invention provides a new mechanism for “Hot-Tracing” using a novel placeholder mechanism and binary rewriting techniques, which leverages existing compiler flags in order to enable light-weight and highly flexible dynamic instrumentation. Broadly, I-Probe can be divided in 2 distinct workflows—1. Pre-processing (ColdPatch), and 2. Hot Tracing. The first phase is a pre-processing mechanism to prepare the binary for phase 2. The second phase is the actual hot-tracing mechanism, which allows users to dynamically instrument functions (more specifically symbols) of their choice.

Abstract: A test automation system can include a web controller configured to provide access to at least one container displayed by an application and a web user interface (UI) configured to be controlled using the web controller. The system can include an application controller object configured to implement an application controller interface and expose methods for performing operations on application controls of the application and an application query object. The application query object can include at least one filter with at least one condition, the at least one condition defining an attribute or property of a UI element to check for. The application query object can be configured to return at least one UI control when the UI control includes at least one UI element that includes features that match criteria defined by the at least one filter and the at least one condition.

Abstract: The present disclosure provides methods and systems for instrumenting a “semantic stack trace” (SST), where semantic information and dependency relationships between a plurality of code elements (“elements”) are captured during runtime execution of various front-end declarative languages, and are subsequently extracted for display in a SST-enabled interactive user interface with traversing capability. Embodiments of the present invention enable a framework for traversing and debugging complex code, providing an unprecedented lens into understanding code behavior in mixed imperative and declarative construction languages.

Abstract: In a distributed system that includes a debug server and debug clients coupled for communications through a data communications network, where the debug server includes a debug administrator, a message router, a back-end debugger, and a debuggee, collaborative software debugging includes: receiving application-level messages, including receiving, from a requesting debug client, a request to establish a variable-specific message for a particular variable; routing the application-level messages among the debug clients, the debug administrator, and the back-end debugger, including establishing the variable-specific message; and returning, to the debug clients, client-specific debug results, including: responsive to each request by a variable evaluating debug client to evaluate a variable and if a variable-specific message has been established for the variable to be evaluated, returning the content of the variable-specific message to be displayed in association with the variable in the variable evaluating debug c

Abstract: A method and system to remotely log debug information is described. A computer executing program code generates debug information upon the occurrence of an error in execution. The debug information is then sent to a remote computer using a network adaptor. In one embodiment, the computer executing the program is Extensible Firmware Interface (EFI) compliant.

Abstract: Embodiments of the invention relate automatically generating and positioning user interface elements. In one embodiment, user interface elements are automatically generated and positioned on a user interface. At least one test script associated with a user interface is received as an input. The test script includes a set of test instructions. Each test instruction in the set of test instructions is parsed. A set of user interface elements referenced by each test instruction is identified in response to the parsing. A determination is made as to whether the user interface includes the set of user interface elements. At least one user interface element in the set of user interface elements is generated in response to the user interface failing to include the at least one user interface element.

Abstract: Customizing a target system. The target system may include a first device with a first programmable hardware element (PHE) and a second device with a second PHE. Synchronization modules may be provided for implementation on the first and second PHEs. The synchronization modules may provide a standard interface for interacting with other code. A user may specify user-created code for the first and second PHEs which utilizes the synchronization modules. The user-created code may interact with the synchronization modules using the standard interface. Accordingly, hardware descriptions may be generated for the first and second PHEs of the target system. Different modules may be used for different interconnects. Additionally, multiple synchronization modules may be used, e.g., dynamically, during operation of the target system.

Abstract: System and method for performing program-related operations over a network via a web browser. A network connection is established between a server computer and a client computer over a network. A universal resource identifier (URI) is sent from the client computer to the server computer over the network, where the URI indicates a program, e.g., a graphical program (GP), or at least a portion of a graphical program interactive development environment (GPIDE), e.g., a graphical program editor, an execution engine, a static or dynamic analyzer, and/or compiler. The at least a portion of the GPIDE is received from the server computer over the network in response to the URI, and executed in a web browser of the client computer to perform some specified functionality with respect to the GP.

Abstract: In a method and apparatus of performing unit testing of a software module, the method provides for reading, by a computer, target data and discovering of functional aspects of a piece of software code, dividing the target data into chunks, estimating a plurality of decision/condition statements of the software code, estimating an amount of possible test cases based on the program inputs, defining a data set over the plurality of identified decisions/conditions, finding subset relationships between all the defined data sets, defining a plurality of optimal data sets, classifying the condition of the plurality of optimal data sets by category, refining the plurality of optimal data sets, and calculating the best amount of data sets.

Abstract: System and method for recording and displaying data associated with a program executing a program. Data associated with the program is displayed in a first instance of a graphical user interface (GUI) element. The data are saved one or more times during or after execution of the program in response to input, including saving information regarding the GUI element. The saved data are then displayed in a second instance of the GUI element in response to user input invoking display of the saved data, based on the saved information regarding the GUI element.

Abstract: The present technology is directed to accurately identifying code execution rhythms from a running program, even when they are occasionally irregular. The present technology is capable of detecting and inferring the rhythms without any prior knowledge or expectations of rates or number of rhythms present in a running program. These code execution rhythms can then be used to further understand and analyze the behavior of a running program, for example, by exposing various rhythms that might have been unknown/unrealized, irregularity of rhythms, or by analyzing the behavior of functions on a per frame basis under different rhythms.

Abstract: Techniques for debugging an application are provided. In some examples, a user interface (such as a graphical user interface) is provided for a user to specify a breakpoint associated with a breakpoint location in an application and a message flow direction associated with the breakpoint. The message flow direction may be selected from one or more message flow directions associated with the breakpoint location. For example, a message flow direction may be a request message flow direction or a reply message flow direction. The breakpoint location may be a logical breakpoint location associated with a component in a component-based application such as an application based on Service Component Architecture (SOA). In an embodiment, an execution of the application is suspended when the breakpoint is reached in connection with the specified message flow direction.