The review, led by Muhammad Sabo Yahaya of Universiti Teknologi PETRONAS in Malaysia and Federal Polytechnic Daura in Nigeria, together with colleagues from Malaysia and Nigeria, focuses on the One-Parameter-at-a-Time (OPAT) paradigm for Combinatorial Interaction Testing (CIT). The approach traces its origins to the In-Parameter-Order (IPO) algorithm introduced in 2002 and its generalized successor, IPOG, which extended the technique to arbitrary interaction strengths. Rather than generating complete test cases one at a time, OPAT builds a test suite incrementally by introducing one parameter per stage. Two complementary mechanisms drive this construction: horizontal growth, which extends existing test cases by assigning values to a newly introduced parameter in a way that maximizes coverage of previously unseen interactions, and vertical growth, which adds new test cases only when necessary to cover any interactions that horizontal expansion could not reach. This incremental structure allows OPAT to reuse existing configurations while maintaining strong scalability as systems grow more complex.

Despite the paradigm’s importance, no previous review had ever synthesized the OPAT literature in isolation. Prior surveys examined combinatorial testing from broader perspectives, treating metaheuristics as black-box optimizers or focusing narrowly on pairwise testing. The new study, published on 15 October 2026, addresses this gap through a systematic search of 1,300 publications across four major digital libraries, ultimately identifying 40 primary studies published between 2000 and 2026. The screening process was rigorous: two independent reviewers achieved a Cohen’s Kappa agreement of 0.83 during title and abstract screening and 0.89 during full-text eligibility assessment, with a third senior reviewer arbitrating any persistent disagreements. Quality assessment showed that 82.5 percent of the included studies scored at least 3.0 out of 4.0 on a four-criterion checklist evaluating algorithmic clarity, experimental rigor, quantitative reporting, and baseline comparison.

The review’s central contribution is a unified taxonomy that classifies OPAT research into five categories: deterministic refinements, scaling and distribution strategies, advanced feature-enhanced strategies, metaheuristic and hybrid strategies, and specialized OPAT adaptations. Deterministic refinements improve the original IPO and IPOG algorithms through better heuristics, dynamic programming, and structural modifications. IPOG-D, for instance, introduces a recursive doubling mechanism that dramatically improves scalability: in one reported experiment, it required only 3 percent of standard IPOG’s execution time for 5-way testing of 20 four-valued parameters, though it generated 51 percent more test cases. MIPOG applies enhanced greedy optimization during both growth phases, consistently producing smaller suites than IPOG, Jenny, and ITCH, particularly at interaction strengths of 4 or higher, but at increased computational cost. VIPO simplifies horizontal growth decisions to accelerate generation while maintaining competitive suite sizes across 11 benchmark configurations.

Scaling and distribution strategies address a different bottleneck: the memory and time constraints that emerge when combinatorial problems reach industrial scale. G_MIPOG partitions both memory and computation across a grid of computers, demonstrating logarithmic speedups as coverage strength increased in tests involving 6-way interactions of 7 to 10 five-valued parameters. MC-MIPOG exploits shared-memory multicore architectures, achieving near-linear speedup as parameter counts increased from 5 to 16 at interaction strength 4 on a 2.4 GHz Core 2 Quad processor. TS_OP distributes the workload using MapReduce and Tuple Space across a network of five workstations, significantly reducing per-machine memory utilization, though at the cost of non-deterministic outputs due to network overhead.

Feature-enhanced strategies tackle the practical realities that pure algorithms often ignore. Real systems impose constraints: certain parameter combinations are invalid, infeasible, or meaningless. The ACTS tool, developed by researchers at the National Institute of Standards and Technology, embeds IPOG variants within a comprehensive framework supporting constraint specification, mixed-strength testing, and multiple user interfaces, and has been adopted by over 1,200 organizations. IPOG-C minimizes redundant constraint checks by selectively evaluating only relevant constraints, while IPO-SAT transforms constraint handling into a satisfiability problem amenable to SAT solvers. Seeding mechanisms, implemented in strategies such as SCIPOG and SCIPOG-VS, allow domain knowledge to be injected directly into the generation process, ensuring that critical or high-risk configurations are always included in the final suite.

Metaheuristic and hybrid strategies represent the most recent evolutionary branch, embedding OPAT’s structured construction within stochastic optimization frameworks. The Harmony Search Algorithm dominates this category, appearing in 77.8 percent of the analyzed stochastic OPAT studies, including OPAT-HS, HCATS, OPATHS, PWiseHA, PHOSC, SCHOP, eIPOG, and eHS. The enhanced Harmony Search variant eHS reported a 90.91 percent success rate in reducing test suite sizes across 33 configurations compared to IPOG, but achieved zero percent success in execution time superiority, illustrating the inherent tension between search quality and computational overhead. GAMIPOG combines a genetic algorithm with deterministic OPAT components, achieving scalability up to interaction strength 15. The hybrid HOS strategy applies a genetic algorithm for horizontal growth and Simulated Annealing for vertical growth, achieving optimal sizes for 61 of 71 benchmark configurations.

Specialized adaptations extend OPAT beyond conventional parameter interaction problems. DEO applies the paradigm to sequence covering arrays for event-driven systems, where the order of events matters as much as their combination. PMC automates test data generation directly from source code for C and C++ unit testing. N-IPO leverages Fibonacci-based value selection to reduce suite sizes for large input domains, while ReqOrder and ParaOrder support input-output relations and variable interaction strengths. These adaptations demonstrate the framework’s flexibility but also its fragmentation: each targets a niche, and none has achieved the broad industrial penetration of tools like ACTS.

Perhaps the review’s most sobering finding concerns reproducibility. The authors demonstrate that direct cross-study benchmarking of execution times is mathematically invalid due to highly heterogeneous self-reported hardware environments and the closed-source nature of most academic tools. Numerical results from different studies cannot be combined into a universal performance ranking without controlling for differences in hardware, implementation environments, benchmark configurations, and parameter settings. The limited availability of executable implementations and source code constitutes what the authors describe as a substantive research gap, not merely a methodological limitation of their own review. Without accessible implementations, independent reproduction and controlled head-to-head evaluation remain impossible.

Looking forward, the review identifies several promising directions: unified optimization frameworks that simultaneously balance scalability, optimality, and feature integration; exploration of underutilized metaheuristics such as Particle Swarm Optimization, Tabu Search, and hyper-heuristics; intelligent and adaptive test generation leveraging historical testing data and fault patterns; deterministic parallel algorithms; and large-scale industrial validation on real-world systems rather than synthetic benchmarks. The authors argue that transitioning OPAT research into industrial-grade, open-source software engineering pipelines requires not only more effective optimization mechanisms but also standardized, transparent, and reproducible empirical evaluation practices. For a field that has quietly underpinned software quality assurance for over two decades, the message is clear: the algorithms have matured, but the science of measuring them has not kept pace.

Subject of Research: One-Parameter-at-a-Time strategies for combinatorial interaction testing in software test suite generation

Article Title: Constructing t-way test suites: a systematic survey and qualitative synthesis of the One-Parameter-at-a-Time approach

Article References: Yahaya, M. S., Hashim, A. S., Mamman, H., Abdullahi, S., Umer, U., Adamu Aliyu, D., & Godowoli, I. M. (2026). Constructing t-way test suites: a systematic survey and qualitative synthesis of the One-Parameter-at-a-Time approach. Frontiers in Computer Science, 8, Article 1946723. https://doi.org/10.3389/fcomp.2026.1946723

Image Credits: AI Generated

DOI: 10.3389/fcomp.2026.1946723

Keywords: combinatorial interaction testing, One-Parameter-at-a-Time, software testing, t-way test suite generation, IPOG algorithm, metaheuristic optimization, Harmony Search Algorithm, constraint handling, systematic literature review, reproducibility, parallel computing, software quality assurance

Assistant Professor Nasir Eisty, a research software engineering and quality assurance expert at the University of Tennessee, Knoxville, has received a $430,000 grant to lead this project. Eisty serves in the Min H. Kao Department of Electrical Engineering and Computer Science, where he specializes in the intersection of software engineering and scientific computing. His work focuses on the practical application of AI agents in the creation and verification of research software, a field that is evolving rapidly as autonomous systems become more capable of interacting with external tools and executing complex tasks.

The core of the problem lies in the nature of agentic AI systems, which can autonomously interact with external tools to achieve programmed goals. In the context of scientific research, these systems are increasingly used to generate code from scratch, execute tests, and validate outputs. However, Eisty points out a significant risk: an AI can generate a test that appears sophisticated, runs successfully, and passes, yet it may be testing the wrong scientific assumption. This discrepancy is particularly dangerous because different scientific domains, such as climate modeling and biological simulation, have distinct definitions of correctness and underlying theoretical constraints.

Traditionally, research software engineers (RSEs) verified simulations by manually identifying important scenarios, encoding them as tests, and evaluating whether the results matched known outcomes. This process was time-consuming and required deep expertise in both the specific scientific domain and software engineering. With the advent of generative AI, scientists can now ask AI systems to analyze scenarios and generate tests, or even have agentic AIs run and modify tests based on results. This capability is valuable for researchers who are domain experts first and software developers second, as it makes good software engineering practices accessible to teams without dedicated engineering resources.

Despite these advantages, the convenience of AI-generated tests comes with a cost. AI systems may fail to capture important edge cases or domain-specific theoretical constraints, leading to incorrect assumptions and irreproducible results. If the scientific assumptions underlying a simulation are not properly accounted for, the credibility of the entire research output is compromised. Eisty’s Software Analytics and Intelligence Lab (SAIL) is investigating how to leverage AI in the scientific software pipeline while maintaining reproducibility, correctness, and long-term utility. The goal is to determine where AI is useful, where it is unreliable, and how humans can remain appropriately involved in the validation process.

The project will involve a detailed study of current RSEs and scientists to understand how they are using generative agentic AIs to design and test their software. The team will then deliberately introduce multiple types of defects into existing research software to evaluate how well AI-generated tests detect these injected issues. By working with domain scientists, the researchers will assess whether the tests reflect the scientific assumptions and questions underlying the software. This approach allows for a controlled environment in which the reliability of AI-generated tests can be measured against known ground truths.

One of the most challenging aspects of this research is defining what it means for an AI-generated test to be scientifically correct. To address this, Eisty and his team plan to study 30 to 40 research software projects across at least five scientific domains, including computational biology, astronomy, climate modeling, machine learning, and computational social science. This diverse set of projects will provide a broad basis for understanding how AI performance varies across different scientific contexts. The findings will help identify patterns in AI reliability and highlight areas where human oversight is most critical.

Upon completion of the experiments, the team will create a curated benchmark suite, open-source tools, and guidelines for responsible AI-assisted software testing. These resources will include a tool to help researchers provide AIs with appropriate scientific context during prompting and a test-development framework that records important information about the AI model and other factors involved in creating each test. The framework will be model-agnostic, allowing RSEs to continue creating reliable and reproducible research software as new AI systems emerge. This ensures that the solutions developed are not tied to a specific technology but are adaptable to future advancements.

The project also includes support for two PhD students who will work with Eisty throughout the research process. This aspect of the grant is crucial for training the next generation of researchers who can help shape the responsible use of AI in scientific software development. Eisty expressed gratitude to the Sloan Foundation for supporting this work, noting that AI is changing software engineering very quickly. The project provides an opportunity not only to study this transformation but also to equip researchers with the skills needed to navigate it responsibly.

Ultimately, this initiative is about finding the right balance between leveraging AI’s ability to accelerate software development and preserving the human judgment, transparency, and rigorous validation that science requires. As AI continues to play a larger role in scientific discovery, ensuring the integrity of the tools used to generate and verify results will be essential. By developing robust frameworks and guidelines, Eisty and his team aim to future-proof research software, ensuring that it remains a reliable foundation for scientific progress in an era of rapid technological change.

Subject of Research: Validation of AI-generated research software for scientific reproducibility

Article Title: With Sloan Foundation Award, Eisty future-proofs research software

Article References: With Sloan Foundation Award, Eisty future-proofs research software. (n.d.). Original publication

Image Credits: AI Generated

DOI: Not provided

Keywords: Artificial Intelligence, Research Software Engineering, Scientific Reproducibility, Alfred P. Sloan Foundation, University of Tennessee, Quality Assurance, Agentic AI, Computational Science, Software Testing, Data Integrity, Sloan, Foundation

The core idea behind software fault prediction is deceptively simple. Instead of waiting for testers to stumble upon defects, machine learning models analyze historical development data and code metrics to flag components that exhibit the statistical fingerprints of fault-prone code. This allows teams to concentrate their testing resources where they matter most, improving reliability while cutting maintenance costs. Yet the field has long been hampered by stubborn obstacles: noisy and inconsistent data, severe class imbalance in which defective modules are vastly outnumbered by clean ones, and models that perform well on one project but collapse when applied to another. The Hyderabad team designed their framework specifically to attack each of these weaknesses in sequence.

The first stage of the pipeline tackles data quality. Raw defect datasets, often assembled from code repositories and issue trackers, are riddled with noise, missing values, and inconsistent scales. The researchers apply a preprocessing method they call fuzzy consensus cubature information filtering, or FCCIF. By combining fuzzy logic, which tolerates uncertainty and imprecision, with cubature information filtering, a mathematical technique for estimating hidden states from noisy observations, FCCIF cleans the data, removes outliers, and normalizes the feature values. The fuzzy consensus element allows the filter to reconcile conflicting information across multiple estimates, producing a stable, denoised input representation that downstream components can trust.

Once the data is clean, the next challenge is deciding which of the many available code metrics actually carry predictive signal. Datasets such as the JM1 software defect prediction dataset used in this study contain dozens of static measures, including lines of code, cyclomatic complexity, Halstead metrics, and operator counts. Feeding all of them into a model invites overfitting and slows training. The team turns to a bio-inspired solution: the superb fairy-wren optimization algorithm, or SFOA, a metaheuristic introduced in 2025 that mimics the behavioral strategies of the Australian songbird to search high-dimensional feature spaces. SFOA iteratively evaluates candidate feature subsets, discarding redundant or irrelevant attributes and retaining only those features that most strongly discriminate between defective and non-defective modules.

With a refined feature set in hand, the heart of the system takes over: a spatio-temporal attention-based hidden physics-informed neural network, abbreviated STAHPINN. This architecture, adapted from a model originally developed for predicting the remaining useful life of engineering systems, is unusual in the software quality domain. Physics-informed neural networks embed known governing relationships directly into their loss functions, constraining predictions to remain consistent with underlying structure rather than merely fitting patterns in the training data. The spatio-temporal attention mechanism allows the network to weigh both the relationships among code features, the spatial dimension, and the temporal evolution of the development process, capturing how a module’s defect risk changes over time as it is modified and re-tested.

STAHPINN performs the final classification, labeling each software module as either defect-prone or non-defective. But even the most sophisticated network depends on well-tuned weight parameters, and the researchers delegate that task to another nature-inspired optimizer: the enzyme action optimizer, or EAO. This 2025 algorithm models the catalytic behavior of enzymes, in which substrates are bound, transformed, and released with remarkable efficiency, to explore the parameter space of the neural network. By optimizing the network’s weights with EAO, the team aims to escape the local minima that plague conventional gradient-based training and to accelerate convergence at the same time.

The reported results are striking. Benchmarked against established baselines including conventional artificial neural networks, YOLOv5, and generic deep learning approaches, the proposed pipeline achieved 99.3 percent accuracy, alongside improvements in precision, recall, F1-score, and the Matthews correlation coefficient, a metric that is particularly informative on imbalanced datasets because it accounts for all four categories of the confusion matrix. The mean absolute error of 0.002 percent and a computational time of 0.8 seconds suggest that the method is not only accurate but fast enough for practical integration into continuous integration and continuous deployment pipelines, where predictions must keep pace with rapid code changes.

The implications extend well beyond the laboratory. Modern software systems, from microservice architectures to automotive control software, are updated continuously, and the cost of a defect discovered in production can be orders of magnitude higher than one caught during development. A prediction engine that flags fault-prone modules in under a second could, in principle, be wired directly into code review workflows, alerting engineers to apply extra scrutiny before risky changes are merged. Prior work in the literature, including transformer-based fault localization for microservices and optimization-driven feature selection methods such as bat and flower pollination algorithms, has moved in this direction, but the combination of physics-informed modeling with attention mechanisms and bio-inspired optimization represents a notably comprehensive approach.

Independent scrutiny will be essential before such claims translate into industry practice. The study reports that no new datasets were generated or analyzed during the research, relying instead on established public benchmarks, and the reported figures await replication by other groups on different projects and languages. Class imbalance, the perennial Achilles heel of defect prediction, remains a domain where headline accuracy figures can be misleading if the majority class dominates; the strong Matthews correlation coefficient reported here is therefore an encouraging sign, but practitioners will want per-project breakdowns and cross-project validation. The authors also note that the work received no specific external funding and that all contributors participated equally.

Nevertheless, the study offers a glimpse of where software engineering is heading: away from reactive debugging and toward predictive quality control that treats code like a physical system governed by learnable laws. If physics-informed networks and metaheuristic optimizers can reliably anticipate where software will break, the economics of software maintenance, estimated to consume a large share of total lifecycle costs, could shift dramatically. For now, the Hyderabad team’s 99.3 percent result stands as a provocative data point in a rapidly evolving race to make software that predicts its own failures, and the wider research community will be watching closely to see whether these numbers hold up in the messy reality of production codebases.

Subject of Research: Automated software fault prediction and predictive quality control using deep learning

Article Title: Automated fault detection and predictive quality control in software system using advanced deep learning techniques

Article References: Saheb, S. K., Sreenivasarao, D., Bhukya, S., & Kolagani, R. (2026). Automated fault detection and predictive quality control in software system using advanced deep learning techniques. Knowledge and Information Systems, 68(1), Article 269. https://doi.org/10.1007/s10115-026-02857-4

Image Credits: AI Generated

DOI: 10.1007/s10115-026-02857-4

Keywords: software fault prediction, deep learning, physics-informed neural networks, feature selection, metaheuristic optimization, predictive quality control, software engineering, machine learning, class imbalance, defect analytics, neural network optimization, software testing

Binary protocols, which encode data directly as compact byte sequences rather than human-readable text, form the backbone of much of the modern digital world. They underpin network devices, industrial control systems, and Internet of Things applications, where efficiency and low overhead are paramount. But their very compactness creates a security blind spot. Unlike text protocols, binary formats lack delimiters, tags, and other redundant markers that make field boundaries obvious. When implementations of these protocols mishandle malformed messages, the consequences can be severe. The researchers point to the infamous EternalBlue vulnerability in the SMB protocol, which arose from improper parsing of binary messages and enabled buffer overflow and remote code execution with global impact, as a stark reminder of what is at stake.

Mutation-based greybox fuzzing has become one of the most widely used techniques for discovering such flaws. Greybox fuzzers occupy a middle ground between blackbox and whitebox approaches: they do not require complete knowledge of a program’s internals, but they do use lightweight runtime feedback, such as coverage information gathered through instrumentation, to guide how inputs are mutated. Tools like AFL, AFL++, and MOPT generate malformed test cases by applying mutation operators such as bit flips and byte substitutions to well-formed seed messages, then monitor the target program for crashes, hangs, and other abnormal behavior. The approach has uncovered countless vulnerabilities, yet the authors argue that existing fuzzers stumble when confronted with structured binary messages.

The team identifies three core challenges. First, protocol parsing is difficult because binary protocols represent data as bit streams with unclear field boundaries and implicit semantics, making it laborious to determine which positions in a message can safely be mutated. Second, evaluating the mutation value of different fields is hard because the effect of changing a field depends on runtime behavior, field dependencies, and the target program’s responses, none of which can be reliably determined statically. Third, and perhaps most damaging, existing fuzzers schedule mutation operators blindly. A bit flip applied to a function code field may drive a program into entirely new logical states, while the same operation on a data field merely alters content. Worse, mutating a length field without adjusting the corresponding payload breaks the message structure, causing the test case to be discarded before it ever reaches deep parsing logic.

MPAuzz tackles these problems in two stages. The first is a feedback-based mutation position exploration module that partitions protocol messages at bit-level granularity rather than the coarser byte level used by most prior tools. This fine granularity matters: in an MQTT message, for example, the high four bits of the header flags field determine the message type while the low four bits serve as flags, a distinction that byte-level analysis cannot capture. The module flips one bit at a time, sends the mutated message to the target, and classifies the result. Normal responses mark a bit as mutable; format anomalies detected with protocol parsing tools such as Tshark mark it as restricted; and mutations of essential control fields such as protocol names and function codes mark regions as immutable. Adjacent bits with similar properties are then merged into continuous regions, giving the fuzzer a map of where mutation is safe, where it must respect constraints, and where it is forbidden.

The second stage is where the ocean comes in. MPAuzz formulates mutation operator scheduling as a multidimensional optimization problem in which each dimension corresponds to the operator choice for one mutation region, and it solves this problem using the Marine Predators Algorithm, a metaheuristic inspired by how marine predators forage. The historically best operator combination plays the role of the predator, while candidate combinations act as prey. The algorithm dynamically switches between Lévy flights, long-distance jumps that enable broad exploration, and Brownian motion, small-step searches that enable fine-grained exploitation. The researchers deliberately chose MPA over alternatives such as multi-armed bandit strategies and particle swarm optimization because mutating one region of a binary message often depends on other regions; treating each region as an independent arm can produce structurally invalid test cases, while PSO’s velocity-based updates risk premature convergence when early coverage gains come from only a few regions.

The scheduling unfolds across three adaptive stages that mirror the fuzzing lifecycle. In the early, high-speed exploration stage, Lévy-distributed random vectors drive wide-ranging tests of operator combinations to avoid premature convergence. In the middle, balanced coordination stage, the population splits: half fine-tunes the elite combination using Brownian perturbations governed by a quadratically decreasing convergence factor, while the bottom-performing half continues exploring with Lévy motion. In the final, low-speed exploitation stage, an enhanced social learning term pulls candidate combinations toward the best-known strategy, changing only one or a few region assignments at a time. Crucially, a candidate combination is retained only if it satisfies region-specific constraints and improves coverage feedback. The framework also includes a repairing step for restricted regions: when a mutable payload region changes size, the associated length field is recalculated automatically, with nested dependencies repaired from the innermost region outward.

To validate the design, the team evaluated MPAuzz on four widely used binary protocol implementations covering MQTT, DTLS, DNS, and CoAP, comparing it against AFLNet and StateAFL, two of the most prominent greybox protocol fuzzers. Each fuzzer ran continuously for 24 hours per target, with each experiment repeated ten times to account for the inherent randomness of fuzzing. The results were decisive. MPAuzz’s valid-test-case ratio exceeded 97 percent on every target, compared with 83.1 percent for a multi-armed bandit variant and 79.5 percent for a PSO variant of the same tool. It reached comparable coverage 3.47 times faster than AFLNet and 2.22 times faster than StateAFL on average, with Vargha-Delaney effect sizes mostly at or above 0.85, indicating a consistent statistical advantage.

The vulnerability discovery results were equally compelling. Instrumenting targets with AddressSanitizer to capture memory-related faults, the researchers found that MPAuzz produced more crashes than both baselines on all four targets. On the Mosquitto MQTT broker, MPAuzz triggered an average of 87.8 crashes per run, compared with 3.9 for AFLNet and 43.2 for StateAFL, and exposed its first crash just 32 minutes into testing, whereas AFLNet failed to crash the target within the allotted time at all. On Tinydtls, MPAuzz found its first crash in 15 seconds. Analysis of the proof-of-concept inputs showed that the anomalies detected in Mosquitto and Libcoap correspond to real, documented vulnerabilities: the medium-severity CVE-2021-28166, a null pointer dereference triggered when an authenticated client sends a mutated SUBSCRIBE message before the server issues a PUBLISH message, and the high-severity CVE-2024-46304. These findings demonstrate that the fuzzer can surface genuine security flaws arising from abnormal protocol-state sequences, not merely superficial parsing errors.

The authors are candid about limitations. MPAuzz currently leans on external parsers such as Tshark and Scapy for protocol-format feedback, so for proprietary or undocumented protocols the precision of restricted and immutable region identification may degrade, though the fuzzer can still operate using runtime responses and coverage feedback alone. The automatic repair mechanism primarily supports length-related constraints; checksums, authentication fields, and state-dependent constraints require protocol-specific rules. The evaluation, while rigorous, covers four protocol implementations, and the team notes that additional targets and longer experiments would strengthen the evidence. Still, the work makes a persuasive case that combining protocol-aware region classification with staged, nature-inspired operator scheduling is a practical path forward for binary-protocol fuzzing, and the researchers plan to reduce reliance on external parsers and extend support for proprietary protocols with complex field dependencies in future work.

Subject of Research: A nature-inspired greybox fuzzing framework for discovering vulnerabilities in binary network protocol implementations

Article Title: Binary protocol greybox fuzzing driven by marine predators algorithm

Article References: Jiang, C., Hong, Z., Zhang, G., Li, Y., & Gu, J. (2026). Binary protocol greybox fuzzing driven by marine predators algorithm. Cybersecurity, 9(1), Article 214. https://doi.org/10.1186/s42400-026-00646-8

Image Credits: AI Generated

DOI: 10.1186/s42400-026-00646-8

Keywords: binary protocols, greybox fuzzing, Marine Predators Algorithm, vulnerability discovery, mutation scheduling, network security, MQTT, DTLS, DNS, CoAP, software testing, cybersecurity