This paper presents a novel stream allocation algorithm for semi-coherent Cell-Free Multi-User Multiple-Input Multiple-Output (CF-MU-MIMO) networks. In such networks, groups of phase-coherent Access Points (APs) are organized into clusters that operate coherently inside the clusters, while inter-cluster phase coherence is not maintained, reflecting practical limitations in achieving network-wide synchronization. The proposed algorithm is tailored for multi-cluster service, where multiple clusters can simultaneously serve each User Equipment (UE). To support this flexibility, different stream sequences are constructed for each UE, and each of the sequences is initialized and dynamically constructed based on the strongest links across all serving clusters and the UEs. During the allocation process, both inter-cluster and inter-stream interference are mitigated using projection-based techniques, thereby improving spatial multiplexing efficiency. Compared to the greedy stream allocation which is commonly adopted in the literature as a low-complexity benchmark due to its near-optimal performance in downlink MIMO systems, the proposed method achieves higher performance with only a modest increase in complexity. Furthermore, a significant enhancement in the achievable sum rate is demonstrated relative to single-user-single-cluster allocation strategies in distributed cell-free systems.

Abstract “In Silico” research drives the world around us, as illustrated by the way our society handles climate change, controls the COVID-19 pandemic and governs economic growth. Unfortunately, the code embedded in the underlying data processing is mostly written by scientists lacking formal training in software engineering. The resulting code is vulnerable, suffering from what is known as threats to instrument validity. This position paper aims to understand and remedy threats to instrument validity in current “in silico” research. To achieve this goal, we specify a research agenda listing how recent software engineering achievements may improve “in silico” research (SE4Silico) and, conversely, how software engineering may strengthen its applicability (Silico4SE).

Several experience reports illustrate that mutation testing is capable of supporting a “shift-left” testing strategy for software systems coded in textual programming languages like C++. For graphical modelling languages like Simulink, such experience reports are missing, primarily because of a lack of adequate tool support. In this paper, we present a proof-of-concept (named MUT4S LX) for automatic mutant generation and test execution of Simulink models. MUT14SLX features 15 mutation operators which are modelled after realistic faults (mined from an industrial bug database) and are fast to inject (because we only replace parameter values within blocks). An experimental evaluation on a sample project (a Helicopter Control System) demonstrates that MUT4SLX is capable of injecting 70 mutants in less than a second, resulting in a total analysis time of 8.14 hours.

The goal of software product lines (SPLs) is rapid development of high-quality software products in a specific domain with cost minimization. To assure quality of software products from SPLs, products need to be tested systematically. However, testing every product variant in isolation is generally not feasible for large number of product variants. An approach to deal with this issue is to use incremental testing, where test artifacts that are developed for one product are reused for another product which can be obtained by incrementally adding features to the prior product. We propose a novel model-based test generation approach for products developed using SPL that follows incremental testing paradigm. First, we introduce Featured Event Sequence Graphs (FESGs), an extension of ESGs, that provide necessary definitions and operations to support commonalities and variabilities in SPLs with respect to test models. Then we propose a test generation technique for the product variants of an SPL, which starts from any product. The proposed technique with FESGs avoids redundant test generation for each product from SPL. We compare our technique with in-isolation testing approach by a case study.

Model-based testing employs models for testing. Model-based mutation testing (MBMT) additionally involves fault models, called mutants, by applying mutation operators to the original model. A problem encountered with MBMT is the elimination of equivalent mutants and multiple mutants modeling the same faults. Another problem is the need to compare a mutant to the original model for test generation. This paper proposes an event-based approach to MBMT that is not fixed on single events and a single model but rather operates on sequences of events of length k ≥ 1 and invokes a sequence of models that are derived from the original one by varying its morphology based on k. The approach employs formal grammars, related mutation operators, and algorithms to generate test cases, enabling the following: (1) the exclusion of equivalent mutants and multiple mutants; (2) the generation of a test case in linear time to kill a selected mutant without comparing it to the original model; (3) the analysis of morphologically different models enabling the systematic generation of mutants, thereby extending the set of fault models studied in related literature. Three case studies validate the approach and analyze its characteristics in comparison to random testing and another MBMT approach.

Model-based testing (MBT) focuses on relevant, mostly user-centric features of the system under consideration (SUC) and enables test case generation without requiring source code. Depending on these features and the preferences of the tester, modeling can be event-based or state-based. This paper compares both techniques using mutation testing, which is originally code-based, but has recently been extended to enable also MBT. For the comparison, the paper introduces frameworks that are composed of a set of models, a set of mutation operators, a set of coverage criteria, and a set of test generation algorithms. The introduced concepts and notions are demonstrated over a case study based on a large web-based commercial portal. Analysis of the experimental data yields results on the discussed frameworks reviewing benefits and drawbacks of event-based and state-based testing.

A go-back (GB) function for canceling recent user or system operations and going back to and resuming of previous state(s) is very often used regardless of the application domain. Therefore, faulty handling of them can cause severe damages in those applications. This paper proposes a mutation-based approach to testing GB functions modeled by pushdown automata. Novel mutation operators, recent coverage criteria, and a new algorithm for test case generation are introduced. A case study validates the approach and discusses its characteristics.