Imported from redsnow1992/skills (tdd/SKILL.md). Install upstream with npx skills add redsnow1992/skills --skill tdd. Copyright stays with the author.

TDD 项目开发框架（PDCA循环版）

一个全面的测试驱动开发（TDD）框架，采用PDCA循环方法进行结构化项目开发，包含分阶段验证、单元测试、集成测试和不可变测试脚本。支持Windows和Linux跨平台运行。

PDCA循环核心

┌─────────────────────────────────────────────────────────────┐
│                         PDCA循环                            │
├─────────────────────────────────────────────────────────────┤
│  Plan (计划)                                               │
│  - 需求分析                                                │
│  - 测试计划制定                                            │
│  - 测试脚本设计                                            │
│  - 开发阶段划分                                            │
├─────────────────────────────────────────────────────────────┤
│  Do (执行)                                                 │
│  - 阶段1开发 (单元测试)                                    │
│  - 阶段2开发 (单元测试)                                    │
│  - 阶段3开发 (集成测试)                                    │
├─────────────────────────────────────────────────────────────┤
│  Check (检查)                                              │
│  - 单元测试验证                                            │
│  - 集成测试验证                                            │
│  - 测试报告生成                                            │
├─────────────────────────────────────────────────────────────┤
│  Act (改进)                                                │
│  - 问题修复                                                │
│  - 需求迭代                                                │
│  - 下一轮PDCA循环                                          │
└─────────────────────────────────────────────────────────────┘

核心原则

测试脚本优先：所有测试脚本必须在开发开始前创建
测试脚本不可变：开发过程中测试脚本不能被修改 - 只能由人来确认是否修改
PDCA循环：每个开发阶段遵循 Plan-Do-Check-Act 循环
全面日志记录：所有测试脚本必须包含详细的日志记录和进度跟踪
单元测试+集成测试：同时包含单元测试和集成测试
需求迭代：每次需求迭代都采用TDD方式

测试类型定义

单元测试 (Unit Test)

测试粒度：最小功能单元
测试范围：单个函数、单模块
测试脚本：*-unit-*.bat/sh
特点：快速、独立、无外部依赖

集成测试 (Integration Test)

测试粒度：模块间交互
测试范围：多个模块协同
测试脚本：*-integration-*.bat/sh
特点：验证模块间接口和交互

跨平台支持

平台	脚本类型	主测试运行器	测试脚本
Windows	`.bat`	`master-test.bat`	`phase-X-*-validation.bat`
Linux/Mac	`.sh`	`master-test.sh`	`phase-X-*-validation.sh`

目录结构

project/
├── tests/                              # 所有测试脚本（最先创建）
│   ├── README.md                       # 测试文档
│   ├── PLAN.md                        # 计划文档
│   ├── windows/                       # Windows脚本
│   │   ├── unit/                     # 单元测试
│   │   │   ├── phase-1-unit-1.bat
│   │   │   └── phase-2-unit-1.bat
│   │   └── integration/              # 集成测试
│   │       ├── phase-3-integration-1.bat
│   │       └── master-integration.bat
│   └── linux/                        # Linux脚本
│       ├── unit/                     # 单元测试
│       │   ├── phase-1-unit-1.sh
│       │   └── phase-2-unit-1.sh
│       └── integration/              # 集成测试
│           ├── phase-3-integration-1.sh
│           └── master-integration.sh
├── src/                              # 开发源代码
│   ├── phase-1/                      # 开发阶段
│   ├── phase-2/
│   └── phase-3/
├── logs/                             # 测试执行日志
│   └── test-results/                 # 详细测试结果
└── docs/                             # 项目文档

阶段一：Plan（计划）

1.1 需求分析

创建 tests/PLAN.md，包含：

# 项目开发计划

## 需求概述
[项目背景和目标]

## PDCA阶段规划

### 第一轮PDCA：基础功能
**目标**: [阶段目标]

#### Plan阶段
- [ ] 需求分析
- [ ] 单元测试设计
- [ ] 集成测试设计
- [ ] 测试脚本编写

#### Do阶段
- [ ] 阶段1开发
- [ ] 阶段2开发
- [ ] 阶段3开发

#### Check阶段
- [ ] 单元测试验证
- [ ] 集成测试验证
- [ ] 测试报告生成

#### Act阶段
- [ ] 问题修复
- [ ] 需求确认

### 第二轮PDCA：功能扩展
[下一轮计划...]

1.2 测试计划制定

为每个PDCA轮次制定测试计划：

阶段	测试类型	测试脚本	验证目标
Phase 1	单元测试	`phase-1-unit-*.bat`	单模块功能
Phase 2	单元测试	`phase-2-unit-*.bat`	单模块功能
Phase 3	集成测试	`phase-3-integration-*.bat`	模块间交互

1.3 测试脚本设计

单元测试脚本模板 (Windows)

@echo off
REM ============================================================================
REM 单元测试: [模块名] - [功能点]
REM 阶段: [Phase-X]
REM 创建日期: [日期]
REM 测试类型: 单元测试
REM ============================================================================

setlocal EnableDelayedExpansion

set "TEST_TYPE=单元测试"
set "TEST_PHASE=Phase-X"
set "TEST_MODULE=[模块名]"
set "TEST_NAME=[功能点]"
set "LOG_FILE=..\..\logs\test-results\phase-x-unit-results.log"
set "PROGRESS_FILE=..\..\logs\test-results\phase-x-unit-progress.log"

REM ============================================================================
REM 初始化
REM ============================================================================
echo [单元测试] ===========================================
echo [单元测试] 测试模块: %TEST_MODULE%
echo [单元测试] 测试功能: %TEST_NAME%
echo [单元测试] 阶段: %TEST_PHASE%
echo [单元测试] ===========================================
echo.

echo [%date% %time%] [单元测试] [%TEST_PHASE%] [%TEST_MODULE%] 开始测试 >> "%LOG_FILE%"
echo [%date% %time%] [单元测试] [进度 0/3] 初始化... >> "%PROGRESS_FILE%"

REM ============================================================================
REM 测试前检查
REM ============================================================================
echo [步骤 1/3] 验证测试环境...
call :log_progress "测试前" "验证测试环境" "1/3"

REM 检查源文件是否存在
if exist "..\..\src\%TEST_PHASE%\[模块文件].java" (
    echo [通过] 源文件存在
    call :log_progress "测试前" "源文件验证: 通过" "1/3"
) else (
    echo [失败] 源文件不存在
    call :log_progress "测试前" "源文件验证: 失败" "1/3"
    exit /b 1
)

REM ============================================================================
REM 执行单元测试
REM ============================================================================
echo [步骤 2/3] 执行单元测试用例...
call :log_progress "测试" "执行单元测试" "2/3"

set TEST_PASSED=0
set TEST_FAILED=0

REM 测试用例1: [具体测试点]
echo [测试用例1] 测试 [功能点1]...
call :execute_unit_test "test_case_1" "[功能点1]"

REM 测试用例2: [具体测试点]
echo [测试用例2] 测试 [功能点2]...
call :execute_unit_test "test_case_2" "[功能点2]"

REM ============================================================================
REM 测试结果汇总
REM ============================================================================
echo [步骤 3/3] 生成测试报告...
call :log_progress "报告" "生成测试报告" "3/3"

echo.
echo [单元测试] ===========================================
echo [单元测试] 测试完成
echo [单元测试] 通过: !TEST_PASSED!  失败: !TEST_FAILED!
echo [单元测试] ===========================================
echo.

echo [%date% %time%] [单元测试] [%TEST_PHASE%] 完成 >> "%LOG_FILE%"
echo [%date% %time%] [单元测试] 结果: !TEST_PASSED! 通过, !TEST_FAILED! 失败 >> "%LOG_FILE%"

call :log_progress "完成" "单元测试完成" "3/3"

if !TEST_FAILED! gtr 0 (
    exit /b 1
) else (
    exit /b 0
)

REM ============================================================================
REM 辅助函数
REM ============================================================================
:execute_unit_test
setlocal
set "TEST_CASE=%~1"
set "TEST_DESC=%~2"

REM 实际测试逻辑
REM 这里应该是编译并运行Java单元测试
REM 例如: javac -cp junit.jar Test.java && java -cp .;junit.jar TestRunner

echo [信息] 执行测试用例: %TEST_CASE%
call :log_progress "测试" "执行: %TEST_DESC%" "2/3"

REM 模拟测试结果
set /a TEST_PASSED+=1
endlocal & set "TEST_PASSED=%TEST_PASSED%" & set "TEST_FAILED=%TEST_FAILED%"
goto :eof

:log_progress
setlocal
set "PHASE=%~1"
set "MESSAGE=%~2"
set "PROGRESS=%~3"
if not "%PROGRESS%"=="" (
    echo [%date% %time%] [%PHASE%] [步骤 %PROGRESS%] %MESSAGE% >> "%PROGRESS_FILE%"
) else (
    echo [%date% %time%] [%PHASE%] %MESSAGE% >> "%PROGRESS_FILE%"
)
echo [%date% %time%] [%PHASE%] [步骤 !PROGRESS!] %MESSAGE%
endlocal
goto :eof

单元测试脚本模板 (Linux)

#!/bin/bash
# ============================================================================
# 单元测试: [模块名] - [功能点]
# 阶段: [Phase-X]
# 创建日期: [日期]
# 测试类型: 单元测试
# ============================================================================

set -euo pipefail

TEST_TYPE="单元测试"
TEST_PHASE="Phase-X"
TEST_MODULE="[模块名]"
TEST_NAME="[功能点]"
LOG_FILE="../../logs/test-results/phase-x-unit-results.log"
PROGRESS_FILE="../../logs/test-results/phase-x-unit-progress.log"

mkdir -p "../../logs/test-results"

log_progress() {
    local phase="$1"
    local message="$2"
    local progress="$3"
    if [[ -n "$progress" ]]; then
        echo "[$(date '+%Y-%m-%d %H:%M:%S')] [$phase] [步骤 $progress] $message" >> "$PROGRESS_FILE"
    else
        echo "[$(date '+%Y-%m-%d %H:%M:%S')] [$phase] $message" >> "$PROGRESS_FILE"
    fi
}

execute_unit_test() {
    local test_case="$1"
    local test_desc="$2"

    echo "[信息] 执行测试用例: $test_case"
    log_progress "测试" "执行: $test_desc" "2/3"

    # 实际测试逻辑
    # 这里应该是编译并运行Java单元测试

    ((TEST_PASSED++))
}

echo "[单元测试] ==========================================="
echo "[单元测试] 测试模块: $TEST_MODULE"
echo "[单元测试] 测试功能: $TEST_NAME"
echo "[单元测试] 阶段: $TEST_PHASE"
echo "[单元测试] ==========================================="
echo ""

echo "[$(date '+%Y-%m-%d %H:%M:%S')] [单元测试] [$TEST_PHASE] [$TEST_MODULE] 开始测试" >> "$LOG_FILE"
log_progress "测试前" "验证测试环境" "1/3"

# 检查源文件是否存在
if [[ -f "../../src/$TEST_PHASE/[模块文件].java" ]]; then
    echo "[通过] 源文件存在"
    log_progress "测试前" "源文件验证: 通过" "1/3"
else
    echo "[失败] 源文件不存在"
    log_progress "测试前" "源文件验证: 失败" "1/3"
    exit 1
fi

echo "[步骤 2/3] 执行单元测试用例..."
log_progress "测试" "执行单元测试" "2/3"

TEST_PASSED=0
TEST_FAILED=0

echo "[测试用例1] 测试 [功能点1]..."
execute_unit_test "test_case_1" "[功能点1]"

echo "[步骤 3/3] 生成测试报告..."
log_progress "报告" "生成测试报告" "3/3"

echo ""
echo "[单元测试] ==========================================="
echo "[单元测试] 测试完成"
echo "[单元测试] 通过: $TEST_PASSED  失败: $TEST_FAILED"
echo "[单元测试] ==========================================="
echo ""

echo "[$(date '+%Y-%m-%d %H:%M:%S')] [单元测试] [$TEST_PHASE] 完成" >> "$LOG_FILE"
echo "[$(date '+%Y-%m-%d %H:%M:%S')] [单元测试] 结果: $TEST_PASSED 通过, $TEST_FAILED 失败" >> "$LOG_FILE"

log_progress "完成" "单元测试完成" "3/3"

if [[ $TEST_FAILED -gt 0 ]]; then
    exit 1
else
    exit 0
fi

集成测试脚本模板 (Windows)

@echo off
REM ============================================================================
REM 集成测试: [系统模块] - [交互功能]
REM 阶段: [Phase-X]
REM 创建日期: [日期]
REM 测试类型: 集成测试
REM ============================================================================

setlocal EnableDelayedExpansion

set "TEST_TYPE=集成测试"
set "TEST_PHASE=Phase-X"
set "TEST_MODULE=[系统模块]"
set "TEST_NAME=[交互功能]"
set "LOG_FILE=..\..\logs\test-results\phase-x-integration-results.log"
set "PROGRESS_FILE=..\..\logs\test-results\phase-x-integration-progress.log"

REM ============================================================================
REM 初始化
REM ============================================================================
echo [集成测试] ===========================================
echo [集成测试] 测试模块: %TEST_MODULE%
echo [集成测试] 测试功能: %TEST_NAME%
echo [集成测试] 阶段: %TEST_PHASE%
echo [集成测试] ===========================================
echo.

echo [%date% %time%] [集成测试] [%TEST_PHASE%] [%TEST_MODULE%] 开始测试 >> "%LOG_FILE%"
echo [%date% %time%] [集成测试] [进度 0/4] 初始化... >> "%PROGRESS_FILE%"

REM ============================================================================
REM 测试前检查 - 验证所有依赖模块
REM ============================================================================
echo [步骤 1/4] 验证依赖模块...
call :log_progress "测试前" "验证依赖模块" "1/4"

REM 检查模块1
if exist "..\..\src\%TEST_PHASE%\module1.java" (
    echo [通过] 模块1存在
    call :log_progress "测试前" "模块1验证: 通过" "1/4"
) else (
    echo [失败] 模块1不存在
    call :log_progress "测试前" "模块1验证: 失败" "1/4"
)

REM 检查模块2
if exist "..\..\src\%TEST_PHASE%\module2.java" (
    echo [通过] 模块2存在
    call :log_progress "测试前" "模块2验证: 通过" "1/4"
) else (
    echo [失败] 模块2不存在
    call :log_progress "测试前" "模块2验证: 失败" "1/4"
)

REM ============================================================================
REM 执行集成测试
REM ============================================================================
echo [步骤 2/4] 编译所有模块...
call :log_progress "编译" "编译所有模块" "2/4"

REM 编译命令
REM javac -d build %TEST_PHASE%\*.java

echo [步骤 3/4] 执行集成测试用例...
call :log_progress "测试" "执行集成测试" "3/4"

set TEST_PASSED=0
set TEST_FAILED=0

REM 集成测试用例1: [模块交互测试]
echo [集成测试用例1] 测试 [模块1] -> [模块2] 交互...
call :execute_integration_test "integration_test_1" "[模块1]与[模块2]交互"

REM 集成测试用例2: [端到端测试]
echo [集成测试用例2] 测试 [端到端流程]...
call :execute_integration_test "integration_test_2" "[端到端流程]"

REM ============================================================================
REM 测试结果汇总
REM ============================================================================
echo [步骤 4/4] 生成测试报告...
call :log_progress "报告" "生成测试报告" "4/4"

echo.
echo [集成测试] ===========================================
echo [集成测试] 测试完成
echo [集成测试] 通过: !TEST_PASSED!  失败: !TEST_FAILED!
echo [集成测试] ===========================================
echo.

echo [%date% %time%] [集成测试] [%TEST_PHASE%] 完成 >> "%LOG_FILE%"
echo [%date% %time%] [集成测试] 结果: !TEST_PASSED! 通过, !TEST_FAILED! 失败 >> "%LOG_FILE%"

call :log_progress "完成" "集成测试完成" "4/4"

if !TEST_FAILED! gtr 0 (
    exit /b 1
) else (
    exit /b 0
)

REM ============================================================================
REM 辅助函数
REM ============================================================================
:execute_integration_test
setlocal
set "TEST_CASE=%~1"
set "TEST_DESC=%~2"

REM 实际测试逻辑
REM 这里应该是运行集成测试

echo [信息] 执行集成测试用例: %TEST_CASE%
call :log_progress "测试" "执行: %TEST_DESC%" "3/4"

REM 模拟测试结果
set /a TEST_PASSED+=1
endlocal & set "TEST_PASSED=%TEST_PASSED%" & set "TEST_FAILED=%TEST_FAILED%"
goto :eof

:log_progress
setlocal
set "PHASE=%~1"
set "MESSAGE=%~2"
set "PROGRESS=%~3"
if not "%PROGRESS%"=="" (
    echo [%date% %time%] [%PHASE%] [步骤 %PROGRESS%] %MESSAGE% >> "%PROGRESS_FILE%"
) else (
    echo [%date% %time%] [%PHASE%] %MESSAGE% >> "%PROGRESS_FILE%"
)
echo [%date% %time%] [%PHASE%] [步骤 !PROGRESS!] %MESSAGE%
endlocal
goto :eof

集成测试脚本模板 (Linux)

#!/bin/bash
# ============================================================================
# 集成测试: [系统模块] - [交互功能]
# 阶段: [Phase-X]
# 创建日期: [日期]
# 测试类型: 集成测试
# ============================================================================

set -euo pipefail

TEST_TYPE="集成测试"
TEST_PHASE="Phase-X"
TEST_MODULE="[系统模块]"
TEST_NAME="[交互功能]"
LOG_FILE="../../logs/test-results/phase-x-integration-results.log"
PROGRESS_FILE="../../logs/test-results/phase-x-integration-progress.log"

mkdir -p "../../logs/test-results"

log_progress() {
    local phase="$1"
    local message="$2"
    local progress="$3"
    if [[ -n "$progress" ]]; then
        echo "[$(date '+%Y-%m-%d %H:%M:%S')] [$phase] [步骤 $progress] $message" >> "$PROGRESS_FILE"
    else
        echo "[$(date '+%Y-%m-%d %H:%M:%S')] [$phase] $message" >> "$PROGRESS_FILE"
    fi
}

execute_integration_test() {
    local test_case="$1"
    local test_desc="$2"

    echo "[信息] 执行集成测试用例: $test_case"
    log_progress "测试" "执行: $test_desc" "3/4"

    ((TEST_PASSED++))
}

echo "[集成测试] ==========================================="
echo "[集成测试] 测试模块: $TEST_MODULE"
echo "[集成测试] 测试功能: $TEST_NAME"
echo "[集成测试] 阶段: $TEST_PHASE"
echo "[集成测试] ==========================================="
echo ""

echo "[$(date '+%Y-%m-%d %H:%M:%S')] [集成测试] [$TEST_PHASE] [$TEST_MODULE] 开始测试" >> "$LOG_FILE"
log_progress "测试前" "验证依赖模块" "1/4"

# 检查模块1
if [[ -f "../../src/$TEST_PHASE/module1.java" ]]; then
    echo "[通过] 模块1存在"
    log_progress "测试前" "模块1验证: 通过" "1/4"
else
    echo "[失败] 模块1不存在"
    log_progress "测试前" "模块1验证: 失败" "1/4"
fi

# 检查模块2
if [[ -f "../../src/$TEST_PHASE/module2.java" ]]; then
    echo "[通过] 模块2存在"
    log_progress "测试前" "模块2验证: 通过" "1/4"
else
    echo "[失败] 模块2不存在"
    log_progress "测试前" "模块2验证: 失败" "1/4"
fi

echo "[步骤 2/4] 编译所有模块..."
log_progress "编译" "编译所有模块" "2/4"

echo "[步骤 3/4] 执行集成测试用例..."
log_progress "测试" "执行集成测试" "3/4"

TEST_PASSED=0
TEST_FAILED=0

echo "[集成测试用例1] 测试 [模块1] -> [模块2] 交互..."
execute_integration_test "integration_test_1" "[模块1]与[模块2]交互"

echo "[步骤 4/4] 生成测试报告..."
log_progress "报告" "生成测试报告" "4/4"

echo ""
echo "[集成测试] ==========================================="
echo "[集成测试] 测试完成"
echo "[集成测试] 通过: $TEST_PASSED  失败: $TEST_FAILED"
echo "[集成测试] ==========================================="
echo ""

echo "[$(date '+%Y-%m-%d %H:%M:%S')] [集成测试] [$TEST_PHASE] 完成" >> "$LOG_FILE"
echo "[$(date '+%Y-%m-%d %H:%M:%S')] [集成测试] 结果: $TEST_PASSED 通过, $TEST_FAILED 失败" >> "$LOG_FILE"

log_progress "完成" "集成测试完成" "4/4"

if [[ $TEST_FAILED -gt 0 ]]; then
    exit 1
else
    exit 0
fi

阶段二：Do（执行）

PDCA轮次1：基础功能

Do-阶段1：单元测试开发

创建单元测试脚本 phase-1-unit-*.bat/sh
开发阶段1代码
运行单元测试验证
通过后进入下一阶段

Do-阶段2：单元测试开发

创建单元测试脚本 phase-2-unit-*.bat/sh
开发阶段2代码
运行单元测试验证
通过后进入下一阶段

Do-阶段3：集成测试开发

创建集成测试脚本 phase-3-integration-*.bat/sh
开发阶段3代码
运行集成测试验证
所有测试通过后进入Check阶段

阶段三：Check（检查）

3.1 主测试运行器

Windows主测试运行器

@echo off
REM ============================================================================
REM 主测试运行器 - PDCA循环版
REM ============================================================================

setlocal EnableDelayedExpansion

set "START_TIME=%date% %time%"
set "MASTER_LOG=..\..\logs\test-results\master-test-results.log"
set "OVERALL_PROGRESS=..\..\logs\test-results\master-progress.log"

echo ============================================ > "%MASTER_LOG%"
echo PDCA测试运行器已启动 >> "%MASTER_LOG%"
echo 启动时间: %START_TIME% >> "%MASTER_LOG%"
echo ============================================ >> "%MASTER_LOG%"

mkdir -p "..\..\logs\test-results"

set PDCA_ROUNDS_RUN=0
set PDCA_ROUNDS_PASSED=0
set PDCA_ROUNDS_FAILED=0

REM ============================================================================
REM 第一轮PDCA: 基础功能
REM ============================================================================
echo.
echo [PDCA轮次 1/2] 启动第一轮PDCA: 基础功能
echo ============================================

call :run_pdca_round "1" "基础功能"

if !ERRORLEVEL! equ 0 (
    set /a PDCA_ROUNDS_PASSED+=1
    echo [主程序] 第一轮PDCA通过
) else (
    set /a PDCA_ROUNDS_FAILED+=1
    echo [主程序] 第一轮PDCA失败
)
set /a PDCA_ROUNDS_RUN+=1

REM ============================================================================
REM 第二轮PDCA: 功能扩展
REM ============================================================================
echo.
echo [PDCA轮次 2/2] 启动第二轮PDCA: 功能扩展
echo ============================================

call :run_pdca_round "2" "功能扩展"

if !ERRORLEVEL! equ 0 (
    set /a PDCA_ROUNDS_PASSED+=1
    echo [主程序] 第二轮PDCA通过
) else (
    set /a PDCA_ROUNDS_FAILED+=1
    echo [主程序] 第二轮PDCA失败
)
set /a PDCA_ROUNDS_RUN+=1

REM ============================================================================
REM 最终总结
REM ============================================================================
set "END_TIME=%date% %time%"

echo.
echo ============================================
echo PDCA测试运行完成
echo ============================================
echo.
echo 总体结果:
echo   PDCA轮次: !PDCA_ROUNDS_RUN!
echo   通过: !PDCA_ROUNDS_PASSED!
echo   失败: !PDCA_ROUNDS_FAILED!
echo.

if !PDCA_ROUNDS_FAILED! gtr 0 (
    echo [主程序] 最终结果: 失败
    exit /b 1
) else (
    echo [主程序] 最终结果: 所有PDCA轮次通过
    exit /b 0
)

goto :eof

:run_pdca_round
setlocal
set "ROUND=%~1"
set "ROUND_NAME=%~2"

echo [%date% %time%] [PDCA轮次 %ROUND%] 开始 >> "%OVERALL_PROGRESS%"

REM 执行单元测试阶段
echo.
echo [PDCA轮次 %ROUND%] [阶段1/3] 单元测试
call :run_unit_tests

REM 执行集成测试阶段
echo.
echo [PDCA轮次 %ROUND%] [阶段2/3] 集成测试
call :run_integration_tests

REM 生成报告
echo.
echo [PDCA轮次 %ROUND%] [阶段3/3] 生成报告
call :generate_pdca_report

echo [%date% %time%] [PDCA轮次 %ROUND%] 完成 >> "%OVERALL_PROGRESS%"

endlocal
goto :eof

:run_unit_tests
call "..\..\tests\windows\unit\phase-%PDCA_ROUND%-unit-1.bat"
goto :eof

:run_integration_tests
call "..\..\tests\windows\integration\phase-%PDCA_ROUND%-integration-1.bat"
goto :eof

:generate_pdca_report
echo [信息] 生成PDCA轮次 %ROUND% 报告
goto :eof

Linux主测试运行器

#!/bin/bash
# ============================================================================
# 主测试运行器 - PDCA循环版
# ============================================================================

set -euo pipefail

START_TIME=$(date '+%Y-%m-%d %H:%M:%S')
MASTER_LOG="../../logs/test-results/master-test-results.log"
OVERALL_PROGRESS="../../logs/test-results/master-progress.log"

echo "============================================" > "$MASTER_LOG"
echo "PDCA测试运行器已启动" >> "$MASTER_LOG"
echo "启动时间: $START_TIME" >> "$MASTER_LOG"
echo "============================================" >> "$MASTER_LOG"

mkdir -p "../../logs/test-results"

PDCA_ROUNDS_RUN=0
PDCA_ROUNDS_PASSED=0
PDCA_ROUNDS_FAILED=0

run_pdca_round() {
    local round="$1"
    local round_name="$2"

    echo ""
    echo "[PDCA轮次 $round] 开始: $round_name"
    echo "============================================"

    echo "[$(date '+%Y-%m-%d %H:%M:%S')] [PDCA轮次 $round] 开始" >> "$OVERALL_PROGRESS"

    # 执行单元测试
    echo ""
    echo "[PDCA轮次 $round] [阶段1/3] 单元测试"
    bash "../../tests/linux/unit/phase-${round}-unit-1.sh"

    # 执行集成测试
    echo ""
    echo "[PDCA轮次 $round] [阶段2/3] 集成测试"
    bash "../../tests/linux/integration/phase-${round}-integration-1.sh"

    # 生成报告
    echo ""
    echo "[PDCA轮次 $round] [阶段3/3] 生成报告"

    echo "[$(date '+%Y-%m-%d %H:%M:%S')] [PDCA轮次 $round] 完成" >> "$OVERALL_PROGRESS"
}

# 第一轮PDCA: 基础功能
echo ""
echo "[PDCA轮次 1/2] 启动第一轮PDCA: 基础功能"
echo "============================================"
run_pdca_round "1" "基础功能"
if [[ $? -eq 0 ]]; then
    ((PDCA_ROUNDS_PASSED++))
    echo "[主程序] 第一轮PDCA通过"
else
    ((PDCA_ROUNDS_FAILED++))
    echo "[主程序] 第一轮PDCA失败"
fi
((PDCA_ROUNDS_RUN++))

# 第二轮PDCA: 功能扩展
echo ""
echo "[PDCA轮次 2/2] 启动第二轮PDCA: 功能扩展"
echo "============================================"
run_pdca_round "2" "功能扩展"
if [[ $? -eq 0 ]]; then
    ((PDCA_ROUNDS_PASSED++))
    echo "[主程序] 第二轮PDCA通过"
else
    ((PDCA_ROUNDS_FAILED++))
    echo "[主程序] 第二轮PDCA失败"
fi
((PDCA_ROUNDS_RUN++))

END_TIME=$(date '+%Y-%m-%d %H:%M:%S')

echo ""
echo "============================================"
echo "PDCA测试运行完成"
echo "============================================"
echo ""
echo "总体结果:"
echo "  PDCA轮次: $PDCA_ROUNDS_RUN"
echo "  通过: $PDCA_ROUNDS_PASSED"
echo "  失败: $PDCA_ROUNDS_FAILED"
echo ""

if [[ $PDCA_ROUNDS_FAILED -gt 0 ]]; then
    echo "[主程序] 最终结果: 失败"
    exit 1
else
    echo "[主程序] 最终结果: 所有PDCA轮次通过"
    exit 0
fi

3.2 测试报告生成

每个PDCA轮次生成详细测试报告：

PDCA轮次 X 测试报告
================================
测试类型: [单元测试/集成测试]
测试阶段: [Phase-X]
测试时间: [时间戳]
--------------------------------
测试结果汇总:
- 通过: X
- 失败: Y
- 总计: Z
--------------------------------
详细结果:
[测试用例1] [通过/失败] [描述]
[测试用例2] [通过/失败] [描述]
--------------------------------
结论: [通过/失败]
建议: [改进建议]

阶段四：Act（改进）

4.1 PDCA核心迭代：A↔C循环

PDCA的精髓在于Act与Check之间的紧密迭代，形成 A→C→A→C 的循环直到完全通过：

┌─────────────────────────────────────────────────────────────┐
│                    PDCA迭代核心 (A↔C循环)                    │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   ┌───────────────────────────────────────────────────┐    │
│   │  Act → Check → Act → Check → ... → 通过 → 完成   │    │
│   │    ↓       ↓       ↓       ↓           ↓        │    │
│   │   修复    验证    再修复   再验证      验证通过   │    │
│   └───────────────────────────────────────────────────┘    │
│                                                             │
└─────────────────────────────────────────────────────────────┘

标准流程：

1. Check (检查) → 发现问题
       ↓
2. Act (改进) → 修复问题
       ↓
3. Check (检查) → 验证修复
       ↓
   ┌─── 通过? ───┐
   │              │
  Yes            No
   │              │
   ↓              ↓
 进入下一阶段   Act (再次修复)
                   ↓
              Check (再次验证)
                   ↓
                   ...循环

4.2 Act阶段详细任务

4.2.1 问题分析

步骤	任务	输出
1	分析Check阶段的测试失败日志	问题清单
2	定位问题根源（不是表面现象）	根本原因
3	制定修复方案	修复计划
4	预估修复风险	风险评估

4.2.2 问题修复

步骤	任务	说明
1	按照修复方案修改代码	只改问题代码
2	更新相关文档（如需要）	保持文档同步
3	记录修复内容	写入日志
4	准备重新验证	-

4.2.3 验证循环（核心）

A↔C迭代是一个灵活的过程，可以尝试多种不同的修复方案：

A↔C 迭代 #1:
  Act: 尝试方案A修复问题
    ↓
  Check: 验证
    ↓
    ├─ 通过 → 进入下一问题
    │
    └─ 失败 → A↔C 迭代 #2:
              Act: 尝试方案B
                ↓
              Check: 验证
                ↓
                ├─ 通过 → 进入下一问题
                │
                └─ 失败 → A↔C 迭代 #3:
                          Act: 尝试方案C
                            ↓
                          Check: 验证
                            ↓
                            ...持续尝试直到通过

多次尝试日志记录示例：

[2026-04-07 22:30:15] [Act] [尝试 1/∞] 修复方案A: 增加重试机制
[2026-04-07 22:30:20] [Check] [尝试 1/∞] 验证结果: 失败 (超时)
[2026-04-07 22:30:25] [Act] [尝试 2/∞] 修复方案B: 调整超时阈值为10s
[2026-04-07 22:30:30] [Check] [尝试 2/∞] 验证结果: 失败 (仍超时)
[2026-04-07 22:30:35] [Act] [尝试 3/∞] 修复方案C: 使用连接池管理
[2026-04-07 22:30:40] [Check] [尝试 3/∞] 验证结果: 部分通过
[2026-04-07 22:30:45] [Act] [尝试 4/∞] 修复方案D: 增加异步处理
[2026-04-07 22:30:50] [Check] [尝试 4/∞] 验证结果: 通过
[2026-04-07 22:30:55] [Act] 问题修复完成: 模块A超时

关键点：

不限制尝试次数，直到问题解决
每次尝试记录使用的方案和验证结果
可以尝试完全不同的技术方案
失败不是终点，而是探索过程的一部分

4.3 Check阶段详细任务

4.3.1 验证执行

步骤	任务	说明
1	运行单元测试	快速验证单模块
2	运行集成测试	验证模块交互
3	记录测试结果	写入日志
4	分析失败原因	-

4.3.2 判定逻辑

Check结果判定:
       ↓
┌─── 有失败? ───┐
│                │
Yes              No
│                │
↓                ↓
记录失败      标记通过
↓                ↓
移交Act        进入下一阶段

4.4 A↔C迭代规则

规则	说明
日志强制	每次A或C必须记录日志
渐进式修复	先修复关键问题，再修复次要问题
回归测试	修复后必须运行完整测试套件
多次尝试	可以尝试多种修复方案，直到问题解决
方案记录	每次尝试都要记录，方便后续追溯

4.5 需求迭代

每个需求迭代都遵循完整的PDCA循环：

需求迭代N
    │
    ├─> Plan: 需求分析 → 测试计划 → 测试设计
    │
    ├─> Do: 开发 → 单元测试 → 集成测试
    │
    ├─> Check: 测试验证 → 报告生成
    │         ↓
    │      [发现问题]
    │         ↓
    └─> Act: (A↔C迭代)ⁿ → 问题修复 → 需求确认
                ↓
            需求确认
                ↓
         下一轮PDCA

进度日志格式

标准格式

[YYYY-MM-DD HH:MM:SS] [测试类型] [阶段] [步骤 X/Y] 消息

PDCA进度格式

[PDCA轮次: 1/2] [YYYY-MM-DD HH:MM:SS] [Check] [步骤 2/3] 执行集成测试

示例

[2026-04-07 22:30:15] [单元测试] [Phase-1] [步骤 1/3] 验证测试环境
[2026-04-07 22:30:16] [单元测试] [Phase-1] [步骤 2/3] 执行单元测试
[2026-04-07 22:30:17] [集成测试] [Phase-3] [步骤 3/4] 执行集成测试
[PDCA轮次: 1/2] [2026-04-07 22:30:20] [Check] [步骤 3/3] 生成测试报告

关键规则

规则	描述
测试脚本不可变性	测试脚本在开发期间不能被修改
需要人工批准	任何测试脚本修改需要明确的人工确认
单元测试优先	先通过单元测试，再进行集成测试
PDCA闭环	每个阶段必须完成Plan-Do-Check-Act循环
需求迭代	每次需求迭代都采用TDD方式
全面日志	每个测试必须记录详细日志和进度

调用场景

当出现以下情况时，应调用此skill：

用户想要使用TDD+PDCA方法论启动新项目
用户要求设置测试驱动开发工作流程
用户想要分阶段验证的结构化项目开发
用户需要单元测试和集成测试框架
用户要求需求迭代管理

快速开始

步骤1：创建计划文档

创建 tests/PLAN.md 定义PDCA轮次和测试计划。

步骤2：创建测试结构

mkdir tests\windows\unit
mkdir tests\windows\integration
mkdir tests\linux\unit
mkdir tests\linux\integration
mkdir logs\test-results

步骤3：编写测试脚本

按照PDCA循环，先创建所有单元测试和集成测试脚本。

步骤4：执行PDCA循环

Plan: 确认测试脚本正确
Do: 开发代码并运行测试
Check: 验证测试结果
Act: 修复问题并继续

步骤5：需求迭代

每次新需求都从Plan阶段开始新的PDCA循环。

About