Partition Testing

Definition

Partition Testing is a functional software testing technique founded on the idea that the input domain of a system under test (SUT) can be divided into sub-domains, with the assumption that inputs belonging to the same sub-domain trigger similar behavior, and that it is therefore sufficient to select one (or a small number of) input(s) from each sub-domain to exercise the SUT's behavior systematically [arXiv:2601.12559v1].

Theoretical Foundations

The foundations of partition testing were laid in the early program-testing theory literature:

• Weyuker & Ostrand (1980) — "Theories of Program Testing and the Application of Revealing Subdomains" (IEEE TSE, vol. 6, no. 3, May 1980). This paper introduced the concept of revealing subdomains, which underpins formal analyses of when and why partition-based selection can be expected to detect faults. [chunk: f6a19b46-f399-4509-b8e4-761ab01cb292]
• Weyuker & Jeng (1991) — "Analyzing Partition Testing Strategies" (IEEE TSE, vol. 17, no. 7, July 1991). This work further analyzes strategies for partition testing and is cited by current research that uses partition testing for processor verification [chunk: f6a19b46-f399-4509-b8e4-761ab01cb292].

Category-Partition Testing

Category-Partition is a specific functional testing technique that operationalizes partition testing by proceeding through several steps [arXiv:2601.12559v1]:

1. Identification of parameters and environment variables that characterize the input space.
2. Identification of categories (partitions) for each parameter.
3. Specification of choices within each category, possibly constrained by predicates.
4. Construction of test frames — combinations of choices across categories.
5. Selection of concrete input values for each frame, producing executable test cases.

A contemporary effort (2026) automates as many of these steps as possible with graphical tool support, allowing the user to specify parameters and environment variables, define categories and choices with type-specific operations (Boolean, Integer, Real, String), and apply alternative selection criteria to combine choices into frames. Nine illustrative case studies are used to demonstrate the tool [arXiv:2601.12559v1].

Application Domains

Library API Testing with LLMs (LISP)

A 2024 paper, "LLM Based Input Space Partitioning Testing for Library APIs" (LISP) [arXiv:2501.05456v1], applies partition testing to library APIs whose parameter spaces involve complex object types. Existing search-based approaches generate many invalid inputs due to limited knowledge of relations between object states and program branches, while symbolic-execution approaches scale poorly. LISP addresses this by:

• Providing the signature and code of the API under test to an LLM.
• Asking the LLM to produce a textual description of each partition of the input space.
• Sampling inputs from each described partition to systematically explore program behavior.

Evaluation on 2,205 library API methods from 10 popular open-source Java libraries (e.g., apache/commons-lang with ~2.6k GitHub stars, guava with ~48.8k GitHub stars) showed that LISP achieves on average 67.82% branch coverage, 1.21× the coverage of EvoSuite, triggered 404 exceptions/errors, and discovered 13 previously unknown vulnerabilities that were assigned CVE IDs [arXiv:2501.05456v1].

Hardware / Processor Verification

Partition testing strategies have been applied to processor implementation verification. A methodology paper (Springer, "A methodology for processor implementation verification") cites Weyuker & Jeng's 1991 analysis of partition testing strategies when discussing how to select revealing inputs from partitioned domains for hardware validation [chunk: f6a19b46-f399-4509-b8e4-761ab01cb292]. Related hardware-verification techniques referenced in that line of work include symbolic instruction graphs (Chandra et al., ICCD 1994), constraint-satisfaction-based test generation (Lewin et al., 1995; Chandra & Iyengar, ICCD-92), coverage-driven bug classification (Abarbanel et al., DAC 1996), and architecture validation (Ho et al., ISCA 1995) [chunk: f6a19b46-f399-4509-b8e4-761ab01cb292].

Key Properties

• Sub-domain uniformity assumption: Inputs in the same partition are assumed to trigger similar behavior, so a small representative sample suffices.
• Revealing-subdomain theory: Provides formal conditions under which partition selection is guaranteed to detect faults (Weyuker & Ostrand, 1980).
• Automation potential: Modern tools (GUI-based for Category-Partition, LLM-based for APIs) can automate category/choice identification, test-frame construction, and input-value selection [arXiv:2601.12559v1; arXiv:2501.05456v1].

See Also

• Analyzing Partition Testing Strategies — Weyuker & Jeng, IEEE TSE 1991, formal analysis of partition testing strategies.
• Category-Partition Testing — operationalization of partition testing with parameters, categories, choices, and frames.
• LISP — LLM-based input space partitioning testing for library APIs.

References

1. E. J. Weyuker, B. Jeng, "Analyzing Partition Testing Strategies", IEEE TSE, vol. 17, no. 7, July 1991. [chunk: f6a19b46-f399-4509-b8e4-761ab01cb292]
2. E. J. Weyuker, T. J. Ostrand, "Theories of Program Testing and the Application of Revealing Subdomains", IEEE TSE, vol. 6, no. 3, May 1980. [chunk: f6a19b46-f399-4509-b8e4-761ab01cb292]
3. "LLM Based Input Space Partitioning Testing for Library APIs", arXiv:2501.05456v1, 2024. [https://arxiv.org/abs/2501.05456v1]
4. "Automated Tool Support for Category-Partition Testing: Design Decisions, UI and Examples of Use", arXiv:2601.12559v1, 2026. [https://arxiv.org/abs/2601.12559v1]
5. "A methodology for processor implementation verification", Springer Nature Link. [chunk: f6a19b46-f399-4509-b8e4-761ab01cb292; https://link.springer.com/chapter/10.1007/bfb0031804]