Improve Software Quality Research Articles

Backpropagation Neural Network optimization and software defect estimation modelling using a hybrid Salp Swarm optimizer-based Simulated Annealing Algorithm

Software Defect Estimation (SDE) is a fundamental problem solving mechanism in the field of software engineering (SE). SDE is a task that identifies software models that are likely to have defects. In addition, SDE plays a vital overall role in improving software quality, reducing software development costs and accelerating software development processes. The Backpropagation Neural Network (BPNN) is a popular machine learning (ML) estimator widely utilized in SE estimation problems. Unfortunately, its performance depends on the initial weight and bias values. Metaheuristic optimization algorithms, as an alternative method, have proven to have strengths in parameter optimizations. Additionally, population-based metaheuristic algorithms suffer from low exploitation capabilities. In this paper, a new hybrid metaheuristic algorithm-based BPNN (SSA–SA) is proposed by hybridizing the Salp Swarm Algorithm (SSA) with the Simulated Annealing (SA) algorithm. The main goal of the hybridization is to adjust the balance between exploration and exploitation in SSA. The proposed algorithm is also assembled with the BPNN estimator to optimize its parameters to reduce the overall estimation error, which boosts the estimation accuracy. Thus, the proposed algorithm addresses the SDE problem. Experimental results prove the superiority of the proposed hybrid algorithm in optimizing BPNN parameters in comparisons against other estimators and algorithms in most SDE datasets and evaluation criteria.

Towards random and enumerative testing for OCaml and WhyML properties

Deductive program verification greatly improves software quality, but proving formal specifications is difficult, and this activity can only be partially automated. It is therefore relevant to supplement deductive verification tools, such as Why3, with the ability to test the properties to be verified. We present a methodological study and a prototype for the random and enumerative testing of properties written either in the Why3 input language WhyML or in the OCaml programming language used by Why3 to run programs written in WhyML. An originality is that we propose enumerative testing based on data generators themselves written in WhyML and formally verified with Why3. Another specificity is that the development effort is reduced by exploiting Why3’s extraction mechanism to OCaml and an existing random testing tool for OCaml. These design choices are applied in a prototypal implementation of a tool, called AutoCheck. The prototype and the paper are designed with simplicity and usability in mind, in order to make them accessible to the widest audience. Starting from the most elementary cases, a tutorial illustrates the implemented features with many examples presented in increasing complexity order.

Energy Efficiency Analysis of Code Refactoring Techniques for Green and Sustainable Software in Portable Devices

Code refactoring is a time-consuming and effort-intensive process that is applied for making improvements to source codes. There exist several refactoring techniques to improve software quality. Some of them aim to reduce the energy consumption of the software. However, the combination of applied refactoring techniques is crucial to the success rate. In addition, to provide sustainable services on portable devices such as mobile phones and laptops, which rely on batteries, improving and optimizing the energy efficiency is important. This study focuses on examining the effect of code refactoring techniques on energy consumption. A total of 25 different source codes of applications programmed in the C# and Java languages are selected for the study, and combinations obtained from refactoring techniques are applied to these source codes. The combinations applied are analyzed using the maintainability index. Power consumption estimation tools are used to measure the energy consumption of the original and refactored codes. The results show that the combinations significantly improve the software’s energy efficiency. The results will provide a better understanding of the relationship between the energy efficiency of software and refactoring techniques. Moreover, they will help developers to improve their object-oriented code in terms of both energy efficiency and sustainability.

Improving bioinformatics software quality through incorporation of software engineering practices.

BackgroundBioinformatics software is developed for collecting, analyzing, integrating, and interpreting life science datasets that are often enormous. Bioinformatics engineers often lack the software engineering skills necessary for developing robust, maintainable, reusable software. This study presents review and discussion of the findings and efforts made to improve the quality of bioinformatics software.MethodologyA systematic review was conducted of related literature that identifies core software engineering concepts for improving bioinformatics software development: requirements gathering, documentation, testing, and integration. The findings are presented with the aim of illuminating trends within the research that could lead to viable solutions to the struggles faced by bioinformatics engineers when developing scientific software.ResultsThe findings suggest that bioinformatics engineers could significantly benefit from the incorporation of software engineering principles into their development efforts. This leads to suggestion of both cultural changes within bioinformatics research communities as well as adoption of software engineering disciplines into the formal education of bioinformatics engineers. Open management of scientific bioinformatics development projects can result in improved software quality through collaboration amongst both bioinformatics engineers and software engineers.ConclusionsWhile strides have been made both in identification and solution of issues of particular import to bioinformatics software development, there is still room for improvement in terms of shifts in both the formal education of bioinformatics engineers as well as the culture and approaches of managing scientific bioinformatics research and development efforts.

A Quantitative Assessment of the Impact of Homogeneity in Personality Traits on Software Quality and Team Productivity

Software industry is increasingly focusing on the improvement of software quality and team performance to survive in a competitive and rapidly growing environment. Previous studies reveal the importance of social and human factors in software engineering. Despite the importance of these personality factors, only a handful of empirical studies have quantitatively evaluated the impact of personality traits on software quality and effectiveness of software engineering teams. This study quantifies the abstract notion of trait-wise team homogeneity based on the Five-Factor Model (FFM). Additionally, this study also aims to measure its impact on team productivity and software quality. Trait-wise team homogeneity measures the Team Homogeneity Index (THI) for each of the five personality traits of FFM. Therefore, five new metrics i.e. Openness THI (O-THI), Conscientiousness THI (C-THI), Extraversion THI (E-THI), Agreeableness THI (A-THI), and Neuroticism THI (N-THI) are proposed. The utility of these five metrics is evaluated by conducting experiments in academic and industrial environments for three different phases of the Software Development Life Cycle (SDLC) i.e. analysis and design, implementation, and testing. During the analysis and design phase, it was observed that teams (composed of either students or professionals) with greater values of C-THI and A-THI produced better quality design models and teams with greater values of C-THI were more productive. In the implementation phase, teams with higher values of O-THI, C-THI, and E-THI were noticeably more productive and produced better quality code. For the testing phase, teams with greater values of C-THI and A-THI produced better quality test cases and were more productive. Results obtained so far indicate that the newly proposed five metrics – O-THI, C-THI, E-THI, A-THI, and N-THI – appear to have the potential to aid managers and academics alike in building productive teams which can produce better quality software.

A new approach to software defect prediction based on convolutional neural network and bidirectional long short-term memory

Software defect prediction (SDP) plays an important role in improving software quality and reliability while reducing software maintenance cost. The problem in the field of SDP is how to determine the defective source code with high accuracy. To build more accurate predictor models, a lot of features are presented, e.g., static code features, social network features, and process features, etc. Several machine learning (ML) and deep learning (DL) algorithms have been developed and adopted to identify and remove defects from the source code, where previous studies have proved that DL algorithms are promising techniques for predicting software defects. The aim of this study is to investigate the prediction performance of two DL algorithms namely, Convolutional Neural Network (CNN) and Bidirectional Long short-term memory (BI-LSTM) in the domain of SDP. To establish the effectiveness of the proposed approach, the experiments were conducted on the available benchmark datasets which obtained from open-source java projects GitHub repository and the models were evaluated by applying seven evaluation metrics which are accuracy, precision, recall, f-measure, matthews correlation coefficient (MCC), area under the ROC curve (AUC), mean square error (MSE). We found out that the best accuracy obtained on training dataset is 81% by using CNN model, while the best accuracy obtained on validation dataset is 80% by using BI-LSTM model. The best AUC obtained on training dataset is 88% by using CNN model, while the best AUC obtained on validation dataset is 83% by using the both models. It is nearly impossible to rule which model is better than the other so every model can be analyzed separately and the best model according to the problem at hand can be used, therefore, based on the problem of this study, The evaluation results show the effectiveness of our proposed models based on standard performance evaluation criteria.

Identifying Incorrect Patches in Program Repair Based on Meaning of Source Code

Automatic Program Repair (APR) techniques have shown the potential of reducing debugging costs while improving software quality by generating patches for fixing bugs automatically. However, they often generate many overfitting patches which pass only a specific test-suite but do not fix the bugs correctly. This paper proposes MIPI, a novel approach to reducing the number of overfitting patches generated in the APR. We leverage recent advances in deep learning to exploit the similarity between the patched method’s name (which often encloses the developer’s intention about the code) and the semantic meaning of the method’s body (which represents the actual implemented behavior) for identifying and removing overfitting patches generated by APR tools. Experiments with a large dataset of patches for QuixBugs and Defects4J programs show the promise of our approach. Specifically, in a total of 1,191 patches generated by 23 existing APR tools, MIPI successfully filters out 254 (32%) of the total 797 overfitting patches with a precision of 90% while preserving 93% of the correct patches. MIPI is more precise and less damaging to the APR than existing heuristic patch assessment techniques, achieving a higher recall than automated testing-based techniques that do not have access to the test oracle. In addition, MIPI is highly complementary to existing automated patch assessment techniques.

A Graph Convolution Network-Based Bug Triage System to Learn Heterogeneous Graph Representation of Bug Reports

Many bugs and defects occur during software testing and maintenance. These bugs should be resolved as soon as possible, to improve software quality. However, bug triage aims to solve these bugs by assigning the reported bugs to an appropriate developer or list of developers. It is an arduous task for a human triager to assign an appropriate developer to a bug report, when there are several developers with different skills, and several automated and semi-automated triage systems have been proposed in the last decade. Some recent techniques have suggested possibilities for the development of an effective triage system. However, these techniques require improvement. In previous work, we proposed a heterogeneous graph representation for bug triage, using word–word edges and word-bug document co-occurrences to build a heterogeneous graph of bug data. Cosine similarity is used to weight the word–word edges. Then, a graph convolution network is used to learn a heterogeneous graph representation. This paper extends our previous work by adopting different similarity metrics and correlation metrics for weighting word–word edges. The method was validated using different small and large datasets obtained from large-scale open-source projects. The top-k accuracy metric was used to evaluate the performance of the bug triage system. The experimental results showed that the point-wise mutual information of the proposed model was better than that of other word–word weighting methods, and our method had better accuracy for large datasets than other recent state-of-the-art methods. The proposed method with point-wise mutual information showed 3% to 6% higher top-1 accuracy than state-of-the-art methods for large datasets.

DevOps Enabled Agile: Combining Agile and DevOps Methodologies for Software Development

The Agile and DevOps software development methodologies have made revolutionary advancements in software engineering. These methodologies vastly improve software quality and also speed up the process of developing software products. However, several limitations have been discovered in the practical implementation of Agile and DevOps, including the lack of collaboration between the development, testing and delivery sectors of different software projects and high skill requirements. This paper presents a solution to bridge the existing gaps between Agile and DevOps methodologies by integrating DevOps principles into Agile to devise a hybrid DevOps Enabled Agile for software development. This study includes the development of a small-scale, experimental pilot project to demonstrate how software development teams can combine the advantages of Agile and DevOps methodologies to fulfill the gaps and provide further improvements to the speed and quality of software development process while maintaining feasible skill requirements.

Cognitive Complexity and Graph Convolutional Approach Over Control Flow Graph for Software Defect Prediction

The software engineering community is working to develop reliable metrics to improve software quality. It is estimated that understanding the source code accounts for 60% of the software maintenance effort. Cognitive informatics is important in quantifying the degree of difficulty or the efforts made by developers to understand the source code. Several empirical studies were conducted in 2003 to assign cognitive weights to each possible basic control structure of software, and these cognitive weights are used by several researchers to evaluate the cognitive complexity of software systems. In this paper, an effort has been made to categorize the Control Flow Graphs (CFGs) nodes according to their node features. In our case, we extracted seven unique features from the program, and each unique feature was assigned an integer value that we evaluated through Cognitive Complexity Measures (CCMs). We then incorporated CCMs’ results as a node feature value in CFGs and generated the same based on the node connectivity for a graph. In order to obtain the feature representation of the graph, a node vector matrix is then created for the graph and passed to the Graph Convolutional Network (GCN). We prepared our data sets using GCN output and then built Deep Neural Network Defect Prediction (DNN-DP) and Convolutional Neural Network Defect Prediction (CNN-DP) models to predict software defects. The Python programming language is used, along with Keras and TensorFlow. Three hundred twenty Python programs were written by our talented UG and PG students, and all experiments were carried out during laboratory classes. Together with three skilled lab programmers, they compiled and ran each individual program and detected defect/no-defect programs before categorizing them into three different classes, namely Simple, Medium, and Complex programs. Accuracy, Receiver Operating Characteristics (ROC), Area Under Curve (AUC), F-measure, Precision and hyper-parameter tuning procedures are used to evaluate the approaches. The experimental results show that the proposed models outperformed state-of-the-art methods such as Nave Bayes (NB), Decision Tree (DT), Support Vector Machine (SVM), and Random Forest (RF) in all evaluation criteria.

Examining the Predictive Capability of Advanced Software Fault Prediction Models – An Experimental Investigation Using Combination Metrics

Background: Fault prediction is a key problem in software engineering domain. In recent years, an increasing interest in exploiting machine learning techniques to make informed decisions to improve software quality based on available data has been observed. Aim: The study aims to build and examine the predictive capability of advanced fault prediction models based on product and process metrics by using machine learning classifiers and ensemble design. Method: Authors developed a methodological framework, consisting of three phases i.e., (i) metrics identification (ii) experimentation using base ML classifiers and ensemble design (iii) evaluating performance and cost sensitiveness. The study has been conducted on 32 projects from the PROMISE, BUG, and JIRA repositories. Result: The results shows that advanced fault prediction models built using ensemble methods show an overall median of F-score ranging between 76.50% and 87.34% and the ROC(AUC) between 77.09% and 84.05% with better predictive capability and cost sensitiveness. Also, non-parametric tests have been applied to test the statistical significance of the classifiers. Conclusion: The proposed advanced models have performed impressively well for inter project fault prediction for projects from PROMISE, BUG, and JIRA repositories.

Standardization Workflow Technology of Software Testing Processes and its Application to SRGM on RSA Timing Attack Tasks

Due to changing software requirements and increasing system complexity, which put forward new challenges to the related testing processes to ensure software trustworthiness. Software testing is an important means to improve software quality, and standardized software testing process has become an effective measure to ensure software testing quality. In order to solve the problem of software quality decline caused by non-standard behaviors in software testing processes, this paper proposes a standardization workflow technology to construct the management system of software testing processes, and applies the workflow management system to the software testing of RSA timing attack tasks. For the numerical experimental setup, two software fault detection time-domain datasets are considered, i.e., datasets generated from the RSA timing attack program in functional testing processes and workflow verification system used to manage the RSA timing attack processes in non-functional testing processes. Then, software reliability is evaluated by employing multiple heterogeneous software reliability growth models (SRGMs) with corresponding assumed conditions, parameter information and reliability prediction methods. Furthermore, we compare the fitting power and predictive performance of multiple SRGMs in terms of the model evaluation criteria, which helps testers select a better SRGM from the model evaluation results for reliability analysis. The experimental results show that the proposed standardization workflow technology can reasonably regulate the software testing processes, making the fault data input into SRGMs more reliable and reliability analysis results more credible.

Compiler IR-Based Program Encoding Method for Software Defect Prediction

With the continuous expansion of software applications, people's requirements for software quality are increasing. Software defect prediction is an important technology to improve software quality. It often encodes the software into several features and applies the machine learning method to build defect prediction classifiers, which can estimate the software areas is clean or buggy. However, the current encoding methods are mainly based on the traditional manual features or the AST of source code. Traditional manual features are difficult to reflect the deep semantics of programs, and there is a lot of noise information in AST, which affects the expression of semantic features. To overcome the above deficiencies, we combined with the Convolutional Neural Networks (CNN) and proposed a novel compiler Intermediate Representation (IR) based program encoding method for software defect prediction (CIR-CNN). Specifically, our program encoding method is based on the compiler IR, which can eliminate a large amount of noise information in the syntax structure of the source code and facilitate the acquisition of more accurate semantic information. Secondly, with the help of data flow analysis, a Data Dependency Graph (DDG) is constructed on the compiler IR, which helps to capture the deeper semantic information of the program. Finally, we use the widely used CNN model to build a software defect prediction model, which can increase the adaptive ability of the method. To evaluate the performance of the CIR-CNN, we use seven projects from PROMISE datasets to set up comparative experiments. The experiments results show that, in WPDP, with our CIR-CNN method, the prediction accuracy was improved by 12% for the AST-encoded CNN-based model and by 20.9% for the traditional features-based LR model, respectively. And in CPDP, the AST-encoded DBN-based model was improved by 9.1% and the traditional features-based TCA+ model by 19.2%, respectively.

Extending Developer Experience Metrics for Better Effort-Aware Just-In-Time Defect Prediction

Developers use defect prediction models to efficiently allocate limited resources for quality assurance and appropriately make a plan for software quality improvement activities. Traditionally, defect predictions are conducted at the module level, such as the class or file level. However, a more recent trend is to perform defect prediction for a single or consecutive commits to the repository, which is known as just-in-time (JIT) defect prediction. JIT defect prediction finds error-prone changes instead of error-prone modules, and as a result, the developer only needs to investigate error-prone changed lines instead of the entire module. When building JIT defect prediction models, researchers used various metrics, including developer experience metrics which measure the developer’s experiences. Despite the fact that software defectiveness is likely to be affected by the experience of developers, developer metrics were understudied in the literature. In this work, we investigate the impact of various novel developer experience metrics and their combinations on JIT defect prediction. Our experimental results are positive. We found that it is possible to improve the cost-effectiveness of defect prediction models consistently and statistically significantly by using our new developer experience metrics.

On the documentation of refactoring types

Commit messages are the atomic level of software documentation. They provide a natural language description of the code change and its purpose. Messages are critical for software maintenance and program comprehension. Unlike documenting feature updates and bug fixes, little is known about how developers document their refactoring activities. Specifically, developers can perform multiple refactoring operations, including moving methods, extracting classes, renaming attributes, for various reasons, such as improving software quality, managing technical debt, and removing defects. Yet, there is no systematic study that analyzes the extent to which the documentation of refactoring accurately describes the refactoring operations performed at the source code level. Therefore, this paper challenges the ability of refactoring documentation, written in commit messages, to adequately predict the refactoring types, performed at the commit level. Our analysis relies on the text mining of commit messages to extract the corresponding features (i.e., keywords) that better represent each class (i.e., refactoring type). The extraction of text patterns, specific to each refactoring type (e.g., rename, extract, move, inline, etc.) allows the design of a model that verifies the consistency of these patterns with their corresponding refactoring. Such verification process can be achieved via automatically predicting, for a given commit, the method-level type of refactoring being applied, namely Extract Method, Inline Method, Move Method, Pull-up Method, Push-down Method, and Rename Method. We compared various classifiers, and a baseline keyword-based approach, in terms of their prediction performance, using a dataset of 5004 commits. Our main findings show that the complexity of refactoring type prediction varies from one type to another. Rename Method and Extract Method were found to be the best documented refactoring activities, while Pull-up Method, and Push-down Method were the hardest to be identified via textual descriptions. Such findings bring the attention of developers to the necessity of paying more attention to the documentation of these types.

HOTFUZ: Cost‐effective higher‐order mutation‐based fault localization

AbstractFault localization techniques are used to deduce the exact source of a failure from a set of failure indications while debugging software and play a crucial role in improving software quality. Mutation‐based fault localization (MBFL) techniques are proposed to localize faults at a finer granularity and with higher accuracy than traditional fault localization techniques. Despite the technique's effectiveness, the immense cost of mutation analysis hinders MBFL's practical application in the industry. Various mutation alternative strategies are utilized to lower the cost of MBFL, but they sacrifice the accuracy of localization results. Higher‐order mutation testing was proposed to search for valuable mutants that drive testing harder and reduce the overall test effort. However, higher‐order mutants (HOMs) never have been used to address the cost problem of MBFL to the extent of our knowledge. This paper proposes a novel, cost‐effective MBFL technique called HOTFUZ, Higher‐Order muTation‐based FaUlt localiZation, that employs HOMs to reduce the cost while minimizing the accuracy degradation. HOTFUZ combines mutants of a program under test into HOMs to decrease the number of mutants by more than half, depending on the order of HOMs. An experimental study is conducted using 65 real‐world faults of CoREBench to assess the proposed approach's cost‐effectiveness. The experimental results show that HOTFUZ outperforms the extant mutation alternative strategies by localizing faults more accurately using the same number of mutants executed. HOTFUZ has three main benefits over existing mutant reduction techniques for MBFL: (a) It keeps the advantage of using the whole set of mutation operators; (b) it does not discard generated mutants randomly for the sake of efficiency; and, finally, (c) it significantly decreases the proportion of equivalent mutants.

A Novel Metric based Detection of Temporary Field Code Smell and its Empirical Analysis

Code smell causes side effects in the source code and impact the code quality. It is beneficial to recognize code smells to improve software quality. Despite 22 classical code smells as characterized by Martin Fowler, all classical code smells have not been considered for the identification and refactoring. Temporary field code smell is one such code smell that has not been given an appropriate level of attention so far regarding its detection as well as refactoring. In this paper, we have proposed a novel metric-based method and developed a tool to detect temporary field code smell. The proposed method works on three novel metrics in addition to existing metric TCC (tight class cohesion) and three new rules (R1, R2, and R3) to detect temporary field code smell. Detection rules were tested on ten open-source GitHub Java projects used in the literature. Results demonstrate that projects under the study that had non-cohesive classes have shown the presence of temporary field code smell ranging from 54% to 100%. Findings have additionally demonstrated that for the undertaken projects, there exists a strong positive correlation between the number of classes exhibiting temporary field smell and number of non-cohesive classes present in a project.

Software quality improvement and validation using reengineering

In software development life cycle, software maintenance is among the critical phases. It is a post-implementation activity that requires rigorous human efforts. For any software developer, maintaining software for a longer period is the primary objective. This objective can be accomplished if good quality software is developed. Maintainability is one of the vital characteristics of software maintenance. Maintainability enables developers to keep the system alive for a longer period of time at a limited cost. Software Maintainability can be enhanced using reengineering. The proposed research validates improvement in the quality of the reengineered software system. The quality of the software is analyzed using a coupling, cohesion, inheritance, and other essential design metrics. The observed improvement in the software design is 62.1%. The execution time of the software is also reduced by 6.5%. Reduction in the cost of maintenance is also another important outcome of this research. The observed reduction in the maintenance cost is 36.8%. Thus, the main objective of the proposed research is to analyze and validate the quality improvement in the reengineered software. Agile Scrum methodology has been used to perform software reengineering. Design Metrics are measured using the Chidamber and Kemerer Java metric (CKJM) version-9.0 tool. For reengineering implementation, Net Beans 7.3 has been used.

Software defect prediction using hybrid model (CBIL) of convolutional neural network (CNN) and bidirectional long short-term memory (Bi-LSTM).

In recent years, the software industry has invested substantial effort to improve software quality in organizations. Applying proactive software defect prediction will help developers and white box testers to find the defects earlier, and this will reduce the time and effort. Traditional software defect prediction models concentrate on traditional features of source code including code complexity, lines of code, etc. However, these features fail to extract the semantics of source code. In this research, we propose a hybrid model that is called CBIL. CBIL can predict the defective areas of source code. It extracts Syntax Tree (AST) tokens as vectors from source code. Mapping and word embedding turn integer vectors into dense vectors. Then, Convolutional Neural Network (CNN) extracts the semantics of AST tokens. After that, Bidirectional Long Short-Term Memory (Bi-LSTM) keeps key features and ignores other features in order to enhance the accuracy of software defect prediction. The proposed model CBIL is evaluated on a sample of seven open-source Java projects of the PROMISE dataset. CBIL is evaluated by applying the following evaluation metrics: F-measure and area under the curve (AUC). The results display that CBIL model improves the average of F-measure by 25% compared to CNN, as CNN accomplishes the top performance among the selected baseline models. In average of AUC, CBIL model improves AUC by 18% compared to Recurrent Neural Network (RNN), as RNN accomplishes the top performance among the selected baseline models used in the experiments.

AREHS: effects of changing boundary conditions on the development of hydrogeological systems: numerical long-term modelling considering thermal–hydraulic–mechanical(–chemical) coupled effects

Abstract. Within the framework of the “Gesetz zur Suche und Auswahl eines Standortes für ein Endlager für hochradioaktive Abfälle” (Repository Site Selection Act – StandAG), the geoscientific and planning requirements and criteria for the site selection for a repository for high-active nuclear waste are specified. This includes, among others, the modelling of hydrogeological scenarios such as how future cold and warm periods and associated glaciation events can change the (petro-)physical properties specified in the StandAG as well as the natural hydrogeological properties of the overall system through, for example, reactivation of faults or changes in hydraulic gradients and consequently flow directions. The main objective of the AREHS (Effects of Changing Boundary Conditions on the Development of Hydrogeological Systems) project, funded by BASE (Federal Office for the Safety of Nuclear Waste Management; FKZ 4719F10402), is to model the effects of changing external boundary conditions on the hydrogeologically relevant parameters and effects (e.g. hydraulic permeability, porosity, migration pathways, fluid availability, hydraulic gradients) of a generic geological repository in Germany in all three potential host rocks (clay, salt and crystalline rocks) and its surrounding hydrogeological setting (Table 1). Special attention is paid to the cyclic mechanical loading and unloading due to glaciation events and the resulting stress changes (M), as well as induced temperature effects (T) due to permafrost and warm periods. As such processes can cause changes in the coupled far-field regime with groundwater flow and groundwater supply (H), as well as fluid transport due to thermal (T) and chemical (C) gradients, and reactivate faults/fractures (M) and thus create new/additional pathways, they are particularly relevant to the integrity of a repository over a period of 1 million years and must be properly captured with coupled THM(C) modelling. Before a model is set up for the different host rocks, a detailed assessment of relevant processes has been conducted based on NEA-2019 FEP catalogue (NEA, 2019) for high-level waste repositories. The modelling is performed using generic 3D models of typical host rock formations satisfying the StandAG criteria. Although the models for salt and clay rock have been adapted from generic models from recent research projects, for crystalline rock a new generic model had to be developed (Fig. 1) considering discontinuities of different scales that have to be incorporated into the THM(C) models explicitly as DFN (Discrete Fracture Network) networks. This is done by coupling two numerical codes: DFN-lab and 3DEC. A central phase in the overall modelling process is the benchmarking of the models with data from existing models and with field-scale studies. This is done separately for all three host rocks. In addition to extending the modelling capacities for glaciation processes and verifying by corresponding benchmarking tests (analytical solutions and literature comparisons), automated workflows have been developed to generate OpenGeoSys models from GOCAD structure models. Script-based automated workflows improve software quality for site investigation, especially in a sense of modularization as well as reproducibility. The generic workflow concept is currently being tested for the literature-based benchmarks and will, therefore, support a persistent and sustainable benchmarking procedure in the future.