Abstract: A method for software debugging in a multi-tenant database network system is provided. When an exception occurs the stack frames in temporary working memory are dumped into long term memory for later analysis. A stack trace is performed from which performance information may be derived, which may aid in discovering the cause of the exception.

Abstract: A commanding interface can provide an efficient computer interface for users of assistive technology by focusing on the tasks that an application can perform, rather than on the interface the application exposes. The commanding interface can provide a search mechanism that searches for and presents functions or functionality in response and dynamically updates results as the search query is entered. Additionally, the commanding interface can prioritize search results based on contextual data, including prior search terms, prior actions, and the context of the user's interaction with the application program. The commanding interface can enable the user to filter the functions and functionality presented through the commanding interface according to types of user-performed activities for which such functions would be utilized, patterns, or heuristically determined associations.

Abstract: A scalable, computer implemented method for finding subtle flaws in software programs. The method advantageously employs 1) scope bounding which limits the size of a generated model by excluding deeply-nested function calls, where the scope bounding vector is chosen non-monotonically, and 2) automatic specification inference which generates constraints for functions through the effect of a light-weight and scalable global analysis. Advantageously, scalable software model checking is achieved while at the same time finding more bugs.

Abstract: A system interprets a process map. The process map indicates a plurality of steps associated with a process. The process map provides a visual representation of the steps. The system executes the process according to the process map, and captures an execution of the process in a recording. The system provides a capability to traverse the recording according to the process map.

Abstract: A system for analyzing a piece of code includes a symbolic state generator adapted to generate symbolic states for statements in the piece of code where exceptions occur. The symbolic state generator is also adapted to provide the symbolic states as inputs to a static analyzer. The system includes a user interface adapted to transfer an exception specifier having an exception causing state to a static analyzer. The static analyzer is adapted to receive the symbolic states from the symbolic state generator and the exception specifier having the exception causing state from the user interface. The static analyzer is adapted to compare the symbolic states with the exception causing states and to provide a output on a basis of the comparison. The exception specifier includes an exception causing state and represents a language run-time exception or a user defined exception.

Abstract: Various technologies and techniques are disclosed for providing a code analysis debugger. A code analysis process is performed to identify possible program defects that are present in particular source code. The results of the code analysis are stored in a results file in a structured format. The structured format contains sections that describe details about the one or more portions of source code that have been identified as possibly having the program defects. The analysis results are retrieved for display. A debugger-like feature allows a user to review a representation of the program defects identified during the code analysis. The debugger-like feature has a graphical user interface that can display at least some of the possible program defects in a call stack for further review.

Abstract: Methods and systems for verifying module codes are presented. The module code may be verified by associating the module code with a user interface screen and determining whether the module code was generated from the user interface screen. A module corresponding to the module code may be executed if the module code is verified. The module code may be verified by using routines from a user interface framework system. The module code may be verified by determining whether a user interface element associated with the module code is disabled. The module code may be verified by determining whether each user interface element associated with the module code is enabled. The module code may be verified by insuring that the module code was generated by the selection of a user interface element. The module codes may be received from a front-end system and verified on a back-end system.

Abstract: A mechanism for replacing memory pointers with implicit pointers is disclosed. A method of embodiments of the invention includes determining a memory pointer in a source code compiling on a computer system. The memory pointer is associated with a first value in the source code and serves as a referencing link to a second value in memory. The method further includes replacing the memory pointer with an implicit pointer as the memory pointer is optimized away during code optimization of the source code such that the implicit pointer is provided in a compiler-generated debug output to serve as an implicit reference link between the first value and second value. The implicit reference link was once provided as an explicit reference link by the memory pointer before getting optimized away.

Abstract: A computer implemented software testing method includes receiving a bug report regarding software under test; storing the bug report in a computer readable data store upon receiving the bug report; setting an a status indicator for the bug report to an open condition upon storing the bug report; requesting execution of a test procedure corresponding to the bug report; executing the test procedure using a processor; receiving a test result from the processor indicating a pass state or a fail state for the test procedure; and setting the status indicator for the bug report to a closed condition if the pass state is determined for the test procedure.

Abstract: Disclosed herein are techniques for compiling a procedure for testing a page. In some implementations, a component definition for a component instance referred to in computer programming language instructions defining a test procedure for testing a page may be received. The page may be defined by a page description implemented in a markup language. The page description may include a reference to a first portion of a component instance. Compiled wrapper code operable to simulate the presence of the component instance may be generated. The compiled wrapper code may represent the first portion of the component instance referenced in the page description. A compiled test procedure may be generated based on the computer programming language instructions. The compiled test procedure may include the compiled wrapper code. The compiled test procedure may be capable of being executed to perform the test procedure.

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: The subject matter described herein relates to a templating system and method. In the templating system and method, each of the domain model and the graphic model are defined according to a template, and the corresponding elements of the domain model and graphic model are created. Next, a binder is created, which associates corresponding attributes in domain and graphic models. Path expressions such as XPath expressions, are used to describe locations in the domain and graphic models. These path expressions, templates, and binders are interpreted or called by a framework, which performs detailed synchronization.

Abstract: A method and system for an open application programming interface (API) dashboard system for monitoring and managing one or more developer programmed applications configured to use one or more services provided by a service owner are provided. The system includes an application area associated with a corresponding programmed application, each application area including a call metrics group configured to display summarized metrics, a services used group configured to display a listing of each service called by the programmed application and metrics associated with each service, and a key management group configured to prompt a developer of the programmed application to request or revoke a key, wherein the key includes a developer identification, a programmed application identification, and signed certificates relating to services used by the programmed application.

Abstract: A computing-device implemented method may include receiving an instruction and dynamically performing tests in a modeling environment in response to the instruction. The dynamically performing tests may include selecting a polymorphic entity, displaying a context menu associated with the polymorphic entity on a display, activating in the context menu a menu item that is linked to one of one or more requirements, generating the test, and performing the test to produce a test result.

Abstract: In a method of creating a custom action, a user interface is presented for entry of lines of a custom action. In response to receipt of a sub-portion of a line of the custom action via said user interface, the sub-portion is automatically checked for errors in syntax. The custom action is stored as a selectable custom action in a dynamic layer of a testing infrastructure. The dynamic layer of the testing infrastructure is associated with a particular instance of a software item.

Abstract: An information processing system integrates a code coverage tool with a debugger. A debugging process is performed on a set of source code for an application program. A set of code coverage information associated with the set of source code is analyzed with respect to a set of debugging information. The set of code coverage information at least identifies a set of instructions that has been executed. A set of source code lines in the set of source code that correspond to the set of instructions that has been executed is identified based on the analyzing. A user is notified through a user interface that the set of instructions associated with the identified set of source code have been executed.

Abstract: A computer program product integrates a code coverage tool with a debugger. A debugging process is performed on a set of source code for an application program. A set of code coverage information associated with the set of source code is analyzed with respect to a set of debugging information. The set of code coverage information at least identifies a set of instructions that has been executed. A set of source code lines in the set of source code that correspond to the set of instructions that has been executed is identified based on the analyzing. A user is notified through a user interface that the set of instructions associated with the identified set of source code have been executed.

Abstract: In a method of testing a software item, a graphical user interface is presented for scheduling a test of the software item. Specified information regarding conduct of a test is received via the graphical user interface. The specified information includes a test time for initiating the test. The test is initiated at the test time.

Abstract: In a method of software development kit (SDK) testing, a graphical user interface is provided for initializing a test of an SDK. An application is created to run against the SDK. The output of the SDK is verified.

Abstract: In a method of binding a software item to a plain English name, a user input of a plain English control name is received into a test file. A user interface under test is automatically searched for a control corresponding to the plain English control name. The corresponding control in the software item under test is automatically bound to the plain English control name.

Abstract: A method and system for application development. Specifically, a generic console interface is provided that is capable of interacting with graphics applications. The console interface is capable of accessing a graphics application by detouring at least one predefined system call made by the graphics application. User input is intercepted that is related to the predefined system call that is detoured. The user input is communicated through the console interface. An operation is performed as implemented by the user input through a dynamically loadable module.

Abstract: An exemplary method includes graphical user interface code executing on a computing device providing a graphical user interface including one or more graphical elements and exposing data associated with the graphical user interface for access and use by a testing subsystem to test the graphical user interface. In certain examples, the exposed data is representative of one or more graphical element type identifiers indicating one or more types of the one or more graphical elements included in the graphical user interface. In certain examples, the exposed data is included in a log of events associated with the graphical user interface. In certain examples, the exposed data is exposed in response to a query from the testing subsystem. Corresponding systems and methods are also disclosed.

Abstract: Certain example embodiments relate to white-box testing techniques, e.g., for graphical user interfaces (GUIs). A test case to be run on the application includes interactions between the application and external components that were gathered as the application ran and received user input from a user until a desired test state was reached, and assertions to be made to the application once that state is reached. A test environment replaces a normal environment in which the application runs. An adapter executes interactions on the test environment's GUI dedicated thread(s). The application is fed with interactions, through the adapter, until the application reaches the desired state. Once the application reaches that state, the application is fed with assertions. Expected data associated with the assertions is compared with data actually being generated by the application. A determination is made regarding whether the test case resulted in success or failure.

Abstract: A unified debug system with multiple user-configurable trace volumes is disclosed, including embodiments as a system, a method, and a computer-readable medium. Embodiments of the present invention provide more robust and flexible solutions for introducing configurable trace volumes to firmware, allowing a user to specify firmware system configurations for trace buffers, trace frames, and trace volumes, and offer other advantages over the prior art. One embodiment of the present invention pertains to a system that includes a firmware component comprising firmware, and a firmware interface communicatively connected to the firmware component. The firmware includes a plurality of trace volumes for storing a plurality of trace entries. The trace volumes are user-configurable through the firmware interface. The plurality of trace volumes includes first, second and third trace volumes. The first trace volume includes storing at least some of the trace entries to a trace buffer in a first volatile memory component.

Abstract: An aspect of the present invention facilitates identification of test cases to be run after changes to modules of a software application. In one embodiment, a reference data is generated by inspecting the instructions (static analysis) forming the modules of the software application, with the reference data specifying a corresponding set of modules in the application that are referenced by each of the modules in the application. The reference data is then examined to find a referencing set of modules which reference any of the changed modules either as immediate reference or multi-level reference through other modules. Test cases invoking any of the modules in the referencing set are identified as suitable test cases to be run.

Abstract: User interface elements are identified and cataloged into a user interface inventory database keyed on a global user interface element identifier. Information is collected for user interface elements activated in an executing application or applications. Scenario information is collected and is used to update the user interface inventory database. Scenario information includes information concerning user interface element usage, state changes, etc. in time. The described information can be collected over a period of time and from a number of different computer systems. The information can be analyzed to determine and quantify usage and testing of user interface elements. The analyzed information can be used to determine how thoroughly a user interface element has been tested, how often the user interface element works as expected, most commonly used user interface elements and other information. The collected information can be used to track, quantify and identify ownership of user interface elements.

Abstract: A system associates at least one review indicator with at least one of multiple elements of a model, where the at least one review indicator indicates whether a corresponding element of the model has or has not been reviewed by a reviewer. The system further displays a status of the at least one review indicator in a user interface.

Abstract: Various technologies pertaining to answering reachability queries are described herein. A reachability query includes a user-specified destination line of code in source code that is desirably analyzed. A theorem prover is employed to identify an execution path through the source code that reaches the destination line of code. Graphical data is presented to the user that illustrates to the user the execution path through the source code that reaches the destination line of code.

Abstract: Mechanisms allow a user to test a BPEL process by simulating partner Web services. To simulate the partner Web services, a development environment is extended to include an intermediate component that intercepts messages intended for a partner Web service and displays those messages in a testing user interface. In the testing user interface, a user can create and send messages in direct response to the messages invoked while executing the BPEL process. The development environment may also include an alternate deployment descriptor, as part of a BPEL engine. The alternate deployment descriptor identifies where a message should be routed. For example, the alternate deployment descriptor lists the address of the intermediate component, rather than the actual partner Web service address, so that messages can be redirected to the testing user interface.

Abstract: A method includes creating an initial test plan including initial estimates of effort and defect distributions, creating an alternative test plan including alternative estimates of effort and defect distributions, and displaying at least one metric of the initial test plan and the alternative test plan side by side for comparison by a user.

Abstract: In one embodiment, a method of batch processing electronic data is provided. The method includes identifying one or more batch processing features common to a plurality of batch processing applications. The method also includes defining software code for managing execution of the common batch processing features, integrating the software code into at least one of the batch processing applications, and defining and taking one or more checkpoints. Moreover, the method includes retrieving input data in response to control data, processing at least a portion of the input data, determining the time of an error in response to the error during processing, retrieving data stored at the most recent one of the checkpoints, and processing at least a portion of the retrieved checkpoint data.

Abstract: A computer implemented method, system, and/or computer program product modifies a master template for an executable document. A version architecture comprises a master template for a master document, a new variation document that describes what changes are to be made to the master template for a specific context, and a resulting modified template based on the master template and rule-based instructions found in the new variation document. A processor defines an executable master document from the master template that, when executed, produces a final product. Specific rules set out conditions for modifying the master template for the specific context. These specific rules are used to define a new variation document, which is applied against the master template to generate a context-specific modified template. The context-specific modified template is then used to generate a context-specific executable document that, when executed, generates a final context-specific product.

Abstract: The invention relates to a method for the computer-assisted analysis of buggy source code in a hardware description language describing the structure and the operation of an integrated circuit. A correction model is provided, which includes a hierarchical structure of nodes arranged in a plurality of hierarchical levels, the nodes being transformation instructions, wherein a transformation instruction describes a group of transformations which are applied to at least one type of a source code section and thereby change the source code section and wherein a transformation instruction, which is a child node of another transformation instruction, constitutes a subset of the group of transformations of the other transformation instruction. Those transformation instructions, which change the source code in such a manner that the changed source code leads to a correct output of the integrated circuit, are determined and output together with the associated source code sections as corrections.

Abstract: A system and method of debugging a multi-threaded process with at least one running thread and at least one suspended thread is disclosed. Embodiments utilize a blocking function to block the thread of a process while other threads are allowed to run. The blocking function may be executed in a suspended thread by a debugger under control of a thread blocking controller. The other threads may implement interprocess communication channels for enabling communication between the process and another application. A simulated user interface (UI) of a debugger enables interaction with users while a hardware simulation thread is blocked, where blocking of the hardware simulation thread may be implemented by a thread blocking component implemented externally to the debugger. Where a thread blocking controller is implemented within the debugger, a debugger UI may interact with a user while the hardware simulation thread is blocked and interprocess communication threads are running.

Abstract: The disclosure provides a solution for associating deployed executables with source code. In the solution, source code of a development environment can be mapped to a deployed executable of a runtime environment. The mapping can ensure that a version of source code from which the deployed executable was produced is always known. The mapping can occur within digitally encoded data stored in a non-transient storage medium. The development environment and the runtime environment can be two distinct and separate computing environments that are isolated from each other.

Abstract: A mechanism for performing dynamic software testing on a computer system based on test result information retrieved in runtime using test result entity. A method of embodiments of the invention includes causing a test execution script to run a first test to test a first component, and the test execution script is supported by a script execution platform on a computer system, and the first component depends on a second component. The method further includes retrieving, in runtime, testing information relating to the second component from a database, if the first test produces unsatisfactory results relating to performance of the first component, and causing, in runtime, the test execution script to run a second test to test the second component.

Abstract: A process and system for debugging of a computer program, is provided. One implementation involves including mark-up information into source code of the application program, generating a debug-enabled version of the computer program including debugging methods based on the mark-up information, and providing the debug-enabled version of the program computer to a debugger for debugging purposes using the debugging methods.

Abstract: A user-interface testing process involves generating plural display-data representations of a common subject for plural respective user-interface instances. The resulting display data is tracked for each of the application user-interface instances so as to generate respective object-level descriptions of the user interface instances. The object-level descriptions are compared to detect differences between the application user-interface instances.

Abstract: The visual display of the timing of execution of a marker. During a time frame, a first application program interface, which is configured to represent a first marker, is executed on a first thread of execution of an application. The first application program interface generates a first event for visualization on the display, when executed. During the time frame, a second application program interface, which is configured to represent a second marker, is also executed on the first thread of execution of the application. The second application program interface generates a second event for visualization on the display, when executed. A visualization of the first marker and the second marker is displayed on a timeline visualization of activity of the first thread of execution of the application in the context of the time frame.

Abstract: A recording medium readable by an information processing apparatus, has recorded thereon a monitoring program for monitoring an operation status of a monitoring target program that runs on an information processing apparatus having a processor and a memory. The monitoring program causes the information processing apparatus to obtain, at a time of installation of a program, information indicating a status where the program is executed in the information processing apparatus and becomes a monitoring target program. The program monitors, on the basis of the information obtained, whether the monitoring target program exists in a memory in which the monitoring target program has been loaded.

Abstract: A parser may be graphically modified without needing to directly alter the parser software and may be graphically modified to adjust for extensibility of the source test program language. The parser may be graphically modify to adjust for extensibility of the destination test program language and to translate a new text based test program language not inherently built into the parser.

Abstract: Methods and systems for monitoring test steps to determine whether the test steps are executable in a test environment are disclosed. The test environment tests various resources, such as programs, data and functions in the electronic devices. The test environment provides a user interface that enables users to edit a sequence of test steps executed in the test environment. The test environment may provide visual representations of the test steps in the sequence of test steps. When the users select a test step in the sequence of test steps, the selected test step is monitored to inform the users whether the selected test step is executable in the test environment. The properties of the selected test step may also be provided and, if the selected test step is not executable in the test environment, users may be informed of the properties that should be specified to make the selected test step executable in the test environment.

Abstract: Systems, computer-readable media, and methods are disclosed for generating compiled scripts from scripts that include at least one scripting-language instruction. The least one scripting-language instruction may include a script extension to specify a computational model of the application and/or a method extension to specify a function of the computational model. The script extension may be identified within the at least one scripting-language instruction and an identifier for the computational model specified by the script extension may be determined. A compiled script may be generated that includes scripting-language code for replacing the script extension by an access of the computational model identified by the identifier. The application may be executed by locating a compiled script for the application based on an identifier assigned to the compiled script, injecting the compiled script into the application, and executing the injected script in the application.

Abstract: Analyzing the performance of multi-threaded applications. An analysis and visualization of thread executions is performed on a graphical timeline using samples of thread execution. This allows users to understand when their application threads are executing, what they were executing, the degree of concurrency in thread execution, and the order in which work is performed in their application. The visualizations and analysis also allow users to sample thread execution contexts using a graphical user interface, as well as the generation of execution profile reports that may be filtered for a specific time range of execution and a subset of the threads running in the application.

Abstract: According to exemplary embodiments, method and systems for software accessibility testing are provided. Aspects of the exemplary embodiments include: obtaining accessibility information on content of a graphical user interface (GUI) of software under test, wherein accessibility information is content of the GUI for which describing text is available or content of the GUI which is accessible by keyboard use; determining content of the GUI which should not be available in a test due to a lack of accessibility information; restricting the GUI to restrict access to the content not available; and providing the restricted GUI to a user for testing.

Abstract: A method and apparatus for generating dynamic test scripts enables the design and use of testing scripts that are independent of an application and the user interface layout of the application. The method and apparatus store a set of test data, checks and an action list independent from a test script. The test script matches the properties of the test data, checks and action list items with the properties of user interface elements in an application at run-time. The run-time matching allows for the script to be utilized for different applications as well as altered or updated versions of those applications with minimal or no changes to the testing script. This method and system are particularly relevant for the testing of applications using the user interface rather than backend utilities (APIs, services etc.).

Abstract: Exemplary embodiments employ a mapping among entities that are related to each other. The entities may include a graphical model, generated code, a generated report, a requirements document and/or an intermediate representation. The mapping may facilitate graphical identifications between parts of one entity that maps to part of another entity. The graphical identification may occur based on a selection of a part in one of the entities.

Abstract: Embodiments allow a runtime environment to link to an editing environment. An object or other feature may be identified for editing in a runtime environment using a specific tool or gesture. Given an identified object, an appropriate source object and/or editing application may be identified and the editing application may be launched for editing the identified object or source object. Similarly, given an identified state, an editing application may be launched to provide the application for editing in the identified state. In some cases, after any editing of an application feature, the runtime environment receives and incorporates the edited feature. The user then sees the revised features in the runtime without having to re-launch and manually return to the specific application state, object, or other feature that was edited. The ability to edit the features of a running application provides various benefits and can facilitate testing of an application's features.

Abstract: A method and system for testing code within a speech application. A test file can be automatically generated to verify the functionality of a new section of code within a graphical call flow builder application. A user can specify through a wizard two points on a path identifying the code section to be tested. The wizard can generate a test file and configure a path to a new subpath. Values are assigned to graphical call flow prompts along the path. Thus, the new code section is reached under the same path conditions for allowing repeatable testing. The system can include a test harness to test a new code section from within a context of the speech application, and a test controller for transitioning to the new code section. The test controller can run the test harness within the speech application to evaluate a functionality of the new code section.

Abstract: A non-stop debugging environment includes a debugger configured to debug a multi-threaded debuggee, where encountering an event by one of the threads stops execution of only the one thread without concurrently stopping execution of other threads. In such a non-stop debug environment, impact indication of thread-specific events includes tracking, by the debugger, activity associated with a thread-specific event and displaying, by the debugger in a graphical user interface (‘GUI’), an indication of thread-specific event impact in dependence upon the tracked activity.