To meet the demand of the world’s largest population, smart manufacturing has accelerated the adoption of smart factories—where autonomous and cooperative instruments across all levels of production and logistics networks are integrated through a Cyber-Physical Production System (CPPS). However, these networks are comprised of various heterogeneous devices with varying computational power and memory capabilities. As a result, many secure communication protocols—that demand considerably high computational power and memory—can not be verbatim employed on these networks, and thereby, leaving them more vulnerable to security threats and attacks over conventional networks. These threats can largely be tackled by employing a Trust Management Model (TMM) by exploiting the behavioural patterns of nodes to identify their trust class. In this context, ML-based models are best suited due to their ability to capture hidden patterns in data, learning and improving the pattern detection accuracy over time to counteract and tackle threats of a dynamic nature, which is absent in most of the conventional models. However, among the existing ML-based solutions in detecting attack patterns, many of them are computationally expensive, require a long training time, and a considerably large amount of training data—which are seldom available. An aid to this is the association rule learning (ARL) paradigm, whose models are computationally inexpensive and do not require a long training time. Therefore, this paper proposes an ARL-based intelligent Behavioural Trust Model (iBUST) for securing the CPPS. For this intelligent TMM, a variant of Frequency Pattern Growth (FP-Growth), called enhanced FP-Growth (EFP-Growth) algorithm is developed by altering the internal data structures for faster execution and by developing a modified exponential decay function (MEDF) to automatically calculate minimum supports for adapting trust evolution characteristics. In addition, a new optimisation model for finding optimum parameter values in the MEDF and an algorithm for transmuting a 1D quantitative feature into a respective categorical feature are developed to facilitate the model. Afterwards, the trust class of an object is identified employing the Naïve Bayes classifier. This proposed model is evaluated on a trust evolution-supported experimental environment along with other compared models taking a benchmark dataset into consideration, where it outperforms its counterparts.

Software module clustering is an unsupervised learning method used to cluster software entities (e.g., classes, modules, or files) with similar features. The obtained clusters may be used to study, analyze, and understand the software entities’ structure and behavior. Implementing software module clustering with optimal results is challenging. Accordingly, researchers have addressed many aspects of software module clustering in the past decade. Thus, it is essential to present the research evidence that has been published in this area. In this study, 143 research papers from well-known literature databases that examined software module clustering were reviewed to extract useful data. The obtained data were then used to answer several research questions regarding state-of-the-art clustering approaches, applications of clustering in software engineering, clustering processes, clustering algorithms, and evaluation methods. Several research gaps and challenges in software module clustering are discussed in this paper to provide a useful reference for researchers in this field.

Requirement prioritisation (RP) is often used to select the most important system requirements as perceived by system stakeholders. RP plays a vital role in ensuring the development of a quality system with defined constraints. However, a closer look at existing RP techniques reveals that these techniques suffer from some key challenges, such as scalability, lack of quantification, insufficient prioritisation of participating stakeholders, overreliance on the participation of professional expertise, lack of automation and excessive time consumption. These key challenges serve as the motivation for the present research. This study aims to propose a new semiautomated scalable prioritisation technique called ‘SRPTackle’ to address the key challenges. SRPTackle provides a semiautomated process based on a combination of a constructed requirement priority value formulation function using a multi-criteria decision-making method (i.e. weighted sum model), clustering algorithms (K-means and K-means++) and a binary search tree to minimise the need for expert involvement and increase efficiency. The effectiveness of SRPTackle is assessed by conducting seven experiments using a benchmark dataset from a large actual software project. Experiment results reveal that SRPTackle can obtain 93.0% and 94.65% as minimum and maximum accuracy percentages, respectively. These values are better than those of alternative techniques. The findings also demonstrate the capability of SRPTackle to prioritise large-scale requirements with reduced time consumption and its effectiveness in addressing the key challenges in comparison with other techniques. With the time effectiveness, ability to scale well with numerous requirements, automation and clear implementation guidelines of SRPTackle, project managers can perform RP for large-scale requirements in a proper manner, without necessitating an extensive amount of effort (e.g. tedious manual processes, need for the involvement of experts and time workload).

To ensure the quality of current highly configurable software systems, intensive testing is needed to test all the configuration combinations and detect all the possible faults. This task becomes more challenging for most modern software systems when constraints are given for the configurations. Here, intensive testing is almost impossible, especially considering the additional computation required to resolve the constraints during the test generation process. In addition, this testing process is exhaustive and time-consuming. Combinatorial interaction strategies can systematically reduce the number of test cases to construct a minimal test suite without affecting the effectiveness of the tests. This paper presents a new efficient search-based strategy to generate constrained interaction test suites to cover all possible combinations. The paper also shows a new application of constrained interaction testing in software fault searches. The proposed strategy initially generates the set of all possible [Formula: see text]-[Formula: see text] combinations; then, it filters out the set by removing the forbidden [Formula: see text]-[Formula: see text] using the Base Forbidden Tuple (BFT) approach. The strategy also utilizes a mixed neighborhood tabu search (TS) to construct optimal or near-optimal constrained test suites. The efficiency of the proposed method is evaluated through a comparison against two well-known state-of-the-art tools. The evaluation consists of three sets of experiments for 35 standard benchmarks. Additionally, the effectiveness and quality of the results are assessed using a real-world case study. Experimental results show that the proposed strategy outperforms one of the competitive strategies, ACTS, for approximately 83% of the benchmarks and achieves similar results to CASA for 65% of the benchmarks when the interaction strength is 2. For an interaction strength of 3, the proposed method outperforms other competitive strategies for approximately 60% and 42% of the benchmarks. The proposed strategy can also generate constrained interaction test suites for an interaction strength of 4, which is not possible for many strategies. The real-world case study shows that the generated test suites can effectively detect injected faults using mutation testing.

Abstract Hyper-heuristic is a new methodology for the adaptive hybridization of meta-heuristic algorithms to derive a general algorithm for solving optimization problems. This work focuses on the selection type of hyper-heuristic, called the exponential Monte Carlo with counter (EMCQ). Current implementations rely on the memory-less selection that can be counterproductive as the selected search operator may not (historically) be the best performing operator for the current search instance. Addressing this issue, we propose to integrate the memory into EMCQ for combinatorial t-wise test suite generation using reinforcement learning based on the Q-learning mechanism, called Q-EMCQ. The limited application of combinatorial test generation on industrial programs can impact the use of such techniques as Q-EMCQ. Thus, there is a need to evaluate this kind of approach against relevant industrial software, with a purpose to show the degree of interaction required to cover the code as well as finding faults. We applied Q-EMCQ on 37 real-world industrial programs written in Function Block Diagram (FBD) language, which is used for developing a train control management system at Bombardier Transportation Sweden AB. The results show that Q-EMCQ is an efficient technique for test case generation. Addition- ally, unlike the t-wise test suite generation, which deals with the minimization problem, we have also subjected Q-EMCQ to a maximization problem involving the general module clustering to demonstrate the effectiveness of our approach. The results show the Q-EMCQ is also capable of outperforming the original EMCQ as well as several recent meta/hyper-heuristic including modified choice function, Tabu high-level hyper-heuristic, teaching learning-based optimization, sine cosine algorithm, and symbiotic optimization search in clustering quality within comparable execution time.

Combinatorial interaction testing (CIT) is a useful testing technique to address the interaction of input parameters in software systems. CIT has been used as a systematic technique to sample the enormous test possibilities. Most of the research activities focused on the generation of CIT test suites as a computationally complex problem. Less effort has been paid for the application of CIT. To apply CIT, practitioners must identify the input parameters for the Software‐under‐test (SUT), feed these parameters to the CIT test generation tool, and then run those tests on the application with some pass and fail criteria for verification. Using this approach, CIT is used as a black‐box testing technique without knowing the effect of the internal code. Although useful, practically, not all the parameters having the same impact on the SUT. This paper introduces a different approach to use the CIT as a gray‐box testing technique by considering the internal code structure of the SUT to know the impact of each input parameter and thus use this impact in the test generation stage. The case studies results showed that this approach would help to detect new faults as compared to the equal impact parameter approach.

A combinatorial testing (CT) is an important technique usually employed in the generation of test cases. The generation of an optimal sized test case is a non‐deterministic polynomial hard problem. In recent times, many researchers had developed various strategies based on the search‐based approach to address the CT issues. This study presented the most recent variable interaction strength (VS) CT strategy using an enhanced variant in the greedy algorithm. Hence, they are referred to as variable strength modified greedy strategy (VS‐MGS). Moreover, the modified strategy supports a VS together with interaction strength up to six. The proposed variant‐greedy algorithm employed the elitism mechanism alongside the iteration in order to improve its efficiency. This algorithm is invariably called the modified greedy algorithm (MGA). Furthermore, the efficiency and performance of the VS‐MGS using MGA were assessed first by comparing its results with the original greedy algorithm results and thereafter benchmarked with the results of the existing VS CT strategies. The VS‐MGS's results ultimately revealed that the adaptation of elitism mechanism with iteration in greedy algorithm resulted in an improved efficiency in the process of generating a near‐optimal test case set size.

Testing processes and workflows in information and Internet of Things systems is a major part of the typical software testing effort. Consistent and efficient path-based test cases are desired to support these tests. Because certain parts of software system workflows have a higher business priority than others, this fact has to be involved in the generation of test cases. In this paper, we propose a Prioritized Process Test (PPT), which is a model-based test case generation algorithm that represents an alternative to currently established algorithms that use directed graphs and test requirements to model the system under test. The PPT accepts a directed multigraph as a model to express priorities, and edge weights are used instead of test requirements. To determine the test-coverage level of test cases, a test-depth-level concept is used. We compared the presented PPT with five alternatives (i.e. the Process Cycle Test (PCT), a naive reduction of test set created by the PCT, Brute Force algorithm, Set-covering-Based Solution and Matching-based Prefix Graph Solution) for edge coverage and edge-pair coverage. To assess the optimality of the path-based test cases produced by these strategies, we used 14 metrics based on the properties of these test cases and 59 models that were created for three real-world systems. For all edge coverage, the PPT produced more optimal test cases than the alternatives in terms of the majority of the metrics. For edge-pair coverage, the PPT strategy yielded similar results to those of the alternatives. Thus, the PPT strategy is an applicable alternative as it reflects both the required test coverage level and the business priority in parallel.

Software testing relates to the process of accessing the functionality of a program against some defined specifications. To ensure conformance, test engineers often generate a set of test cases to validate against the user requirements. When dealing with large line of codes (LOCs), there are potentially issue of redundancies as new test cases may be added and old test cases may be deleted during the whole testing process. In order to address this issue, we have developed a new strategy, called tReductSA, to systematically minimize test cases for testing consideration. Unlike existing works which rely on the Greedy approaches, our work adopts the random sequence permutation and optimization algorithm based on Simulated Annealing with systematic merging technique. Our benchmark experiments demonstrate that tReductSA scales well with existing works (including that of GE, GRE and HGS) as far as optimality is concerned. On the other note, tReductSA also offers more diversified solutions as compared to existing work.

Our continuous dependencies on software (i.e. to assist as well as facilitate our daily chores) often raise dependability issue particularly when software is being employed harsh and life threatening or (safety) critical applications. Here, rigorous software testing becomes immensely important. Many combinations of possible input parameters, hardware/software environments, and system conditions need to be tested and verified against for conformance. Due to resource constraints as well as time and costing factors, considering all exhaustive test possibilities would be impossible (i.e. due to combinatorial explosion problem). Earlier work suggests that pairwise sampling strategy (i.e. based on two-way parameter interaction) can be effective. Building and complementing earlier work, this paper discusses an efficient pairwise test data generation strategy, called G2Way. In doing so, this paper demonstrates the correctness of G2Way as well as compares its effectiveness against existing strategies including AETG and its variations, IPO, SA, GA, ACA, and All Pairs. Empirical evidences demonstrate that G2Way, in some cases, outperformed other strategies in terms of the number of generated test data within reasonable execution time.

We evaluate a new visual process modeling language (PML), called the Virtual Reality Process Modeling Language (VRPML). This evaluation utilizes the well-known ISPW-6 benchmark problem as well as the waterfall development model as case studies, and offers comparison with other PMLs where possible. In addition to providing insights into the strengths and limitations of VRPML, this evaluation highlights important lessons learned and offers valuable guidance for the design of next-generation PMLs.

Process modeling languages (PMLs) are languages used to express software process models. Process centered software engineering environments (PSEEs) are the environments used to define, modify, analyze and enact a process model. While both PMLs and PSEEs are important, it is the characteristics of PMLs that are the focus of the article, which leads to a taxonomy different from that presented in other work primarily with the inclusion of important human dimension issues (e.g. awareness support) from computer supported cooperative work (CSCW).