Abstract: The present invention provides a graphical model in a computing environment, where the graphical model includes at least a caller entity. A call command associated with the caller entity is executed, where the call command includes at least a partial name of the callee entity. The at least one callee entity may be identified based on the partial name of the at least one callee entity provided in the call command. The at least one callee entity may then be called.

Abstract: 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 to a vertex spawner that an instance of each computational vertex is to be spawned in the local execution environment based on the organizational topology and indicated data storage locations, and indicates to the local execution environment that the spawned vertices are to be executed.

Abstract: Various technologies and techniques are disclosed that provide an integrated debugger simulator. A debugger is provided that allows a user to debug an application in a live mode. A simulator is provided to read recorded data from an earlier point in time in an execution of the application. An integrated debugger simulator is provided by multiplexing the debugger between the application in the live mode and the simulator that reads the recorded data. A simulation mode is provided to allow the user to interact with the recorded data using the debugger. In this simulation mode, the user is able to interact with the recorded data using commands and data views available in the debugger. The user can multiplex between the live mode and the simulation mode from within the debugger.

Abstract: A method finds an error in a computer program. A plurality of execution breakpoints are set in the computer program. A portion of the execution of the computer program is simulated as recorded in the trace data in the reverse order until one a plurality of conditions is met, wherein one of the plurality of conditions is an attempt to execute a machine instruction associated with one of the plurality of execution breakpoints.

Abstract: A method finds an error in a computer program. A sequence of machine instructions performed by a processor is recorded as trace data. Further, at least one event is selected from a plurality of events. In addition, an operating system instruction address is determined for the at least one event. Further, at least a portion of the trace data is searched for the operating system instruction address. The execution time for an operating system instruction stored in the operating system instruction address is determined. The execution time is searched through in the database to find task related data. The task related data is displayed.

Abstract: A system and method for recording a state of an object in a computer program being tested. The system and method include: identifying an object having a plurality of fields, each field having a value; executing the computer program including a unit test; recording the values of each field of the identified object; generating assertions for the unit test from the recorded values of each field of the identified object; and inserting the generated assertions into the unit test. The computer program including the unit test having the generated assertions may be re-executed to verify the assertions. Furthermore, the unit test having the generated assertions may be modified and the computer program including the modified unit test having the generated assertions re-executed to generate new assertions.

Abstract: The invention relates to a method of designing a system. The system includes an application having software components and an architecture having hardware components on which the application is run. The system has to satisfy at least one functional and one non-functional requirement. The functional analysis step (11) obtains a breakdown of the functional need relating to the application. A step defines the architecture (12). A step for designs hardware components (13) according to the architecture. A step design software components (14) based on the breakdown of the functional need. A step for integrates the software components in the hardware components (15). A step validates the functional requirements of the system (16). A step validates the non-functional requirement of the system (17). An upstream step (21) validates the non-functional requirement of the system, preceding the steps for designing hardware components (13) and software components (14).

Abstract: During execution of a program, a processor may identify one or more object class instantiations that are associated by the program with a program state obtained during the execution of the program, may store in a file a description of the identified object class instantiations, where at least a portion of the execution of the program is simulatable based on the file, and may modify the first file in response to a user interaction with a graphical representation of one of the described object class instantiations, where a modified version of the portion of the execution of the program is simulatable based on the modified first file.

Abstract: The web load test apparatus includes a virtual web client generation section to generate virtual web clients each of which transmits a request message to a web server and receives a response message according to a scenario; a memory section to store synchronous point that specifies an order in the scenario of the response message, which is a synchronous point among the response messages, into a storage; a waiting section to interrupt the accesses by the clients until a time when all the clients receive the response messages whose orders are indicated by the synchronous point; a resumption section to resume the accesses when all the clients receive the response messages whose orders are indicated by the synchronous point; and a rewrite section to replace the synchronous point stored in the storage with synchronous point that specifies another response message.

Abstract: Software applications (“training applications”) that are designed to train users how to use a target software application may be generated by automatic examination of the target application. In one implementation, a device may extract elements of the target application that affect a user interface of the target application. The device may store the elements as user interface elements and generate a training application that uses at least some of the user interface elements to present portions of an interface of the target application.

Abstract: A testing tool for verifying a reliability of robot software components is provided, and more particularly, a simulation-based interface testing automation system and method that may automatically perform a test for functions and performance of an interface with respect to robot software components are provided. Thus, it is possible to efficiently perform a test for an interface of robot software components. In particular, it is possible to automatically generate test cases required for testing, to perform a test in various languages, and to perform a test suitable for a robot.

Abstract: Systems and methods facilitate accurate and rapid simulation of software by periodically saving simulation states and design stimuli for use as a replay model. Divergences from the stored information may be detected during subsequent re-executions, which can in turn be run using the saved stimuli and states.

Abstract: A video display terminal capable of operating with a graphical user interface such as Windows provides windowing functionality to permit use of popular applications programs resident on a server, without requiring more than application data to be transmitted from the server, and keyboard and mouse information to be transmitted from a terminal to the server. A terminal for communicating with a server includes a network interface for communicating with a server and a processor coupled to the network interface for operating with the network interface and for accessing a windows application resident on the server without executing locally the windows application resident on the server. The processor provides windowing functionality to permit use of a windows application resident on the server without requiring more than windowing information of the windows application to be transmitted from the server, wherein the windowing information includes application data.

Abstract: A system may include a plurality of test environments, each test environment being configured to simulate user actions according to a test configuration. The system may further include a test simulator device including a processor in selective communication with the plurality of test environments and configured to receive a user action; send the user action to a first of the plurality of test environments having a first test environment; and send the user action to a second of the plurality of test environments having a second test environment.

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

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

Abstract: A method and system to emulate an M-bit instruction set. At least some of the illustrative embodiments are a method comprising fetching at least a portion of an instruction (the instruction from a first instruction set that is not directly executable by a processor), indexing into a table to an index location (the index location based on the at least a portion of the instruction), executing a first series of instructions directly executable by the processor (the first series of instructions pointed to by the table at the index location), and thereby emulating execution of the instruction from the first instruction set.

Abstract: Symbolic execution identifies possible execution paths of a computer program or method, each having certain constraints over the input values. The symbolic execution also records updates of memory locations, e.g. updates of the fields of symbolic objects in the heap of an object oriented program, involving a description of the previous heap, the updated symbolic object, a field identification, and a newly assigned symbolic value. The symbolic execution can also record calls to summarized methods, involving a description of previous calls, an identification of the summarized methods, and its symbolic arguments. The behavior of summarized methods can be expressed by axioms. Axioms describe the relationship between summarized methods under certain conditions. Axioms can be generated from parameterized unit tests. A parameterized unit test is a method with parameters which executes a sequence of calls to methods of an implementation under test; it asserts constraints over the inputs and outputs of the calls.

Abstract: The present invention comprises apparatus and systems for measuring, monitoring, tracking and simulating enterprise communications and processes. A central message repository or database is constructed, comprised of monitoring messages sent from process messaging systems. The database may then be accessed or queried as desired. A simulation tool assists in reviewing present and proposed processes and sub-processes before modifying existent systems or creating new systems.

Abstract: Methods and systems for debugging byte code in an on-demand service environment system including a system for simulating execution debug in a multi-tenant database environment. In one embodiment, such a method includes receiving a request at a web-server of the system, wherein the request comprises a request for services from a multi-tenant database implementation within the system, in which the multi-tenant database implementation includes elements of hardware and software that are shared by a plurality of separate and distinct customer organizations, each of the separate and distinct customer organizations being remotely located from a host organization having the system executing therein.

Abstract: A method for preventing a return address from being falsified due to a buffer overflow during the program execution, and for detecting the buffer-overflow beforehand. When the return address is re-written during program execution, the debug function of the central processing unit is used to output an error. The falsification of the return address is detected through the error output. Then the falsified return address is re-written to a value stored in advance to enable the program to return to normal operation. When the falsification of the return address is detected, the executing program is terminated.

Abstract: A method, system and computer program product for recording and replaying a program execution in a client-server environment capable of supporting different client-server communication protocols. A common recorder of the exemplary embodiments identifies respective class files and libraries used by a client application to process client actions and data passed in client requests and server responses. The recorder stores class files and data in a replay file and later re-creates server loads and client actions based on the class files, data and client action results in the replay file during a replay of the execution.

Abstract: An automated software testing and validation system allows testing of a software application under test (SAUT) regardless of the dynamic nature of the SAUT. An abstracted set of hierarchal or linear objects model certain regions of the SAUT. Automated test scripts utilize theses regions to intuitively navigate and identify potions of the SAUT to automate. The scripts can also access specific SAUT elements contain within each defined region. These elements can then be used to invoke actions or verify outputs there from. The system uses a set of rich identification rules embodied in the system which allow the user to configure the identification of any element within the abstracted region. The rules are customizable to allow the user to configure the desired level of loose coupling between the automated scripts and the target element to adapt the scripts to the nature of the SAUT.

Abstract: Methods, data processing systems, and program products supporting the insertion of clone latches within a digital design are disclosed. According to one method, a parent latch within the digital design is specified in an HDL statement in one of the HDL files representing a digital design. In addition, a clone latch is specified within the digital design utilizing an HDL clone latch declaration. An HDL attribute-value pair is associated with the HDL clone latch declaration to indicate a relationship between the clone latch and the parent latch according to which the clone latch is automatically set to a same value as the parent latch when the parent latch is set. Thereafter, when a configuration compiler receives one or more design intermediate files containing the clone latch declaration, the configuration compiler creates at least one data structure in a configuration database representing the clone latch and the relationship between the clone latch and the parent latch.

Abstract: A mechanism for determining a probabilistic security score for a software package is provided. The mechanism calculates a raw numerical score that is probabilistically linked to how many security vulnerabilities are present in the source code. The score may then be used to assign a security rating that can be used in either absolute form or comparative form. The mechanism uses a source code analysis tool to determine a number of critical vulnerabilities, a number of serious vulnerabilities, and a number of inconsequential vulnerabilities. The mechanism may then determine a score based on the numbers of vulnerabilities and the number of lines of code.

Abstract: A method to control a device may include forming an integrated simulation model of an actual environment in which the device is or will be operating. The integrated simulation model may be formed using pre-existing data and real-time data related to the actual environment. The method may also include presenting a simulation including a representation of the device operable in the integrated simulation model of the actual environment and allowing control of operation of the simulation of the device in the integrated simulation model of the actual environment. The method may further include controlling operation of the device in the actual environment using the simulation of the representation of the device in the integrated simulation model of the actual environment.

Abstract: One embodiment of the present invention provides a system for testing a binding Application Programming Interface (API) on a device, wherein the binding API is bound to a native API for the device and provides different commands than the native API. During operation, the system executes a native-API test on the device through the native API to produce a native-API test-result. The system subsequently receives the native-API test-result from the device at a test-harness. Next, the system sends a binding-API test to a test-agent on the device which enables the test-agent to execute the binding-API test through the binding API to produce a binding-API test-result. The system then receives the binding-API test-result from the test-agent. Finally, the system compares the native-API test-result to the binding-API test-result to determine if the binding API is functionally equivalent to the native API.

Abstract: A database development system is provided. The system includes a current-state source representation of a database that can be captured in a model of the database and a metadata component that preserves user intentions describing when a user interacts with the system to perform a refactoring operation (or other code enhancement) for use in subsequent operations by the system. A deployment component is provided that utilizes the preserved user intentions to optimize behavioral upgrades to the system, where simulations can be run against the model to facilitate efficient and automated deployments.

Abstract: A system and method to generate simulations of a target application or software. The method comprises recognizing a start point associated with a multiple path simulation of a target application and automatically generating simulation branches of the multiple path simulation from the recognized start point. The method and system of the invention allows a simulation developer to create “multi-path” simulations more quickly and efficiently by, for example, (i) recognizing which junctions in the simulation are starting points for multiple paths, (ii) where the multiple paths converge, and (iii) the content of the multiple paths.

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

Abstract: The present invention enables a component under test to bind to a single component, that is capable of simulating most depended upon services, including the details of their interface, whether or not they return explicit results or cause side effects, and regardless of the state of their implementation. This invention includes features that allow for dynamic reconfiguration to meet the needs of both manual and automated testing, including the ability to control normal and exceptional results, as well as features to support both unit and integration testing.

Abstract: The processing of server pages is emulated at run time. The system includes a library of custom tags, and a server page emulator for reading the server page, including identifying any calls to the library of custom tags, and further for emulating any calls to the custom tags identified in the server page; and thereby generating and processing the server pages dynamically at runtime. Each server page is parsed to create a tree of nodes for each element of the page, and each node identified as one of template text, custom tag start, custom tag end, and expression language (EL) expression. For each template text node, text is written directly to final markup. For each custom tag node, a return code indicates that the body should be skipped, processed normally, or provided as bulk data to the tag implementation. For each EL expression node, the EL expression is evaluated and the result written to final markup.

Abstract: A method for managing a profile includes generating an initial profile of code using an initial sampling frequency. An information entropy value of the profile is computed. A representative profile of the code is determined from additional profiles using a sampling frequency determined from the information entropy value. Other embodiments are disclosed and claimed.

Abstract: A method of analyzing simulation results of a model, the method comprising: obtaining a process model including model elements including tasks, non-reusable sub-processes, and called reusable sub-processes; assigning a unique identifier to each model-element; generating unique model-element-proxies for all model-elements except for model elements corresponding to a model-reusable-sub-process or a model element contained by a model-reusable-sub-process; generating unique model-element-proxies for model-reusable-sub-processes and model-elements contained by model-reusable-sub-processes; associating each generated model-element-proxy with a corresponding model-element; executing simulation of the process model and persisting for each element instance data produced during simulation, the instance data including an element instance identifier and a corresponding model-element-proxy identifier; querying persisted simulation data for information using model-element-proxy identifiers.

Abstract: A computer system for programming applications in a programming environment, including, a computer adapted to execute software to form a programming environment enabling creation of a software application using multiple programming languages, a multidimensional debugger installed on the computer; wherein the multidimensional debugger is made up from two or more debuggers each for use in debugging a different programming language, wherein the two or more debuggers use a common work memory to share information; and wherein the two or more debuggers use a common user interface.

Abstract: A method for unit testing of business processes for Web services, including steps of mapping the Web service description language (WSDL) elements of a process under test and its partner processes into equivalent Object-Oriented language (OO) elements, and performing testing on the process under test based on Object-Oriented unit testing frameworks. Each Web service interface of the process under test and its partner processes is mapped into an equivalent OO interface, partner stubs are generated on basis of the OO interfaces of the partner processes, WSDL binding and service port information are defined for the generated partner stubs, test cases are formed which contain test logic describing the service invocations between the process under test and its partner processes, and the test cases are executed, wherein the partner stub and its associated mock object collectively implement the service of a corresponding partner process.

Abstract: There are provided a method and system for testing software for an industrial machine with continuous test values reflecting actual environmental factors, using a simulator before the software for the industrial machine is embedded into an actual industrial machine. A method for testing software for an industrial machine, the method comprising the steps of: coding a program for a diagram through which the industrial machine is driven; compiling the program into an instruction with which the industrial machine is driven; downloading the compiled program onto a simulator for implementing a programming interface provided by the industrial machine; executing the compiled program in the simulator: generating a first data for testing the compiled program: transmitting the first test data to the simulator having the downloaded program from a testing tool; and outputting a result data obtained after executing the program having the transmitted first test data and then transmitting the result data to the testing tool.

Abstract: A method for testing a software program creates test data by simulating data exchange messages between a server and a client and stores test data in Comma Separated Value (CSV) files. Data repository files stored in the CSV format can be edited by common tools, like a spreadsheet program, and can be maintained easily. The test automation method provides a data capturer tool so that the data repository could be created based on any existing test environment. The test automation method converts data repository files and simulates messages in order to load data to a mobile infrastructure system and set up data fixtures. The test automation method could be integrated in a build process so that data repository and test cases are validated against any program changes periodically.

Abstract: Methods, systems and computer program products are disclosed for automatically generating hardware description language code from a model. The hardware description language code may be generated from a graphical program/model, such as a block diagram model. The hardware description language code may also be generated from a text-based program/model, such as a model created using MATLAB® tools. In particular, the present invention provides for the automatic code generation of an interface between components in the model. The present invention may provide options for selecting at least one of multiple types or styles of the component interfaces in the model. The selection of the interface types or styles may be controlled by the user or inferred by other parameters, such as implementation parameters.

Abstract: A computer-implemented method for generating and managing test documentation for a software product may include steps of generating a test template; generating at least one test scenario for each of a plurality of functional areas, each test scenario being configured to test a business flow that mimics how an end user would use the software product; associating the generated test scenario(s) with the generated test template; generating at least one test case that includes a plurality of test steps; associating the generated test case(s) with the generated test template; copying the test template to generate test results, the generated test results being independent of the generated test template, and carrying out a test cycle by executing the test scenario(s) and the test case(s) associated with the generated test results of the generated test template and storing the results of the executed test scenario(s) and the executed test case(s) in a database.

Abstract: A method is implemented in a computer infrastructure having computer executable code tangibly embodied on a computer readable storage medium having programming instructions. The programming instructions are operable to receive a maturity level for an organization and select at least one defect analysis starter/defect reduction method (DAS/DRM) defect profile based on the maturity level. Additionally, the programming instructions are operable to determine a projection analysis for one or more stages of the life cycle of a software code project of the organization based on the at least one DAS/DRM defect profile.

Abstract: Systems and methods for run-time switching for simulation with dynamic run-time accuracy adjustment. In one embodiment, a computer implemented method performs a simulation of a computer instruction executing on a simulated hardware design by a first simulation model, wherein the first simulation model provides first timing information of the simulation. The first timing information is stored to a computer usable media. A pending subsequent simulation of the instruction is detected. Responsive to the presence of the first timing information in the computer usable media, the computer instruction is simulated by a second simulation model, wherein the second simulation model provides less accurate second timing information of the simulation than the first simulation model. The simulation run time information is updated for the subsequent simulation with the first timing information.

Abstract: An automated analysis system identifies the presence of malicious P-code or N-code programs in a manner that limits the possibility of the malicious code infecting a target computer. The target computer system initializes an analytical virtual P-code engine (AVPE). As initialized, the AVPE comprises software simulating the functionality of a P-code or intermediate language engine as well as machine language facilities simulating the P-code library routines that allow the execution of N-code programs. The AVPE executes a target program so that the target program does not interact with the target computer. The AVPE analyzes the behavior of the target program to identify occurrence of malicious code behavior and to indicate in a behavior pattern the occurrence of malicious code behavior. The AVPE is terminated at the end of the analysis process, thereby removing from the computer system the copy of the target program that was contained within the AVPE.

Abstract: A computer implemented method, an apparatus, and a computer usable program product for rendering client-side logic in a webpage when the webpage is rendered is provided. A webpage development framework initiates a script component built in a component library of a webpage development framework, wherein the script component is subject to a lifecycle of the webpage development framework. The webpage development framework defines at least one webpage attribute using at least one value-binding expression in the script component, wherein the at least one value-binding expression provides access to a server-side data model. The webpage development framework then evaluates the at least one value-binding expression, wherein the at least one value-binding expression comprises a current value for the server-side data model.

Abstract: The invention relates to a device for testing the structural coverage of a software program and a method implementing the device. The software, stored in a first memory comprises instructions which can be located via addresses on an address bus connecting the processor to the first memory. The device includes a second memory connected to the address bus that can be used to store values in memory associated with each address, these values indicating the conditions for calling up the associated address by the processor. The method consists in erasing all the contents of the second memory, performing tests validating the software, comparing the contents of the second memory with a list of addresses where instructions are located.

Abstract: A generalized software process simulation model is utilized to simulate software engineering processes and support project management and control. The simulation model takes advantage of generic software modeling blocks which represent differing stages or activities in a software development process and are represented in modeling environment. The generic software modeling blocks are also used to represent sub-processes and activities within higher-level processes. The blocks also provide dialog boxes which allow entering and adjustment of data and equations. Through manipulation of blocks and comparisons of simulations, a project manager can simulate and observe the outcome of different process decisions. Additional simulation capabilities are possible, as software engineering is one example of the technology.

Abstract: A software application recreation in a computing environment is provided. One embodiment involves analyzing program execution trace data of a software application, and using the analysis results in recreating an executable version of the software application from data traced at significant points during the software application execution. Recreating an executable version of the software application involves creating white space code to simulate the software application execution timing by replacing business logic code of the software application with white space code in the recreated executable version. The recreated executable version of the software application programmatically behaves essentially similarly to the software application.

Abstract: There is disclosed a system for flattening hierarchically structured flows using a breadth-first approach. At each level of hierarchy of a hierarchically structured source flow, complex nodes are flattened by one level across the entire breadth of the flow. The results of this flattening are placed in a target flow, and any connections that existed in the source flow are re-established in the target flow in such a way that any data input into the target flow will be processed as if it had been input into the source flow. After a processing iteration, if there are still complex nodes remaining in the target flow, the target flow becomes the next source flow, and the process is repeated until the flow has been completely flattened.

Abstract: The operation of an electronic system comprising a plurality of integrated circuits or other circuit elements is simulated using a software-based development tool that provides a generic framework for simultaneous simulation of multiple circuit elements having potentially different clock speeds, latencies or other characteristics. One or more interfaces provided in the software-based development tool permit registration of processing events associated with one or more of the circuit elements. The software-based development tool is further operative to determine a system clock for a given simulation, and to schedule execution of the associated processing events in a manner that takes into account differences between the system clock and one or more circuit element clocks, so as to maintain consistency in the execution of the processing events relative to the determined system clock.

Abstract: End-to-end testing of applications across networks is enabled. To test the application and the infrastructure subsystems, an application server connected to the network contains an application under test. A response simulator is connected to the other end of the network. A test module is accessible to the application and to the simulator and contains a test message to be transmitted to the simulator, and an expected response message from the simulator. The application transmits each test message and compares a response message from the simulator to an expected response message. The simulator obtains the response to each test message from the test module.