compatibility testing

This work addresses the lack of type-theoretic support for under-approximation reasoning in functional program verification. Methodologically, it pioneers the integration of incorrectness logic with refinement types and coverage types, yielding an extended instantiation type system that supports *necessity-guaranteeing* under-approximation reasoning. By encoding incorrectness assertions directly into the type system, the approach enables provable characterization of erroneous program behaviors and synergizes with property-based testing frameworks to jointly verify both the safety and completeness of test generators. The contributions are threefold: (1) it establishes the first formal theoretical bridge between incorrectness logic and typed systems; (2) it enhances the completeness and verifiability of test generation and static analysis for functional programs; and (3) it provides a novel, constructively definable foundation for under-approximation reasoning in program verification tools.

This paper addresses the compositional verification challenge in model-driven testing: whether component-level testing guarantees system-level correctness. We propose a novel paradigm grounded in mutual acceptance and environment consistency. First, we formally define environment consistency and apply it to black-box compositional testing. Second, we design the first decidable mutual acceptance verification algorithm, accompanied by a sound and complete testing procedure. Third, we establish a model-driven theoretical framework that enables rigorous derivation of system-wide correctness from component-level test outcomes. Our approach preserves testing completeness while substantially reducing the complexity of verifying large-scale systems. By bridging formal semantics with practical testability, it provides a feasible, verifiable pathway for high-assurance system validation. (124 words)

This work proposes a novel paradigm that bridges the long-standing divide between testing and formal verification in traditional software validation, enabling them to synergistically enhance both efficiency and quality. Grounded in Design by Contract, the approach leverages the counterexample generation capability of SMT solvers to transform formal verification tools into an integrated engine for automated testing and repair. Within a unified framework, the method simultaneously achieves three key objectives: automatic generation of test cases for faulty programs, construction of regression test suites with full coverage for correct programs, and correctness-guaranteed program repair. This represents the first integration of verification, testing, and repair into a single cohesive methodology.

This work addresses the challenge of applying equivalence class partitioning—a testing requirement under ISO 26262—to legacy embedded firmware in the absence of complete specification documents. The authors propose a binary-level method that automatically infers output-oriented equivalence classes by reconstructing control flow and performing guided symbolic execution to analyze function behavior. Execution paths are clustered based on observable outputs, such as return values and output parameters, and the resulting equivalence classes are represented in a human-readable form to support test design. To the best of the authors’ knowledge, this is the first approach capable of inferring equivalence classes directly from binaries without source code or documentation for safety-critical embedded software. Industrial case studies demonstrate that the inferred classes align closely with expert expectations and offer both high readability and practical utility, effectively aiding functional comprehension and compliance testing of legacy firmware.

Verifying coverage completeness of input generators in property-based testing remains challenging. Method: This paper proposes a static verification approach based on a “must-style” refinement type system, reformulating conventional “may-produce” type semantics into “must-produce” semantics. It formally defines full coverage for higher-order functions and inductive data types, enabling fully automated verification of generator completeness. Contribution/Results: To our knowledge, this is the first refinement type system provably guaranteeing generation of all inputs satisfying both type and constraint specifications. Experimental evaluation demonstrates substantial improvements in detecting coverage gaps across diverse complex generators, while significantly reducing manual verification effort.

This study addresses the imbalance in the test pyramid—characterized by an overreliance on coarse-grained integration and system tests, which leads to difficulties in fault localization and slow execution—by proposing, for the first time, a method to automatically generate unit tests from existing integration tests. The approach combines static and dynamic analysis to automatically isolate component dependencies and enhance coverage at the unit level. Implemented as a Node.js tool and evaluated on twelve open-source JavaScript projects, the technique produces high-quality unit tests that significantly improve test suite structure, thereby increasing both testing efficiency and maintainability.

Existing property-based testing frameworks, such as Hedgehog, lack compositional semantics, making it difficult to formally verify the correctness of generator optimizations. This work develops a formal semantic model for such frameworks, revealing that their distributional semantics are inherently non-compositional. To address this, we propose Hedgehog→, a restricted variant based on arrow calculus, which trades modest expressiveness for compositional distributional semantics. This design enables, for the first time in property-based testing, compositional formal proofs of generator equivalence. We implement a Haskell prototype of Hedgehog→ and demonstrate that it retains sufficient expressiveness to encode practical test generators while providing a rigorous, compositional foundation for reasoning about generator optimizations.

This study addresses the challenges of high cost, error-proneness, and defect propagation in cross-repository code and test reuse during software refactoring. Through action research, the authors conduct bidirectional empirical analyses on real-world cases such as Soot/SootUp and FindBugs/SpotBugs, identifying for the first time the bidirectional reuse requirements and semantic reuse patterns inherent in refactoring scenarios. They propose a semantic alignment–based code mapping approach coupled with a hierarchical, extensible clone detection mechanism. Experimental results demonstrate that their method reduces irrelevant clones by 33%–99% on average and achieves a benchmark precision of 86%. The practical impact is further evidenced by five reported issues and ten pull requests submitted to open-source communities, eight of which have already been merged, confirming the approach’s effectiveness and applicability.

This study addresses the long-standing lack of effective evaluation of sustainability in scientific open-source software. It proposes a data-driven approach to systematically uncover, for the first time, the relationships among code quality, test coverage, and software sustainability. By analyzing code structure, measuring test coverage, and modeling code–test correlations, the authors classify and compare projects within the CASS software portfolio. The findings reveal that sustainable projects consistently exhibit higher and more stable test coverage, along with clearer mappings between code and tests. In contrast, scientific software as a whole demonstrates generally low test coverage, and high code complexity coupled with strong coupling significantly impairs its testability.