Cloud computing enables users to access and utilize various computing resources over the internet, including servers, storage, databases, and analytics. This paradigm offers flexibility, scalability, and cost efficiency, making it a critical technology for numerous applications. In the realm of the Internet of Things (IoT), cloud computing provides a scalable and flexible infrastructure for managing the vast amount of data generated by IoT devices. Specifically, in Industrial Internet of Things applications (IIoT), predictive maintenance has become a key focus, leveraging advanced technologies to forecast equipment failures and minimize downtime. However, achieving high accuracy in fault prediction remains a challenge. To address this, we propose a novel approach called Brokenstick Regression-based Multiobjective Dragonfly Predictive Optimization (BR-MDPO). This method aims to optimize predictive maintenance with enhanced accuracy and execution time. The process begins with IoT devices collecting data, such as vibration, temperature, speed, torque, and operational hours, from industrial machinery. This data is then sent to centralized cloud data centers for predictive analysis. The BR-MDPO technique utilizes the Multi-Objective Dragonfly Optimization algorithm, a metaheuristic inspired by the natural behavior of dragonflies, to solve multi-objective optimization problems. Brokenstick regression analyzes the data to optimize various objective functions. The technique identifies potential failures, facilitating proactive maintenance and informed decision-making to ensure continuous productivity. The proposed method shows a significant improvement in accuracy, precision, and recall by 7%, 5%, and 6%, respectively. The observed results reveal a 6%, 4% and 5% enhancement in the accuracy, precision, and recall. Furthermore, the proposed technique realizes a substantial reduction in error rate by 68%, 15% and 13% reduction in execution time as well as latency compared to conventional methods.

The practice of testing software systems modelled as Finite State Machines (FSMs) has garnered significant attention owing to its simplicity. In FSM-based testing, the tester derives a test suite from the FSM model representing the system’s specification. Subsequently, this test suite is executed against the implementation, and the tester uses the output to decide whether the implementation conforms to the specification. Often, a test suite generation technique requires input sequences to check whether the FSM is in the intended state. This task is referred to asstate identificationand is often carried out using a set of input sequences called a characterising set. Even though the use of characterising sets simplifies testing, they require a reliable reset or reset sequence and additional transfer sequences. Unfortunately, resetting the underlying system can be costly or may entail manual configuration. In addition, transfer sequences do not directly contribute to testing. This work introduces a class of characterising sets (Ordered Characterising Sets(O-WSets)) that avoid using resets or transfers by design. We show that checking the existence of such a characterising set is NP-complete. We introduce the notion of bounded O-WSets (BO-WSets), which are types of O-WSets that limit transfer usage, and give an algorithm that constructs these. In experiments, on average, the proposed approach led to reductions in the number of resets (95% for real FSMs; 99.73% for synthetic FSMs), the number of transfer inputs (53% for real FSMs; 63.3% for synthetic FSMs) and the number of inputs in state identification sequences (50% for real FSMs; 66.6% for synthetic FSMs). Additionally, the proposed algorithm reduced the time and memory required to derive state identification sequences by 85% and 23%, respectively. Finally, the approach led to test suites with 49.3% fewer sequences and 33.3% fewer inputs on average.

Cloud computing enables access to compute, storage, and software over the internet. Security is a critical aspect that enables individuals to exchange information while maintaining their sensitive data's confidentiality, integrity, and availability. Therefore, robust security methods are essential to protect data from unauthorized access. Blockchain-based security methods are decentralized technologies that facilitate secure transactions across multiple entities. Traditional data sharing schemes have encountered several issues, including a lack of security, low confidentiality, and compromised integrity. To address the aforementioned challenge, a novel Davies-Meyer Kupyna Hash based Gestalt Pattern Matched Consortium Blockchain (DKH-GPMCB), is introduced to facilitate secure data transactions between cloud users and servers, enhancing data confidentiality and integrity. Experimental results show that the DKH-GPMCB technique improves data confidentiality and integrity rates by 4 % and 7%, reduces computation time by 8% and 13%, and reduces storage overhead by 14% and 23% compared to conventional methods.

Testing is a crucial phase in the development of complex systems, and this has led to interest in automated test generation techniques based on state-based models. Many approaches use models that are types of finite state machine (FSM). Corresponding test generation algorithms typically require that certain test components, such as reset sequences (RSs) and preset distinguishing sequences (PDSs), have been produced for the FSM specification. Unfortunately, the generation of RSs and PDSs is computationally expensive, and this affects the scalability of such FSM-based test generation algorithms. This paper addresses this scalability problem by introducing a reinforcement learning framework: the$\mathcal{Q}$-Graph framework for MBT. We show how this framework can be used in the generation of RSs and PDSs and consider both (potentially partial) timed and untimed models. The proposed approach was evaluated using three types of FSMs: randomly generated FSMs, FSMs from a benchmark, and an FSM of an Engine Status Manager for a printer. In experiments, the proposed approach was much faster and used much less memory than the state-of-the-art methods in computing PDSs and RSs.

The increasing complexity and criticality of software systems have led to growing interest in automated test generation. One of the most promising approaches is to use model-based testing (MBT), in which test automation is based on a model of theimplementation under test (IUT), with much of the work concerning finite state machine (FSM) models. Many FSM-based test generation techniques use, possibly adaptive, sequences to check the state of the IUT. Of particular interest are adaptive distinguishing sequences (ADSs) because their use can lead to relatively small tests. However, not all systems possess an ADS. In this work, we generalise the notion of incomplete ADSs to non-deterministic partial and observable FSMs. We show that the problem of checking the existence of a set of$k$incomplete ADSs that separates every pair of states is PSPACE-hard. Further, we generalise the notion of invertible sequences to non-deterministic partial and observable FSMs and show how invertible sequences can be used to derive additional incomplete ADSs. We propose a novel algorithm to generate incomplete ADSs and describe the results of experiments that evaluated its performance. The results indicate that the proposed method can generate sequences to identify states of the IUT and is faster and can process larger FSMs than other existing methods.

Summary Tests can be derived from extended finite state machine (EFSM) specifications considering the coverage of single‐transfer faults, all transitions using a transition tour, all‐uses, edge‐pair, and prime path with side trip. We provide novel empirical assessments of the effectiveness of these test suites. The first assessment determines for each pair of test suites if there is a difference between the pair in covering EFSM faults of six EFSM specifications. If the difference is found significant, we determine which test suite outperforms the other. The second assessment is similar to the first; yet, it is carried out against code faults of 12 Java implementations of the specifications. Besides, two assessments are provided to determine whether test suites have better coverage of certain classes of EFSM (or code) faults than others. The evaluation uses proper data transformation of mutation scores andp‐value adjustments for controlling Type I error due to multiple tests. Furthermore, we show that subsuming mutants have an impact on mutation scores of both EFSM and code faults; and accordingly, we use a score that removes them in order not to invalidate the obtained results. The assessments show that all‐uses tests were outperformed by all other tests; transition tours outperformed both edge‐pair and prime path with side trips; and single‐transfer fault tests outperformed all other test suites. Similar results are obtained over the considered EFSM and code fault domains, and there were no significant differences between the test suites coverage of different classes of EFSM and code faults.

Abstract There has been a growing interest in defining models of automata enriched with time, such as finite automata extended with clocks (timed automata). In this paper, we study deterministic timed finite state machines (TFSMs), i.e., finite state machines with a single clock, timed guards and timeouts which transduce timed input words into timed output words. We solve the problem of equivalence checking by defining a bisimulation from timed FSMs to untimed ones and vice versa. Moreover, we apply these bisimulation relations to build the intersection of two timed finite state machines by untiming them, intersecting them and transforming back to the timed intersection. It is known that many problems like inclusion and equivalence checking are undecidable for timed automata. Our results show that TFSMs correspond to a decidable subclass of timed automata that admits a restricted form of $$\varepsilon $$ ε -transitions (i.e., timeouts) where most of the relevant problems like equivalence and intersection are decidable.

Nowadays, extended state machines are prominent requirements specification techniques due to their capabilities of modeling complex systems in a compact way. These machines extend the standard state machines with variables and have transitions guarded by enabling predicates and may include variable update statements. Given a system modeled as an extended state machine, with possibly infinite state space and some non-controllable (parameterized) interactions, a pruning procedure is proposed to symbolically derive a maximal sub-machine of the original system that satisfies certain conditions; namely, some safeness and absence of undesirable deadlocks which could be produced during pruning. In addition, the user may specify, as predicates associated with states, some general goal assertions that should be preserved in the obtained sub-machine. Further, one may also specify some specific requirements such as the elimination of certain undesirable deadlocks at states, or fail states that should never be reached. Application examples are given considering deadlock avoidance and loops including infinite loops over non-controllable interactions showing that the procedure may not terminate. In addition, the procedure is applied for finding a controller of a system to be controlled. The approach generalizes existing work in respect to the considered extended machine model and the possibility of user defined control objectives written as assertions at states.

In black-box testing, test sequences may be constructed from systems modelled as deterministic finite-state machines (DFSMs) or, more generally, observable non-deterministic finite state machines (ONFSMs). Test sequences usually contain state identification sequences, with unique input output sequences (UIOs) often being used with DFSMs. This paper extends the notion ofUIOsto ONFSMs. One challenge is that, as a result of non-determinism, the application of an input sequence can lead to exponentially many expected output sequences. To address this scalability problem, we introduce${\mathcal K}$-UIOs:UIOsthat lead to at most${\mathcal K}$output sequences from states of$M$. We show that checking${\mathcal K}$-UIOexistence is PSPACE-Complete if the problem is suitably bounded; otherwise it is in EXPSPACE and PSPACE-Hard. We provide a massively parallel algorithm for constructing${\mathcal K}$-UIOsand the results of experiments on randomly generated and real FSM specifications. The proposed algorithm was able to constructUIOsin cases where the existingUIOgeneration algorithm could not and was able to constructUIOsfrom FSMs with 38K states and 400K transitions.

An incremental approach is proposed for deriving an adaptive Distinguishing Test Case (DTC) for a subset of states of an observable non-deterministic Finite-State Machine (FSM). The approach considers the states of the subset incrementally while checking the existence of a DTC. Experiments were conducted to assess and compare various versions of the incremental approach with respect to a non-incremental counterpart. In addition, two implementations of an efficient heuristic approach for the considered problem are proposed. The implementations are based on a special traversal of a successor tree up to certain height using some established construction rules. Experiments were conducted to assess the execution time and quality of obtained solutions for large FSMs. Moreover, we determine how often a DTC exists while varying the number of states, outputs and non-determinism of a given FSM. A complete summary of the obtained results is included.

Abstract A top-down approach is presented for checking the existence and derivation of an adaptive distinguishing test case (called also an adaptive distinguishing sequence) for a nondeterministic finite state machine (NDFSM). When such a test case exists, the method returns a canonical test case that includes all other distinguishing tests of the given complete observable NDFSM. In the second part of the paper, a constructive approach is provided for deriving a class of complete observable NDFSMs with n states, n > 2, and 2 n − n − 1 inputs such that a shortest adaptive distinguishing test case for each NDFSM in the intended class has the length (height) 2 n − n − 1. In other words, we prove the reachability of the exponential upper bound on the length of a shortest adaptive distinguishing sequence for complete observable NDFSMs while for deterministic machines the upper bound is polynomial with respect to the number of states. For constructing the intended class of NDFSMs for a given n , we propose a special linear order over all the non-empty subsets without singletons of an n -element set. The obtained tight exponential upper bound initiates further research on identifying certain NDFSM classes where this upper bound is not reachable.

Extended finite state machines (EFSMs) provide a rigorous model for the derivation of functional tests for software systems and protocols. Various types of data-flow, control-flow, graph-based, and state machine based test selection criteria can be used for deriving tests from a given EFSM specification. Also, traditional types of state machine based notions of faults, such as transfer and output parameter faults, and common types of assignment faults can be used to describe the fault domains of EFSMs. We present an assessment of the most known types of EFSM test selection criteria such as test suites that cover single transfer faults, double transfer faults, single output parameter faults, and many types of single assignment faults of a given EFSM specification. Also, test suites that cover edge-pair, prime path, prime path with side trip, and all-uses criterion are derived from the graph and flow-graph representations of the specification. We also consider transition tour and random test suites. The assessment ranks the considered test suites in terms of their length and their coverage of single transfer, double transfer, and different type of single assignment faults. Dispersion of the obtained results is assessed and results are summarized.

We consider a composite system consisting of two communicating finite state machines, an embedded component and a context representing the remaining parts of the system. In this article, a method is proposed for translating a complete internal test suite defined over the unobservable alphabets of the embedded component into a complete external test suite defined over the observable external alphabets of the system, assuming that the context is fault-free. Propositions are established to verify the different steps of the proposed method and a detailed application example illustrating these steps is included.

The composition of two arbitrary component automata can have deadlock states. A method is proposed to minimally reduce a component automaton such that the resulting composition with the other automaton is deadlock-free. The method is applied to deriving compositionally deadlock-free solutions of automata equations over the synchronous composition.

In this paper, we focus on the problem of implementing a periodic concurrent system with timing constraints into multi-context dynamically reconfigurable processors (DRP). A concurrent system has multiple tasks that can be executed in parallel. Moreover, some tasks in a specific set of processes might be required to synchronize each other. We propose a method for assigning tasks into a multi-context DRP such that timing constraints of the system are satisfied and the size of the program area required on each context for implementing the given system is minimized. We formulate the problem as an ILP problem and propose a heuristic algorithm for solving the ILP problem efficiently. Experimental results and a case study using ubiquitous sensor devices are given.

Test derivation based on user defined faults deals with the generation of tests that check if some parts of a given specification are correctly implemented in a corresponding implementation. In this paper, we present a method for test derivation based on user defined faults for extended FSM (EFSM) specifications. Given an EFSM specification ES and a set of selected transitions of ES, the method returns a test suite that is complete with respect to output and transfer faults at the selected transitions, i.e., checks whether the selected transitions are correctly implemented in a corresponding EFSM implementation. Test derivation is based on a formally defined fault model (conformance relation and types of faults) and is guided by some conditions established for complete test derivation. To reduce test derivation efforts, we propose to use appropriate slices of the specification EFSM. The slices, on one hand, preserve the facilities of the original specification (before slicing) EFSM for traversing the selected transitions and for distinguishing their final states and on the other hand, these slices are much smaller than the given specification. Application examples and a simple case study are provided.

Abstract Several authors have studied the relationships between non‐deterministic finite state machines (FSMs). These relationships can be used, for example, for deriving conformance tests from specifications represented by FSMs. In this paper, the separability relation between FSMs is studied. In particular, an algorithm is presented that derives a shortest separating sequence of two non‐deterministic FSMs. Given FSMs S with n states and T with m states, it is shown that the upper bound on the length of a shortest separating sequence is 2mn−1. Moreover, the upper bound is shown to be reachable. However, according to the conducted experiments, on average, the length of a shortest separating sequence of FSMs S and T states is less than mn and the existence of a separating sequence significantly depends on the number of non‐deterministic transitions in these FSMs. The proposed algorithm can also be used for deriving a separating sequence of two different states of a single FSM or for deriving a separating sequence of three or more FSMs. Copyright © 2007 John Wiley & Sons, Ltd.

Grids offer an inexpensive and convenient alternative to solve computationally expensive pmblems. Such problems normally work on massive clata, which is partitioned and allocated to Grid nodes manrrally. Automatic allocation of data to nodes in multi-computers has been known for a long time. Unlike, multi-computers the Grid topologv changes d~namicallv as nodes leave or join the Grid. A job allocated to a node that is required to leave the Grid must be re-allocated. This paper presents a generic algorithm to allocate and aahptivelv re-allocate data to Grid nodes. The experimental resrtlts show that our algorithm re-allocates data quicklv and without compmmising the original allocation quality.

Service overlay networks have recently attracted tremendous interests. In this paper, we propose a new integrated framework for specifying services composed of service components running on different service nodes and for executing the services considering efficient utilization of overlay network resources. For a given service description written in an extended Petri net model, our method automatically derives a set of descriptions of service nodes' behavior which specifies how service nodes on an overlay network collaborate to provide the specified services. The derived descriptions minimize channel utilization, total response time or load of service nodes based on a given cost criterion. The experimental results show that a multimedia service for decorating and transcoding video contents can be well specified and implemented.

The development of test cases is an important issue for testing software, communication protocols and other reactive systems. A number of methods are known for the development of a test suite based on a formal specification given in the form of a finite state machine. Well-known methods are called the W, Wp, UIO, UIOv, DS, H and HIS test derivation methods. These methods have been extensively used by research community in the last years; however no proper comparison has been made between them. In this paper, we experiment with these methods to assess their complexity, applicability, completeness, fault detection capability, length and derivation time of their test suites. The experiments are conducted on randomly generated specifications and on a realistic protocol called the simple connection protocol.

The development of appropriate test cases is an important issue for conformance testing of protocol implementations and other reactive software systems. A number of methods are known for the development of a test suite based on a specification given in the form of a finite state machine. In practice, the system requirements evolve throughout the lifetime of the system and the specifications are modified incrementally. We adapt four well-known test derivation methods, namely, the HIS, W, Wp, and UIOv methods, for generating tests that would test only the modified parts of an evolving specification. Some application examples and experimental results are provided. These results show significant gains when using incremental testing in comparison with complete testing, especially when the modified part represents less than 20 percent of the whole specification.

In this paper, we present a method for the synthesis of extended Petri net-based distributed specifications. Our method finds an optimal allocation of resources (computational data) that optimizes the derived distributed specification, based on some reasonable communication-cost criteria.

The optimal regression testing problem is one of determining the minimum number of test cases needed for revalidating modified software in the maintenance phase. We present two natural optimization algorithms, namely, a simulated annealing and a genetic algorithm, for solving this problem. The algorithms are based on an integer programming problem formulation and the program's control flow graph. The main advantage of these algorithms, in comparison with exact algorithms, is that they do not suffer from an exponential explosion for realistic program sizes. The experimental results, which include a comparison with previous algorithms, show that the simulated annealing and genetic algorithms find the optimal or near-optimal number of retests within a reasonable time. Copyright © 1999 John Wiley & Sons, Ltd.

The optimal regression testing problem is that of determining the minimum number of test cases needed for revalidating modified software in the maintenance phase. The present two natural optimization algorithms, namely simulated annealing and genetic algorithms, for solving this problem. The algorithms are based on an integer programming problem formulation and the program's control-flow graph. The main advantage of these algorithms is that they do not suffer from exponential explosion for realistic program sizes. The experimental results show that they find optimal or near-optimal number of retests in a reasonable time.