open-testing-create

name

open-testing-create

description

Generate concrete test cases, test data, and test scripts from a test design technique and context. Applies 106 test design techniques (boundary value analysis, equivalence partitioning, decision tables, state transitions, pairwise, combinatorial, etc.) to enumerate test conditions and author realistic test cases with inputs, expected results, and traceability. Use this skill whenever the user needs to: create test cases from a technique, apply a testing method to requirements, generate test data, design test scenarios, or populate test scripts. Triggers include: 'test cases', 'create tests', 'test design', 'apply [technique name]', 'generate test data', 'test scenarios', or any technique name (BVA, EP, combinatorial, etc.).

open-testing-create — Test Case & Test Data Generator (CREATES Agents)

What This Skill Does

This skill generates concrete test cases, test data, and test scripts from a test design technique and context. It uses 7 specialized agents (CREATES mnemonic) to parse technique name, load technique procedure from KB, enumerate test conditions systematically, author concrete test cases with IDs and inputs, trace back to requirements, export in desired format, and calculate coverage metrics.

Key flow:

1. Context Agent — Parse technique name and test context
2. Rules Agent — Extract business rules and acceptance criteria
3. Enumerate Agent — Apply technique procedure step-by-step
4. Author Agent — Create concrete test cases with IDs, inputs, expected results
5. Trace Agent — Link test cases to requirements and risk items
6. Export Agent — Output as XLSX, Gherkin, JSON, or CSV
7. Score Agent — Calculate coverage metrics and identify gaps

The 7 CREATES Agents

C_context — Context Agent

Function: Parse technique name, load technique procedure from KB Process:

1. Extract technique name from user request
2. Normalize technique name (e.g., "BVA" → "boundary value analysis")
3. Look up technique-patterns.json → patterns[technique_name]
4. Load technique metadata: description, applicability, test_basis_required, typical_test_count
5. Load technique procedure from techniques/{technique_id}.json

Example invocation:

User: "Create test cases using boundary value analysis for age field (18-65)"
Context Agent:
  - Extracts: technique_name = "boundary value analysis"
  - Loads: technique-patterns.json["boundary value analysis"]
  - Gets: applicability = ["numeric partitions", "range testing"], typical_test_count = "3-5"
  - Loads: techniques/boundary-value-analysis.json → procedure steps

R_rules — Rules Agent

Function: Extract business rules, constraints, acceptance criteria Process:

1. Parse user context for domain rules (e.g., "age 18-65", "password 8-20 chars")
2. Extract constraints: min, max, format, allowed values, exclusions
3. Parse acceptance criteria (explicit or implicit)
4. Map constraints to technique parameters (partitions, boundaries, values)
5. Identify valid/invalid test conditions per rule

Example invocation:

User context: "age field: 18-65, must be integer, required field"
Rules Agent:
  - Identifies constraints:
      * Lower boundary: 18 (inclusive)
      * Upper boundary: 65 (inclusive)
      * Format constraint: integer only
      * Requirement: mandatory field
  - Maps to BVA partitions:
      * Partition 1: age < 18 (invalid)
      * Partition 2: 18 ≤ age ≤ 65 (valid)
      * Partition 3: age > 65 (invalid)
  - Identifies boundaries: 17, 18, 19, 64, 65, 66

E_enumerate — Enumerate Agent

Function: Apply technique procedure to enumerate test conditions Process:

1. Apply technique-specific enumeration algorithm
2. Systematically generate test conditions
3. Map conditions to technique coverage requirements
4. Calculate expected coverage percentage

For Boundary Value Analysis:

Procedure:
  1. Identify boundaries: min, min+1, nominal, max-1, max
  2. For 2 boundaries (age 18-65):
     - Test cases: 17, 18, 19, 64, 65, 66
  3. Coverage: 6 test cases cover 3 partitions (100% partition coverage)

For Equivalence Partitioning:

Procedure:
  1. Partition values into equivalence classes
  2. Select representative from each partition
  3. For age (18-65):
     - Partition 1 (< 18): test value = 5
     - Partition 2 (18-65): test value = 30
     - Partition 3 (> 65): test value = 90
  4. Coverage: 3 test cases cover 3 partitions (100% partition coverage)

For Decision Table:

Procedure:
  1. Identify conditions and actions
  2. Create truth table (2^n rows where n = conditions)
  3. Example: password validation (3 conditions = 8 rows)
     - Condition A: length >= 8? T/F
     - Condition B: has uppercase? T/F
     - Condition C: has digit? T/F
     Actions: Accept, Reject reason
  4. Generate all 8 combinations
  5. Coverage: 8 test situations cover all combinations (100% decision table coverage)

For State Transition Testing:

Procedure:
  1. Identify states and transitions
  2. Build state table
  3. Generate transition sequences (0-switch, 1-switch, 2-switch)
  4. Example: Login flow states = (LoggedOut, Authenticating, LoggedIn, LockedOut)
     Transitions: Login, Logout, Failed, Locked
  5. Generate test cases for each transition
  6. Coverage: N transitions covered at specified coverage level

A_author — Author Agent

Function: Author concrete test cases with ID, precondition, input, action, expected result Process:

1. For each enumerated test condition:
2. Create test case ID (TC-{sequence}-{technique}-{variant})
3. Author precondition (test setup required)
4. Author input (values, data)
5. Author action (user action or system operation)
6. Author expected result (assertion)
7. Author postcondition (cleanup)
8. Assign priority (critical, high, medium, low)

Example output:

Test ID	Precondition	Input	Action	Expected Result	Post-Condition	Priority
TC-001-BVA-LB	Age field on form	17	Submit form	Error: "Age must be 18+"	Form not submitted	High
TC-002-BVA-LB+1	Age field on form	18	Submit form	Form submitted successfully	Record created	Critical
TC-003-BVA-NOM	Age field on form	30	Submit form	Form submitted successfully	Record created	Medium
TC-004-BVA-UB-1	Age field on form	64	Submit form	Form submitted successfully	Record created	Medium
TC-005-BVA-UB	Age field on form	65	Submit form	Form submitted successfully	Record created	Critical
TC-006-BVA-OOB	Age field on form	66	Submit form	Error: "Age cannot exceed 65"	Form not submitted	High

T_trace — Trace Agent

Function: Create traceability links from test cases to requirements and risk items Process:

1. Parse user context for requirement/risk references (e.g., "REQ-001", "RISK-003")
2. For each test case, determine which requirement it validates
3. Create bidirectional traceability: Test Case ↔ Requirement
4. For risk-based tests, link to risk items
5. Calculate coverage: #requirements covered / #requirements total

Example:

Test Case TC-001-BVA-LB validates:
  - Requirement: REQ-012 "Age must be between 18 and 65"
  - Risk: RISK-005 "Underage user registration"

Traceability:
  REQ-012 ← [TC-001, TC-002, TC-005, TC-006] (covered by 4 test cases)
  RISK-005 ← [TC-001] (mitigated by boundary testing)
  Coverage: REQ-012 = 100% (all boundaries tested)

E_export — Export Agent

Function: Export test cases in requested format Process:

1. Format options: XLSX, CSV, JSON, Gherkin (BDD)
2. For XLSX: Use xlsx skill with standard columns (ID, Precondition, Input, Action, Expected Result, Priority, Trace)
3. For Gherkin: Convert to BDD format with Scenario + Given/When/Then
4. For JSON: Export as structured data for CI/CD integration
5. For CSV: Simple comma-separated for import to other tools

XLSX Format:

Columns: Test ID | Precondition | Input | Action | Expected Result | Post-Condition |
         Priority | Req Link | Pass/Fail | Actual Result | Remarks

Gherkin Format:

Feature: Age Validation
  Scenario: Boundary Value Testing - Lower Bound
    Given the age input field is active
    When I enter 17 and submit
    Then an error message "Age must be 18+" appears
    And the form is not submitted

  Scenario: Boundary Value Testing - Valid Range
    Given the age input field is active
    When I enter 30 and submit
    Then the form is submitted successfully
    And a confirmation message appears

JSON Format:

{
  "test_cases": [
    {
      "test_id": "TC-001-BVA-LB",
      "technique": "boundary value analysis",
      "precondition": "Age field on form",
      "input": {"age": 17},
      "action": "Submit form",
      "expected_result": "Error: Age must be 18+",
      "priority": "high",
      "requirement_links": ["REQ-012"]
    }
  ]
}

S_score — Score Agent

Function: Calculate coverage metrics and identify gaps Process:

1. Calculate technique coverage:
   • Partition coverage: #partitions covered / #partitions total
   • Boundary coverage: #boundaries tested / #boundaries identified
   • Condition coverage: #conditions tested / #conditions total
2. Calculate requirement coverage:
   • #requirements with ≥1 test case / #total requirements
3. Identify gaps:
   • Uncovered partitions, boundaries, conditions
   • Untested requirements or acceptance criteria
4. Suggest additional test cases to close gaps

Example Coverage Report:

Boundary Value Analysis (Age field 18-65):
  Partition Coverage: 3/3 (100%)
    - Partition 1 (< 18): COVERED [TC-001]
    - Partition 2 (18-65): COVERED [TC-002, TC-003, TC-004, TC-005]
    - Partition 3 (> 65): COVERED [TC-006]

  Boundary Coverage: 6/6 (100%)
    - 17 (below lower): COVERED [TC-001]
    - 18 (lower): COVERED [TC-002]
    - 19 (above lower): NOT TESTED - gap
    - 64 (below upper): COVERED [TC-004]
    - 65 (upper): COVERED [TC-005]
    - 66 (above upper): COVERED [TC-006]

  Requirement Coverage: 1/1 (100%)
    - REQ-012: COVERED by 6 test cases

  Total Test Count: 6
  Estimated Boundary Defect Detection Rate: 95%

All 106 Supported Techniques

All 106 techniques are in /knowledge-base/techniques/ directory with procedure files. They are organized by type:

• Specification-Based (31): BVA, EP, DTT, STT, UCT, Boundary Testing, Error Guessing, OAT, CTM, CEG, Pairwise, Combinatorial, N-wise, All-Pairs, Base Choice, Catalog, Tree-based, Requirement-Based, Analytical Strategy, MBT, Metamorphic, Property-Based, Scenario, Use Case, Business Rules, Constraint, Data Flow, Syntax, Protocol, Transaction Flow
• Structure-Based (18): Statement, Branch, Branch & Condition, MCDC, MCC, Path, Data Flow Coverage, Call Coverage, Loop, Cyclomatic, Condition, Atomic Condition, Compound, Predicate, Basis Path, Call Depth, Boundary Interior, Stratum
• Experience-Based (9): Exploratory, Checklist, Attack, Error Guessing, Ad-Hoc, Intuitive, Session, Risk-Based, Persona
• Specialized (25): BVA-Robustness, Special Value, Worst-Case, Random, Stress, Load, Performance, Chaos, Penetration, Fuzzing, Mutation, GUI, API, Database, Integration, Contract, Consumer-Driven Contract, Schema, Back-to-Back, Comparison, Compatibility, Configuration, Regression
• Domain-Specific (14): AI/ML Adversarial, Differential, Snapshot, Visual Regression, Accessibility, Security, Cross-Browser, Cross-Platform, Mobile, IoT, Microservices, Cloud, Containerization, Blockchain
• User-Experience (9): Usability, A/B, Multivariate, User Journey, Workflow, Navigation, Interaction, Localization, Globalization

Load any technique via: techniques/{technique_id}.json

Technique Procedure Files (106 Individual Files)

Each technique is defined in /sessions/trusting-pensive-ptolemy/mnt/Open-Testing/knowledge-base/techniques/{technique_id}.json

Example: boundary-value-analysis.json

{
  "technique_id": "boundary-value-analysis",
  "technique_name": "Boundary Value Analysis",
  "procedure": {
    "step_1": "Identify input domain boundaries (min, max)",
    "step_2": "Identify boundary values (min, min+1, max-1, max)",
    "step_3": "Identify output boundaries",
    "step_4": "For each boundary, create test case with value at boundary",
    "step_5": "For each boundary, create test case with value just inside",
    "step_6": "For each boundary, create test case with value just outside"
  },
  "coverage_criterion": "boundary coverage",
  "typical_test_count": "3-5 per boundary",
  "automation_suitability": "high"
}

Test Case Output Format

All test cases follow this standard format:

Field	Type	Description
test_id	string	Unique identifier (TC-{seq}-{technique}-{variant})
test_title	string	Brief description of what is tested
precondition	string	Setup required before test execution
input	object	Input values (maps to business context)
action	string	User action or system operation
expected_result	string	Expected behavior/output
postcondition	string	Cleanup or state after test
priority	enum	critical, high, medium, low
requirement_trace	array	[REQ-001, REQ-002] links
risk_trace	array	[RISK-001] links
technique_variant	string	BVA-LB, BVA-UB, EP-P1, DTT-TS01, etc.
coverage_metric	string	Partition coverage, boundary coverage, etc.

Worked Examples

Example 1: Boundary Value Analysis (Age Field 18-65)

Enumerate Agent: Test values 17, 18, 19, 64, 65, 66 cover 3 partitions

Author Agent creates 6 test cases:

TC ID	Input	Expected	Priority
TC-001	17	Error "Age must be 18+"	Critical
TC-002	18	Accepted	Critical
TC-003	30	Accepted	Medium
TC-004	64	Accepted	Medium
TC-005	65	Accepted	Critical
TC-006	66	Error "Cannot exceed 65"	High

Trace & Score: Links to REQ-005, 100% boundary coverage, 85% fault detection rate

Example 2: Equivalence Partitioning (Email Validation)

Enumerate Agent: 6 partitions identified (valid, no @, no domain, bad extension, too long, too short)

Author Agent creates 6 test cases:

TC ID	Input	Expected	Priority
TC-001	[e-mail]	Pass	Critical
TC-002	testexample.com	Error "Need @"	High
TC-003	test@.com	Error "Invalid domain"	High
TC-004	test@example.c	Error "Ext 2+ chars"	High
TC-005	255+ char email	Error "Too long"	Medium
TC-006	a@b	Error "Too short"	Low

Trace & Score: Links to REQ-008, 100% partition coverage

Example 3: Decision Table (Discount Logic)

Context: Discount rules — Premium: 15% on >$100, Regular: 10% on >$50, New: no discount

Enumerate Agent generates 12 test situations:

Customer	Amount	Discount	Expected
Premium	$45	0%	Minimum not met
Premium	$150	15%	$127.50
Regular	$30	5%	$28.50
Regular	$75	10%	$67.50
New	$200	0%	$200

Author Agent creates 12 test cases: TC-001-DTT-TS01 through TC-012-DTT-TS12

Trace: Links to REQ-012, coverage 100%

Invocation Examples

BVA Invocation

User: "Create test cases using boundary value analysis for login password field:
        minimum 8 characters, maximum 128 characters, must contain uppercase and digit"

open-testing-create will:
  1. Identify technique: boundary value analysis
  2. Load procedure: identify boundaries at 8, 9, 127, 128
  3. Extract rules: min=8, max=128, must_contain uppercase, must_contain digit
  4. Enumerate test values: 7, 8, 9, 127, 128, 129
  5. Author 6 test cases + edge cases (empty, null, special chars)
  6. Trace to REQ-003 "Password strength requirements"
  7. Export as XLSX with ready-to-execute test cases
  8. Score coverage: boundary=95%, partition=100%

Equivalence Partitioning Invocation

User: "Create test cases for payment method field: credit card, debit card, or PayPal"

open-testing-create will:
  1. Identify technique: equivalence partitioning
  2. Load procedure: partition into equivalence classes
  3. Extract rules: allowed values = [CC, DC, PayPal]
  4. Enumerate partitions: P1=CC, P2=DC, P3=PayPal, P4=Invalid
  5. Author 4 test cases (one per partition)
  6. Trace to REQ-015 "Payment method selection"
  7. Export as XLSX or Gherkin
  8. Score coverage: partition=100%

Decision Table Invocation

User: "Create test cases for password validation rule:
        length 8-20 AND (has_uppercase OR has_digit) AND NOT has_space"

open-testing-create will:
  1. Identify technique: decision table testing
  2. Extract conditions: C1=length_valid, C2=has_char, C3=no_space
  3. Build truth table: 2^3 = 8 test situations
  4. Enumerate all 8 combinations
  5. Author 8 test cases (TS-01 through TS-08)
  6. Trace to REQ-008 "Password validation"
  7. Export as XLSX or Gherkin
  8. Score coverage: 8/8 test situations (100% decision table coverage)

Knowledge Base Files Referenced

• terminology.json (1,105 terms) — Test terminology definitions
• technique-patterns.json (106 patterns) — Technique metadata and hints
• techniques/{technique_id}.json (106 files) — Individual technique procedures
• template-analysis.json — Test case template structure
• quality-to-technique.json — Quality characteristic-to-technique mappings

Skill Dependencies

This skill depends on:

• xlsx skill — For generating test case XLSX files
• docx skill — For generating Gherkin DOCX files (optional)

---

Version 1.0 | Open Testing Ecosystem | Generated 2026-04-05