Abstract: A load generator services marketplace may configure and deploy load generators in conjunction with executing an application. The load generators may be selected based on a solution definition, which may include the types of loads and conditions under which loads may be generated. One or more load generators may be configured to operate with a monitoring service, and a connection manager may cause the load generators, application, and monitoring service to execute simultaneously so that the monitoring service may capture performance metrics while the application experiences the load. The marketplace may have load generators from multiple providers and with multiple configurations, as well as a clearinghouse for clearing a financial transaction as the load generators are used.

Abstract: Disclosed are various embodiments for an ingestion process modifying digital items. A computing system receives an uploaded digital item configured to communicate with a testing server application when executed. The ingestion process reconfigures the digital item to communicate with a production server application when executed.

Abstract: One embodiment of the present invention provides a technique for automatic diagnosis of regression test failures. Initially, an automatic regression test system provides the test results per configuration for a revision of the device under test. Next, each failing test is analyzed in conjunction with the information in the version control system that is used to manage the device under test in order to conclude what additional revisions that needs to be tested for each test and configuration in order to find the earliest failing revision. Next, a request is issued to the automated regression test system which performs the requested tests and provides back a list of test results. Next, another analysis takes places and if the earliest failing revision cannot be concluded for each failing test and configuration then another request is issues to the automated regression test system. This continues until the earliest failing revision can be concluded for each failing test and configuration.

Abstract: Embodiments of the present invention are directed to methods and systems for testing web sites and web servers. In discussed embodiments of the present invention, a third-party testing service collects page-access and conversion information on behalf of a web site. The third-party testing service is straightforwardly configured through a user interface and is engaged for real-time, live statistics collection by means of simple modifications of HTML files served or provided to users by a web site.

Abstract: Detecting configuration problems in an ECLIPSE-based software application can be detected. Such a method can begin with the receipt of a user-command to test a configuration of an ECLIPSE-based software application or with a detection of a feature addition/update when an auto-testing feature is enabled. Information about the available sites for the ECLIPSE-based application can then be obtained. Then, a list of software elements required to operate the ECLIPSE-based software application can be compiled. At least one data attribute can be extracted from the meta data of each software element in the compiled list. The extracted data attributes can then be analyzed. When the analysis identifies a configuration problem, the existence of the configuration problem can be validated.

Abstract: Computer code for a mock object is automatically generated and used in testing computer program code. Interactions with a method of an object that is described by the computer program code are captured. From the captured interactions, mock code that creates a mock object is automatically generated. The mock object mimics the captured interactions. Subsequently, test code, which has at least some of the computer program code and mock code, is executed to enable testing of the computer program code.

Abstract: A method is provided for testing a feature provider module of a data storage management application (DSMA), the feature provider module providing a feature. The method includes (a) receiving, at a simulation module of the DSMA when the DSMA is not in communication with an external feature implementation component, a test feature command from the feature provider module, (b) at the simulation module, simulating behavior of an interface module in communication with the external feature implementation component, and (c) at the simulation module, returning a feature response to the feature provider module, the feature response communicating the simulated behavior.

Abstract: A fully declarative build system is described for software build optimization. The build system supports complete control over build and test inputs and build and test operations. The build system takes inputs from a source control system. The inputs can include source code files, test files and various site files used to generate human-oriented materials for the modules. A dependencies file specifies a set of dependencies among the modules of the system. When invoked, the build system determines that changes have been made to the inputs. The system then parses the dependencies file, and based on it, determines exactly which inputs will be affected by the changes. The build system can then rebuild only those modules that will be affected by the changes, as determined from the dependencies file. Alternatively, the system may only perform testing or document generating for files which are dependent on the modified file.

Abstract: A software transactional memory system is provided with overflow handling. The system includes a global version counter with an epoch number and a version number. The system accesses the global version counter prior to and subsequent to memory accesses of transactions to validate read accesses of the transaction. The system includes mechanisms to detect global version number overflow and may allow some or all transactions to execute to completion subsequent to the global version number overflowing. The system also provides publication, privatization, and granular safety properties.

Abstract: A method of reproducing runtime environment for debugging an application includes reading an optimizer file from a non-volatile storage medium. The optimizer file includes a runtime environment, application definition information, and a log. The log includes summaries of events, actions, and a time mark of occurrence for each of the actions. A runtime environment for debugging the application is then defined and the application runtime is set up using the application definition information in the optimizer file. Further, the method includes running the application, attaching an optimizer, and triggering each of the actions to occur at a time mark of occurrence associated with each of the actions. Then, each of the actions and associated events is analyzed by comparing the events produced by running the application with the events in the optimizer file. If a fault is produced by the triggering, a debugger is invoked to analyze the fault.

Abstract: A system, method, and computer program product are provided for hooking code inserted into an address space of a new process. In use, creation of a process is identified. Additionally, code is inserted into an address space of the process. Still yet, at least one module being loaded in association with the process is identified. Further, the code is hooked at an entry point of the at least one module based on a determination of whether the at least one module includes a predefined module.

Abstract: An exemplary method includes receiving source code having a plurality of code segments, providing a desired level of quality for the source code, analyzing the source code to assign a complexity measure to each of the plurality of code segments and assigning a level of code coverage to each of the plurality of code segments based at least in part on the desired level of quality and the complexity measures. An exemplary system prioritizes quality improvements to source code based, in part, on a quality assessment. Such a system can improve code quality by assigning higher test coverage levels to modules with higher complexity.

Abstract: Phase abstraction may be utilized to increase efficiency of model checking techniques. A liveness property may be checked in respect to a phase abstracted model by modifying the liveness property in accordance with the phase abstracted model. A fairness property may be modified to ensure that the fairness property is held by the model checker. A counter-example produced by a model checker is modified to be in accordance to an original model. The counter-example comprises a repetitive behavior. The counter-example may be modified to shorten the repetitive behavior or to apply the repetitive behavior in an earlier cycle of the counter-example.

Abstract: A computer-implemented method for testing an HTTP-communicating service includes: installing a service in a first system, the first system making the service available to a second system for access using an HTTP request; installing a test program in the first system; testing the installed service using the test program, wherein the HTTP request is generated by the test program and received by the installed service; and presenting a result of the testing.

Abstract: Methods and systems to identify and reproduce concurrency bugs in multi-threaded programs are disclosed. An example method disclosed herein includes defining a data type. The data type includes a first predicate associated with a first thread of a multi-threaded program that is associated with a first condition, a second predicate that is associated with a second thread of the multi-threaded program, the second predicate being associated with a second condition, and an expression that defines a relationship between the first predicate and the second predicate. The relationship, when satisfied, causes the concurrency bug to be detected. A concurrency bug detector conforming to the data type is used to detect the concurrency bug in the multi-threaded program.

Abstract: Example embodiments disclosed herein relate to a method for generating test data for form validation, where the method includes maintaining metadata for a database, mapping a control field of the form to a column of the database, and generating test data based on the mapping and the metadata.

Abstract: A method includes instantiating a cloned network that includes a second set of virtual service nodes. The second set of virtual service nodes includes at least one cloned virtual service node that is a clone of a corresponding virtual service node in a first set of virtual service nodes. The at least one cloned virtual service node has access to a history of events that occurred at the corresponding virtual service node in the first set of virtual service nodes. The method includes initiating an interactive debugging session that includes processing of the events of the history of events.

Abstract: In a rule-based system for monitoring process adherence, first and second processing patterns are received and merged to provide a merged processing pattern. Each processing pattern, which may be expressed in a state graph representation, embodies at least a portion of a desired software code development process. Optionally, the merged processing pattern may be presented to a subject-matter expert to obtain feedback thereon. The merged processing pattern may then be converted into an executable process verification rule for use in monitoring process adherence. In an embodiment, development process event data is compared to the executable process verification rules. Violations of the rules result in the generation of failure indications that may be stored and subsequently reported as needed. In this manner, efficiency of automated process adherence monitoring systems may be improved when determining the level of compliance by developers with one or more software code development processes.

Abstract: Remote event receivers can register with a document repository computing system to receive notifications of events occurring at a document repository. The remote event receivers may register to receive notifications synchronously, whereby the remote event receivers can provide a response to the notification prior to the occurrence of the event, or asynchronously, whereby the remote event receivers provide no response. Synchronous remote event receivers can also specify in a response to the notification that the event should be canceled or may specify properties that should be changed. Remote event receivers can be pre-event receivers that receive notifications prior to the occurrence of an event, or post-event receivers that receive notifications following the event. When an event is to occur at the document repository, notifications are provided to the pre-event remote event receivers. Once the event has occurred, notifications are provided to the post-event remote event receivers.

Abstract: In general, in one aspect, a method for distributed testing includes providing a testing framework for the distributed testing of software to a number of clients at least some of which have a different operating environment than other of the clients, transmitting to each testing framework a component for testing, receiving client environment data and testing results from each testing framework, storing the testing results and environment data in a database; and reporting the results of running the tests on the clients.

Abstract: Compiling source code to provide an executable code build. The method includes configuring a pool of substantially identical virtual machines in a distributed cloud computing environment. Configuring may include configuring virtual machines to have generic code compiling functionality. The method further includes determining that source code for a particular user should be compiled. As a result, the method includes selecting a virtual machine from the pool of substantially identical virtual machines and configuring the selected virtual machine in a way that is specific to the user. Source code for the user is retrieved from a source control system deployed in the distributed computing environment. Using the virtual machine configured in the way specific to the user, the user's retrieved source code is compiled to compiled code. After compiling is completed, the configured virtual machine is restored to a generic form.

Abstract: A computer identifies one or more program functions within program code of a computer program affected by a program code change. The computer identifies program function calls made by the one or more program functions to other program functions. The computer adds the one or more program functions and program function calls to a program code database. The computer generates a mapping of relationships between the program functions of the program code. The computer selects one or more test scripts based on the mapping of relationships.

Abstract: In a managed execution environment, an error may be deferred until execution of the application, program, function, or other assemblage of code reaches a point at which calling the reference to a module associated with a missing type or type member becomes inevitable.

Abstract: In accordance with one embodiment of the invention, there is provided a method for modularizing testing of a software product. The method comprises receiving user input indicating a source and a destination of test content; and linking modification of the test content at the destination to modification of the test content at the source. In further related embodiments, receiving the user input may comprise receiving input of a copy/paste gesture for the test content, or a drag/drop gesture for the test content. The linking may comprise using a globally unique identifier to identify each test step of a test document; and using the globally unique identifier as a pointer from the destination to the source of the test content. The method may also comprise rendering the test content to the user as if the test content was in-line at the destination.

Abstract: A computer implemented method, a computer program product and a data processing system provide a method for modifying a computer program during execution of the computer program by a processor unit. A computer receives an instruction string. The instruction string has a new function data therein for replacing current function data of a function of the computer program during execution of the computer program by a processor unit. The function is capable of being changed during execution of the computer program to modify the behavior of the computer program. The computer replaces the current function data with the new function data. The new function data modifies the computer program. The computer program is modified while the computer program is executed by the processor unit.

Abstract: A processor performance profiler is enabled to for identify specific instructions causing performance issues within a program being executed by a microprocessor through random sampling to find the worst-case offenders of a particular event type such as a cache miss or a branch mis-prediction. Tracking all instructions causing a particular event generates large data logs, creates performance penalties, and makes code analysis more difficult. However, by identifying and tracking the worst offenders within a random sample of events without having to hash all events results in smaller memory requirements for the performance profiler, lower performance impact while profiling, and decreased complexity to analyze the program to identify major performance issues, which, in turn, enables better optimization of the program in shorter developer time.

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

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

Abstract: A method and system for repairing a program are provided herein. The method includes statically analyzing a code of a program via a modular program verifier and determining semantic errors within the code of the program based on the static analysis. The method also includes inferring verified repairs to the code of the program based on the semantic errors.

Abstract: Methods, apparatuses, and computer program products for synchronously debugging a software program using a plurality of virtual machines are provided. Embodiments include controlling, by a master debugging module operating on a first virtual machine, execution of the software program within the first virtual machine; controlling, by a slave debugging module operating on a second virtual machine, execution of the software program within the second virtual machine including delaying execution of the software program within the second virtual machine relative to the execution of the software program within the first virtual machine; detecting, by the master debugging module, an error in the execution of the software program within the first virtual machine; and in response to the detection of the error, capturing, by a hypervisor, a snapshot of the second virtual machine.

Abstract: This invention enables a target variable name to be confirmed without inputting all the character string even when a method of giving a name such as allocating a number to the end of the name is performed from the necessity to allocate a variable name having the same meaning to a plurality of different addresses. If narrowed down variable name exists in plurals and one or two or more continuous next character strings match each other among the variable names, the series of character strings without any choice are automatically adopted and confirmed as the character string of the target variable name without waiting for the input of an operator.

Abstract: First tag addresses and data are stored in association with first index addresses in a memory cell unit provided in a cache memory. The first tag addresses and the first index addresses are configured based on address information respectively. Designation address information is provided to designate an address to read one of the stored data. The designation address information is converted to a second index address and second tag address by an address converter, in order to read the one of the stored data according to the designation address information. The memory cell unit is accessed according to the obtained second index address. When one of the first tag addresses matches the second tag address, the one of the data corresponding to the one of the first tag addresses is read. The designation address information and the one of the data are displayed in a cache memory display unit.

Abstract: The tool, MC/DC-Automatic Tool Generator automatically generates test data to satisfy Modified Condition Decision Coverage (MCDC) from input code/model. This tool reduces the effort required to generate MCDC test data significantly. In order to reduce the time required by model checkers, abstraction and optimization methodologies have been implemented to analyze typical reactive software model/code.

Abstract: Systems, methods, and other embodiments associated with test code generation based on test documentation are described. In one embodiment, a method includes identifying a tagged test action object in a test specification document; mapping the identified test action object to an executable test instruction; and providing the executable test instruction for execution to test an application through a user interface associated with the application. The example method may also include storing executable test instructions as an executable test routine, validating test routines to confirm the presence of specified test instructions, and logging execution of the test instructions.

Abstract: A method to test a concurrent program by performing a concolic multi-trace analysis (CMTA) to analyze the concurrent program by taking two or more test runs over many threads and generating a satisfiability modulo theory (SMT) formula to select alternate inputs, alternate schedules and parts of threads from one or more test runs; using an SMT solver on the SMT formula for generating a new concurrent test comprising input values, thread schedules and parts of thread selections; and executing the new concurrent test.

Abstract: A method of preparing a test for an electronic system including a plurality of pieces of equipment interconnected by at least one communications link, in which method, in order to perform the test, use is made of a test bench appropriate for the electronic system under test, which test bench is connected to the system and controlled in application of a command sequence established from at least one informal functional specification; while preparing the test, the informal functional specification, the command sequence, and a link identifying the informal functional specification from which the command sequence was established are all recorded so that after execution of the command sequence and after the test results have been recorded, it is possible to read the link and identify unambiguously the informal functional specification that corresponds to the test results obtained.

Abstract: A technique for debugging code during runtime includes providing, from an outside process, a trigger to a daemon. In this case, the trigger is associated with a registered callback function. The trigger is then provided, from the daemon, to one or more designated tasks of a job. The registered callback function (that is associated with the trigger) is then executed by the one or more designated tasks. Execution results of the executed registered callback function are then returned (from the one or more designated tasks) to the daemon.

Abstract: A computer-implemented method, system, and computer-readable medium for emulating web service operations are presented. In a preferred embodiment, the computer-implemented method includes the steps of: collecting Web Services Description Language (WSDL) based descriptors of selected web service operations; receiving range and diversity descriptors for the selected web service operations; and inputting the WSDL based descriptors, range and diversity descriptors into an Automatic Web Service Emulator Generator (AWSEG) to generate a web service emulation of the selected web service operations.

Abstract: A method for hosting multiple life cycle stages of a web application includes installing a web application in a first environment together with a first version of a support package containing support software components for the web application, the first environment corresponding to a first life cycle stage of the web application, and executing the web application in the first environment together with the first version of the support package. The method further includes installing the web application in a second environment together with a second version of the support package containing support software components for the web application, the second environment corresponding to a second life cycle stage of the web application that succeeds the first life cycle stage of the web application, and executing the web application in the second environment together with the second version of the support package.

Abstract: Described is a method for managing test artifacts. According to an embodiment of the method, a test plan for a product is selected by a user. The test plan has multiple test artifacts that include the test plan and at least one of a test case, an execution record defining a configuration of the product, and a product requirement. One of the test artifacts is selected for a snapshot and the snapshot is acquired. The snapshot acquisition includes storing a current state of the selected test artifact, storing a current state of relationships of the selected test artifact to the other test artifacts, and storing a current state of the other test artifacts that have a relationship with the selected test artifact.

Abstract: A method for testing software may include receiving a user request to run a test, and identifying a test flow document associated with the test. The test flow document may specify a plurality of test steps and define a test flow for the test. Each of the plurality of test steps may correspond to an independently-compiled set of instructions. The method may further include executing the plurality of test steps using dependency injection provided in accordance with the defined test flow.

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

Abstract: A system for designing a circuit, which includes a module, uses a computer. A user may program or adapt the computer to perform computer-aided design functions. The computer obtains a description of the module from the user. The computer parses the description of the module to identify a port of the module, and to obtain information about the port. The computer presents to the user the information that it has obtained about the port.

Abstract: A method for software processing includes extracting from software code under test respective items of meta-information pertaining to elements of the software code and receiving respective quality data regarding the elements of software code. The quality data and meta-information are processed in a computer so as to assign respective metrics to the items of the meta-information responsively to the quality data regarding the elements of the software code to which the items pertain. At least some of the meta-information is presented to a user in accordance with the assigned metrics.

Abstract: A monitoring tool continuously monitors for insertion, call or deletion of objects from a session. Display of this information shows any get object, set object or remove object operations in the session and shows the entry and exit points for each such object, thus assisting the user whenever objects inserted or called remain in the session and are not removed, thus allowing the user to prevent any data buildup in the session.

Abstract: One embodiment of the present invention provides a system that facilitates testing a multi-threaded software application. During operation, the system, in response to invocation of a mock object, identifies a thread and determines whether the identified thread matches a description associated with an actor. The system, in response to the identified thread matching the description associated with the actor, evaluates whether an expectation is met or a stub is executed and returns a value based on the evaluation. In some embodiments, the expectation and the stub are expressed based on a role, wherein the role includes the actor and, optionally, one or more additional actors.

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

Abstract: A system and method for providing a static model map of behaviors in a middleware system, for use in identifying problems. In accordance with an embodiment, the system provides a view of the system which allows for analysis of the various components. Locations within the system where a request spends its time are categorized into either “wait” or “execution” locations. The components exhibit static behaviors which affect the response time and can be predefined for different types of components and analyzed independently. In turn the behaviors can be classified as either “wait” or “execution”, each of which can be considered aspects of a component. Each aspect of a component must satisfy the same efficiency/inefficiency as defined by the requirements on the system. An aspect that does not meet the criteria is considered a “problem aspect” and is analyzed further to find the cause of the problem.

Abstract: Methods and systems are disclosed for evaluating testing of a software system in a testing project in which the testing is performed on software code in a plurality of components of the software system. Multi-dimensional data related to the testing project, including results of the testing, are automatically collected. Values for metrics related to a quality of testing effort that components have undergone in the testing project are developed. In one embodiment, the measure is based on a measure of amount of software code of the plurality of components that has been tested during the testing project. Projected testing results at completion of the testing are developed by forecasting projected values of at least one metric at completion of the testing project.

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.