Abstract: A method is disclosed and includes receiving, using a first client computing system, an instance from an administrative computing system. The instance includes a partition of computing resources of the administrative computing system. The partition of computing resources includes a virtual processor and first machine-readable instructions. The first machine-readable instructions include a first predefined software bug. The method includes executing, using the virtual processor, the first machine-readable instructions. Executing the first machine-readable instructions includes receiving, using the virtual processor, a first input indicating an identification of the first predefined software bug of the first machine-readable instructions.

Abstract: Some examples of the present disclosure relate to generating a distributed debugging environment for a continuous integration (CI) pipeline. For example, a system can detect a failure of a CI pipeline in relation to a code submission for a software project, the CI pipeline being performed in a distributed CI environment including CI nodes. The system can determine a configuration of the distributed CI environment in response to detecting the failure. The system can generate a distributed debugging environment based on the configuration of the distributed CI environment, the distributed debugging environment including debugging nodes that are separate from the CI nodes. The system can modify a configuration setting of the distributed debugging environment for use in determining a source of the failure of the CI pipeline with respect to the code submission.

Abstract: Computer-implemented techniques solve a number of problems with producing idiomatic software documentation for many programming languages from a common specification written in a common specification programming language. The techniques may be employed by a documentation generator computer program that translates the common specification into software programming interface documentation for each of many different programming language targets. The techniques may also be employed by a source-to-source compiler that incorporates the techniques to generate documentation from the common specification for each of many different programming language targets in addition to compiling the common specification into the different target languages.

Abstract: A transmission method includes: dividing a picture into a plurality of regions; generating a plurality of pieces of encoded data that respectively correspond to the plurality of regions by encoding the plurality of regions such that each of the plurality of regions can be decoded independently; packetizing the generated plurality of pieces of encoded data into a plurality of packets such that pieces of encoded data for different regions are not stored in a single packet; and transmitting the plurality of packets. By this, workload for generation of decoding target data is reduced.

Abstract: Software-update risks can be mitigated for end users by implementing some examples described herein. In one example, a system can receive an indication that an end user used a particular feature of an existing version of a software application on a computing device of the end user. The system can also determine that an update for the software application includes a code change to the particular feature. The system can generate a risk score for the update based on the code change. The system can then generate a graphical user interface indicating the risk score for the end user. This may assist the end user in determining whether to apply the update to the existing version of the software application.

Abstract: A method and system for finding vulnerabilities in a program using fuzzing have been provided. The disclosure provides a vulnerability detection framework using a language agnostic single fuzzer that can fuzz smart contracts written in different programming languages. The idea here is that a smart contract written in a high-level language is converted/compiled into an LLVM intermediate representation (LLVM IR) code and then perform the fuzzing on this LLVM IR code instead of fuzzing smart contract source code directly. The process of generating fuzz driver, report driver is automated by handling the standardization issue by carefully dividing the smart contracts into categories. The present disclosure is proposing processes of automation of fuzz or report driver generation. Further the language agnostic feature (done with intermediate representation) is also achieved. Further profiling is achieved which processes fuzzer output and generates meaningful data points.

Abstract: Techniques described herein relate to a method for managing a distributed multi-tiered computing (DMC) environment. The method includes obtaining, by a local controller associated with a DMC domain, a set of correlated services associated with an anomaly; obtaining a service dependency graph associated with the set of correlated services; generating a causal variance for each service using the correlated services and the service dependency graph; generating a weighted rank order of causal services based on the causal variance associated with each service, and the weighted rank order of causal services includes a portion of the services associated with an application associated with the anomaly; and performing remediation based on the weighted rank order of the causal services.

Abstract: In response to an operating system crash, a system may recovering by initiating a reboot and performing a dump of a core file for analysis which includes determining a root cause of the operating system crash and determining a patch for the root cause.

Abstract: A system can identify a file comprising computer-executable instructions, wherein the file has been modified since the file was last transformed into a computer-executable program on which a group of tests was performed. The system can, for respective tests, determine respective line coverage ratios, respective function coverage ratios, and respective branch coverage ratios. The system can select an updated group of tests from the group of tests based on the respective line ratios, the respective function ratios, and the respective branch ratios, the updated group of tests comprising a subgroup of the group of tests. The system can create an updated computer-executable program from the file. The system can test the updated computer-executable program with the updated group of tests.

Abstract: A system and methods to emulate an application executing in real time in a mobile device. The mobile device is emulated in real time using a model running on a processor extrinsic to the mobile device. The model is based on characteristics indicative of performance of the mobile device and/or performance of the operator network. The application is executed in real time within the model and the application executing in the model is monitored to determine resource utilization information by the application and/or by the operator network for the mobile device. The resource utilization information for the mobile device and/or the operator network is displayed.

Abstract: Techniques for automated system requirements analysis are disclosed. A system requirements analysis (SRA) service generates a system model that includes system requirements, at least by performing natural-language processing on a natural-language representation of the system requirements. Based at least on the system model, the SRA service performs an analysis of the system requirements against codified system requirements rules. The SRA service determines, based at least on the analysis of the system requirements against the codified system requirements rules, that the system requirements include a violation of a system requirements rule. The SRA service generates a report that identifies at least (a) the violation of the system requirements rule and (b) a suggested action to remediate the violation of the system requirements rule.

Abstract: An electronic system includes a first data retriever to communicate with a first database associated with an analytic tool, and a second data retriever to communicate with a second database associated with an electronic testing device; wherein the analytic tool is configured to store information regarding actual usage of a product in the first database; wherein the electronic testing device is configured to store product testing data for the product in the second database; wherein the first data retriever comprises a first communication interface to electronically receive the information; wherein the second data retriever comprises a second communication interface to electronically receive the product testing data; and wherein the electronic system further comprises a processing unit configured to compute a score indicating a quality of product testing for the product based on the information regarding the actual usage of the product and/or the product testing data.

Abstract: Systems and methods for customer journey orchestration are described. One or more aspects of the systems and methods include identifying, by a customer journey orchestration application, a customer journey having a previously unidentified fault; initiating, by a mode selection component, a debug mode of the customer journey orchestration application for the customer journey; receiving, by a graphical user interface of the customer journey orchestration application, a user input corresponding to an event of a plurality of events of the customer journey; simulating, by an event simulation component, the event based on the user input and the debug mode; determining, by a status component, a status of the event based on the simulation; and identifying, by a fault identification component, the previously unidentified fault based on the status of the event.

Abstract: A computer-implemented method for local arrangement of remote deployment is provided according to embodiments of the present disclosure. In this method, a starting request to connect with a remote virtualization entity proxy can be received. A network tunnel can be initiated between a local system and the remote virtualization entity proxy. Then, at least one component in the remote virtualization entity proxy can be arranged into a local virtualization entity in the local system via the network tunnel.

Abstract: The invention relates to an apparatus and a system for debugging a solid-state disk (SSD) device. The apparatus includes a Joint Test Action Group (JTAG) add-on board; and a Raspberry Pi. The Raspberry Pi includes a General-Purpose Input/Output (GPIO) interface (I/F), coupled to the JTAG add-on board; and a processing unit, coupled to the GPIO I/F. The processing unit is arranged operably to: simulate to issue a plurality of JTAG command through the GPIO I/F to the SSD device for dumping data generated by the SSD device during operation from the SSD device.

Abstract: Methods, systems, and computer-readable media for verification of configurations of compute clusters. An automatic computational process is used to statically and/or dynamically verify configurations of software components installed on one or more interconnected computing entities constituting a compute cluster. Cluster configuration data is obtained, including data representative of a configuration of the software components. The cluster configuration data is processed to identify errors relating to interactions between the software components. Errors may be reported to users and/or corrected by modifying the compute cluster configuration.

Abstract: An information handling system instantiates a hardware configuration generator to generate platform configurations. The hardware configuration generator provides a ranked list of the platform configurations, receives platform customer service request information, provides a ranked list of part numbers associated with the platform configurations based upon the customer service request information, and modifies the ranked list of platform configurations based upon the ranked list of part numbers.

Abstract: A system is provided for distributed execution of a sequence processing chain. The system comprises an interface adapted to set a measurement sequence for a plurality of measurement sites, each comprising a sequence runner. The system further comprises a sequencer repository adapted to be accessed locally from the plurality of measurement sites. Moreover, the system comprises a sequence state manager adapted to receive measurement sequence states from at least one sequence runner and further adapted to distribute the measurement sequence states to other sequence runners via a network. In this context, the measurement sequence states are associated with data and/or results through the sequence processing chain.

Abstract: A method for detecting computer issues includes identifying a target computer system. A first set of data for a first time period relating an operating metric from the target computer system are received. The operating metric is stored. A second set of data for a second time period relating to the operating metric is received. The first and second sets of data are compared. A difference between the two sets of data is identified. If the difference between the two sets of data is within a range a warning notification is displayed in a graphical user interface. An input is received in the graphical user interface in response to the warning notification being displayed.

Abstract: A system includes a memory device and a processing device coupled to the memory device. The processing device is configured to switch an operating mode of the memory device between a test mode and a non-test mode. The system further includes a test mode access component that is configured to access the memory device while the memory device is in the test mode to perform a test mode operation.

Abstract: Systems and methods for automatic validation of software components comparing source code and feature documentation are provided herein. An exemplary method includes assessing functional validation of software components by comparing the claimed features of software components against the features extracted from their source code. To prevent the issue of having to try unverified software components the present disclosure provides a solution that uses machine learning to extract claimed features of a software component and its actual features that are implemented in its source code. Then, for evaluating the software components, the disclosed solution compares the claimed features of software components against the features extracted from their source code to give a validated score to the developer so that the developer can easily decide on choosing the validated software.

Abstract: Systems and methods for analyzing an event log for a plurality of instances of execution of a process to identify a bottleneck are provided. An event log for a plurality of instances of execution of a process is received and segments executed during one or more of the plurality of instances of execution are identified from the event log. The segments represent a pair of activities of the process. For each particular segment of the identified segments, a measure of performance is calculated for each of the one or more instances of execution of the particular segment based on the event log, each of the one or more instances of execution of the particular segment is classified based on the calculated measures of performance, and one or more metrics are computed for the particular segment based on the classified one or more instances of execution of the particular segment.

Abstract: Mechanisms and methods are provided for establishing vectors indicating the presence, in a first vehicle and second vehicle, of a super-set of vehicle features present across a fleet of vehicles. The first vehicle may be a reference vehicle. A distance function of the vectors may be calculated in order to establish a similarity score indicating the degree of similarity between the designs of the two vehicles. If the second vehicle is sufficiently similar to the reference vehicle, a software update may be recommended and applied.

Abstract: Inputs to a system under test (SUT) are modeled as a collection of attribute-value pairs. A set of testcases is executed using an initial set of test vectors that provides complete n-wise coverage of the attribute-value pairs. For each execution of the testcases, for each attribute-value pair, a non-binary success rate (SAV) is computed based on the binary execution results. in response to a success rate of an attribute-value pair being below a predetermined threshold, a subset of testcases that use the attribute-value pair is identified. Further, sets of code paths for the subset of testcases are identified, each set of code path respectively corresponding to a testcase from the subset of testcases. Further, an intersection of the sets of code paths is determined. Code paths of the SUT that are in the intersection, are highlighted to represent a soft failure with the SUT.

Abstract: Provided is a test facility management system that can evaluate, in a software development process requiring use of test facilities, progress of a process caused by increasing or decreasing a count of the test facilities. The test facility management system can include: a project progress forecast unit that stores a process information database, a facility reservation information database, a process progress history information database, and facility count proposed change information, calculates facility usage remaining time period for the software development process based on process progress history information, specifies a time range during which facilities of the count of proposed change are available, and forecasts, based on the available time range, the progress of the software development process when work for the facility usage remaining time period is carried out by the facilities of the count of the proposed change; and a user interface that outputs the forecasted progress information.

Abstract: Computerized systems and methods are provided to intelligently and dynamically generate at least a first set of tests to be executed on one or more changes made to one or more applications to determine whether the one or more changes were successful. Data is received regarding one or more changes and a failure probability value for each change is determined. A first plurality of fields are generated for completion by a first user. Upon receiving responses for the first plurality of fields, a first customized code is generated and based upon first customized code, a first set of tests to be executed on the second version of the first application is generated. Additionally, the first set of tests are assigned labels, stored for future use, and executed on the second version of the first application.

Abstract: An API reader reads a system application's API specification file and creates a root.yml file containing key:value pairs, in which the keys are objects, and the values are staging_object.yml files. Each staging_object.yml file includes a set of entries, with each entry including a REST operation, a REST endpoint, and a description of the operation to be performed using that entry. An intelligent API converter creates structured object.yml files based on corresponding unstructured staging_object.yml files, and replaces the staging_object.yml files of the root.yml file with the newly created object.yml files. Each object.yml file includes a plurality of entries, corresponding to the entries of the respective staging_object.yml file. Each entry of the object.yml file includes an OPERATION, a JSON payload, and a VALIDATION section. An API builder uses the root.yml file to build a REST API for the system under test which is used to automate testing of the application.

Abstract: A system for automatically addressing serially connected slave devices includes a master device and multiple slave devices each including a serial communication transceiver, an address input port, an address output port, and a controller. The system also includes a serial communication wiring bus connected between the serial communication transceivers of the master and slave devices, and at least one digital address line connected between the address input ports and the address output ports. Each controller is configured to receive a PWM or PFM signal from a previous one of the multiple slave devices, determine an address for the slave device including the controller according to the received PWM or PFM signal, and transmit a PWM or PFM signal indicative of the determined address to a subsequent one of the multiple slave devices.

Abstract: An embodiment of the present invention is directed to a code audit tool that intelligently analyzes and profiles code, such as Python code, based on a variety of previously unmeasured factors and metrics including a set of software dimensions, such as Algorithmic Complexities; Software Sizing Metrics; Anti-Pattern Implementations; Maintainability Metrics; Dependency Mappings; Runtime Metrics; Testing Metrics; and Security Metrics. Once this analysis is complete, a standardized report card or other scoring interface may be generated. This may include analytical findings as well as suggestions and recommend steps so that developers can make informed decisions, enhance their code bases and improve the score assigned to their code.

Abstract: Methods, apparatus, systems, and articles of manufacture are disclosed to determine refined context for bug detection. At least one non-transitory machine-readable medium includes instructions that, when executed, cause at least one processor to at least classify a node on a graph, the graph to represent a computer program, the node to contain partial bug context corresponding to the computer program; identify a location of a software bug in the computer program, the location based on the node; determine a static bug context of the software bug using the location of the software bug; determine a dynamic bug context of the software bug using the location of the software bug; and determine a refined bug context based on a merge of the static bug context and the dynamic bug context.

Abstract: Embodiments of the present disclosure relate to detecting and mitigating errors associated with software pull requests such as software deployment packages. The embodiments include identifying a failure of a pull request, identifying a system error associated with the failure, determining a failure mitigation process based on the failure and the system error, and executing the failure mitigation process to resolve the failure. The errors can be classified as system errors, user errors or planned downtime. The failure mitigation process can include generating an alert associated with the identified system error, updating a status of the pull request, re-evaluating the failure after a predetermined period of time, and retrying deployment of the pull request using an exponential retry process.

Abstract: A testing system includes a client library that functions as a proxy for remote procedure calls to allow commands to be issued directly from a test framework including an interface that enables remote procedure call commands to be sent to a device under test from a mobile device and responses from the device under test to be received and forwarded to the mobile device, even where the mobile device and device under test have different operating systems. A client program adapted to run on the device under test sends and receives remote procedure call commands from the device under test to and from a test server that implements the test framework and manages a device state of the device under test. In a pairing test, the remote procedure call commands include commands adapted to emulate a button press for initiating pairing between the mobile device and the device under test.

Abstract: Methods and systems are disclosed providing an object-oriented regression-candidate filter to improve software build testing. A modification to a current software build may be detected. A set of objects of the current software build that are affected by the modification may be identified. A modification to a previous software build that affected a subset of the set of objects may be identified. A set of tests may be generated to include one or more tests previously executed to test the modification to the previous software build. The set of tests may be executed to test the current software build. A result of the set of tests may be compared to one or more previous test results. Based on the comparison, the modification to the current software build may be verified as operational.

Abstract: Embodiments of the present disclosure include methods and systems for generating and processing energy consumption reports received from a plurality of devices. The reports may include a plurality of call stacks captured and stored by remote device as a result of an energy consumption of the corresponding device. For each energy consumption report, the plurality of call stacks may be analyzed to determine a representative call stack of the energy consumption report. The energy consumption reports may be assigned to one or more of a plurality of energy consumption categories based on distances between the representative call stacks of the energy consumption reports and corresponding representative call stacks of the energy consumption categories. A request may be received for energy consumption reports for a particular energy consumption category. Upon receiving the request, providing a representative set of energy consumption reports assigned to the particular energy consumption category.

Abstract: A system for testing network performance using a server farm is described. A server in a server farm connected to a management network and a core network may execute virtual machines for multiple users that generate interfaces that the users interact with via the management network connection to configure network performance tests. The virtual machines convert the test configurations into instructions for a testing application and execute the tests using the testing application and the connection to the core network. Test results are provided to the users by the interfaces generated by their respective virtual machines via the management network connection.

Abstract: An information handling system includes a first memory and a baseboard management controller. The first memory stores a first firmware partition and a second firmware partition. The baseboard management controller includes a second memory. The baseboard management controller begins execution of a DM-Verity daemon, and performs periodic patrol reads of the first firmware partition. The baseboard management controller detects one or more block failures in the first firmware partition, and stores information associated with the one or more block failures in a message box of the second memory. In response to the entire first firmware partition being scanned, the baseboard management controller switches a boot partition from the first firmware partition to the second firmware partition, and initiates a reboot of the information handling system.

Abstract: Aspects of the disclosure relate to generating test cases based on voice conversation. In some embodiments, a computing platform may receive voice data associated with an agile development meeting. Subsequently, the computing platform may identify, using a natural language processing engine, context of one or more requirements being discussed during the agile development meeting. Based on identifying the context of the one or more requirements being discussed during the agile development meeting, the computing platform may store context data into a database. Next, the computing platform may map the context data to a corresponding task item of a software development project. Thereafter, the computing platform may identify one or more test cases to be generated. Then, the computing platform may cause the identified test cases to be executed.

Abstract: A method of rendering a service graph illustrating dependencies between a frontend and a backend of an application comprises generating a plurality of frontend traces from a plurality of frontend spans and generating a plurality of backend traces from a plurality of backend spans ingested from the application. The method also comprises aggregating frontend metrics data using the plurality of frontend traces and backend metrics data using the plurality of backend traces. The method further comprises determining connection information between one or more frontend traces of the plurality of frontend traces and corresponding backend traces of the plurality of backend traces. The method also comprises rendering the service graph using the connection information and the aggregated frontend and backend metrics data.

Abstract: An analysis device according to one aspect of the present invention supplies a definition for a dependency relation between an input parameter and an output parameter of a standard function, which cannot be derived in a dependency analysis of a control program, the definition being supplied by use of function structure information which is external information. In other words, an analysis device according to this configuration identifies a dependency relation between an input parameter and an output parameter of the standard function on the basis of function structure information that defines a dependency relation between the input parameter and the output parameter of the standard function. Therefore, the dependency relation between the input and the output of a standard function becomes clear, so the dependency relations between a plurality of device variables that mediate the standard function can be identified.

Abstract: Techniques for automated system requirements analysis are disclosed. A system requirements analysis (SRA) service generates a system model that includes system requirements, at least by performing natural-language processing on a natural-language representation of the system requirements. Based at least on the system model, the SRA service performs an analysis of the system requirements against codified system requirements rules. The SRA service determines, based at least on the analysis of the system requirements against the codified system requirements rules, that the system requirements include a violation of a system requirements rule. The SRA service generates a report that identifies at least (a) the violation of the system requirements rule and (b) a suggested action to remediate the violation of the system requirements rule.

Abstract: A user profile may be generating from a source accordingly to embodiments of the present disclosure. In some embodiments, a process (e.g., implemented by a client) includes obtaining a set of commits associated with a user from a source code version control system, extracting at least one signal from the set of commits, obfuscating the signal(s), and outputting the obfuscated signal(s). In some embodiments, a process (e.g., implemented by a server) includes receiving a signal associated with source code, where the signal is extracted from a commit obtained via a source code version control system. The process further includes aggregating the signal with at least one other signal, generating a user profile based at least on part on the aggregated signals, and rendering the user profile on a graphical user interface.

Abstract: Embodiments provide a thread classification method that represents stack traces in a compact form using classification signatures. Some embodiments can receive a stack trace that includes a sequence of stack frames. Some embodiments may generate, based on the sequence of stack frames, a trace signature that represents the set. Some embodiments may receive one or more subsequent stack traces. For each of the one or more subsequent stack traces, some embodiments may determine whether a subsequent trace signature has been generated to represent the sequence of stack frames included within the subsequent stack trace. If not, some embodiments may generate, based on the trace signature and other subsequent trace signatures that were generated based on the trace signature, the subsequent trace signature to represent the subsequent sequence of stack frames.

Abstract: An example method of determining operational health of a virtualized computing system includes: monitoring, at a service executing in the virtualized computing system, a current configuration of a software-defined data center (SDDC) with respect to a desired state, the desired state including: a host cluster having hosts executing a virtualization layer thereon; a software-defined (SD) network deployed in the host cluster; shared storage accessible by the host cluster; a virtual infrastructure (VI) control plane managing the host cluster, the SD network, and the shared storage; and an orchestration control plane integrated with the virtualization layer and the VI control plane; determining a configuration status for the current configuration of the SDDC; monitoring, at the service, operational status of an application management system executing on the SDDC having the current configuration; and determining at least one measure of the operational health in response to the configuration status and the operation

Abstract: A virtualized storage for use in performing dynamic analysis on a sample is configured, at least in part by copying the sample to the virtualized storage. A virtual machine emulator is launched using a snapshot of a virtualized platform. The virtualized platform is previously configured to use the virtualized storage, and the snapshot is configured to use a placeholder file to occupy space for later use when installing the sample. A location of the copied sample in an image corresponding to the virtualized storage is determined. The copied sample is installed and dynamic analysis is performed on the sample.

Abstract: Systems and methods are disclosed that predict whether a configuration item of a service provider cloud infrastructure client instance has a vulnerability, prior to scanning for the client instance for the vulnerability. In particular, operating system and/or application information of the vulnerability may be compared to that of the configuration item, operating system and/or application information of past vulnerabilities may be compared to that of the vulnerability, additional vulnerabilities that are solved by solutions that remedy the vulnerability may be compared to the configuration, and/or a machine-learning model may be trained to determine how similar past vulnerabilities of the configuration item are to the vulnerability. Based on one or more of these comparisons, a predicted vulnerable item may be generated that indicates that the configuration item is subject to the vulnerability.

Abstract: A method for testing a system under test (SUT) in an active environment includes executing, by the testing system, on the SUT, a test from a set of tests. The method further includes, monitoring a first execution time to complete the test on the SUT in the active environment. Based on the first execution time being different than a second execution time of the test, marking, by the testing system, a code path associated with the test. The second execution time is a duration to complete execution of the test on the SUT in a clean execution environment. The method further includes communicating, by the testing system, the code path for analyzing a soft failure of the SUT in the active environment, wherein the soft failure occurs in the active environment during execution of the SUT based at least on a parameter of the active environment.

Abstract: A visual-programming tool processes nodes of a graph corresponding to operations or functions in program code associated with a plurality of programs, (e.g., games), stored as graph of nodes with logical connections signifying inputs, outputs, and/or units of connected nodes. The visual-programming tool resolves valid types and/or units associated with respective connected nodes and can propagate valid types and/or units throughout the graph.

Abstract: An endpoint system receives a target file for evaluation for malicious scripts. The original content of the target file is normalized and stored in a normalized buffer. Tokens in the normalized buffer are translated to symbols, which are stored in a tokenized buffer. Strings in the normalized buffer are stored in a string buffer. Tokens that are indicative of syntactical structure of the normalized content are extracted from the normalized buffer and stored in a structure buffer. The content of the tokenized buffer and counts of tokens represented as symbols in the tokenized buffer are compared against heuristic rules indicative of malicious scripts. The contents of the tokenized buffer and string buffer are compared against signatures of malicious scripts. The contents of the tokenized buffer, string buffer, and structure buffer are input to a machine learning model that has been trained to detect malicious scripts.

Abstract: A computer-implemented method comprising, during execution of a software program comprising a procedure, determining whether an execution of the procedure satisfies a predetermined coverage criterion. In accordance with a determination that the execution of the procedure satisfies the predetermined coverage criterion, recording information related to the execution of the procedure to a log, the information based on data received from instrumented code included in the software program, and automatically generating an arrange section of a unit test for the procedure based on an initialization sequence determined from the recorded log, the initialization sequence comprising a sequence of program instructions which when executed invoke the procedure.

Abstract: Embodiments for simulating timing-related error conditions in a distributed system, by allowing a user to define a fault map specifying one or more faults to be committed by components in the distributed system. These generated fault events are to be executed in different components of the distributed system in a serialized distributed order. An event injection process delivers the fault map messages to the nodes in the distributed system, and the nodes then execute an operation sequence containing the fault events in the proper order as coordinated by the event injection process. The faults are then committed by the associated components in the nodes. Execution of these fault events occurs before, after or during a regular component procedure or action to simulate the desired timing-related error.