Ask: "Which file would you like me to analyze and generate tests for? Please provide the file path."

# Verify file exists
if [[ ! -f "{file_path}" ]]; then
    echo "❌ File not found: {file_path}"
    exit 1
fi

Read {file_path}

# Find all public methods/functions
Grep pattern="(fun|override fun|suspend fun)\s+\w+" {file_path} -n

# Find properties
Grep pattern="(val|var)\s+\w+:" {file_path} -n

# Find nullable types
Grep pattern="\w+\?" {file_path} -n

# Find collections (empty collection tests needed)
Grep pattern="List<|Set<|Map<" {file_path} -n

# Find boundary values
Grep pattern="(Int.MAX|Int.MIN|Long.MAX)" {file_path} -n

# Find error handling patterns
Grep pattern="(throw|catch|try|require|check)" {file_path} -n

# Find exceptions
Grep pattern="Exception|Error" {file_path} -n

# Find mutable state
Grep pattern="(var|private var)\s+\w+" {file_path} -n

# Find suspend functions
Grep pattern="suspend\s+fun" {file_path} -n

# Find coroutine scopes
Grep pattern="CoroutineScope|launch|async" {file_path} -n

## Behaviors Found in {FileName}

### Public API (X methods, Y properties):
1. `methodName(param: Type): ReturnType` - Description
2. `property: Type` - Purpose

### Edge Cases Identified:
- Null handling: {scenarios}
- Empty collections: {scenarios}
- Boundary values: {scenarios}

### Error Scenarios:
- Throws XException when {condition}
- Returns null when {condition}

### State Transitions:
- {initial state} → {action} → {new state}

### Dependencies:
- Requires: {external dependencies}
- Side effects: {logging, I/O, etc.}

@Test
fun `GIVEN {precondition} WHEN {action} THEN {expected result}`()

GIVEN valid inputs WHEN executing method THEN should return expected output
GIVEN initial state WHEN action performed THEN should succeed

GIVEN null input WHEN processing THEN should handle gracefully
GIVEN empty list WHEN iterating THEN should return empty result
GIVEN max value WHEN incrementing THEN should handle overflow

GIVEN invalid input WHEN validating THEN should throw IllegalArgumentException
GIVEN null parameter WHEN calling method THEN should throw NullPointerException

GIVEN initial state WHEN action performed THEN should transition to new state
GIVEN logged out WHEN login called THEN should be logged in

GIVEN suspend function WHEN executing THEN should complete successfully
GIVEN async operation WHEN awaiting THEN should return result

# Find existing test file
Glob pattern="**/*{ClassName}Test.kt"

# If exists, read to avoid duplicates
Read {existing_test_file}

# Identify coverage gaps

TodoWrite with all test cases:
1. [pending] Test happy path: GIVEN valid user WHEN creating THEN returns user
2. [pending] Test null handling: GIVEN null input WHEN processing THEN throws exception
3. [pending] Test empty collection: GIVEN empty list WHEN summing THEN returns zero
4. [pending] Test boundary: GIVEN max value WHEN incrementing THEN handles overflow
... (all identified scenarios)

// Copyright (C) 2025 Rodrigo Sicarelli
// SPDX-License-Identifier: Apache-2.0
package {package_name}

import kotlinx.coroutines.test.runTest
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.TestInstance
import kotlin.test.*

/**
 * Tests for {ClassName} following GIVEN-WHEN-THEN patterns.
 */
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
class {ClassName}Test {
    // Tests will be added here
}

# If new file
Write {test_file_path} {content}

# If existing file (adding tests)
Edit {test_file_path} {old_content} {new_content}

@Test
fun `GIVEN valid user data WHEN creating user THEN should return user instance`() = runTest {
    // GIVEN
    val userData = UserData(name = "John", email = "john@test.com")
    val creator = UserCreator()  // Isolated instance

    // WHEN
    val user = creator.create(userData)

    // THEN
    assertNotNull(user)
    assertEquals("John", user.name)
    assertEquals("john@test.com", user.email)
}

@Test
fun `GIVEN null input WHEN processing THEN should throw IllegalArgumentException`() = runTest {
    // GIVEN
    val processor = DataProcessor()

    // WHEN & THEN
    assertFailsWith<IllegalArgumentException> {
        processor.process(null)
    }
}

@Test
fun `GIVEN empty list WHEN calculating sum THEN should return zero`() = runTest {
    // GIVEN
    val emptyList = emptyList<Int>()
    val calculator = SumCalculator()

    // WHEN
    val sum = calculator.sum(emptyList)

    // THEN
    assertEquals(0, sum)
}

@Test
fun `GIVEN async operation WHEN executing THEN should complete successfully`() = runTest {
    // GIVEN
    val asyncService = AsyncService()

    // WHEN
    val result = asyncService.fetchData()  // suspend function

    // THEN
    assertNotNull(result)
    assertTrue(result.isSuccess)
}

# Compile test
./gradlew compileTestKotlin

# Run specific test
./gradlew test --tests "{ClassName}Test.{testMethodName}"

# Verify passes
# If fails: debug, fix, retry
# If passes: mark completed in TodoWrite

./gradlew test --tests "{ClassName}Test"

# Check for "should" pattern (forbidden)
Grep pattern='fun \`should' {test_file} -n

# If found, must fix before completing

# Format code
./gradlew spotlessApply

# Run all tests one final time
./gradlew test --tests "{ClassName}Test"

# Ensure all pass

✅ BEHAVIOR ANALYSIS & TEST GENERATION COMPLETE

📁 Target File:
{file_path}

📊 Analysis Results:
- Public methods: {count}
- Properties: {count}
- Edge cases identified: {count}
- Error scenarios: {count}
- State transitions: {count}

🧪 Tests Generated:
- Total tests: {count}
- Happy path: {count}
- Edge cases: {count}
- Error paths: {count}
- State transitions: {count}
- Async/suspend: {count}

✅ Compliance:
- GIVEN-WHEN-THEN naming: ✅
- Vanilla assertions: ✅
- @TestInstance(PER_CLASS): ✅
- Isolated instances: ✅
- No mocks: ✅
- All tests pass: ✅

📄 Test File:
{test_file_path}

📋 Coverage:
- Methods covered: {count}/{total}
- Behaviors covered: {count}/{total}
- Coverage percentage: {percentage}%

🎯 Next Steps:
- Run tests: ./gradlew test --tests "{ClassName}Test"
- Review generated tests
- Add any additional edge cases if needed