A Framework for Continuous Regression and Integration Testing in IoT Systems Based on Deep Learning and Search-Based Techniques

Tremendous systems are rapidly evolving based on the trendy Internet of Things (IoT) in various domains. Different technologies are used for communication between the massive connected devices through all layers of the IoT system, causing many security and performance issues. Regression and integration testing are considered repeatedly, in which the vast costs and efforts associated with the frequent execution of these inflated test suites hinder the adequate testing of such systems. This necessitates the focus on exploring innovative scalable testing approaches for large test suites in IoT-based systems. In this paper, a scalable framework for continuous integration and regression testing in IoT-based systems (IoT-CIRTF) is proposed, based on IoT-related criteria for test case prioritization and selection. The framework utilizes search-based techniques to provide an optimized prioritized set of test cases to select from. The selection is based on a trained prediction model for IoT standard components using supervised deep learning algorithms to continuously ensure the overall reliability of IoT-based systems. The experiments are held on two GSM datasets. The experimental results achieved prioritization accuracy up to 90% and 92% for regression testing and integration testing respectively. This provides an enhanced and efficient framework for continuous testing of IoT-based systems, as per IoT-related criteria for the prioritization and selection purposes.


I. INTRODUCTION
The Internet of Things (IoT)-based systems are increasingly penetrating all business industries, in which the main characteristic of these systems is the heterogeneity of their components and technologies. Huge numbers of diverse independent devices, such as embedded objects, actuators and sensors, are continuously connected, leading to an enormous scale of components [1]. Such systems usually include a data generator layer, which aggregates data from all connected devices. Then through the network layer, different protocols and gateways are used for data transition to apply analytical processes, providing appropriate services to the targeted user's applications [2]. Testing is required at all stages, when everything is connected, and data are transmitted through networks [3]. Issues and threats are increasingly faced, especially regarding The associate editor coordinating the review of this manuscript and approving it for publication was Shaohua Wan . the privacy of critical personal data in order to maintain security and performance processes [4].
Thus, research studies on testing IoT-based systems are dramatically increasing, in which the changes on such large systems are endless. Continuous runtime regression and integration testing are repeatedly required to face the frequent dynamic integration of IoT components [5], as well as system change requests. A huge number of test cases (TCs) are usually generated over time that could be relevant or irrelevant to a specific new integration or change request. Hence, the need for minimizing the number of executed TCs is exponentially increasing to reduce testing costs and maximize efficiency.
Many limitations have been explored for testing IoT systems, such as the inability to handle the dynamicity of connected components [6], diversity of network protocols and technologies [7], real time complexity and scalability of systems that manage their connectivity [8]. In addition, the systems' interoperability should be frequently verified by checking the consistency of services provided by different sensors [1], as well as the transmitted data between receivers and suppliers should be verified against the confidentiality of networks and the safety of users' data [9].
The applicability of automated test suites generation through Model Based Testing (MBT) Techniques have been investigated, in which TCs can be constructed from a graph model, i.e. finite state machines, UML diagrams, etc. [10] to continuously generate test suites and execute automatically in order to check the coverage of newly added components [5]. However, MBT techniques lacked to effectively execute the generated test suites as per any new changes [11]. Thus, they do not support integration and regression testing, in which all generated test suites should be executed in such rapidly evolving systems [12]. Such critical limitation causes great time and cost consumption. Consequently, the selection and prioritization of test suites are vitally needed to execute the related TCs only during regression testing, avoiding redundancy and irrelevant TCs. On the other hand, Search Based Testing (SBT) techniques have been considered for TCs prioritization and reduction, such as Genetic Algorithms (GAs), Hill climbing, Ant Colony and Simulated Annealing (SA) techniques [8]. They proved lower performance and high time consumption, compared to MBT, when used for TCs generation [13]. Yet, SBT techniques have never been investigated for testing IoT-based systems.
In this paper, a scalable framework for prioritizing and selecting TCs in IoT-based systems (IoT-CIRTF) is introduced based on deep learning and SBT techniques. This framework is intended to support continuous integration testing and regression testing for IoT-based systems by providing an optimized self-adaptive prioritized set of TCs to select from to continuously ensure the overall reliability of these systems upon the addition or removal of their independent components. The SBT techniques are utilized to select the relevant TCs after the training phase of the proposed framework on the IoT system specifications using the Long Short-Term Memory (LSTM) classifier, which is a deep learning supervised prediction algorithm [26], [27]. Deep learning algorithms have not been considered for testing IoT-based systems yet, in which IoT-CIRTF uses them to classify the given TCs to the targeted IoT components. The matched TCs are then executed with respect to the change requests in the requirements -for regression testing -or to the newly added modules of the specific IoT system -for integration testing.

II. RELATED WORK
Several testing approaches have been directed to IoT-based systems, where MBT techniques were dominant [29], [30]. Some MBT limitations were addressed, such as the time consumed for TCs generation and TCs redundancy when reconfigurations or changes occur, and the lack of TCs prioritization or selection approaches to handle continuous integration and regression testing in IoT-based systems [31]. Some studies lacked the presence of a real-world case study, or the scalability of testing approaches to fit IoT-based systems. Another challenge was the process automation, in which the tracking and testing of runtime systems were very exhaustive in terms of time and cost [10]. The following subsections present the main approaches introduced in the literature that consider testing in IoT systems.

A. TESTING TECHNIQUES IN IOT-BASED SYSTEMS
Most of the MBT techniques used for TCs generation in IoT systems from modeled systems were based on reformatting the model to an XML code, then constructing TCs from that generated code. In [32], a runtime verification of IoT systems was achieved using an MBT tool, which generated a sequence diagram and TCs statements during runtime with an event processing language for complex diagrams. This approach was developed and tested using Constrained Application Protocol (COAP) only for data transmission between devices, which made it unavailable for any other protocols. [33] introduced an approach for runtime testing in component-based systems. By applying TCs selection and MBT techniques, it selected TCs from previously created and new ones as per changes using UPPAAL tool. Yet, it was not proven experimentally how efficient it worked with IoT systems.
In [34], a study for some testing tools for IoT systems was presented, like MBTAAS, IOTSim and MAMMotH for TCs generation from models. A comparison was made to show what to use when considering different IoT systems' layers and the testing types to cover according to the systems' complexity. The absence of reliable evaluation, in terms of accuracy and efficiency, was the main limitation.
In [35], the VDM++ formal specification tool was investigated for integration testing in distributed systems. It used sequence diagrams to generate relevant TCs and overcome their explosive number by observing the system to decide whether a distribution of the integrated components would be required to test locally by manual testers.
Authors in [10], emphasized that there are still influential and unexplored areas for TCs effective selection, in which many tools lacked TCs prioritization, wasting huge time, cost and efforts. They recommended that there should be selection-based criteria to prioritize TCs of IoT-based systems, including all functional and non-functional requirements. The survey of [36], discussed that all current testing techniques for IoT systems lack integration testing handling.

B. TEST CASES PRIORITIZATION IN IOT SYSTEMS
Some metrics were proposed in [30] to measure the importance of TCs and decide the most valuable ones to prioritize and rerun for regression testing. The suggested metrics included measuring the faulted devices' locations in the area around using Newton's law to select TCs according to the nearest devices, in which TCs were generated as per the location of devices. This was dependent on the system's behavior with experienced testers, indicating that there was no standard generic approach to apply for IoT-based systems, as the metrics would differ from one system to another. VOLUME 8, 2020 For the selection of relevant TCs at retesting phases, the Ant Colony Optimization algorithm was proposed in [37] integrated with Bayesian approaches to calculate the probability of each TC. TCs appearing the most in detected failures had a higher priority. No experiments were conducted to evaluate the proposed approach. Furthermore, it was not mandatory to select the same set of TCs due to any changes, as it should have considered another metrics, such as the propagation of the changed features or components.

C. RESEARCH GAP AND LIMITATIONS IN IOT TESTING
Most of the testing-related studies in IoT-based systems have shown a real focus on TCs generation using MBT techniques, supporting TCs generation for newly added components. However, this raises a crucial concern regarding their applicability for continuous integration and regression testing in such evolving IoT-based systems, provided the increasing number of associated TCs. Thus, further investigations are needed to prioritize and select TCs in order to minimize the time and efforts required for the repeated integration and regression testing expected for IoT-based systems, allowing fast faults detection and localization with respect to new changes or components. The current literature lacks proven experimentations for efficient and reliable approaches to face the detected challenges.

III. THE IOT CONTINUOUS INTEGRATION AND REGRESSION TESTING FRAMEWORK (IOT-CIRTF)
In this study, an IoT-related framework for continuous integration and regression testing (IoT-CIRTF) is proposed based on a hybrid combination of deep learning and search-based techniques. Fig.1 presents the system architecture of the proposed framework. It consists of three main layers as described in the following subsections.

A. THE IOT COMPONENTS TRAINING LAYER
As the number of requirements in IoT systems and their associated test cases is increasing continuously, the cost and time needed to test such systems are directly proportional. This layer is responsible for generating a trained model for IoT components in order to learn the specifications of the IoT system and classify them according to standard IoT system components. The created model would provide the backbone to automate the classification, selection and prioritization of test cases throughout the framework, decreasing the overall time, efforts and cost of testing IoT systems. The input of this layer is the specifications of the IoT system to extract the standard components. These specifications describe the different and huge number of components and technologies connected in the IoT system, such as data gathering (i.e. RFID, Sensors, actuators, GPS), communication protocols (i.e. MQTT, HTTP, Wifi, Zigbee, WAN), cloud processing and user devices/applications. The layer consists of some modules as follows: • IoT specifications pre-processing, in which the specifications are cleaned and reduced by omitting stop words and redundancy using NLP techniques.
• IoT components features extraction, which uses the LSTM deep learning classifier to analyze the cleaned reduced specifications, resulted from the previous process to extract the main features of the IoT system's specifications. The extracted features represent the selected words having high weights from the whole specifications, which are needed to classify the IoT TCs in the next layer effectively [14], [15]. These features describe certain IoT standard components, which are the defined classes (i.e. user device, protocols and gateways, sensors and actuators, data processing). The LSTM classifier was proven to work effectively with long sequences [16]. It calculates the probability of each word to follow another, given the sequences of words with their weights.
• IoT components training by classifier, in which it works on the extracted features by the classifier based on LSTM algorithm [26], [27]. Algorithm 1 presents the LSTM classifier, consisting of four layers/nodes. The extracted features are used by the classifier in order to recognize the classification pattern to follow, so that the class labels that the IoT components belong to are determined [28]. The output is the IoT components trained model that is used in the next layers of the framework to classify the IoT TCs as per the IoT components.

Algorithm 1 LSTM Deep Learning Algorithm in IoT-CIRTF
In our IoT-CIRTF, LSTM classifier is modified to fit long sequences of the IoT requirements and is configured to work on four layers/nodes, in which LSTM functions run four times to increase the accuracy of learning, avoiding low accuracies when applying two LSTM layers/nodes [20]. The first layer uses the Sigmoid function to calculate the scalar value of the three main LSTM gates (i.e., forget, input and output gates), maintaining their values in [0, 1] range as shown in (1), (2), (3) [19]: where f (t) is the forget gate that defines how many features with very low weights are going to be ignored, x (t) is the current feature/word in the IoT system's specifications sequences at time t. i (t) is the input gate that represents the input sequence of IoT system's features or words, o (t) is the output gate that defines the words/features to be added to the hidden gate h (t) for later use, which may be added to the sequence of extracted features as in (6). Hence, the first itera-  (4), (5) and (6) [19]: where cv (t) is the candidate value to use as an input for the next cell c (t) through time t, w c,x and u c,h are the weights for the current word x and the previous hidden state h (t−1) , b c is the bias value initialized by 1, c (t) is the new cell state value, and c (t−1) is the previous cell state. The new hidden state h (t) is calculated by multiplying the data to output o (t) by the Sigmoid of the current cell state value σ (c (t) ).
The results are then passed as an input to the Softmax function to output a normalized vector (values between 0 and 1) [17]. Softmax function operates on a vector of multiple classes to get a vector of the potential probabilities of the outcome classes. Hence, the training is conducted on the sequences of IoT specifications having their predicted class labels. These classes are determined as per the common architectures of IoT-based systems based on the IoT system's standard components as: sensors and actuators, protocols and gateways, user devices and data processing [22], [23].
The third layer boosts the learning model using the Backpropagation Through Time (BPTT) gradient technique [24]. BPTT is used to improve learning by enhancing the given weights to decrease the loss value and increase the accuracy of classification using a learning rate decay technique. It starts from the final output and moves backward through the same gates to re-train the classifier, where changes are applied to the weights. The network is then rolled up with the updated weights. This helps having a more accurate classifier. Thus, the learning decay rate determines the maximum number of possible call backs.
Finally, the Cross-Entropy Loss function is considered to evaluate the accuracy of the LSTM classifier as shown in (7) [25]: where CE is the Cross-Entropy, c is the current class, M is number of classes, y o,c is 1 in case the observed class p o equals c, otherwise y o,c is 0, and log(p o , c) is the log of the probability of having class c. Thus, CE sums the loss value given the probabilities of all classes. The lower the loss value, the higher the accuracy of the classifier [21].

B. THE IOT TEST CASES CLASSIFICATION LAYER
This layer is responsible for classifying the TCs of the IoT system as per the IoT standard components using the trained model generated from the IoT Components Training Layer. The created classes would narrow the search space of TCs for selection and prioritization during the continuous regression and integration testing of the IoT system. The inputs are all previous test runs for this IoT system and the traceability matrix that has a list of IoT TCs mapped to requirements. It consists of several modules as follows: • IoT test cases attributes extraction: the previous test runs and the traceability matrix of the system's specifications are considered to extract the main data identifying each TC, such as ID, name, description, coverage rate (CR), fault detection rate (FDR) and execution time (ET). The CR of a TC is the value of how many system's requirements are covered by this TC, the fault detection rate is the value of how many faults are detected by this TC compared to the total number of defects, and the execution time is the time taken by the TC to execute. The extracted TCs' attributes are used to classify TCs as per the IoT components, where the CR, FDR and ET are further utilized for TCs prioritization. The priority of a TC increases when its coverage and fault detection rates are higher while its execution time is lower [43], [44]. The coverage rate is calculated for each TC by the summation of the covered requirements divided on the total number of the requirements as shown in (8) [45]: where CR is the coverage rate, TC ID is the TC identity, R ID is the requirement identity and n is the total number of requirements. Using the previous IoT system's runs, the FDR and ET are extracted for each TC as per the traceability matrix. FDR is calculated by the summation of the faults that are covered by the TC as shown in (9) [46]: where FDR is the fault detection rate, TC ID is the TC identity, F is the fault, f ID is the fault identity and n is the total number of faults.
• The test cases classification as per IoT components, with the extracted attributes, as the TC name, ID, description, as well as the IoT components' trained model, are proposed to classify each TC as per the IoT standard components. The classification of TCs facilitates the selection of relevant TCs for the next layer, when a new module in case of integration testing or change requests in case of regression testing are encountered. The output of this layer is the classified TCs as per the IoT components.

C. THE IOT SELECTION AND PRIORITIZATION LAYER
This layer is responsible for selecting and prioritizing IoT TCs either for integration or regression testing based on the received inputs. TCs are prioritized and selected for a regression testing if the input is a change request, whereas if the inputs are the system architecture and new specifications, then TCs are selected and prioritized for an integration testing as follows.
• Change request classification as per IoT components, which indicates the application of regression testing for IoT TCs selection. The input is expected to be the change request, which should be classified as per the IoT components using the generated IoT components trained model. The classification of the change request determines the class of the IoT standard component for this change request to which it belongs to, whether sensors and actuators, protocols and gateways, user devices, or data processing. This helps reducing the costs and efforts required to select TCs by narrowing the search space out of the massive set of all TCs. After this classification, the IoT TCs selection starts based on the classified changed request and the classified IoT system TCs from the previous layer. Thus, IoT TCs are selected.
• IoT Integration testing Recommender, in which the Modules Interfaces Extraction receives a new module and the IoT system architecture, indicating the application of integration testing for IoT TCs selection. This optimizes integration testing for the nature of IoT systems. It extracts the modules' interfaces that are related to the integration between the input module's specifications and its adjacent modules. Modules Dependency Calculation is then responsible of calculating the dependency of modules by identifying the required number of stubs and drivers, in order to recommend the efficient integration testing approach to consider next, i.e. topdown, bottom-up or sandwich . . . etc., that decreases the number of needed stubs or drivers at the Integration Testing Handler. The integration testing approach is recommended based on the number of connected modules to this new module to test. If the number of connected follower modules are less than the connected ancestor modules but not yet implemented, then stubs are needed. If the number of the connected ancestor modules are less than the connected follower modules but not yet implemented, then drivers are needed. If the number of stubs and drivers is equal, then it is recommended to use stubs over drivers [40]. Otherwise, if all ancestor and follower modules are implemented, then all related TCs are selected without the need for any stubs or drivers.
• Test cases selection using the classified IoT components, in which the relevant TCs are selected during the regression or integration testing according to the related IoT standard components. In case of regression testing, the change request in IoT specifications that is under consideration should have been classified as per the IoT standard components. Accordingly, the TCs related to the classified IoT standard component are selected.
In case of integration testing, TCs are selected based on the new IoT module under consideration with respect to the provided system architecture. The modules that are expected to be connected to the new module determine the set of TCs to select, which are classified according to IoT standard components.
• Test Cases prioritization using multi search-based techniques, in which the proposed IoT-CIRTF utilizes GAs [42] and SA [41] search-based techniques according to the extracted attributes CR, FDR and ET, to use in the prioritization Fitness Function (FF) [41]. By calculating FF for each TC, IoT-CIRTF decides whether this sequence of TCs is better than the previous sequence. The prioritization process starts by choosing a random TC, creating a sequence of ordered TCs. This sequence may not be the best solution, and accordingly, calculations keep processing until they stop as per a stop condition determined by the SBT algorithm to find the best sequence of ordered TCs. FF calculates each TCs weight as shown in (10): where TC ID is the TC identity, TC index is the TC index indicating its position in the ordered sequence, n is the total number of TCs, CR i is the coverage rate, FDR i is the fault detection rate and ET i is the execution time of the TC. The SBT algorithm keeps running until reaching the stopping condition, which represents the number of iterations to keep running for both SA and GA algorithms [48]- [51]. Algorithm 2 presents GA as the global search approach, while Algorithm 3 presents SA as the local search approach as applied in the proposed IoT-CIRTF. SBT is used to search for an optimized sequence of ordered TCs. Local search approaches search for the best solution by looking to the nearby solution TC, while global search approaches find the optimum solution anywhere in the search space. IoT-CIRTF applies both approaches to validate the accuracy of finding the best sequence of TCs, in which the number of TCs in IoT systems should be reduced to effectively manage the time and cost needed for continuous testing.  (6), where the weights of TCs are calculated as per the three essential parameters CR, FDR, ET. The output of IoT-CIRTF is the selected prioritized TCs for the regression or integration testing in the IoT-based system. VOLUME 8, 2020

IV. IOT-CIRTF EXPERIMENTAL EVALUATION
Various experimentations were considered to evaluate the proposed IoT Continuous Integration and Regression Testing Framework (IoT-CIRTF) with respect to the accuracy encountered at three perspectives: the deep learning layer, the TCs classification layer, and the IoT TCs selection and prioritization layer while applying regression and integration testing for IoT-based systems.

A. THE DATASET
The global system for mobile communications (GSM) was used as our dataset [52]. It was selected for our experimentation as it includes IoT system specifications and their associated TCs. It supports mobile operators for cellular networks, where huge devices are connected to obtain services through the internet. To avoid failures when connecting IoT devices to mobile networks, GSM has provided two datasets: IoT device connection efficiency and Mobile IoT (MIoT). Both datasets include the architecture for the configuration of the mobile network controls, consisting of common TCs as per the IoT systems specifications. The IoT device connection efficiency dataset includes 80 requirements and 100 TCs [53], [54], whereas the MIoT dataset contains 51 requirements and 41 TCs [55].
The component diagram of this architecture shows the dependency between the components, which will be used for the integration testing evaluation as described later. We have created the traceability matrix (TR) for these datasets to present the related TCs of all requirements, and other documents showing all TCs with their previous runs information and extracted attributes [56]. Sample parts of the used datasets based on GSM are shown in Fig.2.

B. THE EXPERIMENTAL METHODOLOGY
A system was developed for IoT-CIRTF using JAVA 8 and Python 3.7.3 programming languages. Experiments are performed on an Intel(R) Core (TM) i7-75500U CPU (2.40 GHz), 8 GB RAM and 64-bit Windows 8 operating system. Several runs were conducted to create and train LSTM classifier reaching best accuracy when using 4 layers/ nodes of LSTM and around 100 epochs to cover the whole IoT system specifications.
As for the prioritization, SBT (GA and SA) required to execute a number of iterations based on the stop conditions of both algorithms to reach the best solution of ordered TCs. The main evaluation criterion for TCs prioritization is measured by precision, where it is defined by the total number of TCs in the correct order, divided by the total number of TCs as shown in (11) by [57].
Pr e cision = TP TP + FP (11) where TP is the total number of TCs correctly ordered, i.e. true positive, and FP is the total number of TCs incorrectly ordered, i.e. false positive. The experiments can be categorized into three perspectives to examine each layer at IoT-CIRTF as detailed below.

C. IOT COMPONENTS TRAINING LAYER EVALUATION
In order to examine the learning process of mapping the IoT system specifications to the IoT standard components (i.e. User device, protocols and gateways, sensors and actuators, data processing), the used datasets were split into 80% for training and 20% for testing. The learning was then applied using two layers of LSTM, i.e. Bi-directional algorithm. An average accuracy of 75% was obtained, where the large sentences in the IoT specifications led to the need for improving the results. Therefore, four layers of LSTM were applied [58], leading to an average accuracy of 96%.

D. IOT TEST CASES CLASSIFICATION LAYER EVALUATION
As for the evaluation of TCs classification as per the four standard IoT components based on the LSTM classifier, the TCs classification's accuracy was 96% on average, with an average of 100 epochs, after having an accuracy of 75% when using two layers of LSTM only. Other studies as in [59] have achieved accuracy of 92.84%, 97.2% in [60], 74% in [61], and (81.2%) in [62] when applying adaptations on the number of layers with long sequences of data in different prediction and classification applications. based on the best trained LSTM classifier [63]. Fig.3 shows the classification accuracy of both datasets through the loss rate using the Cross-Entropy Loss function for the four layers of LSTM. The results indicate that the loss rate percentage decreases as the number of LSTM classifier layers increases, in which using more layers prompts having less classification errors with the used classifier [20].

V. IOT TEST CASES SELECTION AND PRIORITIZATION EXPERIMENTAL RESULTS
The experiments on this layer consider two main parts: for regression testing and for integration testing. The evaluation is based on the selection and prioritization results as follows.

A. REGRESSION TESTING EXPERIMENTAL RESULTS
The correct selection of TCs is determined by the IoT system's traceability matrix that matches the IoT standard component as per the classified change request. Fig.4 shows the results of TCs prioritization for regression testing, where the y axis represents the FF value of the selected prioritized TCs, and the x axis represents the number of iterations. Prioritization was applied using both SA and GA algorithms for both mentioned datasets. The results are shown through 10 iterations. The total number of iterations varied according to the used algorithm and stopping condition. The FF values of the MIoT dataset are lower than those of the IoT device efficiency dataset, as the size of the later dataset is larger [56].
The results indicate that GA works more accurate with large datasets, since it is a global SBT technique that pursues a population of values rather than singular neighbor values as in the case of local SBT algorithms like the SA algorithm.
The results of SA are near to the results of GA for the regression testing with the used datasets, where the number of selected TCs for regression testing is less than the TCs selected for integration testing. The increase of FF triggers better sequence of selected ordered TCs, due to the increase of FDR, CR and the decrease of ET. In addition, precision is calculated to validate the accuracy of the prioritization results. The average precisions achieved for the IoT device connection efficiency dataset were 72% and 88% for the SA and GA algorithms respectively. The average precisions achieved for the MIoT dataset were 90% and 81% using SA and GA algorithms respectively, resulted at the final iteration, as shown in Fig.6.

B. INTEGRATION TESTING EXPERIMENTAL RESULTS
The evaluation of Integration testing at IoT-CIRTF is determined by the efficiency of deciding the correct integration testing type. The architecture is read as an XML file, then the dependency is calculated between the newly implemented module to test and the ancestor and follower modules to determine the optimum integration testing type. Fig.5 shows the TCs prioritization accuracy results using both GA and SA algorithms, where the x axis presents the number of iterations and the y axis presents the FF value of the selected prioritized TCs.
The accuracy of the prioritized selected TCs using GA and SA for integration testing was examined by precision. In the case of the IoT device connection efficiency dataset, the precision average values were 80% and 92% for the SA and GA algorithms respectively. As for the MIoT dataset, the average precisions were 77% and 89% for SA and GA respectively. The precision values resulted from the final iteration of the used algorithms, as shown on Fig.6. GA proved more efficient percentages when used for the integration testing, where the number of selected TCs was more than those for the regression testing. Prioritization using global SBT such as GA is more efficient with larger selected TCs.

VI. CONCLUSION
Challenges are usually faced during the integration and regression testing of IoT systems, in which the nature of these systems requires continuous testing. In this paper, the IoT Continuous Integration and Regression Testing Framework (IoT-CIRTF) is proposed for continuous regression and integration testing in IoT-based systems based on a hybrid combination of deep learning and search-based techniques. The LSTM classifier was trained for two IoT-based system specifications datasets, achieving an average accuracy of 96% using 100 epochs for 4 layers.
The classifier considered 4 standard components of IoT systems, with loss rates of 4% and 6% when applied for the IoT device connection efficiency and Mobile IoT (MIoT) datasets respectively, indicating the accuracy of the classifier. The prioritization accuracy of the selected TCs for both integration and regression testing was examined by calculating the precision The results for regression testing were 72% and 88% using Simulated Annealing (SA) and Genetic algorithms (GAs) algorithms for the IoT device connection efficiency dataset, and 90% and 81% using SA and GA algorithms for the Mobile IoT (MIoT) dataset respectively. As for the integration testing, the precision results were 80% and 92% using SA and GA algorithms for the IoT device connection efficiency dataset, and 77% and 89% using SA and GA for the MIoT dataset respectively.
As for the future work, it is planned to extend our proposed IoT-CIRTF framework to include other IoT testing areas, such as compatibility testing, configuration testing, scalability testing and security testing.
NAGWA LOTFY BADR received the M.S. degree in computer science and the Ph.D. degree in software engineering and distributed systems from Liverpool John Moorse University, U.K., in 1996 and 2003, respectively. She had done Postdoctoral studies with Glasgow University, U.K. She is currently a Professor and the Dean of the Faculty of Computer and Information Sciences (FCIS), Ain Shams University (ASU). She is the Head of committee that contributed in research projects funded by national and international grants in information systems, bioinformatics, business analytics, and health informatics for the last few years. Her research interests include software engineering, cloud computing, big data analytics, social networking, arabic search engines, and bioinformatics.
MOHAMED F. TOLBA (Senior Member, IEEE) was the Vice President of the Ain Shams University, from 2002 to 2006, and the Dean of the Faculty of Computer and Information Sciences, from 1996 to 2002. Since 1984, he has been a Professor of scientific computing. He has also supervised more than 70 M.Sc. and 45 Ph.D. degrees in ASU and other Egyptian Universities. He is a Consultant to different local and international organizations for IT. He has more than 280 publications in the fields of AI, image processing, pattern recognition, scientific computing, simulation, and modeling.
Since 2000, he has been a ACM Member. He was a member of different International Associations for Science and Technology, such as IASTED and ISCA, the He participated in several international, regional, and local conferences. He was the Honorary Chair and a Co-Chair for many of them.