| Entries |
| Document | Title | Date |
|---|
| 20080209403 | PROFILING APPARATUS AND PROFILING PROGRAM - A profiling apparatus including a program execution section that executes an target program, an interrupt generation section that generates an interruption every predetermined time, a gathering section that is activated upon occurrence of the interruption to gather a data access destination in the target program and a number of interruptions at the data access destination, and a display section that displays information gathered by the gathering section. | 08-28-2008 |
| 20080216054 | Storing and Restoring Snapshots of a Computer Process - A method to trace a variable or other expression through a computer program is disclosed. A user determines the variable and the conditions upon which activity of the variable will be monitored. As a result of the invention, every time that variable is referenced in a memory operation or other activity by the program and the conditions set forth by the user are satisfied, the state of that variable is saved as a snapshot without interrupting or stopping execution of the program. The snapshots are accumulated in a history table. The history table can be retrieved and the state of the variable in any given snapshot can be restored. Other variables and expressions can be attached to the trigger variable and the states of these other variables at the time of the activity of the trigger variable may also be saved in the snapshot. The method may be incorporated into a program as a tracing device or a program product separate from the logical processing device executing the program. | 09-04-2008 |
| 20080229285 | APPARATUS AND METHOD FOR MANIPULATING VARIABLE STATES - The invention includes a computer readable storage medium with executable instructions to run a segment of code and identify associated variables. The segment of code is stopped at a predetermined breakpoint and state values that correspond to the associated variables are identified. A variable is selected from the associated variables via a Graphical User Interface, where the selected variable has a variable state. The variable state is saved to a data store via the Graphical User Interface. | 09-18-2008 |
| 20080263520 | METHOD FOR VISUALLY INDICATING PRECEDING AND SUCCEEDING SOURCE CODE LINES THAT ARE EXECUTED IN A GRAPHICAL DEBUGGING ENVIRONMENT - A method for visually displaying an indicator for preceding and succeeding source code lines being executed within a graphical debugging environment. The method includes displaying within a GUI source code lines for a segment of currently examined source code, displaying a visual indicator that is associated with a presently examined source code line, and determining a previously examined source code line, wherein the location of the previously examined line of source code is determined by the use of information that is associated with the previously examined line of source code. The method further includes displaying a visual indicator that is associated with the previously examined line of source code, determining a next source code line that is to be examined, and displaying a visual indicator that is associated with the next source code line that is to be examined. | 10-23-2008 |
| 20080263521 | Debugging a Statechart Using a Graphical Program - System and method for configuring wires in and/or debugging a statechart. The statechart may be created or displayed on a display and may include a plurality of state icons connected by wires. The state icons may represent states and the wires may represent transitions between the states. One or more of the wires may be configured, e.g., according to user input. A graphical program may be created which specifies a debugging operation for the statechart. The statechart may be executed and may provide data to the graphical program. The graphical program may receive first data produced by the statechart, e.g., during execution. The graphical program may perform the debugging operation based on the first data. | 10-23-2008 |
| 20080263522 | Common Debug Adaptor - Software developers working on multi-language systems with various debug tools (BPEL, AE, Java, etc.) can use a common debug adaptor (CDA). The CDA implements a method of debugging in a multi-computer program language environment. The method includes registering various debug tools associated with different programming languages in the multi-computer program language environment, each one of the plurality of debug tools providing suspended threads and stack frames in response to a debug event in the multi-computer program language environment. The method can further include receiving the suspended threads and stack frames from the plurality of debug tools. The method can further include correlating the received suspended threads and stack frames under a common suspended thread; and providing the common suspended thread in a debug view. Such a method can have a number of attributes intended to assist developers facing debugging problems in multi-language systems. | 10-23-2008 |
| 20080270988 | METHOD AND SYSTEM FOR DEBUGGING A PROGRAM IN A MULTI-THREAD ENVIRONMENT - A method and system for debugging a program in multithread environment which interrupts the running of a debuggee program begins by replacing the instruction at the position at which a breakpoint for debugging is desired to be set with a breakpoint instruction. When the breakpoint instruction is replaced back with the instruction at the position at which the breakpoint for debugging is set, an instruction is set in front of the breakpoint for debugging as a fence breakpoint; and when the instruction at the position at which the breakpoint for debugging is set, is replaced again with the breakpoint instruction. On completion, the fence breakpoint is replaced with the original instruction of the debuggee program at that position. | 10-30-2008 |
| 20080276223 | Dynamic Source Code Analyzer - The invention is an improved integrated development environment (IDE). In particular, the improved IDE comprises a text editor, a source code analyzer, a rule database, and a solution database. The rule database stores source code patterns that represent classes of bugs, while the solution database stores source code patterns that represent corresponding alternative source code that corrects the bugs. The source code analyzer dynamically evaluates source code as a programmer develops the source code in the text editor, periodically comparing source code with the patterns in the rule database. If the source code analyzer matches a pattern with any source code, the source code analyzer displays the corresponding source code pattern from the solution database. The source code analyzer further gives the programmer the option to select the source code pattern from the solution database, at which time the editor changes the source code to conform to the appropriate pattern. | 11-06-2008 |
| 20080282230 | PRODUCT, METHOD AND SYSTEM FOR USING WINDOW AUTHENTICATION IN TESTING GRAPHICAL USER INTERFACE APPLICATIONS - The invention discloses an authentication technique for allowing an automated testing program to determine whether a failure during software application testing is caused by an event unrelated to the test, in order to improve correction of programming defects discovered using automated testing. Specifically, a product, method and system is provided for using window authentication in testing graphical user interface (GUI) applications. | 11-13-2008 |
| 20080288923 | Source Program Analysis Device And Method - There is provided an analyzing apparatus for finding the possibility of dividing up and executing a source program using debugging information generated when compiling the source program and memory access information generated by running object code on a simulator. The analyzing apparatus includes: a memory that stores block IDs for grouping some out of the source statements in the source program as processing blocks associated with code memory addresses of respective instructions, based on the debugging information; and a graphical display functional unit that graphically displays, on a display device, based on the memory access information and together with cycle times, an access state for execution memory when the source program is performed, the access state including code memory addresses, variable memory addresses, and access types and being displayed using a different style for each block ID associated with the code memory addresses of the respective instructions. | 11-20-2008 |
| 20080295078 | In-process debugging using external debugging infrastructure - An in-process debugging experience can be implemented using an infrastructure that supports out-of-process debugging. A program that is to be debugged may be written in a command-line language that receives and processes input through an input loop. The interpreter for the language runs in a first process. A helper program is started in a second process, and attaches to the first process as if it were an out-of-process debugger. A debugging module is loaded into the interpreter, which provides user debugging commands that may utilize the helper program. When the program to be debugged generates a debug event, the event is received by the helper process, which uses a debug primitive to start a new instance of the input loop in the first process. Debugging commands provided by the debugging module can be entered by the user into the new instance of the input loop. | 11-27-2008 |
| 20080320448 | Method and Apparatus for Autonomic Test Case Feedback Using Hardware Assistance for Data Coverage - A method, apparatus, and computer instructions for presenting coverage data relating to data access occurring during execution of code. The coverage data containing data access indicators associated with memory locations is obtained. The data access indicators that have been set by a processor in the data processing system in response to access of the memory locations during execution of the code by the processor are identified to form set data access indicators. Each set instruction access indicator is associated with a portion of the memory locations allocated for the code. A presentation for coverage data is generated, wherein the set data access indicators are identified in the presentation. | 12-25-2008 |
| 20090037882 | Techniques for Determining a Web Browser State - A technique for determining a browser state during a web page test includes providing, from a test automation tool, a first input to a web page provided via a browser. The technique also includes detecting, with a network monitoring tool, outgoing traffic from the browser associated with the first input and detecting, with the network monitoring tool, incoming traffic to the browser associated with a response to the first input. An indication is provided from the network monitoring tool to the test automation tool when the incoming traffic is detected by the network monitoring tool. Finally, the test automation tool provides a second input to the web page following the indication. | 02-05-2009 |
| 20090037883 | TESTING FRAMEWORK TO HIGHLIGHT FUNCTIONALITY COMPONENT CHANGES - A computer program product stored on machine-readable media, the product including machine executable instructions for tracking a defect during development of a software work product, the computer program product including instructions for displaying the defect; identifying a component of the work product including the defect; displaying information related to the defect; and receiving input related to testing of the defect to update tracking information. | 02-05-2009 |
| 20090055802 | SELECTIVE MONITORING OF SOFTWARE APPLICATIONS - An application monitoring system autonomously selects routines for performance monitoring based on characteristics of the content of the routines. These characteristics are preferably related to aspects of routines that are likely candidates for performance improvement, such as repetitive loops, event waits, synchronized blocks, and on. Routines that appear to be relatively un-improvable are excluded from initial monitoring, and routines that are subsequently determined to be relatively un-improvable, based on performance analysis and/or user feedback, are excluded from future monitoring. The determination of each routine's candidacy for monitoring is maintained over time, so that each subsequent monitoring session need not repeat the determinations. Changed routines are routinely re-monitored and/or re-assessed to affirm or modify the routine's candidacy for subsequent monitoring. | 02-26-2009 |
| 20090070743 | System and method for analyzing software applications - Techniques are provided to analyze software applications, and in particular, to obtain visibility to the execution of a database application. As the software application issues requests to a database, the system determines based on a first set of programmable parameters whether the requests are of a type to trigger data collection. If so, a second set of programmable parameters are utilized to determine which data, if any, to collect for one or more sub-portions of the request. In one embodiment, the sub-portions are commands recognized by a database management system. Collected data is used to generate visual and textual models of the application. | 03-12-2009 |
| 20090094581 | THREAD SWAP VISUAL INDICATION - A computer implemented method, apparatus, and computer usable program code for indicating thread swaps. A code is presented on a graphical user interface. A portion of the code is executed. A determination is made as to whether a change from an initial thread to a current thread occurred when execution of the portion of the code stops at a line of code in the portion of the code. A graphical indication is displayed identifying a thread swap in the graphical user interface in association with the line of code in which the thread swap occurred. | 04-09-2009 |
| 20090138855 | TEST IMPACT FEEDBACK SYSTEM FOR SOFTWARE DEVELOPERS - Various technologies and techniques are disclosed for facilitating a feedback process regarding the impact that changes to source code will have on tests. Changes contained in at least one source code file are analyzed in combination with code coverage information contained in a data store for a plurality of tests to determine when any of the tests will be impacted by the changes. When at least one test is determined to be impacted by the changes made to the source code file, a warning notification is displayed to a user to notify the user of a possible impact of the changes on the at least one test. | 05-28-2009 |
| 20090144705 | DEBUGGING DEVICE AND DEBUGGING METHOD - A debugging device configured to debug a program includes an analysis section configured to analyze information of a code that does not need to be debugged in which a predetermined processing instruction is described, the code being generated by optimization of a compiler for a source code of the program, and an output section configured to output processing content information, a start address, and an end address of the code that does not need to be debugged which are obtained by the analysis. | 06-04-2009 |
| 20090150868 | Method and System for Capturing Movie Shots at the Time of an Automated Graphical User Interface Test Failure - A method of capturing movie shots at the time of an automated Graphical User Interface (GUI) test failure. When an automated GUI test application performs an action during a test of a GUI, the GUI test application adds a text description of the action to a test log and captures a screenshot image of the GUI. The GUI test application adds the screenshot image to a rolling First-In-First-Out (FIFO) queue that includes up to a most recent N screenshot images, where N is a pre-defined configurable number. If an error occurs, the GUI test application captures a final failure point screenshot image. The GUI test application adds the final screenshot image to the rolling FIFO queue and the test log. The GUI test application assembles the screenshot images from the rolling FIFO queue into a chronologically animated movie file and attaches the movie file to the test log. | 06-11-2009 |
| 20090158256 | FEEDING TEST METRICS INTO AN INTEGRATED DEVELOPMENT ENVIRONMENT TO AID SOFTWARE DEVELOPERS TO IMPROVE CODE QUALITY - A method, apparatus and program product for using test results to improve code quality are provided. An IDE or program operable with an IDE retrieves automated test results for a code sequence. The IDE or separate program detects the code sequence during source code development in an IDE. The test results are then presented in the IDE during source code development. | 06-18-2009 |
| 20090178029 | Dependent Object Framework for JUnit Testing - Methods and apparatus, including computer program products, implementing and using techniques for testing a software application component. A dependent object framework is provided. The dependent object framework includes a set of static methods, a set of dependent object files, and a set of properties files. A test program is received. The test program references one or more objects described by the set of dependent object files. The one or more objects are loaded using at least one of the static methods of the dependent object framework. The received test program is run and a result of the test program is displayed. | 07-09-2009 |
| 20090183142 | DEBUGGING LAZILY EVALUATED PROGRAM COMPONENTS - A system and method for facilitating debugging a computer program is provided. Mechanisms of the present invention facilitate presenting information and enable a developer to interact with a lazily evaluated program component. A debugging system may display data associated with a lazily evaluated program component, and may enable the programmer to control evaluation and viewing of elements of the lazily evaluated program component. In response to a user command, a debugging system may evaluate elements of the program component and display associated data. A user interface enables a user to view, interact with, and debug lazily evaluated program components as well as a program containing such components. | 07-16-2009 |
| 20090187889 | METHOD AND SYSTEM FOR INCONSISTENCY RESOLUTION WITH CYCLE DETECTION IN A MODEL-DRIVEN SOFTWARE ENVIRONMENT - A method and system for inconsistency resolution in a model-driven software development environment are provided. A method includes performing a safety analysis for resolutions in response to detected inconsistencies to determine whether the resolution, if implemented, will lead to a resolution cycle when applied to a given inconsistency. The determination includes processing a resolution tree for the inconsistency and, using a resolution strategy tree, for each resolution that resolves an inconsistency, analyzing whether beginning with the resolution, it is possible to resolve all the inconsistencies subsequently introduced as side effects without a resolution cycle occurring. The analysis includes traversing the resolution strategy tree, whereby all resolution strategies derived by traversing the resolution strategy tree lead to a resolution cycle if the resolution strategy tree is infinite. The method includes categorizing the resolution that resolves the inconsistency and applying a resolution for the inconsistency based upon the resolution category. | 07-23-2009 |
| 20090187890 | Method and System for Associating Profiler Data With a Reference Clock - A computer implemented method, apparatus and program product for analyzing performance data particular to an algorithm using a profiler algorithm, and automatically associates the performance data with a reference clock time. The performance data may be automatically associated with a tag, also associated with the reference clock time. Using the tag, the performance data may be associated with a portion of the algorithm. For instance, the tag may be associated with a corresponding tag associated with the algorithm. User input may be received that designates both the tag and an additional tag associated with the program code. Aspects may identify tags in the performance data that correspond to both the tag and additional tag of program code. The portion of the performance data bounded by the identified tags in the performance data may be retrieved and displayed to a user. In this manner, the performance data may be automatically associated with a portion of algorithm. | 07-23-2009 |
| 20090193396 | Debugging a Statechart for a Real Time Target - System and method for debugging a statechart on a target device. The statechart may be created or displayed on a display and may include a plurality of state icons connected by wires. One or more debugging operations may be specified for the statechart. The statechart may be executed on the target device. The target device may provide debugging information to a computer during execution of the statechart. The debugging information may be displayed on the computer and may be usable to aid in debugging the statechart. | 07-30-2009 |
| 20090204947 | METHOD AND SYSTEM FOR CORRELATING TRACE DATA - A computer program product comprises a computer useable medium. The computer useable medium has a computer readable program such that when the computer readable medium is executed on a computer, the computer is caused to configure a calling interceptor at a service invocation point corresponding to a first component service of a software application to monitor a service invocation made by the first component service of a second component service of the software application, record a first set of correlation data represented by a first correlation indicator into a trace file, record a unique identifier into the trace file, and send the unique identifier to the second component service thought the service invocation. | 08-13-2009 |
| 20090210862 | Intelligent computer program debugger, and system and method for implementing the same - A method for displaying a user-defined artifact in a debugger view is provided. The user-defined artifact is defined in a software application that is developed by a computer software application developer. The software application is included in a packaged application that includes instructions, with each instruction being either a user-defined instruction or a non-user defined instruction. A breakpoint is defined at a desired instruction of the packaged application. The method includes initiating debugging of the packaged application and hitting the breakpoint defined at the desired instruction. Also included is identifying the user-defined artifact in the software application and obtaining data to populate the debugger view. Further included is filtering-in data associated with the user-defined artifact and displaying the debugger view showing the filtered-in data. The method also includes marking data not associated with the user-defined artifact and stepping through the user-defined instruction. | 08-20-2009 |
| 20090249298 | Evaluation of Software based on Change History - A method for software processing includes obtaining change information, which records changes that have been performed in respective locations in software code. The change information is processed so as to assign to at least some of the locations respective priorities, which are indicative of respective likelihoods that the locations contain program faults. The at least some of the locations are presented to a user in accordance with the assigned priorities. | 10-01-2009 |
| 20090249299 | Evaluation of Software based on Review History - A computer-implemented method for software processing includes obtaining review information pertaining to reviews that have been conducted on respective locations in software code. The review information is processed so as to assign to at least some of the locations respective priorities, which are indicative of respective likelihoods that the locations contain program faults. The at least some of the locations are presented to a user via an output device in accordance with the assigned priorities. | 10-01-2009 |
| 20090254885 | SYSTEM AND A METHOD FOR MANAGING CONFIGURATIONS OF AUTOMATIC TESTS - The present invention is a new and innovative system and method for managing and organizing the set of configurations of tests independently of the definition and execution of scenario suit of the tests. The proposed system and method enable managing the setups and teardown configurations for any type of test of any type of tested item. Additionally, embodiments of the proposed configuration management system and method may include recovery protocol for defining the needed configurations when tests fail. According to embodiments of the present invention the setup and teardown configurations are organized in a tree hierarchy, each branch of the hierarchic configuration tree is designated for a group of tests. The system further verifies that the different configurations do not contradict each other | 10-08-2009 |
| 20090254886 | Virtual debug port in single-chip computer system - The invention is a method and apparatus for debugging of software on an array-type single chip computer system | 10-08-2009 |
| 20090265689 | Generic validation test famework for graphical user interfaces - A scalable system and method is described that automatically identifies one or more generic tests for testing a GUI. A generic test case is written once instead of writing test cases for every single page or assembly. Each page has a corresponding page type. Each generic test is mapped to one or more testing rules, where the testing rules each have a rule type. An automated system is provided to scan target directories for all relevant pages related to a software product, identify a page type for each page, identify the appropriate generic test cases to be applied to each page, execute the generic test cases, and provide an output to indicate the results of the tests on the various pages. The generic tests for the GUIs can thus be automatically applied to identify and eliminate a certain class of bugs matching the behavior of the generic test case. | 10-22-2009 |
| 20090271768 | DISCRIMINATING PROGRAM CODE UPDATES AFTER MERGING FOR LIVE REVIEW - A method for dynamically discriminating a program code patch update after merging a patch file into unmodified source code for dynamic review. The method includes providing a graphical user interface (GUI) to enable a user to merge a source code patch file into an existing, pre-modified version of source code to generate a variant form of the existing, pre-modified source code and binary artifacts, via the GUI, presenting a display image highlighting differences between existing, pre-modified source code and the variant form after merging the source code patch file into the existing, pre-modified source code, via the GUI, presenting the user with an option of debugging the existing, pre-modified version of the source code, the GUI presenting linked views highlighting the existing, pre-modified version of the source code with the variant form of the source code, in parallel, debugging the variant form of the source code, the GUI presenting linked views highlighting the existing, pre-modified version with the variant form of the source code, in parallel and debugging both the existing, pre-modified version of the source code and the variant form of the source code, in parallel, while stepping through the existing, pre-modified and variant forms of the source code synchronously, while the GUI presents the linked views. | 10-29-2009 |
| 20090288070 | Maintenance For Automated Software Testing - Embodiments of a maintenance mode for automated testing are provided. In this regard, an embodiment of a system, among others, comprises a software application; a test script for testing the software application; an object repository comprising objects belonging to the software application; and a maintenance mode, wherein if a step in the test script fails, the maintenance mode prompts a tester to change at least one of the test script and the object repository. | 11-19-2009 |
| 20090307666 | REAL-TIME VALIDATION OF INTERACTIVE APPLICATIONS - A validation tool providing real-time validation of interactive content applications includes a static analysis engine that extrapolates the timeline of an application and the application's behavior over that timeline. The static analysis engine watches various types of data associated with the application's markup document and works through an editor to inform the user if the application has exceeded defined limits as the application is being built. The validation tool is further configured with a dynamic simulator that is arranged as a state machine that shares state information with the static analysis engine to enable the validation tool to display useful information such as pixel buffer usage at a given time code. The validation tool is further configured to provide a real-time application preview with which the user may interact to immediately evaluate cause and effect of any changes that are made in the application code using the editor. | 12-10-2009 |
| 20090313607 | Code Coverage Tool - A code coverage tool tests a program under test that executes on a processor of an information handling system (IHS). The code coverage tool may apportion the program under test into code portions of interest that exhibit a user-specified granularity level. A user may request that the code coverage tool change the granularity level of the code portions of interest in real time. The code coverage tool conducts testing of the code portions of interest according to test criteria that the user may specify in real time. The code coverage tool may provide test results for each of the code portions of interest in real time. The code coverage tool may also provide a summary report after providing real time test results for the code portions of interest. The user may specify that the code coverage tool generate real time test results in the form of sensory output, for example auditory output or visual output, for each of the code portions of interest. The code coverage tool may alter the type of sensory output in real time at the request of the user. | 12-17-2009 |
| 20090319995 | ENHANCING SOURCE CODE DEBUGGING AND READABILITY USING VISUAL SYMBOLS - The present invention provides the ability to enable a special view of source code in which the textual name of classes, variables, methods and object instances can be replaced with graphical symbols. A method of displaying computer source code according to the present invention comprises assigning unique graphical symbols to a plurality of corresponding textual names of source code classes, methods, and variables, replacing the plurality of textual names of the classes, methods, and variables with the corresponding assigned unique graphical symbols, and displaying the source code with the unique graphical symbols in place of the corresponding textual names of the classes, methods, and variables. | 12-24-2009 |
| 20090319996 | ANALYSIS OF THREAD SYNCHRONIZATION EVENTS - Thread blocking synchronization event analysis software uses kernel context switch data and thread unblocking data to form a visualization of thread synchronization behavior. The visualization provides interactive access to source code responsible for thread blocking, identifies blocking threads and blocked threads, summarizes execution delays due to synchronization and lists corresponding APIs and objects, correlates thread synchronization events with application program phases, and otherwise provides information associated with thread synchronization. The visualization may operate within an integrated development environment. | 12-24-2009 |
| 20090328004 | METHOD TO COLLABORATIVELY RESOLVE JAVA PROGRAM ERRORS WITHIN AN INTEGRATED DEVELOPMENT ENVIRONMENT - The present disclosure is directed to a method to collaboratively resolve a Java program error. The context of the access is uniquely identified based on two parameters—the error and the specific library where the error occurred. The developer uses the same interface to contribute to discussions irrespective of the error or the library. The method automatically determines the forum for the discussion. Finally, the method is able to notify the developer when the error is resolved so that the developer can contribute resolution information back to the discussion. | 12-31-2009 |
| 20090328005 | DEBUGGER CALL STACK CACHING - A debugger backend computes and stores a previous call stack of multiple threads of a debuggee process based on previous call stack information provided from a debugging agent. The debugger backend stores a first hash of threads of the debuggee process and stack memory of the previous call stack. The debugger backend sends the first hash to the debugging agent in response to a request of the current call stack from a debugger user interface (UI), and provides the previous call stack to the debugger UI in response to the debugging agent indicating that that first hash matches a second hash of thread registers of the debuggee process and stack memory of the current call stack. | 12-31-2009 |
| 20100017788 | DEBUGGING SOFTWARE THROUGH VISUAL REPRESENTATIONS MAPPED TO COMPUTER CODE - Debugging tools to allow a developer to debug software at a higher level of abstraction than the source code. These tools may be configured to recognize certain source code, and map it to visual representations that can be shown to the developer. The tools may allow the developer to set breakpoints in those visual representations, and they may allow the debugger to stop at those breakpoints, show the developer the visual representation and indicate the stopped location of the program being debugged, for example, by highlighting a particular component of the visual representation. The tools may also map breakpoints in visual representations to actual source code breakpoints. | 01-21-2010 |
| 20100037210 | GENERATING FUNCTIONAL TEST SCRIPTS - A method for eliminating ambiguity and incorrectness of the specification determined in a requirement defining phase in developing an information system, and systematically verifying whether an automatically executed test scenario agrees with the original requirements in a functional testing phase, includes extracting an input variable, an output variable, and the respective types of the variables from a specification file in screens; extracting screen-transition information from a composite functional specification containing specifications in screens; and executing the following processes from the top for each screen that appears in screen transition. For the input variable, the apparatus generates a test script indicative of an action (clicking or a character set) corresponding to an object associated with the input variable. For the output variable, the apparatus generates a test script for comparing text information displayed on a screen with an expected value determined from the output variable. | 02-11-2010 |
| 20100042975 | MESSAGE LOGGING FOR SOFTWARE APPLICATIONS - A computer system comprises a storage medium configured to store software instructions; a processing unit configured to execute the software instructions; a bus; and an acknowledge device coupled to the processing unit via the bus. The processing unit is further configured to periodically write debug messages to the acknowledge device during execution of the software instructions and the acknowledge device is configured to acknowledge the debug messages prior to processing the debug messages. | 02-18-2010 |
| 20100050157 | SYSTEM AND PROCESS FOR DEBUGGING OBJECT-ORIENTED PROGRAMMING CODE - A process and system for interactive debugging of a computer program, is provided. One implementation involves providing a class for an object oriented computer program capable of executing on a computer system, the class having class methods defining a semantic field of the class; automatically monitoring the class during execution of the program, and leveraging said class methods by executing the class methods upon object-typed variables to obtain a pseudo-field value; and presenting the pseudo-field value along with fields of the said object-typed variables, on a user interface for debugging purposes. | 02-25-2010 |
| 20100050158 | SYSTEM AND PROCESS FOR DEBUGGING OBJECT-ORIENTED PROGRAMMING CODE LEVERAGING PREPROCESSORS - 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. | 02-25-2010 |
| 20100050159 | SYSTEM AND PROCESS FOR DEBUGGING OBJECT-ORIENTED PROGRAMMING CODE LEVERAGING RUNTIME METADATA - A system and process for debugging of a computer program, is provided. One implementation includes a function configured for including mark-up information marking certain methods as special fields in a source code of the application program, such annotations denoting debugging instructions and indications of which methods are intended for debugging only; a processing module configured for generating a production version of the application program including the same semantics as the original application program but potentially fewer methods and no debug related annotations, wherein methods that are not annotated as debugging only methods are maintained; and a debugger configured for debugging purposes using the debugging methods. | 02-25-2010 |
| 20100058296 | Programmatic Analysis of Graphical Sub-Programs within a Graphical Program - A system and method for visually indicating one or more problems in a graphical program. The graphical program may be programmatically analyzed to discover a problem (or potential problem) in the graphical program. The problem found during the programmatic analysis of the graphical program may then be visually indicated on a display device. Visually indicating the problem may comprise visually indicating one or more objects in the graphical program to which the problem corresponds. Visually indicating the graphical program object(s) may comprise displaying information or altering the appearance of the object(s) in order to call the user's attention to the object(s). | 03-04-2010 |
| 20100064282 | DECLARATIVE TESTING FOR USER INTERFACES - The claimed matter provides systems and/or methods that actuate and/or facilitate declarative testing of software applications. The system can include devices that receive or elicit declarative definitions of testing scenarios and employs the declarative definitions to test a software application under consideration. Further, the system also compares the supplied declarative definitions with the results obtained from execution of the declarative definition. Where dissimilarity is observed the differences are persisted and the differences so persisted utilized as subsequent declarative definitions in order to iterate to a goal set forth in the declarative definition. In particular, the claimed matter can commence with a declarative answer, focus on a multiplicity of possible scenarios rather than the numerous operations needed to attain these scenarios, and utilize the differences obtained from execution of the declarative answer in order to simplify verification of software products. | 03-11-2010 |
| 20100070949 | PROCESS AND SYSTEM FOR ASSESSING MODULARITY OF AN OBJECT-ORIENTED PROGRAM - The present invention describes a process, system and computer program product for assessing the modularity of an object-oriented program. The process includes calculation of metrics associated with various properties of the object-oriented program. Analysis is performed on the basis of the calculated metrics. | 03-18-2010 |
| 20100095276 | TEST DATA CREATION AND EXECUTION SYSTEM FOR SERVICE ORIENTED ARCHITECTURE - A test data creation and execution system provides an efficient way to dramatically improve testing of web service based applications. The test data creation and execution system assists testers in identifying and executing various combinations of unit tests, as well as integration and regression testing of web services and methods of web services. The test data creation and execution system provides testers the functionality to rapidly produce high quality web services based applications. | 04-15-2010 |
| 20100100872 | METHODS AND SYSTEMS FOR IMPLEMENTING A TEST AUTOMATION FRAMEWORK FOR TESTING SOFTWARE APPLICATIONS ON UNIX/LINUX BASED MACHINES - This disclosure describes, generally, methods and systems for implementing a test automation framework. The method may include receiving test scenarios. Each of the test scenarios may include at least one test case. The method may further include spawning a process for each of the test scenarios. The processes may be executed in parallel on a Linux based operating system. The method may parse each of the test cases using a parser, execute the parsed test cases using an execution module, and generate test results for each of the test scenarios. Further, the method may display the test results on a Windows based graphical user interface (GUI). | 04-22-2010 |
| 20100125833 | Graphical Representation of a Java Bytecode - 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. | 05-20-2010 |
| 20100125834 | Dynamic Tracing on Java Exceptions - Embodiments of the invention provide a method and system for tracing Java bytecode. The system provides a user interface for selecting the methods, both primary and secondary, that the user desires to monitor. The user can record the execution of the program and playback the execution of the program while monitoring each of the designated methods and the variables and similar data related to those methods in order to identify a cause of an exception or error in the program. | 05-20-2010 |
| 20100131927 | AUTOMATED GUI TESTING - Graphical User Interface (GUI) automation tools continue to evolve in their sophistication and complexity. However, it is still necessary to tailor such automation to the machine configuration that the test is being run on. This can be a costly and time consuming exercise when developing software for a myriad of different platforms. Broadly contemplated herein, in accordance with at least one embodiment of the invention, are arrangements and processes for recording a test solely on one machine while generating images on all the other available environments. | 05-27-2010 |
| 20100138811 | Dynamic Performance Profiling - A dynamic performance profiler is operable to receive, in substantially real-time, raw performance data from a testing platform. A software-based image is executing on a target hardware platform (e.g., either simulated or actual) on the testing platform, and the testing platform monitors such execution to generate corresponding raw performance data, which is communicated, in substantially real-time, as it is generated during execution of the software-based image to a dynamic profiler. The dynamic profiler may be configured to archive select portions of the received raw performance data to data storage. As the raw performance data is received, the dynamic profiler analyzes the data to determine whether the performance of the software-based image on the target hardware platform violates a predefined performance constraint. When the performance constraint is violated, the dynamic profiler archives a portion of the received raw performance. | 06-03-2010 |
| 20100180260 | METHOD AND SYSTEM FOR PERFORMING AN AUTOMATED QUALITY ASSURANCE TESTING - A method includes selecting a plurality of test cases. The method also includes designing the plurality of test cases to perform the automated quality assurance. The method further includes calibrating the plurality of test cases and manage the plurality of test cases in a visual hierarchy. The method also includes reflecting the functional modules in a cohesive group based on the calibration. The method further includes executing the plurality of test cases through at least one of a manual testing mode and an automatic testing mode. The method includes registering information associated with the plurality of test cases. Moreover the method includes generating one or more reports for the plurality of test cases. Furthermore the method includes displaying the one or more reports generated for the plurality of test cases on a visual interface. | 07-15-2010 |
| 20100192128 | SYSTEM AND METHODS OF USING TEST POINTS AND SIGNAL OVERRIDES IN REQUIREMENTS-BASED TEST GENERATION - An electronic system for test generation is disclosed. The system comprises a source code generator, a test generator, and a code and test equivalence indicator, each of which take functional requirements of a design model as input. The test generator generates test cases for a first test set and a second test set, where the first test set comprises a target source code without references to test points in the source code and the second test set comprises a test equivalent source code that references the test points of the source code. The code and test equivalency indicator generates test metrics for the first and second test sets and comparatively determines whether the target source code is functionally identical to the test equivalent source code based on an analysis of the test metrics and a comparison of the target and the test equivalent source codes. | 07-29-2010 |
| 20100199263 | TEST CASE PATTERN MATCHING - A method of providing feedback on source code being created includes receiving source code and processing the received source code according to a predefined rule set to create a representation of the received source code. A source code repository is accessed that includes source code fragments. Each source code fragment in the repository has been processed according to the predefined rule set to create representations of the respective source code fragments. The representation of the received source code is compared to each representation of the source code fragments. A matching score is calculated for the representation of the received source code with respect to each representation of the source code fragments based upon an output of the comparison step. An output derived from the calculated matching scores is presented. | 08-05-2010 |
| 20100211933 | DEBUGGING AND PERFOMANCE ANALYSIS OF APPLICATIONS - While an application is still running and using a resource that the application has already allocated, real-time capture is used to allow for a minimal overhead, quick turnaround solution for debugging and performance analysis. Application programming interface interception can be used to construct a database of resource usage that can then be mined for dependencies. | 08-19-2010 |
| 20100218169 | CONTRACT FAILURE BEHAVIOR WITH ESCALATION POLICY - An error handling system is described herein that provides a facility for controlling the behavior of software when the software violates a contract condition. The system provides configurable runtime behavior that takes place when a contract fails. The error handling system provides an event that a hosting application or other software code can register to handle and that the system invokes upon detecting a contract failure. The application's response to the event determines how the system handles the failure. If the event is unhandled, the system triggers an escalation policy that allows an administrator or application to specify how the system handles contract failures. Thus, the error handling system provides increased control over the handling of contract failures within software code. | 08-26-2010 |
| 20100235815 | SIMULTANEOUSLY DISPLAYING MULTIPLE CALL STACKS IN AN INTERACTIVE DEBUGGER - Visual representations of multiple call stacks in a parallel programming system include a stack segments graph constructed by coalescing data from multiple stacks. The graph has nodes that represent stack segments and has arcs between adjacent segments. Similar stack frames are represented by the same node. In a stack prefix view of the graph, arcs are directed from a node representing stack frames to a node representing subsequently executed stack frames. In a method-centered view, an arc is shown between a node representing stack frames of a selected method and a node representing adjacent stack frames. The graph can be based on call stacks of all tasks or all threads, or based on call stacks of tasks or threads flagged by a user. Stack frame, thread, and/or task details are also displayed. | 09-16-2010 |
| 20100242024 | User Interface System and Method for Controlling Conversion of a Source Job Control Language File into a Test Job Control Language File - A user interface system for interactively controlling conversion of a source JCL into a test JCL for execution in a test environment is provided. The system includes a memory storing the source JCL containing program codes and an instruction file for converting the source JCL into the test JCL according to the test environment. A user interface module executable by a processor displays a plurality of jobs to be executed in the test environment and receives a user selection of one or more of the displayed jobs for conversion of the user selected jobs into the test JCL according to the stored instruction file. | 09-23-2010 |
| 20100251215 | METHODS AND SYSTEMS OF DETERMINING RISK LEVELS OF ONE OR MORE SOFTWARE INSTANCE DEFECTS - An exemplary method includes displaying a graphical user interface configured to facilitate identification of one or more defects within a software instance, receiving data representative of at least one instruction via the graphical user interface to assign a severity risk value, an impact risk value, and a likelihood risk value to each of the one or more defects, and generating a defect risk factor corresponding to each of the one or more defects that indicates a risk level of each of the one or more defects, the generating based on a combination of the severity risk value, the impact risk value, and the likelihood risk value corresponding to each of the one or more defects. | 09-30-2010 |
| 20100269101 | EVENT LOGGING AND PERFORMANCE ANALYSIS SYSTEM FOR APPLICATIONS - An event logging and analysis mechanism which creates an event object for event of an application to be logged. The event logging mechanism logs into the event object the start time, end time and other information regarding the event. The analysis of the collected event objects may include hierarchical and contextual grouping as well as aggregation of events considered to be identical. The mechanism operates independent of the application whose events it logs and can be turned on and off independently. A user may define the levels of hierarchy and contexts upon which to analyze the event objects. | 10-21-2010 |
| 20100275184 | RESOURCE MONITORING - Monitoring resources of a computing device during testing of software applications provides useful feedback to developers and implementers of the software application. By periodically collecting system counter data during automated testing of the software application, and correlating the collected data to a state of the test, the actions of the test causing any undesirable resource issues can be readily identified. | 10-28-2010 |
| 20100281466 | PROCESS FOR VERIFYING COMPUTER CODES AND CORRESPONDING VERIFICATION SYSTEM - A process for detecting errors in computer code in C/C++ language in a computer, which comprises the operations of:—making available in said computer a source computer program (P) containing computer codes in C/C++ language; compiling (Z) said source computer program (P) to obtain an executable program (E); and—executing ( | 11-04-2010 |
| 20100306744 | Debugger With Audiation - A method and computer program product are provided for audiating the occurrence of debugger events within a software debugger. The method begins by assigning a sound characteristic to a debugger event occurring within a software program under debug. Next, the audiation of the sound characteristic associated with the event is optimized to maximize performance of the debugger. Finally, the optimized sound characteristic associated with the event is played upon the occurrence of the event. | 12-02-2010 |
| 20100318971 | Systems And Methods For Identifying Graphic User-Interface Components - Systems and methods for identifying a target position on a computer display are provided. A system receives computer display data indicative of contents of a computer display and identifies a first area of interest within the computer display. Identifying the area of interest includes receiving a first image and searching the computer display for the first image. Upon finding a match for the first image, a location of the match for the first image is identified as a first point. A second image is received and searched for on the computer display. Upon finding a match for the second image, the location of the match is identified as a second point. The first point and the second point are used in defining an area of interest. A target position is located within the area of interest. | 12-16-2010 |
| 20100333068 | COMPATIBILITY EVALUATION APPARATUS, COMPATIBILITY EVALUATION METHOD, AND RECORDING MEDIUM - A compatibility evaluation apparatus for evaluating compatibility between a platform program and an application program that uses interfaces provided by the platform program, includes an application analyzing unit configured to analyze the application program and extract a list of the interfaces used by the application program; an incompatibility interface usage determination unit configured to extract, from the list of the interfaces used by the application program, an interface that corresponds to an incompatible interface that does not satisfy a specification, the interface being extracted with the use of a first storage unit storing information indicating contents of incompatibility for each of the incompatible interfaces among the interfaces provided by the platform; and a compatibility report creating unit configured to record, in a second storage unit, the information indicating contents of incompatibility for each interface that has been extracted by the incompatibility interface usage determination unit. | 12-30-2010 |
| 20110016453 | MODULARIZING AND ASPECTIZING GRAPHICAL USER INTERFACE DIRECTED TEST SCRIPTS - A test structure for testing graphical user interface applications (GAPs) modularizes test scripts by separating statements that define GAP test logic from statements that navigate to GAP objects. Composition rules weave the statements together to generate the test scripts that are executed to test the GAP. Because the test structure is modular, test logic can be reused across different GAPs and different versions of the same GAP. Reusing test logic is not only an efficient practice from a test engineer's point of view, but also leads to a reduction in test programming errors. The modular test structure also facilitates the efficient modification of test scripts to account for modifications in the underlying GAPs, greatly reducing the time, cost, and resource expenditures needed to arrive at updated test scripts. | 01-20-2011 |
| 20110029955 | Integrated Data Viewer - 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. | 02-03-2011 |
| 20110029956 | Method And System Of Testing Software Using Real Time Replication - Method and system of testing software using real time replication. At least some illustrative embodiments are methods comprising interacting (by a human tester) with a first software program executed on a first computer system (the interacting causes an operation to be performed on the first software program), duplicating the operation on a second software program executed on a second computer system coupled to the first computer system (the duplicating on the second computer system in real time with the interacting and the duplicating without a human tester), programmatically analyzing a result of the operation on the first computer system against a result of the operation on the second computer system, and notifying the human tester (by way of the first computer system) when the result of the operation on the second computer system is unexpected. | 02-03-2011 |
| 20110047530 | Method and System for Testing a Software Program - Methods and systems for testing a software program are provided. The methods include receiving a textual input for testing at least one static type used by the software program. The textual input of an embodiment is pre-linked to the at least one static type. The method includes creating a dynamic type based on the textual input in a dynamically typed language. The dynamic type is populated based on a predefined set of test vectors and is then passed on to the software program. The software program is executed using the dynamic type. Executing the software program by using the dynamic type invokes the at least one static type used by the software program. | 02-24-2011 |
| 20110055815 | Incremental Runtime Compliance Validation of Renderable Objects - Mechanisms are provided for debugging a graphical user interface (GUI) of a computer application code. The mechanisms detect a user interaction with a first renderable object of the GUI during execution of the computer application code. The mechanisms identify one or more second renderable objects of the GUI that are reachable from the first renderable object based on an identity of the first renderable object and a type of the user interaction. Moreover, the mechanisms apply one or more compliance rules to the first renderable object and one or more second renderable objects, the compliance rules specifying requirements for at least one relationship between the first renderable object and the one or more second renderable objects. Additionally, the mechanisms output results of the application of the one or more compliance rules to the first renderable object and one or more second renderable objects. | 03-03-2011 |
| 20110067004 | WEB-BASED INTEGRATED TEST AND DEBUGGING SYSTEM - A computer-implemented method, system, and computer program product for a web-based integrated test and debugging system is provided. The method includes configuring a proxy widget on a server to communicate with a debug widget on a browser, and configuring the proxy widget to communicate with an integrated development environment (IDE) external to the server. The method also includes running a process on the server associated with one or more process-control widgets on the browser. The method further includes polling the IDE via the proxy widget to access a debug and test infrastructure of the IDE for debug data associated with the process, and relaying the debug data associated with the process from the proxy widget to the debug widget to provide web-based integration of testing and debugging on the browser while the process is running on the server. | 03-17-2011 |
| 20110078661 | MARKER CORRELATION OF APPLICATION CONSTRUCTS WITH VISUALIZATIONS - The use of marker(s) in the source code of a program under evaluation. A representation of the marker(s) remains in the binary version of the program under evaluation. During execution, upon executing the marker, data is gathered regarding the timeline of the execution of the marker in the context of overall timeline of execution. A visualization of the marker is then displayed that illustrates the execution of the marker in the context of a larger timeframe of execution. Optionally, the marker may be associated with text, or other data, at least some of which being rendered with the visualization. Accordingly, an application developer, or indeed anyone evaluating the program, may place markers within source code and/or evaluate the timeline of execution of those markers. | 03-31-2011 |
| 20110078662 | Debugging a Graphical Program Deployed on a Programmable Hardware Element - Debugging a graphical program deployed on a programmable hardware element. The graphical program may be received. The graphical program may include a plurality of nodes and connections between the nodes which visually represents functionality of the graphical program. A hardware description may be generated based on the graphical program. The hardware description may describe a hardware implementation of the graphical program. The hardware description may be deployed to the programmable hardware element and the programmable hardware element may be executed. The graphical program may be displayed on a display of a host computer system that is coupled to the programmable hardware element. Debugging information may be received from the programmable hardware element during said executing. The debugging information from the programmable hardware element may be displayed in the graphical program displayed on the display. The displayed debugging information may be used to debug the hardware implementation of the graphical program. | 03-31-2011 |
| 20110083123 | AUTOMATICALLY LOCALIZING ROOT ERROR THROUGH LOG ANALYSIS - A computerized method for automatically locating a root error, the method includes receiving a first log having one or more log messages produced by one or more successful runs of a program, creating a finite state machine (FSM) from the first log of the program, the FSM representing an expected workflow of the program and creating a graph from the first log, the graph illustrating one or more dependencies between two or more components in the program. The method then includes receiving a second log produced by an unsuccessful run of the program, and determining, using a microprocessor, one or more root errors in the second log using the FSM and the graph. | 04-07-2011 |
| 20110088014 | AUTOMATED TEST EXECUTION PLAN GENERATION - A set of user-configured testing parameters for a software application under test can be received by a test execution plan generation tool. At least one testing objective for the software application can be defined by user-configurable testing parameters. A test execution plan can be automatically generated utilizing the user-configured testing parameters and a predefined test execution plan data model. The predefined test execution plan data model can include testing metadata representing software testing domain data for a software testing system being used to evaluate the software application under test. The testing metadata can specify details of finite shared resources of a test center shared by all projects under test. The generated test execution plan can detail specific allocation of the finite shared resources dedicated towards at least one phase of testing the software application to satisfy the at least one testing objective for the software application. | 04-14-2011 |
| 20110088015 | SYSTEM AND METHOD FOR REMOTELY DEBUGGING APPLICATION PROGRAMS - A method, system, and apparatus for debugging an application program from a workstation that is remote from a server on which the application program resides includes invoking the application program from the workstation via a network interface; displaying a user frame at the workstation that includes information generated by the application program; providing a debug view option at the workstation for generating a debug frame of the application program; and displaying the debug frame at the workstation when the debug view option is selected. A user can select options to switch between the user frame and the debug frame. The debug frame includes information about one or more components of the application program such as a list of the variables or objects, and the fields, methods, and/or the constructors associated with them. When the debug view option is selected, the information for the user frame is saved, and can be restored to regenerate the information on the user frame when the user view option is selected. The developer can view internal, public, and private code associated with the application program without compromising the security of other application programs on the server. This ability to remotely debug application programs in accordance with the present invention is thus more time and cost efficient than previous methods, and also alleviates concerns about security and unauthorized access to the server. | 04-14-2011 |
| 20110107304 | Quality Assurance Testing - A quality assurance system has a test generator for applying tests to an application program and a correlator for logging events that occur during testing in correlation with test steps so as to generate a test log. The quality assurance program has a user interface for providing an interactive presentation displaying a list of events and a list of test steps such that: 1) selecting a test step will cause a correlated event to be highlighted, and 2) selecting an event will cause a correlated test step to be highlighted. | 05-05-2011 |
| 20110107305 | Visualizing Thread Life Time in Eclipse - A computer method involving receiving by an integrated development environment component an output file from a thread tracking component, generating a Gantt chart of a thread from the output file to visualize a life of the thread, and displaying the Gantt chart to a requesting user. | 05-05-2011 |
| 20110107306 | MULTI-VIEW DEBUGGING - Debugging an executing process. A method includes accessing a unique key that is common to two or more different representations of a same function in the process. A runtime for the executing process is annotated with the unique key. The method further includes detecting that the function is executing. The unique key is used to provide an indication in one or more of the two or more different representations that the function is executing. | 05-05-2011 |
| 20110107307 | Collecting Program Runtime Information - System(s), method(s), and computer program product(s) for collecting program runtime information are provided. In one aspect, this comprises: an instrumentation module for inserting, by program instrumentation, monitoring code into the constructor of an exception class in a program to run; and a monitoring module implemented by said monitoring code, the monitoring module for collecting program runtime information during the running process of the program. In another aspect, this comprises: obtaining verification point variables from assertions for a program to be tested; inserting monitoring code into positions in the program that access the obtained verification point variables; and as the program runs, collecting runtime information of the program by the inserted monitoring code. | 05-05-2011 |
| 20110113405 | AUTOMATED METHOD AND SYSTEM FOR COLLECTING AND REPORTING API PERFORMANCE PROFILES - A method to measure the performance of an Application Programming Interface (API) includes selecting a target API and tracking memory allocation for the functional calls of the selected API to generate a list of functions called by the API. The individual functions are then called within the API in isolation and timing and memory allocation data for each are collected and recorded. The recorded results are then bucketized according to a log base 2 method and made accessible by API users to indicate the performance of specific APIs. | 05-12-2011 |
| 20110119654 | DEBUGGING SERVICES FOR DOMAIN SPECIFIC LANGUAGES - A computer system displays an interactive development environment including a domain specific language (DSL) grammar input receiving area that allows the user to view and interact with DSL grammar inputs, a DSL language input receiving area that allows the user to view and interact with DSL language inputs and a parse output area that allows the user to view the current state of the DSL parser. The computer system begins stepping through each DSL language input to determine whether the DSL language inputs have created an error relative to the DSL grammar. The computer system also presents the resulting output for each DSL language input, so that as the user provides subsequent step inputs, the interactive development environment successively steps through each DSL language input and presents, at each step, the DSL grammar inputs, the DSL language inputs and the corresponding output in the parse output area. | 05-19-2011 |
| 20110126172 | SYSTEMS AND METHODS FOR VIRTUAL MACHINE THREAD TRACING - Embodiments of the invention broadly contemplate systems, methods, apparatuses and program products providing a mechanism in a run-time environment or Virtual Machine (VM) which enables a user to specify the combination of method(s) and thread(s) the user wants to collect traces for, without having to make any modifications to the application source code. | 05-26-2011 |
| 20110131551 | GRAPHICAL USER INTERFACE INPUT ELEMENT IDENTIFICATION - Systems, methods, and other embodiments associated with graphical user interface input element identification are described. One example system identifies a graphical user interface (GUI) element through which an input to an application was received based on comparing images generated from data provided by the application. Data that describes the GUI element may then be provided. | 06-02-2011 |
| 20110131552 | AUGMENTING VISUALIZATION OF A CALL STACK - In one embodiment, a method comprises the steps of obtaining software architecture information for describing software architecture of the software; parsing the software architecture information to generate a set of module objects, wherein the module objects correspond to software modules of the software; obtaining a call object of the software call stack, wherein the call object corresponds to a method or function executed when the software is running; comparing an invocation interface of the module object with the call object; and associating corresponding information of the module object with the call object of the software call stack according to a comparison result. | 06-02-2011 |
| 20110138360 | LEVERAGING THE RELATIONSHIP BETWEEN OBJECT IDs AND FUNCTIONS IN DIAGNOSING SOFTWARE DEFECTS DURING THE POST-DEPLOYMENT PHASE - A hashing tool can be used to generate Object UIDs from a software application. The software application can be tested. A change and release management system can receive Object UIDs involved in a defect uncovered during the testing. The change and release management system can receive names of functions involved in the defect uncovered during the testing and defect fixing. A graphical representation of function names versus Object UIDs for which the defect occurred can be created. | 06-09-2011 |
| 20110138361 | COMPUTER METHOD AND APPARATUS FOR DEBUGGING IN A DYNAMIC COMPUTER LANGUAGE - A computer based method and apparatus generate a class relationship diagram of dynamic language objects. In response to a user selecting a subject object implemented in the dynamic language, a diagramming member forms and displays a class relationship diagram of the subject object The class relationship diagram visually illustrates relationships between the subject object and objects it inherits from and objects it contains as extracted from the inheritance chain of the subject object. UML or graph notation may be employed in the generated class relationship diagram. | 06-09-2011 |
| 20110145794 | ENTERPRISE JAVABEANS EXPLORER - 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. | 06-16-2011 |
| 20110154293 | SYSTEM AND METHOD TO IDENTIFY PRODUCT USABILITY - A data entry device is provided to enter data related to usability of a user interface of a product. A processor provides a usability score card on the data entry device. The score card facilitates entry of usability issues regarding the user interface, and entry of data related to three dimensions of each issue including a risk severity, a probability of occurrence of the issue, and a probability of detecting the issue. The processor processes the data to provide an overall usability score of the user interface. | 06-23-2011 |
| 20110154294 | Relational Modeling for Performance Analysis of Multi-Core Processors - 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. | 06-23-2011 |
| 20110154295 | Design Time Debugging - A design time debugging tool provides debugging information available from the compiler during design time, as if a user were debugging code that provided the debugging information, by exposing information available from the compiler without initiation of a debugging session and without executing the program being debugged. | 06-23-2011 |
| 20110161933 | SOFTWARE DEFECT TRACKING - An apparatus, system, and method are disclosed for improved tracking of software item defects. The approach involves maintaining defect attributes for a particular software bug. Certain attributes are user-defined while others are derived. Attributes may be, for example, questions, requests for action, requests for approval, or others. The primary attributes and derived attributes for the bug are associated with users that are associated with the software bug, and a determination is made as to whether or not action is required by the individual users for the software bug using the attributes. If action is required, the user is alerted that action is required for the software bug. The actions and/or bugs may be presented to the user using an inbox format. The inbox may sort actions based on priority, what type of attribute is relevant to the user, or using other categorizations. | 06-30-2011 |
| 20110161934 | GENERATING AND MONITORING DATA ITEMS - A method and apparatus for generating dummy data for use in testing a data processing application using a computing device having a processor, a memory, a display device and an input device. A developer specifies attributes of dummy data, and specifies at least one probability distribution. A representation of the probability distribution is then shown on the display device and the probability distribution is applied to the specified attributes to generate dummy data values. | 06-30-2011 |
| 20110173589 | Cross-Browser Interactivity Testing - Multi-browser interactivity testing connects a leader browser and one or more follower browsers. Direct user input to the follower browsers is blocked. User input to the leader browser directed at a Document Object Model element is intercepted. A corresponding element is located in each follower browser, using attribute values or other mechanisms. The user input is applied to the leader element, and applied to the follower element(s) by simulated system level events, and the results are displayed in real time on all browsers. Layout which depends on interactive behaviors such as login or accordion controls, and other aspects of interactivity can be tested without manually repeating the input for each browser, and despite differences in the screen territories assigned to an element by different browser's layout engines. The leader and follower browser roles can also be interchanged automatically. | 07-14-2011 |
| 20110173590 | SYSTEM AND METHOD FOR AUTOMATED TESTING OF SOFTWARE APPLICATIONS WITH DYNAMIC USER INTERFACES SPANNING MULTIPLE TECHNOLOGIES - The present disclosure provides a system, method and computer program product that uses abstraction to enable the definition, development and maintenance of testing libraries for both simple and complex user interface controls. The system and method hide the granular details from the test designer while still promoting reuse. Using the system and method, designers can define a library of functionality for common controls that map 1-to-1 with visual controls, which may be re-implemented across many APIs or programming languages. | 07-14-2011 |
| 20110197179 | SIMULATING A LINE OF SOURCE CODE IN A DEBUGGING TOOL - 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. | 08-11-2011 |
| 20110202901 | AUTOMATED SOFTWARE TESTING AND VALIDATION SYSTEM - An automated software testing system allows automated test script generation with fully parameterized scripts, execution, and result correlation in a recreatable and adaptable manner. A software Application Under Test (AUT) is identified and includes a process having Graphical User Interface (GUI) windows, objects and data elements. A test thread tree is generated corresponding to the windows, objects and data elements in the process. A data structure is generated to enumerate test cases indicative of the windows, objects and data elements in the AUT process. Also generated is a parameterized script indicative of each of the test cases and having string values instead of hard-coded data of the AUT process. A global change manager automates modifying in the data structure, data object attributes across multiple scripts. A Scenario view or data generation member generates Test Descriptions and automates documentation of test cases based on the script. The script is executed to apply each of the test cases to the AUT and receive a response for each test case from the AUT. | 08-18-2011 |
| 20110209122 | FILTERED PRESENTATION OF STRUCTURED DATA AT DEBUG TIME - A debugger provides a user interface for specifying filters of data structure data values. A programmer or the like specifies desired filters using the user interface. The debugger applies these filters to determine how to present program data, for example, at a breakpoint, or during a post-mortem inspection of program data. | 08-25-2011 |
| 20110214107 | METHOD AND SYSTEM FOR TESTING GRAPHICAL USER INTERFACES - A method for testing and monitoring a graphical user interface (GUI) comprises capturing a screenshot of the GUI; extracting at least one graphical element from the screenshot of the GUI; generating a test script based on at least one action and at least one parameter assigned to the at least one extracted graphical element; executing the test script to test at the least functionality and visual of the at least one extracted graphical element; and reporting the test results. | 09-01-2011 |
| 20110225567 | IDENTIFICATION OF USER INTERFACE CONTROLS - A mechanism is disclosed for identifying non-standard user interface controls in a target application. The mechanism includes an accelerator, an agent, and a dialog. The agent is configured to be installed into the target application and to interface with the accelerator. The dialog is configured to select non-standard controls in the target application where each non-standard control includes a set of properties. The agent is configured to provide the properties of the selected non-standard controls to the accelerator. The accelerator is configured to determine a set of common properties for the selected non-standard controls and to automatically generate an identification rule for the determined set of common properties. | 09-15-2011 |
| 20110231823 | AUTOMATED VISUAL TESTING - Some embodiments of a system and a method to automate visual testing of an application have been presented. For instance, images generated by the application under test can be automatically captured. To reduce false positives in the automated visual testing, masks are applied onto the images to filter out some predetermined parts of the images. Then the masked images are compared with a set of predetermined patterns. Differences between the masked images and the predetermined patterns may be reported. | 09-22-2011 |
| 20110246968 | Code-Clone Detection and Analysis - Techniques for detecting, analyzing, and/or reporting code clone are described herein. In one or more implementations, clone-code detection is performed on one or more source code bases to find true and near clones of a subject code snippet that a user (e.g., a software developer) expressly or implicitly selected. In one or more other implementations, code clone is analyzed to estimate the code-improvement-potential (such as bug-potential and code-refactoring-potential) properties of clones. One or more other implementations present the results of code clone analysis with indications (e.g., rankings) of the estimated properties of the respective the clones. | 10-06-2011 |
| 20110246969 | SYSTEM, METHOD AND COMPUTER PROGRAM PRODUCT FOR DEBUGGING AN ASSERTION - In accordance with embodiments, there are provided mechanisms and methods for debugging an assertion. These mechanisms and methods for debugging an assertion can enable improved interpretation and analysis of data validation results, more efficient development associated with data validation, etc. | 10-06-2011 |
| 20110252405 | DETECTING USER INTERFACE DEFECTS IN A SOFTWARE APPLICATION - One embodiment is a method that displays an inspection tool and output generated by a software application being tested for defects. The method detects a defect in a user interface of the output of the software application and generates an annotation of the defect. | 10-13-2011 |
| 20110258603 | METHOD AND SYSTEM FOR SIMULATING AND ANALYZING CODE EXECUTION IN AN ON-DEMAND SERVICE ENVIRONMENT - In accordance with embodiments, there are provided mechanisms and methods for simulating and analyzing code execution in a multi-tenant environment. These mechanisms and methods for simulating and analyzing code execution in a multi-tenant environment can enable embodiments to provide an improved interface for analyzing the performance of application on the multi-tenant database. The ability of embodiments to provide better analysis of simulated execution can enable higher quality application developed in less time. | 10-20-2011 |
| 20110258604 | Collapsible Stack Trace - A tool for analyzing software is enhanced to provide multiple views of a stack trace, with each view having a different level of detail. Different views may be lightly simplified, moderately simplified, or heavily simplified. The display of a complete stack trace includes entries for all stack frames in the stack trace. The display of a simplified stack trace includes entries for fewer than all stack frames in the stack trace, thereby “hiding” or “collapsing” entries for some of the stack frames, relative to the complete stack trace display. After a user specifies a level of complexity with which to show a stack trace, the enhanced analysis tool GUI updates the stack trace display according to the specified level. A complexity level is associated with a set of heuristics that is used to create a view of a stack trace at that complexity level. | 10-20-2011 |
| 20110271257 | DEFECT MANAGEMENT IN INTEGRATED DEVELOPMENT ENVIRONMENTS - A method for managing defects in an integrated development environment is disclosed herein. In one embodiment, such a method includes identifying one or more files associated with a defect. These one or more files may then be linked to the defect using a tag or other suitable linking mechanism. Once the files are linked to the defect, the method may allow the defect to be selected from a defect list. The files associated with the defect are optionally displayed upon selecting the defect. The method further enables an action to be selected for one or more of the files associated with the defect in the defect list. The method then automatically performs the action on the one or more files. A corresponding apparatus and computer program product are also disclosed herein. | 11-03-2011 |
| 20110276947 | CONTEXT-BASED EVALUATION OF EQUATIONS - Some embodiments provide a system that facilitates the evaluation of an equation. During operation, the system obtains one or more data-access functions to be used in the equation. Next, the system obtains an analysis context for the equation separately from the data-access functions. The analysis context may include one or more analysis parameters that specify one or more data sources and/or types of analysis to be used in evaluating the equation. Finally, the system evaluates the equation using the data-access functions and the data sources. | 11-10-2011 |
| 20110289481 | USER INTERFACE ANALYSIS MANAGEMENT - A target shim injected into a target process detects activity in a user interface and sets a target-busy status. A source shim injected into a source process detects the input being sent toward the target process to drive automated testing. The source shim determines that the target-busy status is set, and prevents the source process from sending the input until the status is clear. The target shim clears the status after confirming that a screen capture, accessibility test, localizability test, or other user interlace analysis operation has completed. Multiple source shims and/or multiple target shims may be present. Copies of a single automation shim component may be tailored for use as source shims or as target shims. Security processes and operating system processes may be listed to prevent interference from automation shims. User interface analysis module(s) may be loaded and/or unloaded “hot” while the target process is running. | 11-24-2011 |
| 20110289482 | PERFORMANCE DETECTION AND DEBUGGING OF APPLICATIONS - The system and method establish a baseline of a parameter of an application. The parameter can be based on time spent in a function, out of range variables, memory allocations, memory de-allocations, page faults, time spent in a section of code, time spent in a line of code, and the like. The baseline is done while the application is operating. A threshold for the parameter is generated by the system and/or defined by a user. The system then breaks into a debugger and/or stores state information when the threshold is met. | 11-24-2011 |
| 20110307867 | Creating Hierarchical Message Sequence Charts for Visualizing User-Interactive Applications - In one embodiment, access use information associated with a user-interactive software application, the use information identifies one or more transitions between specific ones of one or more displayable views of the software application and one or more corresponding user actions that cause the transitions; and construct a hierarchical message sequence chart (hMSC) comprising one or more basic message sequence chars (bMSCs) and one or more edges linking specific ones of the bMSCs to represent the use information, comprising: represent the views and the user actions with respect to the views identified in the use information with the bMSCs; represent the transitions and the user actions that cause the transitions identified in the use information with the edges; and for each one of the transitions identified in the use information, link the bMSCs representing the views associated with the transition with the edge representing the transition. | 12-15-2011 |
| 20110314451 | VALIDATING TRANSLATIONS OF EXTERNALIZED CONTENT FOR INCLUSION IN AN APPLICATION - A method and system for validating translated files for inclusion in an application being developed. Translatable files having externalized content in a single base language are sent for translation into other languages. Translated files resulting from a translation of the translatable files are received. Each translated file is statically and dynamically validated to detect error(s). The static validation is based on comparing the translatable files to the translated files. The dynamic validation is based on a simulation of how a user interface of the application presents the externalized content, without including an actual presentation of the externalized content by the user interface. Modified translated files that correct the detected error(s) are received and provided for a presentation of the externalized content by the user interface. | 12-22-2011 |
| 20110321013 | INTERACTIVE ENVIRONMENT FOR TEST CASE GENERATION ASSOCIATED WITH A COMPUTER CODE - A method of generating test cases for a given computer code is provided. The method includes: building a method call graph for a computer code under test, wherein the method call graph holds method calls between code elements of the code; presenting code elements having relevancy for testing for a portion of the computer code in response to a selection of the portion, wherein the relevancy is determined using the method call graph; associating test values for code elements in response to selection from a suggested range of test values generated for each selected code element respectively; and generating a test case useable for testing the selected portion of computer code, wherein the test case refers to the selected code elements relevant for the selected portion with the associated selected values, wherein at least one of the building, the presenting, the associating, and the generating is executed by a processor. | 12-29-2011 |
| 20110321014 | TESTING COMPATIBILITY OF A COMPUTER APPLICATION - 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. | 12-29-2011 |
| 20120023482 | SYSTEM AND METHOD FOR USE IN INDICATING EXECUTION OF APPLICATION CODE - A method for use in indicating an execution of application source code. Application object code is generated based on application source code. The application object code includes a plurality of object code portions of interest corresponding to a plurality of source code portions of interest within the application source code. For each execution of an object code portion of interest, an execution event is associated with the corresponding source code portion of interest. Source code portions of interest may be assigned an execution frequency based on a quantity of associated execution events. | 01-26-2012 |
| 20120023483 | SYSTEM AND METHOD FOR USE IN INDICATING EXECUTION OF APPLICATION CODE - A method for use in indicating an execution of application source code. Application object code is generated based on application source code. The application object code includes a plurality of object code portions of interest corresponding to a plurality of source code portions of interest within the application source code. An execution breakpoint is associated with each object code portion of interest. When an object code portion of interest is executed, the corresponding execution breakpoint is removed, and an execution event is associated with the corresponding source code portion of interest. Source code portions of interest that are associated with an execution event may be indicated by a presentation interface. | 01-26-2012 |
| 20120023484 | AUTOMATION OF TESTING FOR USER INTERFACE APPLICATIONS - A host software application implementing business processes and providing a graphical display associated with a user interface (UI) for a user in a client program executing on a client frontend device that is separate from a backend device storing metadata associated with the UI may be initiated. An automation graphical symbol may provide the user with an option to initiate a test on events of the host software application, during execution of the host software application. A request from the user may be received, to initiate a test on events of the host software application. Information may be received from the user indicating one or more selected specific events for performing the test. The test may be initiated on the selected specific events, based on a state of execution of the host software application at an initial time of the user indicating the selected specific events for performing the test. | 01-26-2012 |
| 20120023485 | Dynamic Test Scripts - 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.). | 01-26-2012 |
| 20120030655 | Generating and Modifying Textual Code Interfaces from Graphical Programs - A graphical program is analyzed, where the graphical program includes an I/O interface including one or more ordered parameters for providing input to or receiving output from the graphical program. A function is generated in a textual programming language based on the analyzing, where the function implements the functionality of the graphical program, and includes a textual function I/O interface with the one or more ordered parameters of the I/O interface of the graphical program. User input is received specifying a modified textual function I/O interface that differs from the textual function I/O interface. A wrapper for the function is generated with the modified textual function I/O interface, where the wrapper includes the function, and where during execution the wrapper receives or outputs values in accordance with the modified textual function I/O interface, and provides values to or receives values from the function via the textual function I/O interface. | 02-02-2012 |
| 20120042302 | SELECTIVE REGRESSION TESTING - The present disclosure includes systems and methods for a selective regression testing. One method for selective regression testing includes grouping a number of test cases into a number of groups, analyzing a modification that is to be accomplished on a computing system to determine a level of risk of the modification to the computing system, applying one or more rules to determine which groups of test cases to apply to test the modification based upon the determined level of risk, and selecting one or more of the groups of test cases based upon the application of the one or more rules. | 02-16-2012 |
| 20120047490 | ARCHITECTURE FOR STATE DRIVEN TESTING - An architecture for a test script editor that can be used by anybody in the development team, including non-programmer business analyst testers. Software testers can generate test scripts for validating and verifying software without navigating all possible actions or keywords. The current application state is described with one or more test objects. Each test object has one or more associated test methods and each test method can describe one or more state transitions. Only test methods accessible through test objects in the current application state are displayed to the software tester. The current state changes only if the state transition described by the test method selected by the software tester indicates a change from the current state. | 02-23-2012 |
| 20120084758 | Collaborative Software Debugging In A Distributed System With Client-Specific Variable Evaluation - In a distributed system that includes a debug server and debug clients coupled for data 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, by the debug server from the debug clients asynchronously during a debug session of the debuggee, a plurality of application-level messages; routing, by the message router in accordance with an application-level message passing protocol, the application-level messages among the debug clients, the debug administrator, and the back-end debugger, including providing distributed control of the back-end debugger to the debug clients with application-level messages routed to the back-end debugger; and returning, by the debug server to the debug clients in response to the application-level messages routed to the back-end debugger, client-specific debug results. | 04-05-2012 |
| 20120089965 | APPLICATION SERVICES SOURCE REFACTORING - An embodiment of the disclosure can compile source of an interactive application with debug options enabled. Execution activity of the interactive application can be enabled. A code path of a selected service of the interactive application can be executed in a debug environment using a user interface of the selected service to identify execution data associated with the selected service. Unresolved branch conditions in the execution data can be addressed for each code path of the selected service. A source extraction of the selected service can be performed. | 04-12-2012 |
| 20120096437 | STEP GRANULARITY SELECTION IN A SOFTWARE DEBUGGER - 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. | 04-19-2012 |
| 20120096438 | CHECKPOINT ENTRY INSERTION DURING TEST SCENARIO CREATION - A test module can be configured to initiate test scenario creation for a target application, and an interaction entry definition module can be configured to define, during the test scenario creation, a plurality of interaction entries representing a sequence of user interactions with a plurality of user interface elements of the target application. A test scenario compiler can be configured to include the plurality of interaction entries in a test scenario file representing a test scenario, and a checkpoint entry definition module can be configured to receive an indicator that a property of a user interface element from the plurality of user interface elements has been selected for verification, and configured to define a checkpoint entry configured to trigger verification of the property of the user interface element from the plurality of user interface elements based on the test scenario file during test scenario verification of the target application. | 04-19-2012 |
| 20120096439 | TRACEABILITY IN A MODELING ENVIRONMENT - 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. | 04-19-2012 |
| 20120102463 | Collaborative Software Debugging In A Distributed System With Multi-Member Variable Expansion - In a distributed system that includes a debug server and debug clients coupled for data 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 a request from a requesting debug client to notify other debug clients of an expansion of a multi-member variable; routing the application-level messages among the debug clients, the debug administrator, and the back-end debugger, including providing distributed control of the back-end debugger to the debug clients and distributing, to the other debug clients, a notification of the expansion of the multi-member variable; and returning to the debug clients in response to the application-level messages routed to the back-end debugger, client-specific debug results. | 04-26-2012 |
| 20120102464 | Collaborative Software Debugging In A Distributed System With Collaborative Step Over Operation - In a distributed system that includes a debug server and debug clients coupled for data 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 step over command that includes an instruction to ignore, during the step over command, events established by the requesting debug client; routing the application-level messages among the debug clients, the debug administrator, and the back-end debugger, including providing distributed control of the back-end debugger and routing the step over command to the back-end debugger; performing the step over command, including ignoring the events established by the requesting debug client and processing any other events; and returning, to the debug clients in response to the application-level messages routed to the back-end debugger, client-specific debug results. | 04-26-2012 |
| 20120102465 | Collaborative Software Debugging In A Distributed System With Client-Specific Access Control - In a distributed system that includes a debug server and debug clients coupled for data communications through a data communications network, where the server includes a debug administrator, a message router, a back-end debugger, and a debuggee, collaborative software debugging includes receiving, by the debug server, a plurality of application-level messages, including receiving, from a session owner, a request to enable a predefined operational mode; enabling the predefined operational mode; routing, by the message router in accordance with an application-level message passing protocol and in accordance with the enabled predefined operational mode, the application-level messages among the debug clients, the debug administrator, and the back-end debugger, including providing distributed control of the back-end debugger to the debug clients with application-level messages routed to the back-end debugger; and returning, by the debug server to the debug clients in response to the application-level messages routed to the back-end debugger, client-specific debug results. | 04-26-2012 |
| 20120102466 | Collaborative Software Debugging In A Distributed System With Graphic Representation Of Source Code Ownership Assignments - In a distributed system that includes a debug server and debug clients coupled for data 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 a request to assign ownership of a portion of source code; routing the application-level messages among the debug clients, the debug administrator, and the back-end debugger, including providing distributed control of the back-end debugger and forwarding, to the debug administrator, the request to assign ownership of the portion of source code; assigning ownership of the portion of the source code to the owning debug client; and returning, to the debug clients, client-specific debug results, including returning to the debug clients a description of the assignment of ownership to the owning debug client. | 04-26-2012 |
| 20120102467 | Collaborative Software Debugging In A Distributed System With Client-Specific Display Location Upon Event Notification - In a distributed system that includes a debug server and debug clients coupled for data 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 presenting a client-specific GUI; detecting user input including receiving a specification of display preferences specifying a preferred location at which to display source code of debuggee upon receipt of an event notification; receiving an event notification of an encountered event, the event notification specifying a location of the encountered event; and displaying client-specific debug results at the preferred location in source code without regard to the location of the encountered event. | 04-26-2012 |
| 20120117541 | Collaborative Software Debugging In A Distributed System With Dynamically Displayed Chat Sessions - In a distributed system that includes a debug server and debug clients coupled for data 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, a request to establish a chat session associated with a location in source code of the debuggee; routing the application-level messages among the debug clients, the debug administrator, and the back-end debugger; returning client-specific debug results, including sending, to the debug clients, a notification of an established chat session; and administering, by the message router, chat content for the established chat session among debug clients. Debug clients display the chat content in a chat box at the location in source code when the view of source code includes the location. | 05-10-2012 |
| 20120117542 | Collaborative Software Debugging In A Distributed System With Client-Specific Event Alerts - In a distributed system including a debug server and debug clients coupled for data communications through a network, where the debug server includes a debug administrator, message router, back-end debugger, and a debuggee, collaborative software debugging includes: presenting a client-specific GUI; detecting user input through the GUI, including user input specifying a location to establish an event; establishing a client-specific event alert to be invoked upon receipt of an event notification for the event; generating application-level messages, including a request to establish the event; sending application-level messages to the debug server, including the request; receiving client-specific debug results, including an event notification for the event; and displaying the client-specific debug results, including invoking the client-specific event alert responsive to the event notification, without invoking an alert by at least one of the other debug clients receiving the event notification. | 05-10-2012 |
| 20120117543 | Collaborative Software Debugging In A Distributed System With Client-Specific Display Of Local Variables - In a distributed system that includes a debug server and debug clients coupled for data communications through a network, collaborative software debugging includes presenting a client-specific GUI that includes a client-specific local variables pane; detecting user input including detecting, by at least one particular debug client, user input setting the client-specific local variables pane to display local variables of a stack frame associated with an active routine owned by the particular debug client; generating and sending to the debug server application-level messages; receiving client-specific debug results; and displaying the client-specific debug results, including: displaying, in the particular debug client's client-specific local variables pane, the local variables of the stack frame associated with the active routine owned by the particular debug client; and displaying, in another debug client's client-specific local variables pane, local variables of another stack frame. | 05-10-2012 |
| 20120124557 | AUTO RETRACT AND BACKGROUND WARM UP - 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. | 05-17-2012 |
| 20120124558 | SCENARIO TESTING COMPOSABILITY ACROSS MULTIPLE COMPONENTS - Testing of multi-layered software using a scenario description that includes multiple action descriptions that are each interrelated in accordance with a scenario flow. Test software is run against each of at least some of the layers in the software. For each layer, an execution context is identified. Code is then identified and run for each action description and each execution context. | 05-17-2012 |
| 20120124559 | Performance Evaluation System - A computer implemented method and system for concurrently evaluating performance of multiple users in one or more tests provides a performance evaluation platform that is accessible to a client application on each of multiple client devices via a network. The client application manages interaction of the users with the performance evaluation platform via the network. The client application, in communication with the performance evaluation platform, configures an adaptive test environment at each of the client devices of the users based on one or more tests selected by the users. The client application on each of the client devices loads the selected tests from the performance evaluation platform and transmits solution responses to the selected tests acquired from the users to the performance evaluation platform. The performance evaluation platform configures processing elements for concurrently processing the solution responses and concurrently evaluates the performance of the users in the selected tests. | 05-17-2012 |
| 20120131556 | XPATH-BASED SELECTION ASSISTANCE OF GUI ELEMENTS DURING MANUAL TEST SCRIPT AUTHORING FOR XML-BASED APPLICATIONS - An automated software testing system can include a test script authoring graphical user interface and an element selection assistant. The test script authoring graphical user interface is an interface for manual test script authoring of an XML representation of a GUI for software applications formed from one or more XML based source code documents. A search section is a user input section within which a user is permitted to input at least one of an XPATH expression and a text string. The element selection assistant can be for searching the XML-based code documents using a search XPATH expression. The search XPATH expression can be the XPATH expression input into the search section or a generated XPATH expression automatically generated from the text string. The result section can present results from the element selection assistant. | 05-24-2012 |
| 20120131557 | INTERACTIVE TROUBLESHOOTING FLOWCHARTS - An interactive troubleshooting system is described herein that provides a dynamically changing user interface that readers click through to solve problems. Each click changes the display of the flowchart so that irrelevant troubleshooting options are unavailable and the reader's path through the overall flowchart is clearly shown. By showing the path, the reader can see the process and the interrelationships between system components and understand more deeply the troubleshooting process beyond the step-by-step troubleshooting tasks. The interactive troubleshooting system clearly displays a path taken through the flowchart, and reduces visual clutter. Upon following a path, sections of the flowchart that cannot be followed due to the steps taken are made unavailable. The interactive troubleshooting system provides a visual indication of areas of troubleshooting focus. The system can record the user's path through the flowchart. Once a root cause is identified, the system can query the user to capture end-of-process feedback information. | 05-24-2012 |
| 20120144373 | Computer Program Testing - Systems, methods and computer-executable instructions for testing computer programs are provided. A computer program (application under test—AUT) is analyzed and data records are created for each user interface object of each screen of the AUT. The data records form a dataset which may be copied and edited to define a series of test functions to be performed on the AUT. Corresponding test code is provided to perform the test functions, the test code referencing the data records of the dataset. | 06-07-2012 |
| 20120151446 | AUTOMATIC RECONNECTION OF DEBUGGER TO A REACTIVATED APPLICATION - Although a software developer writing software for a mobile device typically performs the development and some of the debugging of the application on a software development computer, the application also has to be debugged as it passes through the deactivate, terminate and reactivate states as it executes on the mobile device. To debug an application the developer can launch the debugger on the software development computer. The debugger can launch the application on the mobile device. If an event that terminates the application occurs, the debugger connection is terminated. In accordance with aspects of the subject matter disclosed herein, the debugger is automatically reattached to the restarted (activated) application. Reattaching the debugger automatically to the restarted application allows the developer to debug the mobile device application as an application passing through multiple states rather than debugging multiple instances of an application. | 06-14-2012 |
| 20120151447 | DISPLAY OF DATA FROM PARALLEL PROGRAMMING CONTEXTS - The display of a debugging interface for use with parallel computing. When a break state has been entered in a particular code context (such as a method) by a particular execution context (such as a thread), related execution contexts are found that were also executing in the particular code context. While in the break state, multiple expressions are then evaluated for each of the execution contexts. The results are then displayed with perhaps navigation controls that allow the results to be efficiently navigated. | 06-14-2012 |
| 20120151448 | AUTOMATED TEST EXECUTION PLAN GENERATION - A set of user-configured testing parameters for a software application under test can be received by a test execution plan generation tool. At least one testing objective for the software application can be defined by user-configurable testing parameters. A test execution plan can be automatically generated utilizing the user-configured testing parameters and a predefined test execution plan data model. The predefined test execution plan data model can include testing metadata representing software testing domain data for a software testing system being used to evaluate the software application under test. The testing metadata can specify details of finite shared resources of a test center shared by all projects under test. The generated test execution plan can detail specific allocation of the finite shared resources dedicated towards at least one phase of testing the software application to satisfy the at least one testing objective for the software application. | 06-14-2012 |
| 20120159449 | Call Stack Inspection For A Thread Of Execution - Call stack inspection for a thread of execution, including, for each stack frame in the call stack, beginning with the stack frame at the top of the call stack: inspecting the stack frame; determining whether the stack frame was present in the call stack on a previous inspection of the call stack; if the stack frame was not present on a previous inspection, indicating in the stack frame the stack frame's presence on the current inspection of the call stack; and if the stack frame was present on a previous inspection, notifying a user. | 06-21-2012 |
| 20120159450 | DISPLAYING SUBTITLES - Example methods, apparatus and articles of manufacture to display subtitles are disclosed. A disclosed example method includes selecting a test script that corresponds to an application, and superimposing a subtitle bar including a test instruction from the test script over a portion of a display of the application within a user interface so that the subtitle bar reduces interference with viewing a region of interest of the display, wherein the test instruction provides an action a user is to perform to test the application. | 06-21-2012 |
| 20120159451 | IDENTIFYING THREADS THAT ENCOUNTER AN INSTRUCTION AT WHICH ANOTHER THREAD IS HALTED - In an embodiment, execution of a first thread of a plurality of threads is halted at a first instruction. A subset of the plurality of threads is determined that execute the first instruction while the first thread is halted at the first instruction. Identifiers of the subset of the plurality of threads that execute the first instruction while the first thread is halted at the first instruction are presented via a user interface for the first thread. | 06-21-2012 |
| 20120159452 | GRAPHICAL USER INTERFACE FOR EXPLORING SOURCE CODE EXECUTION BEHAVIOR - Described herein are interactive graphical user interfaces that visualize execution behavior of source code together with theoretical execution behavior of the source code together with the source code itself. Structure of the source code is analyzed to determine theoretical execution behavior of the source code. Thereafter, symbolic execution of the source code is undertaken to output an execution trace. The execution trace is shown together with the theoretical execution behavior of the source code. | 06-21-2012 |
| 20120167051 | ELECTRONIC DEVICE AND METHOD FOR PROGRAM STRUCTURE ANALYSIS - An electronic device for program structure analysis is provided. The electronic device stores at least one program. The electronic device obtains one program from the data storage in response to user input and extracts structure identifiers of the program. After the identifiers of the program are obtained, the electronic device analyzes the obtained structure identifiers according to a predetermined rule to obtain a structure of the program. The structure of the program can be displayed using a table, web, or help file. | 06-28-2012 |
| 20120167052 | METHOD AND SYSTEM FOR PROVIDING A VISUAL DEBUGGER FOR AN INTERPRETED STATISTICAL LANGUAGE - Methods and systems for visual debugging of an interpreted language in, for example, an Interactive Development Environment are provide. Example embodiments provide an S-PLUS Visual Debugging System (“SPVDS”), which includes an S-PLUS Workbench Debugger (“SPWD”) that provides “step-based” visual debugging, enabling programmers to step through execution of expressions by setting and otherwise managing breakpoints, examining variables and expressions, and controlling execution such as by step, step-in, step-out, step-over, continue, stop commands. In addition, the SPWD provides a profiler which tracks the number and duration of calls to functions and the amount of memory allocated to variables. This abstract is provided to comply with rules requiring an abstract, and it is submitted with the intention that it will not be used to interpret or limit the scope or meaning of the claims. | 06-28-2012 |
| 20120167053 | TARGETING CODE SECTIONS FOR CORRECTING COMPUTER PROGRAM PRODUCT DEFECTS USING RECORDS OF A DEFECT TRACKING SYSTEM - An unresolved defect can be identified in a computer program product. It may not be initially known which of a plurality of different code segments of the computer program product are able to be modified to correct to repair the unresolved defect. A subset of the different code segments can be predicted utilizing information contained within a database of previously reported defects. The predicting can be determined based on a set of code segments that were previously modified to correct or repair the previously reported defects as detailed within the database. | 06-28-2012 |
| 20120167054 | Collecting Program Runtime Information - System(s), method(s), and computer program product(s) for collecting program runtime information are provided. In one aspect, this comprises: an instrumentation module for inserting, by program instrumentation, monitoring code into the constructor of an exception class in a program to run; and a monitoring module implemented by said monitoring code, the monitoring module for collecting program runtime information during the running process of the program. In another aspect, this comprises: obtaining verification point variables from assertions for a program to be tested; inserting monitoring code into positions in the program that access the obtained verification point variables; and as the program runs, collecting runtime information of the program by the inserted monitoring code. | 06-28-2012 |
| 20120174072 | RECURSIVE METHOD CALL REPRESENTATION IN A PLOT VIEW OF METHOD EXECUTION PERFORMANCE - Embodiments of the present invention provide a method, system and computer program product for graphically representing recursive method calls in a plot view. In an embodiment of the invention, a method for graphically representing recursive method calls in a plot view includes tracing entry and exit points for method calls in an executing computer program subject to performance testing in a performance test application executing in memory of a computer. The method further includes plotting a duration of execution for each of the method calls in a visual plot according to the traced entry and exit points. Finally, the method includes visually displaying a recursive relationship between selected ones of the method calls in the visual plot in response to determining a recursive relationship from the traced entry and exit points. | 07-05-2012 |
| 20120185829 | Method and system for debugging a job running on a legacy system - The present invention concerns a computer-implemented method for debugging a job running on a legacy system, wherein the method comprises the following steps:
| 07-19-2012 |
| 20120192155 | CODE ADVISOR FOR WEB COMPATIBILITY AND INTEROPERABILITY - Various embodiments provide an investigative tool to enable webpage content to be analyzed. In at least some embodiments, the investigative tool, hereinafter “code advisor”, allows the use of Application Programming Interfaces (APIs) to be tracked. By tracking API use as script for a webpage executes, the code advisor can determine if compatibility and/or interoperability issues exist in regards to webpage content. If an issue does exist, in at least some embodiments, code advisor can select one or more messages associated with the issue and provide guidance to enable the issue to be addressed. | 07-26-2012 |
| 20120192156 | TEST CASE PATTERN MATCHING - A method of providing feedback on source code being created includes receiving source code and processing the received source code according to a predefined rule set to create a representation of the received source code. A source code repository is accessed that includes source code fragments. Each source code fragment in the repository has been processed according to the predefined rule set to create representations of the respective source code fragments. The representation of the received source code is compared to each representation of the source code fragments. A matching score is calculated for the representation of the received source code with respect to each representation of the source code fragments based upon an output of the comparison step. An output derived from the calculated matching scores is presented. | 07-26-2012 |
| 20120198421 | Testing Lifecycle - Systems and methods for testing in a testing lifecycle are described herein. In one embodiment, the testing system includes an extraction module to extract at least one test case pertaining to a requirement associated with a first build, a modified requirement and an incremental requirement associated with an updated build. Further, an execution module executes the extracted test cases on the build to verify the requirement associated with the build. | 08-02-2012 |
| 20120198422 | Cross-Browser Testing of a Web Application - An apparatus for cross-browser testing of a web application is disclosed, including: a first broker residing among a plurality of browsers for receiving information of a user action from a browser operated by a user among the plurality of browsers and for transmitting the information of the user action to other browsers so that the other browsers can execute the user action; a second broker residing between the plurality of browsers and the web application for receiving at least one web request generated by executing the user action from the plurality of browsers and for determining whether to be able to merge the at least one web request, so as to determine whether the plurality of browsers are compatible with the web application. An associated method is also provided. | 08-02-2012 |
| 20120204155 | Systems and Methods for Interactive Testing of a Computer Application - Embodiments of methods, systems, apparatuses, and computer-readable may relate to interactive testing of source code. The method may include executing at least a part of the source code at the processing device and presenting the execution to a user. One or more gestures of the user may be captured while executing the part, where the user provides the gestures based on the execution presented to the user. The gestures may then be associated with the executing part, and a report may be generated that comprises information for the executing part associated with the captured gestures. | 08-09-2012 |
| 20120210305 | Event Management In A Non-Stop Debugging Environment - Event management in a non-stop debugging environment that includes a debugger configured to debug a debuggee, the debuggee including a number of threads of execution, where encountering an event by one of threads stops execution of only the one thread without concurrently stopping execution of other threads and event management includes: encountering, by a first thread, an event that stops execution of the first thread; while execution of the first thread is stopped, encountering, by each of one or more other threads, an event stopping execution of the other thread; queuing, by the debugger, the events stopping execution of the other threads; receiving, by the debugger from a user, an indication to flush one or more events from the queue; and flushing, by the debugger, the one or more events from the queue. | 08-16-2012 |
| 20120222013 | MODELING SOFTWARE BEHAVIOR USING LEARNED PREDICATES - The described implementations relate to analysis of computing programs. One implementation provides a technique that can include accessing values of input variables that are processed by test code and runtime values that are produced by the test code while processing the input variables. The technique can also include modeling relationships between the runtime values and the values of the input variables. The relationships can reflect discontinuous functions of the input variables. | 08-30-2012 |
| 20120222014 | METHOD AND APPARATUS FOR DETECTING SOFTWARE BUGS - A computer-implemented method and apparatus for unit testing, the method comprising: intercepting user interactions when a user is testing a function implemented by user code; recording execution data for the function execution; generating one or more tests based on the execution data, wherein each test is generated in accordance with a heuristic applicable for the function; detecting a code change in the function; and automatically executing the tests function to test the user code as changed. | 08-30-2012 |
| 20120240104 | APPLICATION SERVICES SOURCE REFACTORING - An embodiment of the disclosure can compile source of an interactive application with debug options enabled. Execution activity of the interactive application can be enabled. A code path of a selected service of the interactive application can be executed in a debug environment using a user interface of the selected service to identify execution data associated with the selected service. Unresolved branch conditions in the execution data can be addressed for each code path of the selected service. A source extraction of the selected service can be performed. | 09-20-2012 |
| 20120266138 | Event Management In A Non-Stop Debugging Environment - Event management in a non-stop debugging environment that 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 and event management includes: receiving, by the debugger, a user request to establish a dynamically disabled event that is disabled for all threads upon a stop in execution of any thread; establishing, by the debugger, the dynamically disabled event; identifying, by the debugger, a stop in execution of a particular thread; and disabling, by the debugger, the dynamically disabled event for all threads of the debuggee. | 10-18-2012 |
| 20120266139 | Thread-Specific Watch Event Administration In A Non-Stop Debugging Environment - A non-stop debugging environment includes a debugger configured to debug a multi-threaded debuggee, where encountering an event by one of threads stops execution of only the one thread without concurrently stopping execution of other threads. In the non-stop debugging environment, thread-specific watch event administration includes holding from execution, by the debugger, a thread triggering a watch event; determining, by the debugger, whether the watch event was set for the thread triggering the watch event; if the watch event was set for the thread triggering the watch event, setting, by the debugger, the debug perspective of a GUI to the thread triggering the watch event; and, if the watch event was not set for the thread triggering the watch event: retrieving, by the debugger, watch event information from the thread triggering the watch event; and resuming, by the debugger without user interaction, execution of the thread triggering the watch event. | 10-18-2012 |
| 20120266140 | Impact Indication Of Thread-Specific Events In A Non-Stop Debugging Environment - 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. | 10-18-2012 |
| 20120272216 | Collaborative Software Debugging In A Distributed System With Variable-Specific Messages - 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 client's client-specific GUI along with the evaluation of the variable. | 10-25-2012 |
| 20120272217 | Collaborative Software Debugging In A Distributed System With Execution Resumption On Consensus - In a distributed system that includes a debug server and debug clients coupled for data communications, where the debug server includes a debug administrator, a message router, a back-end debugger, and a debuggee, collaborative software debugging includes receiving a number of application-level messages including a request to resume execution of the debuggee; routing the messages by the message router, providing distributed control of the back-end debugger to the debug clients, including: polling one or more debug clients for approval to resume execution of the debuggee and resuming execution of the debuggee only if a number of debug clients providing approval to resume execution of the debuggee exceeds a predefined threshold, and returning, by the debug server to the debug clients in response to the application-level messages routed to the back-end debugger, client-specific debug results. | 10-25-2012 |
| 20120272218 | Collaborative Software Debugging In A Distributed System With Stacked Run-To-Cursor Commands - In a distributed system that includes a debug server and debug clients coupled for data communications, where the debug server includes a debug administrator, a message router, a back-end debugger, and a debuggee, collaborative software debugging includes receiving a number of application-level messages, including receiving from a requesting debug client a run-to-cursor command; routing the messages among the debug clients, the debug administrator, and the back-end debugger, including: sending, to debug clients, a request for approval to carry out the run-to-cursor command; receiving responses to the request; and commanding the back-end debugger to execute the debuggee to a cursor position of one of the debug clients only after receiving a predefined number of approvals; and returning, by the debug server to the debug clients in response to the application-level messages routed to the back-end debugger, client-specific debug results. | 10-25-2012 |
| 20120272219 | Collaborative Software Debugging In A Distributed System With Symbol Locking - In a distributed system that includes a debug server and debug clients coupled for data 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, from the debug clients, application-level messages, including receiving, from a symbol locking debug client, a request to lock one or more symbols from value modification; routing, by the message router, the application-level messages among the debug clients, the debug administrator, and the back-end debugger, including: establishing a lock for each of the one or more symbols; and returning, to the debug clients, client-specific debug results including, returning, responsive to a request to modify a value of a locked symbol, an indication that the symbol is locked without modifying the value of the locked symbol as requested. | 10-25-2012 |
| 20120272220 | SYSTEM AND METHOD FOR DISPLAY OF SOFTWARE QUALITY - A method for code analysis comprising steps of inputting program code to an analyzer, assigning an objective quality measure to components of the analyzed code; and displaying graphically the objective quality measures. | 10-25-2012 |
| 20120278790 | Collaborative Software Debugging In A Distributed System With Real-Time Variable Modification Indicators - In a distributed system that includes a debug server and debug clients coupled for data 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, by the debug server from the debug clients asynchronously during a debug session of the debuggee, a plurality of application-level messages, receiving, from a requesting debug client, a request to notify other debug clients that the requesting debug client is presently modifying a value of a particular variable; routing, by the message router, the application-level messages among the debug clients, the debug administrator, and the back-end debugger, including distributing to the other debug clients a notification of the modification the value of the particular variable; and returning, to the debug clients, client-specific debug results. | 11-01-2012 |
| 20120278791 | UTILIZING TEMPORAL ASSERTIONS IN A DEBUGGER - A temporal assertion of a computer program may be defined based on a temporal property. A checker may be generated to monitor the temporal assertion and indicate upon a violation thereof. The checker may be operatively coupled to a debugging module operative to execute the computer program in a debugging session. The execution may be paused in response to an indication from the checker of a violation of the temporal assertion, while continuing the debugging session. A user may then review the state of the computer program to assess what caused the assertion to fail and whether such a violation indicates the presence of a bug or not. | 11-01-2012 |
| 20120291017 | DEBUGGER AND DEBUGGING METHODS USING BREAKPOINTS CONDITIONED ON THE STATIC IDENTITY OF DATA - A method of debugging a program includes setting a breakpoint in the program identifying a location within the program, a reference-typed expression that is valid within the scope of the location, and a set of statically-specified data entities to which the expression refers, upon encountering the location during a current run of the program, determining whether the associated expression evaluates to a reference corresponding to one of the statically-specified data entities, pausing the program at the location if a value of the expression refers to one of the statically-specified data entities, and continuing the program without pausing if the value does not refer to one of the statically-specified data entities. | 11-15-2012 |
| 20120297367 | TESTING AN APPLICATION - A device receives a test case from a management server. The test case includes a request used for a test of an application, an expected response to the request, and an identifier of an application server that executes the application. The device transmits, based on the identifier, the request to the application server. The device further receives a test response in reply to the request. The device also generates a test result based on the expected response and the test response, and displays the test result. | 11-22-2012 |
| 20120311537 | PERFORMANCE VISUALIZATION INCLUDING HIERARCHICAL DISPLAY OF PERFORMANCE DATA - Systems and methods provide a display indicating performance characteristics of a computer application. The display may include a call graph having nodes that represent subunits of the application. A first set of statistics for the subunit may be represented in the size or dimensions of the node. A second set of statistics may be displayed in the interior of the node. A third set of statistics may be displayed in response to selecting the node. | 12-06-2012 |
| 20120317548 | USER-SPACE PROBE BASED DEBUGGING - Methods and systems for user-space probe debugging are described. In one embodiment, a computing system receives a request from a user interface to debug a target application. In response to the request, the computing system runs the target application in a debug mode with an attached debugger. The debugger and the target application appear as a single application in a user-space of the computing system. The debugger has access to application memory of the target application. The computing system receives a command to perform a debug operation on the target application, such as setting a breakpoint, reading the application memory, or the like. The debugger performs the debug operation on the target application without communicating with a kernel of the computing system, and outputs debug information after performing the debug operation. | 12-13-2012 |
| 20130007716 | Collaborative Software Debugging In A Distributed System With Private Debug Sessions - In a distributed system that includes a debug server and debug clients coupled for data 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, by the debug server from the debug clients, application-level messages including receiving, from a requesting debug client, a request to establish a private debug session of the debuggee; routing, by the message router, the application-level messages among the debug clients, the debug administrator, and the back-end debugger, including forwarding, to the back-end debugger, the request to establish a private debug session of the debuggee; and; and returning, by the debug server to the debug clients in response to the application-level messages routed to the back-end debugger, client-specific debug results, including establishing the private debug session of the debuggee for the requesting debug client. | 01-03-2013 |
| 20130007717 | Integrating Compiler Warnings Into A Debug Session - Integrating compiler warnings into a debug session including: receiving, by a debugger for a debug session of a debuggee from a compiler, compiled source code for execution and compiler warning data describing one or more compiler warnings generated at compile time of the debuggee, each compiler warning resulting from a source code variable statement in the debuggee source code; receiving, by the debugger, a request to evaluate a variable; determining, from the compiler warning data, whether evaluating the variable is dependent upon a source code variable statement resulting in a compiler warning; and, if evaluating the variable is dependent upon a source code variable statement resulting in a compiler warning, returning, by the debugger responsive to the request along with a result of the evaluation, a compiler warning indicator. | 01-03-2013 |
| 20130007718 | Software Debugging With Execution Match Determinations - Software debugging including: inserting, by a compiler compiling source code into a debuggable program, a phantom breakpoint at one or more lines of source code; including in the program; executing the program including encountering phantom breakpoints and removing each encountered phantom breakpoint; creating, upon exiting execution, a copy of the program that includes only phantom breakpoints not encountered during execution; providing the copy to a debugger; identifying, by the debugger, source code lines of the copy that do not include a phantom breakpoint; inserting an executed phantom breakpoint at the identified lines of the copy; executing the copy of the debuggable program including removing encountered breakpoints; and, after exiting execution of the copy, determining whether execution of the copy matches the execution of the debuggable program including, determining that the executions do not match if any phantom breakpoints were removed from the copy or any executed phantom breakpoint remains in the copy. | 01-03-2013 |
| 20130014085 | VISUAL INTERFACE OF AUTOMATED SOFTWARE TESTING - A system and method for testing a software application, comprising: a structure of actions to be executed by the software application; a visual interface of the software application comprising a plurality of components; and a first link between one of the actions and a corresponding one of the components in the visual interface. | 01-10-2013 |
| 20130014086 | DEBUGGER CONNECTION - 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. | 01-10-2013 |
| 20130019227 | Debugging Inline Functions in Optimized CodeAANM Chiu; Jen-LungAACI RedmondAAST WAAACO USAAGP Chiu; Jen-Lung Redmond WA US - Various embodiments provide an ability to present content associated with an inline function via a code debugging tool. In some embodiments, the code debugging tool can be configured to enable manipulation of commands associated with the inline function. Alternately or additionally, one or more calls to the inline function can be manipulated independently from each other within the debugging tool. | 01-17-2013 |
| 20130024842 | SOFTWARE TEST AUTOMATION SYSTEMS AND METHODS - Described are a system and method for performing an automated quality assessment on a software program under test. A test automation system executes a test on a software program Data related to the test is automatically collected. The data includes first information determined by the test automation system in response to executing the test. The data further includes second information related to the test and received from a source other than the test automation system. The first information is analyzed. A quality assessment of the software program is generated from the analyzed first information and from the second information. | 01-24-2013 |
| 20130024843 | METHODS AND APPARATUS FOR APPLICATION PERFORMANCE AND CAPACITY ANALYSIS - A computer-implemented method is provided for determining the performance of an application platform that includes one or more applications associated with a plurality of resources of a computer system. The method includes disposing a plurality of synthetic resource consumers within the application platform, each synthetic resource consumer configured to consume at least one of the plurality of resources. A workload profile is provided to the plurality of synthetic resource consumers. The workload profile includes parameters specifying resource consumption by the plurality of synthetic resource consumers. Performance data is acquired based on the impact of the workload profile on the plurality of resources and the plurality of applications. | 01-24-2013 |
| 20130024844 | CONTINUOUS EVALUATION OF PROGRAM CODE AND SAVING STATE INFORMATION ASSOCIATED WITH PROGRAM CODE - A device receives an input associated with a program code being created or edited, and determines whether to perform an evaluation on the program code based on the input. The device waits for another input to be received when the evaluation is not to be performed, and performs the evaluation on the program code to generate a result, when the evaluation is to be performed. The device determines whether to display the result, waits for the other input to be received when the result is not to be displayed, and provides the result for display when the result is to be displayed. | 01-24-2013 |
| 20130036403 | METHOD AND APPARATUS FOR DEBUGGING PROGRAMS - A computer-implemented method, apparatus and computer program product for debugging programs, the method comprising: displaying a graphic waveform showing values of one or more state variables of a computer program being debugged in two or more points in time; receiving a user selection from points in time, of an indication to a selected point in time in execution from the graphic waveform; and resuming within a debugger an execution state of the computer program associated with the selected point in time. | 02-07-2013 |
| 20130055207 | DEMAND-DRIVEN ANALYSIS OF POINTERS FOR SOFTWARE PROGRAM ANALYSIS AND DEBUGGING - A “Demand-Driven Pointer Analyzer” (DDPA) provides a “demand-driven” field-sensitive pointer analysis process. This process rapidly and accurately identifies alias sets for selected pointers in software modules or programs of any size, including large-scale C/C++ programs such as a complete operating system (OS). The DDPA formulates the pointer analysis task as a Context-Free Language (CFL) reachability problem that operates using a Program Expression Graph (PEG) automatically constructed from the program code. The PEG provides a node and edge-based graph representation of all expressions and assignments in the program and allows the DDPA to rapidly identify aliases for pointers in the program by traversing the graph as a CFL reachability problem to determine pointer alias sets. In various embodiments, the DDPA is also context-sensitive. | 02-28-2013 |
| 20130061210 | INTERACTIVE DEBUGGING ENVIRONMENTS AND METHODS OF PROVIDING THE SAME - Described are systems and methods for generating interactive in memory objects from stored program failure data. An anomalous condition related to a program failure is detected. Data is captured regarding the anomalous condition. The captured data is stored. The stored data is converted into at least one in-memory object. A runtime environment is reproduced about a region of code related to the program failure from the at least one in-memory object. | 03-07-2013 |
| 20130074042 | VISUALIZING THREAD STATE DURING PROGRAM DEBUGGING - The present invention extends to methods, systems, and computer program products for visualizing thread state during program debugging. A tooltip can present a visual summary of the execution state of the application threads, what the values are, and patterns in the values, during debugging. As such, a developer debugging a parallel application can see the status of threads within a thread block. A visual tooltip (or other presentation mechanism) can be activated by hovering (e.g., placing a mouse pointer) over a user interface element. A visual tooltip can be presented by hovering over a status rollup visualization of the thread states or by hovering over an icon that appears in the code gutter for a code segment. Accordingly, developers can get a concise visual summary of thread states, variables, and values during debugging. | 03-21-2013 |
| 20130074043 | Self Generating Automation System (SGAS) including framework for automation of software functional testing - A business process component based framework enables test automation to be automated using a component generator and a script generator. The framework is implemented as a two-layer structure. A test script on the top layer is a test case with action description of each step. A component on the bottom layer is a representative of an autonomous GUI interface unit, such as a window. The component can execute any actions on any GUI objects on what it represents. In such a framework, each test case becomes a sequence of calling components. Each called component becomes a slave executing the actions. Both script and component become simple enough to be automated. In an exemplary embodiment, a script generator and a component generator are developed to automatically generate test scripts and components, which are implemented with QuickTest Professional, using test cases and GUI repository of components as their input, respectively. | 03-21-2013 |
| 20130074044 | EVENT MANAGEMENT IN A NON-STOP DEBUGGING ENVIRONMENT - Event management in a non-stop debugging environment that includes a debugger configured to debug a debuggee, the debuggee including a number of threads of execution, where encountering an event by one of threads stops execution of only the one thread without concurrently stopping execution of other threads and event management includes: encountering, by a first thread, an event that stops execution of the first thread; while execution of the first thread is stopped, encountering, by each of one or more other threads, an event stopping execution of the other thread; queuing, by the debugger, the events stopping execution of the other threads; receiving, by the debugger from a user, an indication to flush one or more events from the queue; and flushing, by the debugger, the one or more events from the queue. | 03-21-2013 |
| 20130074045 | INTEGRATING COMPILER WARNINGS INTO A DEBUG SESSION - Integrating compiler warnings into a debug session including: receiving, by a debugger for a debug session of a debuggee from a compiler, compiled source code for execution and compiler warning data describing one or more compiler warnings generated at compile time of the debuggee, each compiler warning resulting from a source code variable statement in the debuggee source code; receiving, by the debugger, a request to evaluate a variable; determining, from the compiler warning data, whether evaluating the variable is dependent upon a source code variable statement resulting in a compiler warning; and, if evaluating the variable is dependent upon a source code variable statement resulting in a compiler warning, returning, by the debugger responsive to the request along with a result of the evaluation, a compiler warning indicator. | 03-21-2013 |
| 20130086555 | STEP GRANULARITY SELECTION IN A SOFTWARE DEBUGGER - 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. | 04-04-2013 |
| 20130091493 | Debugging a Graphics Application Executing on a Target Device - Debugging a graphics application executing on a target device. The graphics application may execute CPU instructions to generate graphics commands to graphics hardware for generation of graphics on a display. A breakpoint for the graphics application may be detected at a first time. In response to detecting the breakpoint, one or more graphics commands which were executed by the graphics hardware proximate to the first time may be displayed. Additionally, source code corresponding to CPU instructions which generated the one or more graphics commands may be displayed. | 04-11-2013 |
| 20130097589 | EVENT MANAGEMENT IN A NON-STOP DEBUGGING ENVIRONMENT - Event management in a non-stop debugging environment that 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 and event management includes: receiving, by the debugger, a user request to establish a dynamically disabled event that is disabled for all threads upon a stop in execution of any thread; establishing, by the debugger, the dynamically disabled event; identifying, by the debugger, a stop in execution of a particular thread; and disabling, by the debugger, the dynamically disabled event for all threads of the debuggee. | 04-18-2013 |
| 20130097590 | IMPACT INDICATION OF THREAD-SPECIFIC EVENTS IN A NON-STOP DEBUGGING ENVIRONMENT - 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. | 04-18-2013 |
| 20130097591 | THREAD-SPECIFIC WATCH EVENT ADMINISTRATION IN A NON-STOP DEBUGGING ENVIRONMENT - A non-stop debugging environment includes a debugger configured to debug a multi-threaded debuggee, where encountering an event by one of threads stops execution of only the one thread without concurrently stopping execution of other threads. In the non-stop debugging environment, thread-specific watch event administration includes holding from execution, by the debugger, a thread triggering a watch event; determining, by the debugger, whether the watch event was set for the thread triggering the watch event; if the watch event was set for the thread triggering the watch event, setting, by the debugger, the debug perspective of a GUI to the thread triggering the watch event; and, if the watch event was not set for the thread triggering the watch event: retrieving, by the debugger, watch event information from the thread triggering the watch event; and resuming, by the debugger without user interaction, execution of the thread triggering the watch event. | 04-18-2013 |
| 20130104107 | DATA FLOW VISUALIZATION AND DEBUGGING - Computation execution can be visualized and debugged. A computation such as a database query plan graph can be extracted from a database query expression. Trace points can be injected into the database query expression while preserving original behavior. Query graphs can be generated with automatic inserting of mechanisms to connect to trace points, enabling visualization of query execution lifecycle states, collection of data traces across operators, and historical debugging with replay of data sets. | 04-25-2013 |
| 20130111447 | SUPPORTING DEBUGGING OF PROGRAM AND GRAPHICAL USER INTERFACE FOR SUPPORTING DEBUGGING | 05-02-2013 |
| 20130111448 | STEP GRANULARITY SELECTION IN A SOFTWARE DEBUGGER | 05-02-2013 |
| 20130117730 | INTEGRATED DEBUGGER AND CODE COVERAGE TOOL - A method, information processing system, and computer program product integrate 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. | 05-09-2013 |
| 20130117731 | SOFTWARE TESTING - In one general aspect, a computer-based software testing method is disclosed that includes presenting to a user an interactive visual user interface of an application under test that includes a plurality of user interface controls, with each of the presented user interface controls having a predefined native interaction mode. The method also includes intercepting normative pointing-device-based user interaction with each of a plurality of the user interface controls, with the normative pointing-device-based user interaction mode being different from the native interaction mode. Interface definitions are built for the application based on results of the steps of intercepting for the plurality of interface controls. | 05-09-2013 |
| 20130139127 | SYSTEMS AND METHODS FOR PROVIDING CONTINUOUS INTEGRATION IN A CONTENT REPOSITORY - A mechanism for continuous integration in a content repository is disclosed. A method of the invention includes retrieving by a computing system an application from an archive of the computing system and executing at least one test file corresponding to the application in the archive. The method further includes storing the application and results from executing the at least one test file as metadata for the application in the content repository. | 05-30-2013 |
| 20130152049 | WARNING OF REGISTER AND STORAGE AREA ASSIGNMENT ERRORS - A system for tracking register and/or storage area assignments and warning a programmer of potential assignment errors. More specifically, the system tracks programmer assignments to registers and storage areas and determines if a register or storage area has been modified prior to a call to a program or process external to the source code being examined. The system notes whether a modified register or storage area is restored to its original value subsequent to the external call. If the register or storage area has not been restored, the system displays a warning of a possible assignment error. | 06-13-2013 |
| 20130152050 | SYSTEM AND METHOD FOR DATA COLLECTION AND ANALYSIS OF INFORMATION RELATING TO MOBILE APPLICATIONS - A system and method are provided for data collection and analysis of information related to applications. Specifically, the developer of the application may install analytic software, which may be embodied as a software development kit (SDK), on an integrated development environment (“IDE”) associated with the developer, wherein the analytic software may be installed with a wizard-like interface having a series of easy to follow instructions. Once installed, the application, with the analytic software incorporated therein, may be provided and installed on a plurality of end user devices. Thereafter, the analytic software may work in conjunction with analytic processing logic to assist the developer in obtaining pertinent information related to bugs associated with the application that is being executed on an end user device. | 06-13-2013 |
| 20130152051 | TIME-BASED NAVIGATION WITHIN RESOURCE UTILIZATION DATA - The present invention extends to methods, systems, and computer program products for time-based navigation within resource utilization data. A computer system is configured to present resource utilization data representing performance of computer resources. The resource utilization data is displayed on a diagnostic data trace during the execution of the application. The user can select a desired time range and the resource utilization data within the time range will be displayed at other traces. The diagnostic data trace is still presented so that the user can understand the relation between the selected time range and the overall time length. Further, the user can modify the selected time range by change the extents of the selected time range using resizing tool. The resource utilization data within the modified selected time range, similarly, is also displayed along with the diagnostic data trace. | 06-13-2013 |
| 20130152052 | LINKING DIAGNOSTIC VISUALIZATIONS TO APPLICATION CODE - The present invention extends to methods, systems, and computer program products for linking diagnostic visualizations to regions of application code. Diagnostic visualizations emitted during execution of an application are displayed. The diagnostic visualizations partially represent the abstract objective of the application (e.g., as envisioned by a developer). Diagnostic data for at least one of a plurality of components is displayed. The diagnostic data indicates the performance of the at least one of the plurality of components during execution of the application. The displayed one or more diagnostic visualizations and the displayed diagnostic data is correlated to link the one or more diagnostic visualizations to the at least one of the plurality of components. Linking the one or more diagnostic visualizations to the at least one of the plurality of components can better indicate how the application's behavior reconciles the abstract objective. | 06-13-2013 |
| 20130167122 | VALIDATING VISUAL COMPONENTS - Methods, systems, apparatus, and computer-readable media for validating components of a dynamic user interface in an on-demand multi-tenant service environment are disclosed. Organizations corresponding to tenants in the on-demand multi-tenant service environment are identified. A multi-tenant database system residing on multiple servers is provided for each of the identified organizations. Dynamic user interface pages associated with the organizations are identified. First and second compilation outputs based upon respective first and second invocations of a compiler configured to compile the one or more dynamic user interface pages are produced with reference to respective first and second builds of computer program code. Differences between the first and second compilation outputs are identified and presented in a user interface on a display device of the multi-tenant service environment. The differences can be identified by performing a comparison and selecting one or more differences that match a pattern specifier. | 06-27-2013 |
| 20130205280 | DEBUGGING CODE VISUALLY ON A CANVAS - A debugger session is initiated to monitor application execution. A debugger canvas corresponding to the debugger session is identified and displayed. The displayed debugger canvas includes one or more code bubbles created during a prior debugger session. The one or more code bubbles already present on the displayed debugger canvas are reused during the current debugger session. Accordingly, existing code bubbles and bubble sets are reused on a debugger canvas when entering a debug session, thus providing a more stable and manageable view for debugging an application in an integrated development environment. The code fragments in code bubbles on a debugger canvas can be analyzed, inspected, and edited during or after a debug session. Notations can also be added to a debugger canvas in the form of note bubbles and context data bubbles. | 08-08-2013 |
| 20130219365 | METHOD AND SYSTEM FOR VISUAL FEEDBACK - An apparatus, method, and system for visual feedback are disclosed. The apparatus, method, and system may include a module for detecting a first feedback trigger designating a first area including at least one pixel, capturing a screenshot including at least the first area, generating a workspace including the screenshot, generating a first design element anchored to the first area within the workspace, receiving an input in or a modification of the first design element, detecting a workspace submission trigger, and transmitting the workspace including the first area and the first design element to a remote server. | 08-22-2013 |
| 20130219366 | STEPPING AND APPLICATION STATE VIEWING BETWEEN POINTS - Various technologies and techniques are disclosed for providing stepping and state viewing in a debugger application. A start and end breakpoint are assigned, Source code execution begins, and upon reaching the start breakpoint, a logging feature begins storing one or more values that may be impacted upon execution of code between the start breakpoint and an end breakpoint. More lines of source code are executed until the end breakpoint is reached. When the end breakpoint is reached, the debugger is put into break mode. While in break mode, a playback feature is provided to allow a user to play back a path of execution that occurred between the start breakpoint and the end breakpoint. The playback feature uses at least some of the values that were stored with the logging feature to show how each referenced variable changed in value. | 08-22-2013 |
| 20130275950 | SYSTEM, METHOD AND COMPUTER PROGRAM PRODUCT FOR MONITORING AND/OR ANALYZING AT LEAST ONE ASPECT OF AN INVOCATION OF AN INTERFACE - A system, method and computer program product are provided. In use, execution of a portion of internal code of an interface is identified. Further, in response to the execution of the portion of internal code, at least one aspect of an invocation of the interface is monitored and/or analyzed. | 10-17-2013 |
| 20130283237 | Debugging a Statechart for a Real Time Target - System and method for debugging a statechart on a target device. The statechart may be created or displayed on a display and may include a plurality of state icons connected by wires. One or more debugging operations may be specified for the statechart. The statechart may be executed on the target device. The target device may provide debugging information to a computer during execution of the statechart. The debugging information may be displayed on the computer and may be usable to aid in debugging the statechart. | 10-24-2013 |
| 20130290934 | MONITORING APPLICATIONS EXECUTING ON A COMPUTER DEVICE USING PROGRAMMATIC TRIGGERS - A method is disclosed for monitoring one or more applications that are executing on a computing device. A user is enabled to insert programmatic triggers in an application. One or more operations of the application is monitored during one or more durations that is determined by the programmatic triggers. An output is provided that is based on the monitored one or more operations. | 10-31-2013 |
| 20130298110 | Software Visualization Using Code Coverage Information - A method for visualization of a software program includes receiving code coverage data generated by the software program, the code coverage data being associated with a test case, by a visualization tool in a computing system; and generating, by the visualization tool, a visualization of an execution of the test case by the software program based on the code coverage data; and displaying the visualization to a user. | 11-07-2013 |
| 20130305223 | Dashboard for Architectural Governance - A software architecture as designed is governed. A rules engine tests code for implemented architectural decisions. Deviation from designed architecture is detected by execution of the rules engine. The dashboard generates a graphical or textual representation indicating violations and/or changes in the implemented architecture over time. A dashboard assists in managing implementation of the architecture by indicating deviation or the results of change to coding. | 11-14-2013 |
| 20130311974 | DEBUGGER INTEGRATION OF REPORTING TOOL RENDERER - A debugging tool for a program includes a display of custom UI components to visually depict external parameters with an internal program state, thus enabling full context information during program debugging. A trace process on a program being executed by a computer is examined by a debugger, which retrieves internal state data of the program being executed. The internal state data is displayed in a first window of a user interface generated by the debugger. A script is then executed by the debugger to interact with the program being executed by the computer, to retrieve a result set associated with external parameters of the program being executed, and display the result set in a second window of the user interface. | 11-21-2013 |
| 20130311975 | Automated tagging and tracking of defect codes based on customer problem management record - A routine for tagging and tracking source code may be implemented in a software development environment. The routine begins upon the identification of a defect in a software product or system. Once the defect has been identified and rectified, a search of other source code (typically located in a source code management system that supports version control) is specified. Using the search specification, the system automatically identifies the code snippet to be searched and begins searching the identified codebase for duplicates. A ticket or service record is then created for every duplicate/similar code snippet found during the search. The ticket/record enables software defect tracking to be carried out on the newly-located instances of the code. The system also automatically manages the code snippets identified by the duplicate detection. | 11-21-2013 |
| 20130318500 | Debugging in a Dataflow Programming Environment - A dataflow program defining actors that pass tokens from one to another via connections is processed by causing one or more processors to access and execute instructions of the dataflow program. As instructions of the dataflow program are being executed, a first set of trace records is created that represents a sequence of events (e.g., token production/consumption, actor state change, or action firing). A first subset of the trace records is displayed and one of these is selected. The first set is processed to identify, based on definitions specified by the dataflow program, a second set of trace records, of which a subset is displayed. | 11-28-2013 |
| 20130318501 | CAPTURING DOMAIN VALIDATIONS AND DOMAIN ELEMENT INITIALIZATIONS - Specifying and/or enforcing a domain model can include generating a pictorial diagram specifying a rule within a development environment, wherein the pictorial diagram includes a first subject element specifying criteria for selecting artifacts within the development environment. The pictorial diagram can be enabled within the development environment. Responsive to an execution event, the pictorial diagram can be executed by selecting each artifact matching the criteria of the first subject element and performing the rule specified by the pictorial diagram upon each selected artifact within the development environment. | 11-28-2013 |
| 20130318502 | REGISTRATION-BASED REMOTE DEBUG WATCH AND MODIFY - A remote debugging technique provides anonymity of program variables and selective debugging capability by providing a registration facility by which program variables are registered locally with a debugging module. An external program then communicates with the debugging modules and observes and/or modifies the program variables by specifying either an index or a variable name. The need to publish symbols is thereby averted and only the variables that a developer is interested in observing need be registered. | 11-28-2013 |
| 20130326484 | SYNCHRONIZATION POINT VISUALIZATION FOR MODIFIED PROGRAM SOURCE CODE - Visualization of synchronization points in modified program source code includes identifying the synchronization points in a program source code segment. The identification is performed in response to a modification of the program source code segment. The visualization of the synchronization points also includes storing line numbers of the synchronization points and line contents corresponding to text located at stored line numbers in the program source code segment. The visualization of the synchronization points further includes implementing, as part of a debugging session: retrieving the synchronization points and the line contents, displaying the line contents of the synchronization points on a display screen, and providing a user with an option to step through the synchronization points in the program source code while skipping the remaining portions of the program source code segment. Displaying the line contents includes visually differentiating the synchronization points from remaining portions of the program source code segment. | 12-05-2013 |
| 20130332907 | EXCEPTION HANDLING FOR A DISTRIBUTED RUNTIME - Embodiments are directed to handling errors in a distributed software application and to handling errors in a distributed software application. In one scenario, a computer system instantiates a distributed application which is configured for execution on multiple different computer systems. The computer system determines that an exception has occurred during the execution of the distributed application on at least one of the computer systems and translates the exception that occurred during distributed execution in a distributed environment into a serial exception that appears to have occurred during serial execution in a serial execution environment. The computer system then presents the translated serial exception to an application developer or other user. | 12-12-2013 |
| 20130332908 | Serial Debugging Experience for Parallel Programs - Systems, methods, and computer program products for facilitating a serial debugging experience for programs running in a distributed, non-deterministic, out-of-order (i.e., parallel) fashion are disclosed. Such systems, methods, and computer program products provide a modified combination of breakpoints, stepping, and call stacks that facilitate the ability to improve the debugging experience for out-of-order program execution. In an embodiment, a task scheduler provides a distributed task graph. Then, the user may hit breakpoints sequentially within the graph's execution and use deterministic stepping (i.e., step-in, step-out, and step-over functions) to create a logical call stack from a distributed task graph. Such embodiments allow the program to execute in a distributed and parallel manner, while presenting the user a sequential execution experience in the debugger. | 12-12-2013 |
| 20130339930 | MODEL-BASED TEST CODE GENERATION FOR SOFTWARE TESTING - A method of creating test code automatically from a test model is provided. In the method, an indicator of an interaction by a user with a user interface window presented in a display of a computing device is received. The indicator indicates that a test model definition is created. A mapping window includes a first column and a second column. An event identifier is received in the first column and text mapped to the event identifier is received in the second column. The event identifier defines a transition included in the test model definition and the text defines code implementing a function of a system under test associated with the transition in the mapping window. A code window is presented in the display. Helper code text is received. The helper code text defines second code to generate executable code from the code implementing the function of the system under test. Executable test code is generated using the code implementing the function of the system under test and the second code. | 12-19-2013 |
| 20130346948 | CREATING A TEST CASE - A method for creating as test case for a client can include identifying an object in the client, using a parser module. A list of potential test case tasks for testing the client can be populated from the parser module into a test ease task window. A test case flow can be built by placing a desired task from the list of potential test ease tasks in a test case development window. The method can continue by assigning the object to the desired task in the test case development window, The test case can be generated from the test case flow. | 12-26-2013 |
| 20140013308 | Application Development Environment with Services Marketplace - An application development environment may have a user interface to a marketplace for development related services, such as monitoring, debugging, load generating, analysis, and other services. Service providers may make their products available through the marketplace, and in some cases, the providers may bid for placement in the user interface. The services may be paid or free, and a clearinghouse may handle financial transactions that may occur. The application development environment may include an editor, debugger, compiler, and other tools by which a developer may write, edit, test, and debug an application. The marketplace may detect characteristics about the application under development, and make those characteristics available to various service providers. | 01-09-2014 |
| 20140013309 | Interactive Graph for Navigating Application Code - Code elements may be selected from a graph depicting an application. The graph may show code elements as nodes, with edges representing connections between the nodes. The connections may be messages passed between code elements, code flow relationships, or other relationships. When a code element or group of code elements are selected from the graph, the corresponding source code may be displayed. The code may be displayed in a code editor or other mechanism by which the code may be viewed, edited, and manipulated. | 01-09-2014 |
| 20140013310 | Selective Monitoring of Software Applications - Au application monitoring system autonomously selects routines for performance monitoring based on characteristics of the content of the routines. These characteristics are preferably related to aspects of routines that are likely candidates for performance improvement, such as repetitive loops, event waits, synchronized blocks, and on. Routines that appear to be relatively un-improvable are excluded from initial monitoring, and routines that are subsequently determined to be relatively un-improvable, based on performance analysis and/or user feedback, are excluded from future monitoring. The determination of each routine's candidacy for monitoring is maintained over time, so that each subsequent monitoring session need not repeat the determinations. Changed routines are routinely re-monitored and/or re-assessed to affirm or modify the routine's candidacy for subsequent monitoring. | 01-09-2014 |
| 20140033178 | METHOD AND APPARATUS FOR REVERSE DEBUGGING SOURCE CODE USING CAUSAL ANALYSIS - A method and apparatus for reverse debugging source code using causal analysis is disclosed. The method comprises executing byte-code created from a plurality of lines of source code, wherein the plurality of lines of source code comprise at least one breakpoint; storing execution data after execution of each line of source code in the plurality of lines of source code until execution reaches the at least one breakpoint; performing a code execution analysis using the execution data and the plurality of lines of source code; receiving an input via a graphical user interface (GUI), wherein the input requests specific execution details based on the code execution analysis; and responding via the GUI to the input. | 01-30-2014 |
| 20140059521 | Systems and Methods for Editing A Computer Application From Within A Runtime Environment - 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. | 02-27-2014 |
| 20140068565 | ANALYSIS AND TIMELINE VISUALIZATION OF THREAD ACTIVITY - 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. | 03-06-2014 |
| 20140075416 | GRAPHICAL CONVERSION BETWEEN TEST PROGRAM LANGUAGES - 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. | 03-13-2014 |
| 20140082592 | MARKER CORRELATION OF APPLICATION CONSTRUCTS WITH VISUALIZATIONS - 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. | 03-20-2014 |
| 20140089899 | METHOD FOR THE COMPUTER-ASSISTED ANALYSIS OF BUGGY SOURCE CODE IN A HARDWARE DESCRIPTION LANGUAGE - 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. | 03-27-2014 |
| 20140096112 | IDENTIFYING EXECUTION PATHS THAT SATISFY REACHABILITY QUERIES - 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. | 04-03-2014 |
| 20140101640 | WHITE-BOX TESTING SYSTEMS AND/OR METHODS FOR USE IN CONNECTION WITH GRAPHICAL USER INTERFACES - 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. | 04-10-2014 |
| 20140109055 | SOFTWARE TEST AUTOMATION - 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. | 04-17-2014 |
| 20140109056 | SCHEDULED SOFTWARE ITEM TESTING - 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. | 04-17-2014 |
| 20140109057 | SOFTWARE DEVELOPMENT KIT TESTING - 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. | 04-17-2014 |
| 20140109058 | TEST LANGUAGE INTERPRETER - 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. | 04-17-2014 |
| 20140109059 | INTEGRATED DEBUGGER AND CODE COVERAGE TOOL - 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. | 04-17-2014 |
| 20140109060 | INTEGRATED DEBUGGER AND CODE COVERAGE TOOL - 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. | 04-17-2014 |
| 20140123113 | SYSTEM AND A METHOD FOR ANALYZING A PIECE OF CODE - 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. | 05-01-2014 |
| 20140165045 | SYSTEM AND METHOD FOR DISPLAY OF SOFTWARE QUALITY - A method for code analysis comprising steps of inputting program code to an analyzer, assigning an objective quality measure to components of the analyzed code; and displaying graphically the objective quality measures. | 06-12-2014 |
| 20140173567 | MANAGING WINDOW FOCUS WHILE DEBUGGING A GRAPHICAL USER INTERFACE PROGRAM - An embodiment of the present invention utilizes the abilities of an operating system to manage the window focus while debugging a graphical user interface program. In an example, a debugger program intercepts a breakpoint in the code of a graphical user interface computer program undergoing automated testing by a separate computer program. The debugger program instructs the operating system to save states of the window focus. Responsive to determining the breakpoint condition has ended, the debugger program instructs the operating system to restore saved states of the window that had focus prior to the breakpoint condition. Another embodiment of the present invention arranges similar window focus management where an operating system on its own is unable to save and restore states of the window that had focus prior to the breakpoint condition. | 06-19-2014 |
| 20140173568 | DEBUGGING A GRAPHICAL USER INTERFACE CODE SCRIPT WITH NON-INTRUSIVE OVERLAYS - An embodiment of the present invention manages window focus non-intrusive over-lays while debugging a graphical user interface program. In an example, the computer displays in a first graphical user interface, wherein the computer program is designed to manipulate a second graphical user interface of another computer program. The computer receives a command to debug the second graphical interface computer program and converts the first graphical user interface into a focus-less graphical user interface so the focus does not transfer from the second graphical user interface. The computer debugs the computer program and upon completing debugging, the computer restores the first graphical user interface into focus. | 06-19-2014 |
| 20140173569 | MANAGING WINDOW FOCUS WHILE DEBUGGING A GRAPHICAL USER INTERFACE PROGRAM - An embodiment of the present invention utilizes the abilities of an operating system to manage the window focus while debugging a graphical user interface program. In an example, a debugger program intercepts a breakpoint in the code of a graphical user interface computer program undergoing automated testing by a separate computer program. The debugger program instructs the operating system to save states of the window focus. Responsive to determining the breakpoint condition has ended, the debugger program instructs the operating system to restore saved states of the window that had focus prior to the breakpoint condition. Another embodiment of the present invention arranges similar window focus management where an operating system on its own is unable to save and restore states of the window that had focus prior to the breakpoint condition. | 06-19-2014 |
| 20140173570 | DEBUGGING A GRAPHICAL USER INTERFACE CODE SCRIPT WITH NON-INTRUSIVE OVERLAYS - An embodiment of the present invention manages window focus non-intrusive over-lays while debugging a graphical user interface program. In an example, the computer displays in a first graphical user interface, wherein the computer program is designed to manipulate a second graphical user interface of another computer program. The computer receives a command to debug the second graphical interface computer program and converts the first graphical user interface into a focus-less graphical user interface so the focus does not transfer from the second graphical user interface. The computer debugs the computer program and upon completing debugging, the computer restores the first graphical user interface into focus. | 06-19-2014 |
| 20140189648 | FACILITATED QUALITY TESTING - Provided is an online application distribution system. The online application distribution system, in this aspect, includes an application reservoir. The online application distribution system, in this aspect, further includes a beta test manager configured to determine if a user associated with the system will participate in beta testing for a beta application in the application reservoir. | 07-03-2014 |
| 20140189649 | Online Community-Based Expert Quality Assurance - Systems and methods are provided for incentivizing software quality assurance professionals to join and participate in an online community focused on software quality assurance testing and discussions. Point(s) are provided for providing testing results and these points may be utilized to obtain products or services. | 07-03-2014 |
| 20140189650 | Setting Breakpoints Using an Interactive Graph Representing an Application - Breakpoints may be set by selecting nodes on a graph depicting code elements and relationships between code elements. The graph may be derived from tracing data, and may reflect the observed code elements and the observed interactions between code elements. In many cases, the graph may include performance indicators. The breakpoints may include conditions which depend on performance related metrics, among other things. In some embodiments, the nodes may reflect individual instances of specific code elements, while other embodiments may present nodes as the same code elements that may be utilized by different threads. The breakpoints may include parameters or conditions that may be thread-specific. | 07-03-2014 |
| 20140189651 | Animated Highlights in a Graph Representing an Application - Highlighted objects may traverse a graph representing an application's code elements and relationships between those code elements. The highlighted objects may be animated to represent how the objects are processed in an application. The graph may represent code elements and relationships between the code elements, and the highlighting may be generated by tracing the application to determine the flow of the object through code elements and across relationships. A user may control the highlighted graph with a set of playback controls for playing through the sequence of highlights on the graph. The playback controls may include pause, rewind, forward, fast forward, and other controls. The controls may also include a step control which may step through small time increments. | 07-03-2014 |
| 20140189652 | Filtering and Transforming a Graph Representing an Application - A graph representing code element and relationships between code elements may have elements combined to consolidate or collapse portions of the graph. A filter may operate between the graph data and a renderer to show the graph in different states. The graph may be implemented with an interactive user interface through which a user may select a node, edge, or groups of nodes and edges, then apply a filter or other transformation. When the user selects to combine a group of code elements, the combined elements may be displayed as a single element. In some cases, the single element may be presented with visual differentiation to show that the element is a collapsed or combined element, as opposed to a singleton element. | 07-03-2014 |
| 20140189653 | CONFIGURABLE TESTING OF COMPUTER PROGRAMS - Configurable testing of a computer program includes: storing a set of one or more testing specifications, and attribute information defining one or more attributes of a recognizable portion of the computer program; and processing, using at least one processor, the computer program according to at least a first testing specification associated with the computer program. The processing includes: traversing a representation of the computer program that includes elements that represent recognizable portions of the computer program, and while traversing the representation, recognizing recognizable portions of the computer program, and storing values of attributes, defined by the attribute information, of the recognized portions of the computer program. | 07-03-2014 |
| 20140196013 | DATA PRESENTATION IN INTEGRATED DEVELOPMENT ENVIRONMENTS - Methods and apparatus are provided to access and present data from a process executing on a separate device, with the data being presented in a form suitable for the type of data, such as a graphical structure that represents the data. The methods include receiving a request to display a first data object stored in a memory of a second computing device, wherein the first object is of a first data type in a process configured to execute on the second computing device, generating an expression configured to convert the first data object to a defined data format, sending the expression to the process, executing the expression in the process to produce intermediate data that represents the first object in the defined format, receiving the intermediate data, creating a second object of a second data type based upon the intermediate data, and displaying a graphical structure of the second object. | 07-10-2014 |
| 20140201717 | SIMULATION ENVIRONMENT FOR DISTRIBUTED PROGRAMS - A dataflow of a distributed application is visualized in a locally simulated execution environment. A scheduler receives a job graph which includes a graph of computational vertices that are designed to be executed on multiple distributed computer systems. The scheduler queries a graph manager to determine which computational vertices of the job graph are ready for execution in a local execution environment. The scheduler queries a cluster manager to determine the organizational topology of the distributed computer systems to simulate the determined topology in the local execution environment. The scheduler queries a data manager to determine data storage locations for each of the computational vertices indicated as being ready for execution in the local execution environment. The scheduler also indicates an instance of each computational vertex to be spawned and executed in the local execution environment based on the organizational topology and indicated data storage locations. | 07-17-2014 |
| 20140215441 | PROVIDING DIRECTIONAL DEBUGGING BREAKPOINTS - 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. | 07-31-2014 |
| 20140215442 | SYSTEM AND METHOD TO IDENTIFY CODE EXECUTION RHYTHMS - 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. | 07-31-2014 |
| 20140237452 | Call Stacks for Asynchronous Programs - 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. | 08-21-2014 |
| 20140258985 | Debugger With Method Restart Capability - 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. | 09-11-2014 |
| 20140282414 | METHOD AND SYSTEM FOR DEBUGGING OF A PROGRAM - 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. | 09-18-2014 |
| 20140282415 | METHOD AND SYSTEM FOR DEBUGGING A PROGRAM - 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. | 09-18-2014 |
| 20140282416 | METHOD AND SYSTEM OF VISUALLY COMBINING PROFILING DATA FROM INSTRUMENTATION AND SAMPLING - 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. | 09-18-2014 |
| 20140282417 | JAVASCRIPT DEBUGGING USING JUST MY CODE - 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. | 09-18-2014 |
| 20140282418 | RECORDING PROGRAM EXECUTION - 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. | 09-18-2014 |
| 20140298297 | AUTOMATIC FEATURE-DRIVEN TESTING AND QUALITY CHECKING OF APPLICATIONS - 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. | 10-02-2014 |
| 20140298298 | INTERMEDIARY FOR TESTING CONTENT AND APPLICATIONS - 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. | 10-02-2014 |
| 20140304686 | RESPONDING TO A PROBLEM DURING SOFTWARE TESTING - 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. | 10-09-2014 |
| 20140317602 | Graphical User Interface Debugger with User Defined Interest Points - A mechanism is provided in a data processing system for debugging a web application. The mechanism loads a web application having a plurality of source code files in a browser with an associated debugger executing in the data processing system. Responsive to receiving user selection of a record function, the debugger records user actions and changes in the source code files to a recording file. The mechanism replays the recording file in the browser and presenting debug information to the user in panels of the debugger. | 10-23-2014 |
| 20140325486 | TECHNIQUES FOR TESTING SOFTWARE - A technique for testing software includes monitoring whether a predefined event occurs in a software test instance. In response to occurrence of the predefined event, different types of snapshots of the software test instance are generated according to a property of the event. The snapshots are used to record a state of the software test instance when the predefined event occurs. The different types of snapshots are stored in information related to the predefined event. | 10-30-2014 |
| 20140331208 | COMPUTER AND METHOD FOR DEBUGGING PROGRAM - A computer-implemented method for debugging a program includes responding to user input to debug a program step by step. The debugging information of each line of the program is temporarily stored. Request available stored debugging information is displayed according to user input. Any stored debugging information is deleted when debugging of the program is finished. | 11-06-2014 |
| 20140337822 | STORAGE OF SOFTWARE EXECUTION DATA BY BEHAVIORAL IDENTIFICATION - Methods and systems for analyzing software. For example, one method can include executing a software program including a function by a computer. The method also includes producing an execution sequence for the function when, during execution, the software program executes the function. The method further includes generating an identifier for the execution sequence, wherein the identifier uniquely identifies a path of execution through the function represented by the execution sequence. In addition, the method includes saving the identifier and making the identifier available to at least one user through a user interface. | 11-13-2014 |
| 20140344787 | VISUALIZING A COMPUTER PROGRAM EXECUTION HISTORY - A software application profiling environment is provided, where the software application profiling environment monitors an execution of a software application, where a software application includes one or more computer programs. The software application profiling environment further stores execution history information for the one or more computer programs of the software application. The software application profiling environment further displays some or all of the computer program instructions of the computer program, and further displays a visualization of the stored execution history information. The visualization can be a static visualization or a dynamic visualization. Further, the visualization can be overlaid on top of the computer program instructions of the computer program. | 11-20-2014 |
| 20140351795 | DEBUGGER GRAPHICAL USER INTERFACE SYSTEM, METHOD, AND COMPUTER PROGRAM PRODUCT - A debugger graphical user interface (GUI) system, method, and computer program product are provided. In use, a list of constructs is displayed a first portion of the GUI of the debugger. Further, waveforms corresponding to the constructs or source code corresponding to the constructs is displayed in a second portion of the GUI of the debugger. | 11-27-2014 |
| 20140359580 | CODE AND MODEL COVERAGE AS A TIME SERIES - A device receives code that is an executable representation of a dynamic system that includes a behavior that changes over time, and executes one or more portions of the code. The device determines coverage information associated with the executing code, where the coverage information provides a measure of completeness associated with the executing code. The device receives a selected option for displaying the coverage information, and provides for display a time-based view of the coverage information based on the selected option. The device permits a user to manipulate one or more time periods associated with the time-based view. | 12-04-2014 |
| 20140366005 | ABSTRACT LAYER FOR AUTOMATIC USER INTERFACE TESTING - Systems and methods for providing automatic software testing of a graphical user interface (GUI) are described. The system may contain a plurality of user interface (UI) testing tools executing on a computer system. Each of the plurality of UI testing tools may be configured to interact with one or more of the plurality of GUI components to perform automatic testing of the GUI. The system may contain an abstract layer coupled with the plurality of UI testing tools. The abstract layer may be configured to provide a uniform interface for accessing the plurality of UI testing tools. The system may further contain an automatic test platform coupled with the abstract layer and configured to issue a test command to the abstract layer simulating a user action performed on a GUI component of the plurality of GUI components. The abstract layer may be configured to identify the GUI component based on a first uniform identifier in the test command and utilize the first uniform identifier to communicate with one of the plurality of UI testing tools for interacting with the GUI component. | 12-11-2014 |
| 20140366006 | VISUALIZING RECORDED EXECUTIONS OF MULTI-THREADED SOFTWARE PROGRAMS FOR PERFORMANCE AND CORRECTNESS - A system graphically visualizes performance and/or correctness features of a recorded execution of a multi-threaded software program. The system may process chunk-based information recorded during an execution of the multi-threaded program, prepare a graphical visualization of the recorded information, and display the graphical visualization on a display in an animated fashion. The system may allow a viewer to interactively control the display of the animated graphical visualization. | 12-11-2014 |
| 20150012911 | Interface simulator for test rig in data distribution service - A method of interface simulation is provided for enabling publication and subscription of messages for a given problem domain, without requiring development of software or code. The method includes identifying a set of messages using the DDS as a problem domain; generating said . java message class from said problem domain generated from a .idl file for Interface Definition Language (IDL); processing said .java message class by Java reflection; generating a plurality of .java message stubs generated in the IDL format of said problem domain; incorporating said plurality of .java message stubs into a .jar message class file by said Java reflection; and rendering a graphical display that enables an operator to select and edit a .java message object from said plurality of stubs in said .jar message class. | 01-08-2015 |
| 20150020055 | SYSTEM, METHOD, AND COMPUTER PROGRAM PRODUCT FOR AUTOMATED STABILITY TESTING OF DEVICE FIRMWARE - A method, system, and computer-program product are provided for automatically performing stability testing on device firmware. The method includes the steps of copying a binary file corresponding to a version of a firmware to one or more nodes that each include a testbench, causing the one or more nodes to perform tests utilizing the version of the firmware, and determining whether a new build of the firmware is available. If the new build is available, then the steps include copying a second binary file corresponding to the new build to the one or more nodes and causing the one or more nodes to perform the tests utilizing the new build. However, if the new build is not available, then the steps include then causing the one or more nodes to perform one or more further iterations of the tests utilizing the version of the firmware. | 01-15-2015 |
| 20150052502 | SETTING BREAKPOINTS IN A CODE DEBUGGER USED WITH A GUI OBJECT - An embodiment of the invention pertains to debugging program code associated with graphical objects, wherein the code responds to events of user interactions with the object. A menu is generated that includes user interaction events, and an associated program window is adapted to present the menu to a user when requested, wherein the user can select user interaction events from the menu. For each selected event, the method identifies a component of the program code that is responsive to that selected event. The method further includes setting a breakpoint in the program code in selected relationship with each identified program code component, wherein the subsequent occurrence of one of the selected user interaction events triggers a corresponding one of the breakpoints. | 02-19-2015 |
| 20150052503 | Automatically Capturing User Interactions And Evaluating User Interfaces In Software Programs Using Field Testing - A method includes analyzing, on a first computing device, data from second computing device(s) of user interaction with a user interface of an application previously executed on the second computing device(s). The data corresponds to events caused by the user interaction with the user interface of the application. The first computing device generates representation(s) of the analyzed data and outputs the representation(s) of the user interaction. Another method includes capturing and logging, by a computing device, events caused by user interaction with a user interface of an application when the application is executed on the computing device. In response to a trigger, data comprising the captured and logged events is sent toward another computing device. Another method includes instrumenting a measurement library into an application to create an instrumented version of the application, and sending the instrumented application to computing device(s). Methods, apparatus, software, and computer program products are disclosed. | 02-19-2015 |
| 20150058824 | Targeted Cloud-based Debugging - Various arrangements for debugging code are presented. A computer system, such as a web server, may compile code into compiled code. The code may contain one or more subsections, include a first taskflow. A selection of the first taskflow may be received from a remote, developer computer system via a network. The selection of the first taskflow may indicate that the first taskflow is to be debugged. Execution of the first taskflow of the compiled code may occur by the computer system. While the computer system is executing the first taskflow of the compiled code, debugging functionality of the first taskflow may be provided to the developer computer system. | 02-26-2015 |
| 20150067651 | PERFORMANCE METRIC VISUALIZATION SYSTEMS AND METHODS - A method of providing performance metric data includes displaying a set of computer instruction elements using an integrated development environment application executed by a processor, receiving a user selection of at least one of the displayed elements using the integrated development environment application, sending a request for a value of a performance metric associated with the user-selected element from the integrated development environment application to a performance data server, receiving the value of the performance metric from the performance data server, and displaying the value of the performance metric with the set of computer instruction elements using the integrated development environment application. | 03-05-2015 |
| 20150067652 | Module Specific Tracing in a Shared Module Environment - A module-specific tracing mechanism may trace the usage of a module on behalf of the module developer. The module may be used by multiple application developers, and the tracing system may collect and summarize data for the module in each of the different applications. The data may include usage data as well as performance data. Usage data may include anonymized data for each time the module may be invoked and called, and performance data may include the processing time, memory consumption, and other metrics. The module-specific tracing may be enabled or disabled by an application developer. | 03-05-2015 |
| 20150074650 | MULTIVARIATE A/B TESTING OF MOBILE APPLICATIONS - The present disclosure is directed towards systems and methods for multivariate testing, which comprises, in response to a request for one or more content items on an access device, identifying one or more data items associated with the access device and identifying one of a set of payloads based on the one or more data items associated with the access device. The identified payload is retrieved and the rendered on the access device. | 03-12-2015 |
| 20150082282 | MOBILE APPLICATION TESTING PLATFORM - 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. | 03-19-2015 |
| 20150082283 | TESTING USER INTERFACE RESPONSIVENESS FOR MOBILE APPLICATIONS - Embodiments are directed towards testing a responsiveness of a graphical user interface (GUI) for an application executing on a computer. During execution of each portion of a test, stimuli may be provided to the application. The stimuli may be provided to the application thread that is associated with rendering graphics for the GUI. Responses from the application to the stimuli may be monitored to determine a responsiveness of the application for at least one portion of the test. The responsiveness may be determined based on a wait time between providing a request and receiving a reply to the request, which may indicate that the application is in a state to accept input through the GUI. Responsiveness may be determined separately for each portion of the test. A displayable report may be generated to include the responsiveness of the application for each portion of the test. | 03-19-2015 |
| 20150095891 | ELIMINATING REDUNDANT INTERACTIONS WHEN TESTING COMPUTER SOFTWARE APPLICATIONS - Testing computer software applications includes comparing multiple execution paths associated with multiple interactions performed with a computer software application during execution of the computer software application in order to determine which of the execution paths are similar in accordance with a predefined similarity criterion, identifying a subset of the interactions whose associated execution paths are similar in accordance with the predefined similarity criterion, and performing fewer than all of the interactions in the subset with the computer software application during execution of the computer software application. | 04-02-2015 |
| 20150121345 | SYSTEM AND METHOD TO FACILITATE A USER INTERFACE ENABLED REVIEW OF STATIC ANALYSIS WARNINGS - A system and method for facilitating verification of software code. A first program point is selected, from the software code, indicating static analysis warning to be reviewed. Further, review-assisting information including at least one of a set of modification points and a controlling condition are determined for the user to judge whether the warning generated is safe or unsafe. From the set of modification points, non-useful modification points may be filtered out in order to determine only relevant modification points. After filtering, the system presents the review-assisting information (relevant modification points and controlling conditions) in a systematic manner to the user for facilitating verification of the software code. | 04-30-2015 |
| 20150121346 | METHOD AND APPARATUS FOR DEBUGGING HDL DESIGN CODE AND TEST PROGRAM CODE - Disclosed is a method of debugging a simulation system including design code representing a design of an electronic circuit and test program code configured to exercise the design code. The method includes using an interactive debugging tool to execute an interactive simulation of the test program code and the design code, and, during the interactive simulation, displaying, using the interactive debugging tool, information of a simulation results file storing a plurality of signal values generated by executing the test program code and the design code during a previously executed simulation. | 04-30-2015 |
| 20150135166 | SOURCE CODE GENERATION, COMPLETION, CHECKING, CORRECTION - Automated generation, or completion, or checking of source code is described whereby a probabilistic model having been trained using a corpus of natural source code examples is used. In various examples the probabilistic model comprises probability distributions describing belief about structure of natural source code and takes into account source code analysis from a compiler or other source code analyzer. In various examples, source code analysis may comprise syntactic structure, type information and other data about source code. In various examples, the trained probabilistic model is used to predict sequences of source code elements. For example, to generate source code, to auto-complete source code, to error check source code, to error correct source code or for other purposes. | 05-14-2015 |
| 20150301924 | INJECTION OF DATA INTO A SOFTWARE APPLICATION - One embodiment is a method for injecting data into a software application. The method displays a plurality of different controls of a software application and receives a single selection of data stored in a data source. In response to this selection, the method injects the data from the data source into the plurality of different controls of the software application. | 10-22-2015 |
| 20150301926 | User Interface Test Coverage - A user interface (“UI”) code coverage system and process determines the coverage by test code of UI Components in a computer program. In other words, the UI code coverage system and process determine whether the test code tests a UI Component. In at least one embodiment, the UI code coverage system and process identify the particular UI Components tested by the test code, provide coverage (i.e. tested) statistics, provide a visualization of the UI Component tested, provide a visualization of tested and not-tested (also referred to respectively as “covered” and “not covered”) UI Components of a UI Screen. | 10-22-2015 |
| 20150309916 | REMOTE DEBUGGING INTO MOBILE WEB APPLICATIONS ACROSS DEVICES - Disclosed herein are technologies for remote debugging in mobile web applications using a platform-independent debugging proxy server. Particularly, the debugging proxy server acts as an intermediary by fetching and performing instrumentation on a requested webpage by a target browser. This Abstract is submitted with the understanding that it will not be used to interpret or limit the scope or meaning of the claims. | 10-29-2015 |
| 20150331785 | Pre-translation testing of bi-directional language display - A method for testing the display of bi-directional language script prior to translation in an application under test can include using unidirectional glyphs with shaping indicators to simulate right-to-left characters. The using step can include reversing an ordering of a first set of unidirectional text characters in an input string and mapping the unidirectional text characters to right-to-left code points in a bi-directional language code page to produce a pseudo-translated string. Multiple unidirectional language glyphs can be loaded where each corresponds to a same one of the right-to-left character code points as had been used to produce the pseudo-translation. The pseudo-translation and the glyphs can be combined to simulate right-to-left character rendering in the application under test such the resultant output is visually similar to the input string. Finally, the glyphs can include character shaping indicia such that a resultant output allows for the detection of shaping errors. | 11-19-2015 |
| 20150339211 | Debugger With Method Restart Capability - 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. | 11-26-2015 |
| 20150339213 | AUTOMATED TESTING OF AN APPLICATION SYSTEM - A system for automatically testing an application system graphical user interface (GUI) includes first and second application servers communicatively connected across a communication network. The second application server retrieves a GUI page provided by the first application server as part of the application system, and identifies text elements and user input objects in an image of the retrieved GUI page. Each user input object is then associated with a text element. Test parameter values are retrieved from a database storing test parameter data, and the application system is tested. In particular, for each user input object of the GUI page, a respective test parameter value is provided that is associated in the database with a same text element as is associated with the user input object. A response of the application system is then monitored. | 11-26-2015 |
| 20150339215 | Systems and Methods for Testing Terminal Applications - 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. | 11-26-2015 |
| 20150347274 | Performance Optimization Tip Presentation During Debugging - Assistance is given to aid in optimizing a program's performance during initial development while the program's features are still being implemented and/or debugged, without interfering with that development, by providing easy-to-ignore yet accurate tips about a program's performance inside a debugger. Raw performance information for a software program which is being debugged in a debugger is adjusted by removing from it a measured debug overhead or other diagnostic overhead. Some factors considered when measuring overhead include pauses, context switches, debug versus release build presence, bounds checking, funceval, and call stack analyses. The debugger is enhanced to display the adjusted program performance measure in a graphical user interface, next to the corresponding source code. The enhanced debugger updates the adjusted program performance measure value and keeps its screen location current as the developer moves through the source code, providing more detailed performance information upon request. | 12-03-2015 |
| 20150347275 | Breakpoint Setting Through a Debugger User Interface - A debugging system may display snapshot information that may be collected in response to an event identified while an application executes. The debugging system may allow a user to browse the various data elements in the snapshot, and may allow the user to modify a snapshot configuration by including or excluding various data elements within the snapshot data. The user interface may have a mechanism for including or excluding data elements that may be presented during browsing, as well as options to change the events that may trigger a snapshot. The updated snapshot configuration may be saved for future execution when the event conditions are satisfied. | 12-03-2015 |
| 20150347276 | SCREENSHOT VALIDATION TESTING - Embodiments of the present invention disclose a method, computer program product, and system for comparing screenshots of an application interface. In one embodiment, the method includes receiving test scenario parameters, wherein the parameters include a first screenshot of an application interface, one or more page objects associated with the first screenshot, generating a second screenshot of an updated application interface, identifying one or more page objects within the second screenshot based on a scope of each of the page objects associated with the first screenshot, comparing a section of the second screenshot to a section of the first screenshot that includes one or more page objects associated with the first screenshot that correspond to one or more page objects included in the section of the second screenshot, and determining whether the section of the second screenshot matches, within a predetermined tolerance level, the section of the first screenshot. | 12-03-2015 |
| 20150347282 | PERFORMANCE TESTING FOR BLOCKS OF CODE - Systems, methods, and computer-readable storage media for testing performance of blocks of code. A system can first receive a request to run a performance test for a selected portion of code in an application. Next, the system can obtain a baseline performance test result corresponding to the performance test for the selected portion of code in the application, and run the performance test for the selected portion of code in the application. The system can then generate a performance test result based on the performance test and the baseline performance test result. The system can also present the test result and/or the baseline performance test result via a graphical user interface. | 12-03-2015 |
| 20150347284 | SCREENSHOT VALIDATION TESTING - Embodiments of the present invention disclose a method, computer program product, and system for comparing screenshots of an application interface. In one embodiment, the method includes receiving test scenario parameters, wherein the parameters include a first screenshot of an application interface, one or more page objects associated with the first screenshot, generating a second screenshot of an updated application interface, identifying one or more page objects within the second screenshot based on a scope of each of the page objects associated with the first screenshot, comparing a section of the second screenshot to a section of the first screenshot that includes one or more page objects associated with the first screenshot that correspond to one or more page objects included in the section of the second screenshot, and determining whether the section of the second screenshot matches, within a predetermined tolerance level, the section of the first screenshot. | 12-03-2015 |
| 20150363292 | Risk Analysis of Codebase Using Static Analysis and Performance Data - An example system is configured to calculate performance statistics for a set of analysis tools; analyze a codebase using one or more analysis tools from the set of analysis tools; generate an analysis result for each analysis tool of the one or more analysis tools, the result describing one or more faults and one or more validations identified by the corresponding analysis tool; and estimate a risk of defects in the codebase based on the analysis result associated with each of the one or more analysis tools and the performance statistics associated with each of the one or more analysis tools. | 12-17-2015 |
| 20150363301 | TEST SCRIPT CREATION BASED ON ABSTRACT TEST USER CONTROLS - The life cycle of an application can be shortened by initiating the creation of a mock-up test script before the development of an application is complete. The concurrent creation of the mock-up test script and the application can reduce a time associated with the life cycle of an application. Mock-up test script creation is based on the user interface (UI) specification and a mock-up graphical user interface (GUI) without business logic. Test script creation can include associating a functional specification and a UI specification with a proposed application and creating a mock-up GUI for testing based on the UI specification. Test script creation can include developing an application based on the proposed application that includes a logic based on the functional specification and a GUI based on the UI specification and creating a mock-up test script based on the mock-up GUI and not based on the logic, the functional specification, and the GUI. | 12-17-2015 |
| 20150370688 | AUTOMATIC UPDATING OF GRAPHICAL USER INTERFACE ELEMENT LOCATORS BASED ON DIMENSION COMPARISON - An automated testing system is described for efficient testing of software applications. Locators are used by the test to find user interface elements in an application's graphical user interface during testing. If during a test a user interface element is not found, which may be due to a changed locator during code refactoring, the system finds the user interface element based on the element's type and on previously stored information about the element. Such information can be a snapshot image of the element, the coordinates of the element's location, dimensions of the element, or other information. Once the missing element is found, a new locator for the element is read and the test is performed using the new locator. | 12-24-2015 |
| 20150370696 | METHOD AND APPARATUS FOR DISPLAYING PC REAL BROWSING EFFECT FOR MOBILE PHONE INTERFACE - The present invention relates to the field of displaying a mobile phone interface, and particularly to a method and apparatus for displaying a PC real browsing effect for a mobile phone interface, comprise: a step and device for displaying applications and master keys of a the main interface of the mobile phone on the PC user interface; a step and device for detecting a predefined user action made by a user on the PC user interface, wherein the predefined user action comprises a first predefined user action and a second predefined user action, a step and device for, upon detecting that the first predefined user action is associated with any one of the applications, displaying an application interface of the application or an application interface of a lower level on the PC user interface. | 12-24-2015 |
| 20150378878 | AUTOMATION TESTING OF GUI FOR NON-STANDARD DISPLAYS - The embodiments herein relate to Graphical User Interface (GUI) testing and, more particularly, to automate the testing of GUI for non-standard displays. Initially, an automation module is pre configured with the test cases that are required to test the GUI of the Device Under Test (DUT). Further, the DUT's display is auto configured with an interpretation & reconstruction module which fetches the display parameters and allocates required memory in a memory buffer. Later, the automation module provides the system inputs to DUT in which test cases are executed. Now, the interpretation & reconstruction module interprets and reconstructs the GUI content of DUT by fetching it from its display port. Later, the reconstructed display content will be updated to the memory buffer which is further verified by automation module. | 12-31-2015 |
| 20160041893 | SYSTEM AND METHOD FOR DISPLAY OF SOFTWARE QUALITY - A method for code analysis comprising steps of inputting program code to an analyzer, assigning an objective quality measure to components of the analyzed code; and displaying graphically the objective quality measures. | 02-11-2016 |
| 20160041896 | Integration Process Management Console With Error Resolution Interface - An information handling system for resolving integrated business process system errors includes a processor executing instructions to scrub an error message for an integrated business process system error from an integrated business process event to remove user specific information. The information handling system further includes a processor interface device for transmitting a search request to a multi-user community scrubbed system error database at a storage device for scrubbed resolution articles using the scrubbed error message. The information handling system includes the processor interface device sending the scrubbed resolution articles in a rank-order to display, via an error resolution graphical user interface. | 02-11-2016 |
| 20160048443 | Automatically Capturing User Interactions And Evaluating User Interfaces In Software Programs Using Field Testing - A method includes analyzing, on a first computing device, data from second computing device(s) of user interaction with a user interface of an application previously executed on the second computing device(s). The data corresponds to events caused by the user interaction with the user interface of the application. The first computing device generates representation(s) of the analyzed data and outputs the representation(s) of the user interaction. Another method includes capturing and logging, by a computing device, events caused by user interaction with a user interface of an application when the application is executed on the computing device. In response to a trigger, data comprising the captured and logged events is sent toward another computing device. Another method includes instrumenting a measurement library into an application to create an instrumented version of the application, and sending the instrumented application to computing device(s). Methods, apparatus, software, and computer program products are disclosed. | 02-18-2016 |
| 20160055076 | SOFTWARE TESTING CAPABILITY ASSESSMENT FRAMEWORK - An improved testing assessment tool and methodology maps the Testing Maturity Model (TMM) structure to individual test areas, thereby enabling comprehensive and targeted improvement. In this way, the present invention uses the five TMM maturity levels to assess individual areas, rather than merely assigning a single maturity level to the entire organization. Embodiments of the present invention include a quick assessment that includes a relatively small number of questions to be subjectively answered using the TMM hierarchy. Embodiments of the present invention further include a full assessment that includes a relatively large number of questions to be discretely answered, with these results being use to evaluate various testing areas using the TMM hierarchy. | 02-25-2016 |
| 20160062870 | STRUCTURED QUERY LANGUAGE DEBUGGER - The present disclosure describes methods, systems, and computer program products for debugging structured query language (SQL) statements. One computer-implemented method includes receiving a request to fetch a debug execution plan considering different structured query language (SQL) execution optimization levels and including a mapping for a SQL statement, receiving a request to initialize a debugging process of the SQL statement, verifying received and attached filter criteria provided using a SQL debug channel, setting SQL statement breakpoints, triggering the SQL statement, transmitting a notification that a SQL process is attached to a debugger associated and ready for external execution control, providing state details and an intermediate result upon reaching a particular breakpoint associated with the SQL process, providing an ability to change the process state and influence the process, and providing a SQL final execution response after reaching the end of the execution of the triggered SQL statement. | 03-03-2016 |
| 20160062871 | PROGRAM INFORMATION GENERATING SYSTEM, METHOD, AND COMPUTER PROGRAM PRODUCT - A program information generating system includes an acquisition unit that acquires dependency information indicating dependency among a plurality of events generated by execution of a program and selection information identifying a selected event that is the event selected by a user; a generation unit that generates display information, on the basis of the dependency information and the selection information, such that a dependency path that is formed of the plurality of events having the dependency and includes the selected event is displayed in a distinguishable manner; and a display control unit that controls a display unit, on the basis of the display information, such that a display image indicating an execution state of the program is displayed. | 03-03-2016 |
| 20160062875 | METHOD FOR ALTERING EXECUTION OF A PROGRAM, DEBUGGER, AND COMPUTER-READABLE MEDIUM - A method for altering execution of a program on a computer. The program resides in a memory unit that has a logical address space assigned thereto. The method comprises: operating the computer to start executing the program; operating the computer to suspend execution of the program; selecting a patch insertion address within a logical address range of the program, saving the original code residing at the patch insertion address; generating a patch routine; writing a jump instruction to the patch insertion address, thus overwriting said original code, wherein the jump instruction is arranged to instruct the computer to jump to a start address of the patch routine; and operating the computer to resume execution of the program. The patch routine is arranged to prompt the computer to: save a current context of the program; execute a user code; restore the saved context of the program; and execute a surrogate code. | 03-03-2016 |
| 20160077952 | REGISTRATION-BASED REMOTE DEBUG WATCH AND MODIFY - A remote debugging technique provides anonymity of program variables and selective debugging capability by providing a registration facility by which program variables are registered locally with a debugging module. An external program then communicates with the debugging modules and observes and/or modifies the program variables by specifying either an index or a variable name. The need to publish symbols is thereby averted and only the variables that a developer is interested in observing need be registered. | 03-17-2016 |
| 20160085660 | REAL-TIME USAGE CHECKING OF DYNAMICALLY GENERATED PROGRAM OUTPUT - Receive output dynamically generated by a running program and check that output for spelling, grammar, and/or other usage errors, providing notice to a user of any errors found. The dynamically generated output includes an assembly of component parts not statically assigned in a predetermined configuration or with predetermined content, but rather generated and/or configured by the executing program as it runs. | 03-24-2016 |
| 20160085661 | Multi-Browser Testing For Web Applications - In one aspect, there is an apparatus. The apparatus may include at least one processor, and at least one memory including computer program code. The at least one processor, the at least one memory, and the computer program code may be configured to cause the apparatus to perform operations including detecting, at a first synchronization application, an event representative of an action on a user element of a test web page. The operations may further include sending, by the first synchronization application, the detected event and an indication of the test web page to enable rendering of the test web page at a second device including a second synchronization application. | 03-24-2016 |
| 20160092338 | INSTALLATION HEALTH DASHBOARD - The disclosure generally describes computer-implemented methods, software, and systems for presenting error information. Logs are received from different locations, the logs associated with a plurality of builds at the different locations and associated with one or more systems. The logs are stored in a centralized location. Build information is generated for a given build, including identifying errors associated with the given build. Information for a current log associated with the given build is analyzed, including accessing information for previous logs associated with previous related builds related to the given build. Based on the analyzing, error diagnostic information that is to be presented is determined, including an analysis of errors that occurred in the given build and previous related builds. Instructions are provided, the instructions operable to present the error diagnostic information to a user, including providing log information, for presentation in a user interface. | 03-31-2016 |
| 20160092347 | MEDICAL SYSTEM TEST SCRIPT BUILDER - Computerized systems and methods facilitate the generation of customized test scripts for testing customized healthcare information technology systems. A number of different test script templates may be provided that each corresponds with a different scenario of use of the healthcare information technology system. A user may select a test script template and modify the test script template to generate a customized test script to meet the unique design and/or patient scenarios for a given installation of a healthcare information technology system. The test script template modification process may include first presenting an outline of the test script template, which the user may choose to modify. A detailed view of the test script template may then be provided that allows the user to view and customize actions and expected results in order to generate the customized test script. | 03-31-2016 |
| 20160103761 | SYSTEMS AND METHODS FOR PREPARING AN APPLICATION TESTING ENVIRONMENT AND FOR EXECUTING AN AUTOMATED TEST SCRIPT IN AN APPLICATION TESTING ENVIRONMENT - Systems and methods for preparing an application testing environment and for executing an automated test script in an application testing environment are disclosed. According to an aspect, a method includes providing graphical user interface (GUI) test automation objects. The method also includes classifying each of the GUI test automation objects as one of a test essential object and a test navigation object. Further, the method includes serializing the GUI test automation objects classified as a test navigation object for subsequent testing in a testing environment. | 04-14-2016 |
| 20160117237 | SYSTEMS AND/OR METHODS FOR MONITORING LIVE SOFTWARE - Certain example embodiments described herein relate to techniques for observing an internal state of a software application executing in a runtime environment. For instance, certain example embodiments include traversing a structure of multiple live data objects in the executing software application; generating a graph of shadow data objects based on the traversing, with each shadow data object of the graph corresponding to a live data object of the executing software application; and providing access to the generated shadow graph via a user interface. | 04-28-2016 |
| 20160140023 | MODELING AND TESTING INTERACTIONS BETWEEN COMPONENTS OF A SOFTWARE SYSTEM - Various systems and methods for are disclosed. For example, a method can involve extracting information from a response. The response is generated in response to a request generated by a test module during execution of a test case. The extracted information describes characteristics of transactions within the test case. The method can then involve generating a display, based upon the extracted information. The display includes information identifying each of the components that participated in at least one of the transactions within the test case. Such a method can be performed by a computing device implementing the test module. | 05-19-2016 |
| 20160140024 | METHOD AND DEVICE FOR TESTING SEMICONDUCTOR MANUFACTURING EQUIPMENT AUTOMATION PROGRAM - A method for testing an equipment automation program may be implemented using a hardware device and may include the following steps: receiving user input through a user interface of the device; automatically identifying a test scenario based on the user input; automatically and sequentially fetching a plurality of messages according to the test scenario; and automatically and sequentially sending the messages to the equipment automation program. | 05-19-2016 |
| 20160140033 | Test Bundling and Batching Optimizations - Test bundling and batching by a test execution framework may be customized in accordance with test suite requirements for testing platform implementations on network-connected, resource-limited devices. Tests, test data and test results may be communicated in bundles or batches. Multiple tests may be bundled into a test application bundle and communicated over a single data connection. Test data for the tests in a bundle may be packaged into a single batch and transferred using a single data connection. Similarly, results from executing the tests in a test application bundle may be batched and transferred together over a single connection. Additionally, a custom user interface may be utilized to allow for customizing the test bundling policy for individual test suites. Providing the ability for a user to customize the test bundling policy may significantly reduce the number of data connections required during test suite execution. | 05-19-2016 |
| 20160147638 | ENGINEERING TOOL, PROGRAM EDITING DEVICE, AND PROGRAM EDITING SYSTEM - An engineering tool includes a program display/editing unit that edits an official program to be run as an actual product and a debugging program to be used at the time of operation confirmation of the official program distinctively in such a manner that the debugging program is executed by a controller when the debugging program is selected and that the official program is executed by the controller without the debugging program being executed when the debugging program is not selected. | 05-26-2016 |
| 20160147641 | CROSS-BROWSER WEB APPLICATION TESTING TOOL - A system for cross-browser testing of one or more web applications may include receiving user selection of web browsers, one or more test fields each corresponding to a specified web element, one or more attributes each corresponding to a specified property of a web element, and a tolerance value for each of the one or more selected attributes. A system for cross-browser testing may be configured to compare a selected attribute of each selected test field within a web page rendered by one selected browser with a corresponding attribute of a corresponding test field within the web page rendered by another selected browser relative to a selected tolerance value, and generate a report of the comparison. A system for cross-browser testing may be configured for comparisons independent of a human language used and may include a language translation module. | 05-26-2016 |
| 20160162322 | Remote Debugging As a Service - Debugging capabilities for software running in a cloud-computing environment are disclosed. A controller identifies which machines in the cloud are running instances of software to be debugged. An agent is deployed onto the machines in the cloud to facilitate communication with the developer's machine. When the developer wants to debug software on the agent's machine, the agent downloads and installs a monitor onto the machine. The agent configures the machine for remote debugging via the monitor. A security mechanism ensures that only authenticated developers can access the monitor and the remote machine for debugging. A controller automatically determines which machines can be debugged, updates a list of processes available for debugging on the machines, and identifies how to connect a developer's debugging client to the machines. The controller permits remote debugging only upon request from an authenticated developer and only for those processes that the developer is permitted to debug. | 06-09-2016 |
| 20160162387 | PROMOTION DETERMINATION BASED ON AGGREGATED CODE COVERAGE METRICS - Techniques are described for aggregating code coverage data generated from various types of testing of software modules, and automatically determining whether to promote software upwards in a multi-level software deployment hierarchy based on the aggregated code coverage data. In embodiments, a code coverage metric is determined for a software module, and the metric is compared to a set of promotion criteria, including whether the metric meets a predetermined threshold for quality. In some cases, the threshold may be a general threshold, a threshold based on the level of possible promotion, and/or a threshold that is based on an identified category for the software module such as whether the module is a front-end module, a shared module, a legacy module, or a critical module. | 06-09-2016 |
| 20160170867 | EXPOSING METHOD RELATED DATA CALLS DURING TESTING IN AN EVENT DRIVEN, MULTICHANNEL ARCHITECTURE | 06-16-2016 |
| 20160188442 | RECORDING PROGRAM EXECUTION - 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. | 06-30-2016 |
| 20160188446 | COLLABORATIVE COMPUTER AIDED TEST PLAN GENERATION - Arrangements described herein relate to generation of test plans. A list of test case selection criteria can be presented to each of a plurality of stakeholders. At least one user input is received from each of the plurality of stakeholders selecting at least one test case selection criterion from the list of test case selection criteria and, for each selected test case selection criterion, assigning a criterion priority. Test cases, which correspond to the selected test case selection criteria, can be automatically selected to include in a candidate test plan. A candidate priority can be automatically assigned to each test case selected to be included in the candidate test plan. The processor selects the test cases to include in the candidate test plan and assigns the candidate priorities to the selected test cases based on processing the criterion priorities assigned to the selected test case selection criteria by the stakeholders. | 06-30-2016 |
| 20160196204 | Smart Validated Code Searching System | 07-07-2016 |
| 20160196205 | METHOD AND APPARATUS FOR ACCESSING REMOTE MOBILE DEVICES | 07-07-2016 |
| 20160253256 | CODE USAGE MAP | 09-01-2016 |
| 20160378641 | METHODS AND SYSTEMS FOR INTERNALLY DEBUGGING CODE IN AN ON-DEMAND SERVICE ENVIRONMENT - A remote debug session for a server group is provided. A server group including multiple servers that perform workload sharing receives a request to debug code executed at the server group. The code is executed on behalf of a client of a database associated with the server group. At least one of the servers of the group initiates a debugging session and establishes a communication connection with the client. The server group maintains the connection open with the client for the duration of the debugging session. Subsequent requests related to the debug session can be handled in a number of ways by the server group, and all communication to the client about processing the requests is through the connection. | 12-29-2016 |
| 20160378642 | EVALUATING USER INTERFACE USABILITY FOR TASK COMPLETION - According to one embodiment of the present invention, a system for tracking and presenting states of a user interface includes at least one processor. The at least one processor may be configured to track the visibility and usage of each of a plurality of areas of a user interface. The processor may be further configured to determine the navigation sequence through the plurality of areas of the user interface when utilized to complete a task. The processor may be configured to graphically present the visibility, usage, and determined navigation sequences on a display that includes a layout of the user interface, where the graphical presentation of the visibility, usage, and determined navigation sequences may be displayed within their corresponding areas of the layout of the use interface. | 12-29-2016 |
| 20170235662 | SOFTWARE APPLICATION QUALITY ASSESSMENT | 08-17-2017 |
| 20170235665 | VARIABLE DETECTION IN SOURCE CODE TO REDUCE ERRORS | 08-17-2017 |
| 20180024911 | SOFTWARE CODE DEBUGGER FOR QUICK DETECTION OF ERROR ROOT CAUSES | 01-25-2018 |
| 20180024912 | Application Testing System and Method | 01-25-2018 |
| 20180024918 | DETERMINING A TEST CONFIDENCE METRIC FOR A TESTING APPLICATION | 01-25-2018 |
| 20190146905 | Test Bundling and Batching Optimizations | 05-16-2019 |
| 20220138082 | Applied Computer Technology for High Efficiency and Scalable Value Stream Mapping - A system for value stream mapping is disclosed, the system comprising a processor and memory. The memory is configured to store a value stream map (VSM) model for a process, the VSM model comprising a sequence of active stages for a plurality of items of the process, wherein each active stage is associated with one or more status values attributable to the items. The processor is configured to (1) access a time series of status change data about items for the process, wherein the status change data comprises a plurality of status values exhibited by the items over time and (ii) transform the accessed time series into a VSM based on a correlation between (i) the status values exhibited by the items from the accessed time series and (ii) the status values associated with the active stages of the VSM model. Corresponding methods and computer program products are also disclosed. | 05-05-2022 |
