GRAphRef: Unified Graph-Based Test Generation

• GRAphRef is a graph-based framework that unifies input conversion, mutation, and repair for generating valid test inputs from complex structured data.
• It represents structured inputs as attributed graphs and applies neighbor-similarity-guided mutations to maintain local semantic and structural integrity.
• The framework’s constraint-refinement phase efficiently repairs mutated inputs, yielding high structural validity and semantic consistency in real-world evaluations.

Searching arXiv for the specified paper and closely related items to ground the article. GRAphRef is a graph-based test input generation framework for highly structured inputs that unifies input conversion, mutation, and repair within a single representation. It maps structured inputs such as 3D triangle meshes, point clouds, and grid-based images to labeled, attributed graphs; applies neighbor-similarity-guided mutations; and then uses a constraint-refinement phase to repair invalid outputs. The framework is positioned against handcrafted fuzzing tools and input generators that are specific to particular input types and often generate invalid inputs that are subsequently discarded, and it is evaluated on eight real-world mesh-processing AI systems using structural validity, semantic preservation, and performance overhead as principal criteria (Yang et al., 28 Jul 2025).

1. Problem setting and scope

GRAphRef is motivated by the observation that modern AI applications increasingly process highly structured data, such as 3D meshes and point clouds, where test input generation must preserve both structural and semantic validity. Existing fuzzing tools and input generators are described as typically handcrafted for specific input types and as often generating invalid inputs that are subsequently discarded, leading to inefficiency and poor generalizability. Within this setting, GRAphRef investigates whether test inputs for structured domains can be unified through a graph-based representation, enabling general, reusable mutation strategies while enforcing structural constraints (Yang et al., 28 Jul 2025).

The framework is formulated as a generalized pipeline with three stages: converting an input into a rich, attribute-annotated graph, applying guided graph mutations that preserve local semantics, and automatically repairing any constraint violations introduced by mutation. This design makes the graph the common intermediate representation across heterogeneous structured inputs. A plausible implication is that the framework treats validity preservation not as a post hoc filter but as an explicit algorithmic component of test generation.

2. Graph representation and constraint model

GRAphRef represents a structured input as a labeled, attributed graph

$G = (V, E, A_V, A_E),$

where $V$ is the set of graph vertices corresponding to primitive elements of the input, $E \subseteq V \times V$ is the set of undirected edges capturing adjacency or connectivity, $A_V : V \to \mathbb{R}^d$ assigns each vertex a $d$-dimensional attribute vector, and $A_E : E \to \mathbb{R}$ assigns each edge a weight or label (Yang et al., 28 Jul 2025).

The representation is intentionally broad. For meshes, vertices may correspond to mesh vertices; for point clouds, to point samples; and for images, to pixels. Edge structure likewise varies by domain: mesh edges, nearest-neighbor links, or four-way pixel neighbors. Vertex attributes may include $(x,y,z)$ coordinates, normals, color values, or intensity, while edge attributes may encode Euclidean distance $\|A_V(u)-A_V(v)\|$, manifold flags, or semantic tags.

Domain-specific correctness is encoded as a finite constraint set

$C = \{C_1,\dots,C_m\},$

with each $C_k$ a predicate over graph structure or attributes. For manifoldness in a triangle mesh, the paper lists representative constraints:

• $V$0: $V$1 face $V$2, $V$3
• $V$4: $V$5 face $V$6, $V$7
• $V$8: $V$9 edge $E \subseteq V \times V$0, $E \subseteq V \times V$1
• $E \subseteq V \times V$2: $E \subseteq V \times V$3, $E \subseteq V \times V$4

These constraints can also be written in the DSL form exemplified by $C = \{C_1,\dots,C_m\},$3 This constraint layer makes structural validity explicit at the graph level rather than leaving it implicit in the original input format.

3. Guided mutation and constraint refinement

The mutation stage is neighbor-similarity-guided rather than purely random. GRAphRef defines a neighborhood-similarity measure

$E \subseteq V \times V$5

so that vertices with similar attributes receive higher similarity scores. The stated purpose is to bias mutations toward locally similar neighbors and thereby preserve semantic coherence (Yang et al., 28 Jul 2025).

Each mutation operator is a probabilistic transform $E \subseteq V \times V$6. The framework implements twenty operators in total, including vertex shift, edge flip, and face split. Two representative operators are specified in detail.

For vertex insertion on an edge, an edge $E \subseteq V \times V$7 is selected with probability proportional to $E \subseteq V \times V$8, and a new vertex $E \subseteq V \times V$9 is inserted with attribute

$A_V : V \to \mathbb{R}^d$0

where $A_V : V \to \mathbb{R}^d$1 and $A_V : V \to \mathbb{R}^d$2. The original edge is replaced by $A_V : V \to \mathbb{R}^d$3 and $A_V : V \to \mathbb{R}^d$4, and incident faces are updated accordingly.

For edge rewiring, a vertex $A_V : V \to \mathbb{R}^d$5 is chosen with probability proportional to $A_V : V \to \mathbb{R}^d$6, then $A_V : V \to \mathbb{R}^d$7 and $A_V : V \to \mathbb{R}^d$8 are chosen with probability proportional to $A_V : V \to \mathbb{R}^d$9. The edge $d$0 is removed and $d$1 is added. This operator preserves degree while exploring alternate connectivity.

After mutation, GRAphRef enters a constraint-refinement phase. Given a candidate graph $d$2, it checks each domain constraint and seeks repairs satisfying

$d$3

The framework does not invoke a heavyweight SMT solver. Instead, it uses a rule-based, targeted repair engine. Reported repair patterns include:

• Degenerate Face $d$4 $d$5 remove face or re-triangulate
• Duplicate Vertices $d$6 $d$7 merge $d$8
• Non-manifold Edge $d$9 split or duplicate vertices to restore 2-manifold property

Because these repair rules are local and target-specific, they restore validity in $A_E : E \to \mathbb{R}$0 time and are reported to dramatically reduce discards. This suggests that GRAphRef treats refinement operationally as localized repair under explicit constraints rather than as unconstrained random exploration.

4. Evaluation methodology and metrics

The evaluation compares GRAphRef with AFL, MeshAttack, Saffron, and two ablations, denoted no-neighbor and no-repair, across eight mesh-processing AI systems, including MeshCNN and HodgeNet. The experiments use ShapeNetCore mesh seeds and model outputs from those systems, with aggregated results reported over 1800 s fuzzing and 96 seeds per tool (Yang et al., 28 Jul 2025).

The paper defines several metrics. Structural validity is measured by the Validity Rate

$A_E : E \to \mathbb{R}$1

along with Connectivity (Conn), the average number of connected components per generated graph. Semantic preservation is measured by prediction consistency under a downstream model $A_E : E \to \mathbb{R}$2:

$A_E : E \to \mathbb{R}$3

An additional semantic measure is embedding drift,

$A_E : E \to \mathbb{R}$4

where $A_E : E \to \mathbb{R}$5 is a feature-extraction network.

Performance overhead is decomposed into graph conversion, mutation, and constraint refinement:

$A_E : E \to \mathbb{R}$6

For statistical analysis, the study applies two-sample $A_E : E \to \mathbb{R}$7-tests to compare mean VIRs, SPSs, and total times across tools, reporting $A_E : E \to \mathbb{R}$8-values and effect sizes (Cohen’s $A_E : E \to \mathbb{R}$9). The methodology therefore combines validity, task-level semantic consistency, and latency accounting in a single framework.

5. Empirical results and efficiency profile

The reported aggregated results show that GRAphRef attains the highest structural validity and semantic preservation among the compared tools (Yang et al., 28 Jul 2025).

Tool	Validity (VIR)	Sem. Pres. (SPS)
AFL	68.2% $(x,y,z)$0	62.5% $(x,y,z)$1
MeshAttack	73.8% $(x,y,z)$2	60.1% $(x,y,z)$3
Saffron	81.4% $(x,y,z)$4	64.3% $(x,y,z)$5
GraphNoNeighbor	89.0% $(x,y,z)$6	71.2% $(x,y,z)$7
GraphGen (no-refine)	90.6% $(x,y,z)$8	77.8% $(x,y,z)$9
GRAphRef (full)	93.5% $\|A_V(u)-A_V(v)\|$0	84.5% $\|A_V(u)-A_V(v)\|$1

Relative to AFL, the full system shows a $\|A_V(u)-A_V(v)\|$2 of $\|A_V(u)-A_V(v)\|$3 $\|A_V(u)-A_V(v)\|$4. Relative to the no-neighbor ablation, it shows a $\|A_V(u)-A_V(v)\|$5 of $\|A_V(u)-A_V(v)\|$6 $\|A_V(u)-A_V(v)\|$7. The summary statements in the paper emphasize three points: GRAphRef recovers 93.5% valid meshes versus 68.2% for AFL $\|A_V(u)-A_V(v)\|$8; full neighbor guidance plus repair yields 84.5% consistent predictions, a 12.7-point gain over the no-neighbor ablation; and the total generation overhead is 2.8 ms/input, approximately $\|A_V(u)-A_V(v)\|$9 slower than AFL, but still under 10 ms.

The latency breakdown attributes approximately 30% of total time to constraint refinement, approximately 25% to graph conversion, and approximately 45% to mutation. The paper further states that these overheads scale linearly in $C = \{C_1,\dots,C_m\},$0 and remain modest even on million-vertex meshes. A plausible implication is that the repair stage is not merely a correctness mechanism but a bounded-cost component compatible with high-throughput structured-input generation.

6. Relation to graph-refinement traditions

A separate line of graph-refinement research is exemplified by RHOG, a refinement-operator library for directed labeled graphs. In that setting, a directed labeled graph is written

$C = \{C_1,\dots,C_m\},$1

graph subsumption is defined through a label-respecting homomorphism, and refinement is studied through downward and upward refinement operators over the partial order $C = \{C_1,\dots,C_m\},$2. RHOG also provides refinement-based distance and similarity functions, including anti-unification-based similarity and properties-based similarity, together with algorithms for subsumption checking and minimal refinements (Ontañón, 2016).

This suggests a useful conceptual distinction. In GRAphRef, refinement is a constraint-repair mechanism applied after mutation to restore validity of generated structured inputs. In RHOG, refinement is a formal operator framework for traversing a subsumption lattice of directed labeled graphs. The two uses share the vocabulary of graph refinement, but they are directed toward different technical objectives: GRAphRef addresses test input generation under structural and semantic constraints, whereas RHOG formalizes graph subsumption, refinement, and graph similarity. A plausible implication is that the broader graph-refinement literature provides a theoretical backdrop for thinking about graph transformations, even when the operational role of refinement differs substantially across systems.