Classification Tree

Classification Trees are a structured, systematic method for designing test cases by decomposing complex inputs into features and categorising them. This method ensures comprehensive, meaningful coverage of the input space, beyond random sampling.

Definitions

• Test Object
  • The test table input instance (e.g. a date composed of a year, month, and day is a testable input instance)
• Classification
  • A category or dimension of input or system condition that is relevant for testing.
• Classification Tree
  • A tree structure where the root represents the test object or function under test
  • The first-level nodes are classifications
  • The leaf nodes under each classification are classes
• Test case derivation
  • By selecting one class from each classification, you can derive a test case

Steps of the classification tree method (Example)

We are to test a validate_date(date) function.

1. Identifying the test object
2. Decomposing it into features
3. Identifying classifications (aspects) within each feature.
4. Refining classifications if needed.
5. Combining classifications systematically to generate test cases.

1. Identify the test object

Test object: a date

2. Decompose the test object into features

A date has:

• Year
• Month
• Day

This can be be represented as:

date
├── year
├── month
└── day

3. Identify classifications within each feature

These are aspects or categories that might impact behaviour.

Year classification

year
├── ordinary
│   ├── negative (e.g., -50)
│   └── nominal (e.g., 2023)
└── leap year
    ├── ordinary (e.g., 2004)
    └── century (e.g., 2000 is leap; 1900 is not)

Month classification

month
├── February
├── 30-day months
│   └── April, June, September, November
└── 31-day months
    └── January, March, etc.

Day classification

day
├── start (1st)
├── middle (e.g., 15th)
├── end (last valid day of month)
└── invalid (> 31)

4. Refine classification if needed

You can further divide classes based on how detailed you want the tests. For example, leap years can be split into:

• 4-divisible but not century years (e.g., 2004)
• 400-divisible years (e.g., 2000)

Recursively apply these procedures as long as possible.

5. Combine classifications systematically to create test cases

Produce test cases by combining as many classifications as possible. For example, date composed of leap year, with 30 day months, and starting date.

def validate_date(date):
    ...
 
# Sample test case
mydate = "2004-04-01"  # Leap year, 30-day month, starting date
validate_date(mydate)

Example combinations

Year	Month	Day	Example Date	Why?
Leap	April	1st	2004-04-01	Valid date; 30-day month, leap year
Ordinary	February	30th	2023-02-30	Invalid; Feb never has 30 days
Century	February	29th	2000-02-29	Valid; leap century year
Negative	March	15th	-50-03-15	Invalid; negative year
Leap	February	29th	2004-02-29	Valid; leap day
Ordinary	April	31st	2023-04-31	Invalid; April has only 30 days

This process ensures systematic coverage and helps identify corner cases.

Example 2

Consider a login object, which is created when a user enters the username and password, which are then together considered for validation. This is how we build the tree

Login Attempt (user/pwd)
├── Username
│   ├── Valid
│   ├── Non-existent
│   ├── Empty
│   ├── Too long
│   └── Special characters
│
└── Password
    ├── Correct
    ├── Incorrect
    ├── Empty
    ├── Too short
    ├── Too long
    └── Special characters

TC	Username	Password	Expected Result
1	Valid	Correct	✅ Login successful
2	Valid	Incorrect	❌ Login failed
3	Valid	Empty	❌ Login failed
4	Valid	Too short	❌ Login failed
5	Valid	Too long	❌ Login failed
6	Valid	Special characters	❌ Login failed (if disallowed)
7	Non-existent	Any	❌ Login failed
8	Empty	Any	❌ Login failed
9	Too long	Any	❌ Login failed
10	Special characters	Correct	❌ Login failed (if username invalid)
11	Special characters	Special characters	❌ Login failed
12	Non-existent	Correct	❌ Login failed
13	Empty	Empty	❌ Login failed
14	Too long	Too long	❌ Login failed

Summary

• Systematic classification avoids random gaps in testing
• Recursive decomposition ensures all features are considered
• Combining features leads to well-defined test cases with clear coverage

---

Back to parent page: Software Testing

Web_and_App_Development Software_Testing Blackbox_Testing SOFT3202 Classification_Tree