What Is the Classification Tree Method?

The Classification Tree Method (CTM) is a visual test design technique developed at the German software testing institute (DaimlerChrysler). It provides a structured way to decompose the input domain of a test object into a tree of classifications and classes, then generate test cases by selecting combinations from the tree.

Key Concepts

  • Test object: The root node — the system, function, or feature being tested
  • Classification: A test-relevant aspect or dimension (like a parameter category)
  • Class: A specific value or partition within a classification
  • Combination table: A matrix below the tree showing which classes combine into test cases

Classification Tree Structure

graph TD A[Test Object: Online Payment] --> B[Payment Method] A --> C[Amount] A --> D[Currency] B --> B1[Credit Card] B --> B2[PayPal] B --> B3[Bank Transfer] C --> C1["Small (<$50)"] C --> C2["Medium ($50-$500)"] C --> C3["Large (>$500)"] D --> D1[USD] D --> D2[EUR] D --> D3[GBP]

The tree decomposes “Online Payment” into three classifications (Payment Method, Amount, Currency), each with their own classes.

Building a Classification Tree: Step by Step

Step 1: Identify the test object and its test-relevant aspects.

Step 2: For each aspect, create a classification node.

Step 3: Under each classification, list the possible classes (values/partitions).

Step 4: Add refinements — classes can have sub-classifications if needed.

Step 5: Build the combination table to select test cases.

The Combination Table

Below the tree, create a table where:

  • Columns = test cases
  • Rows = classes (leaf nodes)
  • Marks (X or dot) show which class is selected for each test case
TC1TC2TC3TC4TC5
Credit CardXX
PayPalXX
Bank TransferX
SmallXX
MediumXX
LargeX
USDXX
EURXX
GBPX

Each test case picks exactly one class from each classification.

CTM vs. Equivalence Partitioning

CTM builds on EP but adds:

  • Visual structure — the tree makes the decomposition clear
  • Hierarchical refinement — classes can be further subdivided
  • Explicit combination selection — the table shows exactly which combinations you’re testing

When to Use CTM

  • Complex input domains with multiple related parameters
  • When you need a visual overview of the test space
  • When stakeholders need to review test coverage visually
  • As a complement to pairwise testing for selecting meaningful combinations

Advanced Classification Trees

Hierarchical Refinement

Classes can have sub-classifications, creating deeper trees:

graph TD A[User Registration] --> B[User Type] A --> C[Input Method] B --> B1[Individual] B --> B2[Business] B2 --> B2a[SMB] B2 --> B2b[Enterprise] C --> C1[Manual Form] C --> C2[Social Login] C2 --> C2a[Google] C2 --> C2b[GitHub]

This creates a richer decomposition where Business users are further classified into SMB and Enterprise, and Social Login into Google and GitHub.

Combining CTM with Pairwise

For large trees, exhaustive combination of all classes produces too many test cases. Apply pairwise selection to the combination table:

  1. Build the classification tree
  2. List all leaf-node classes as parameters
  3. Feed into PICT or generate pairwise combinations manually
  4. Fill the combination table with pairwise-selected test cases

This gives you the visual benefits of CTM with the efficiency of pairwise testing.

Tool Support: Classification Tree Editor (CTE)

CTE XL is a dedicated tool for creating classification trees:

  • Visual tree editor with drag-and-drop
  • Automatic combination generation (exhaustive, pairwise, etc.)
  • Export to test management tools
  • Available as free academic version
Test Object: Product Search

Classifications:
├── Search Query
│   ├── Single word
│   ├── Multiple words
│   ├── With special characters
│   └── Empty
├── Filters
│   ├── No filters
│   ├── Category filter
│   ├── Price range filter
│   └── Multiple filters
├── Sort Order
│   ├── Relevance
│   ├── Price (low to high)
│   ├── Price (high to low)
│   └── Newest
└── Pagination
    ├── First page
    ├── Middle page
    └── Last page

With 4 x 4 x 4 x 3 = 192 exhaustive combinations, pairwise on this tree produces approximately 16-20 test cases.

Exercise: Build a Classification Tree

Scenario: You’re testing a file export feature with these aspects:

  • File format: PDF, CSV, Excel, JSON
  • Data range: Last 7 days, Last 30 days, Custom range, All data
  • Content: Summary only, Detailed, With charts
  • Delivery: Download, Email, Cloud storage

Tasks:

  1. Draw the classification tree
  2. Create a combination table with at least 6 test cases
  3. Ensure every class appears in at least one test case (minimum coverage)
Hint

The largest classification has 4 classes, so you need at least 4 test cases for minimum coverage. To cover all classes across all classifications, you likely need 4-6 test cases. Try to cover interesting combinations like “JSON + With charts” (is that even valid?).

Solution

Classification tree:

File Export
├── Format: PDF, CSV, Excel, JSON
├── Range: 7 days, 30 days, Custom, All
├── Content: Summary, Detailed, With Charts
└── Delivery: Download, Email, Cloud

Combination table (6 test cases, all classes covered):

TC1TC2TC3TC4TC5TC6
PDFXX
CSVX
ExcelX
JSONXX
7 daysXX
30 daysX
CustomXX
AllX
SummaryXX
DetailedXX
With ChartsXX
DownloadXX
EmailXX
CloudXX

Note: JSON + With Charts (TC4 doesn’t have it, but consider: can JSON include charts? This is a good question for the spec!)

Every class appears in at least one test case. 6 tests instead of 4 x 4 x 3 x 3 = 144 exhaustive.

Pro Tips

  • Start with the test object clearly defined. A vague root leads to a vague tree. “Login” is better than “User Management.”
  • Keep classifications independent. If two classifications are highly dependent, consider merging them or adding constraints.
  • Use CTM for communication. The visual tree is excellent for review meetings — stakeholders can quickly spot missing aspects.
  • Refine iteratively. Start with a simple tree, then add sub-classifications as you learn more about the system.
  • Mark invalid combinations. In the combination table, mark impossible combinations (like JSON + Charts) to prevent generating useless test cases.