PicMe QA 验收测试清单 (QA Execution Checklist)

adb shell am start -W com.mamba.picme/com.mamba.picme.ui.MainActivity

// 在测试代码中注入异常
object TestInject {
    var forceEglFailure = false
}

aapt dump badging app-release.apk | grep uses-permission
tcpdump -i any port 443 -w capture.pcap  # 抓包验证

# 启动性能测试
adb shell am start -W com.mamba.picme/com.mamba.picme.ui.MainActivity

# 开启调试浮层
adb shell setprop picme.debug.perf true

# 清除应用数据
adb shell pm clear com.mamba.picme

# 查看日志
adb logcat -s PicMe:Agent PicMe:BeautyEngine PicMe:*

# 截图
adb shell screencap -p /sdcard/screenshot.png
adb pull /sdcard/screenshot.png

#!/bin/bash
# perf_test.sh

# 冷启动测试
START_TIME=$(adb shell am start -W com.mamba.picme/com.mamba.picme.ui.MainActivity | grep mTotalTime | awk -F= '{print $2}' | awk '{print $1}')
echo "Cold startup: ${START_TIME}ms"

# 帧率测试
adb shell dumpsys SurfaceFlinger --list | grep CameraPreview | while read surface; do
    adb shell dumpsys SurfaceFlinger --stats $surface
done

# 内存测试
adb shell dumpsys meminfo com.mamba.picme | grep Total PSS

/**
 * Agent 测试编排器
 *
 * 支持双模式输入：
 * - 自然语言模式：通过 LLM 解析为 AgentCommand 序列
 * - 格式化模式：直接解析 JSON/YAML 为 AgentCommand
 *
 * 两种模式最终都通过 CapabilityRegistry 执行，并收集结果生成报告。
 */
class AgentTestOrchestrator(
    private val registry: CapabilityRegistry,
    private val reporter: ExecutionReporter,
    private val llmParser: AgentCommandParser? = null  // 自然语言模式需要
) {
    /**
     * 模式 B: 执行格式化的测试用例（P0 回归首选）
     */
    suspend fun <T> execute(case: AgentTestCase<T>): AgentTestResult<T>

    /**
     * 模式 A: 执行自然语言测试意图（探索性测试）
     */
    suspend fun executeIntent(
        naturalLanguage: String,
        context: AgentContext
    ): AgentTestResult<String>

    /**
     * 执行测试套件
     */
    suspend fun executeSuite(suite: TestSuite): SuiteReport

    /**
     * 从 JSON 测试描述生成并执行（支持混合模式）
     */
    suspend fun executeFromJson(json: String): SuiteReport
}

/**
 * Agent 状态探针
 *
 * 通过 CapabilityRegistry 查询应用内部状态，
 * 替代脆弱的截图+图像识别验证方式。
 */
class AgentStateProbe(private val registry: CapabilityRegistry) {

    /**
     * 查询当前场景
     */
    fun currentScene(): SceneManager.Scene

    /**
     * 查询指定 Capability 是否可用
     */
    fun isCapabilityAvailable(capabilityName: String): Boolean

    /**
     * 查询命令在当前场景是否可执行
     */
    fun isCommandAvailable(command: AgentCommand): Boolean

    /**
     * 获取当前页面状态快照
     */
    suspend fun captureStateSnapshot(): StateSnapshot

    /**
     * 等待条件满足（带超时）
     */
    suspend fun waitFor(
        condition: () -> Boolean,
        timeout: Duration = 10.seconds,
        pollInterval: Duration = 500.milliseconds
    ): Boolean
}

{
  "caseId": "TC-CAMERA-03",
  "name": "拍照与 GPU 后处理验证",
  "category": "CAMERA",
  "priority": "P0",
  "steps": [
    {
      "description": "确保在相机页面",
      "if": "scene != 'CAMERA'",
      "then": [{"method": "navigate_to", "params": {"destination": "camera"}}],
      "assert": {"scene": "CAMERA"}
    },
    {
      "description": "确保后置摄像头",
      "if": "lensFacing == 'front'",
      "then": [{"method": "flip_camera", "params": {}}],
      "assert": {"lensFacing": "back"}
    },
    {
      "description": "设置美颜参数",
      "action": {"method": "adjust_beauty", "params": {"smoothing": 80, "whitening": 60}},
      "assert": {"beautySmooth": ">= 80"}
    },
    {
      "description": "触发拍照",
      "action": {"method": "capture", "params": {}},
      "assert": {"commandResult": "success"}
    },
    {
      "description": "验证 GPU 处理耗时",
      "wait": {"condition": "processing == false", "timeout": 5000},
      "assert": {"gpuProcessTimeMs": "< 1000"}
    }
  ]
}

# 动态加载 JSON 测试用例执行
./scripts/agent-tester case scripts/tests/camera/tc-camera-03.json

// 自然语言测试意图
val intent = "拍张照片，然后切换到相册确认照片已保存"

// 由 LLM 解析为命令序列
val commands = llmParser.parseIntent(intent, context)
// 返回: [AgentCommand.CapturePhoto, AgentCommand.NavigateTo("gallery")]

// 顺序执行并验证
commands.forEach { command ->
    val result = registry.dispatch(command, context)
    // 每步都有明确反馈
}

/**
 * TC-CAMERA-03: 拍照与 GPU 后处理验证（Agent 命令版本）
 */
fun tcCamera03CaptureAgent(registry: CapabilityRegistry, probe: AgentStateProbe): 
    AgentTestCase<Map<String, Any>> = agentTestCase("TC-CAMERA-03-A", "拍照与 GPU 后处理验证(Agent)") {
    
    category(TestCategory.CAMERA)
    priority(TestPriority.P0)

    step("确保在相机页面") {
        action { ctx, _ ->
            if (probe.currentScene() != SceneManager.Scene.CAMERA) {
                registry.dispatch(AgentCommand.NavigateTo("camera"), context)
            }
        }
        assertState("当前场景为相机") { _ ->
            probe.currentScene() == SceneManager.Scene.CAMERA
        }
    }

    step("确保后置摄像头") {
        action { ctx, _ ->
            val state = probe.captureStateSnapshot()
            if (state.cameraState?.lensFacing == "front") {
                registry.dispatch(AgentCommand.FlipCamera, context)
            }
        }
        assertState("使用后置摄像头") { state ->
            state["lensFacing"] == "back"
        }
    }

    step("设置美颜参数") {
        action { ctx, _ ->
            val settings = BeautySettings(smoothing = 80f, whitening = 60f)
            val result = registry.dispatch(AgentCommand.AdjustBeauty(settings), context)
            ctx.setMetadata("beautyResult", result.isSuccess.toString())
        }
        assertCommandSuccess("美颜命令执行成功")
        assertState("美颜参数已应用") { state ->
            (state["beautySmooth"] as? Float)?.let { it >= 80f } == true
        }
    }

    step("触发拍照") {
        action { ctx, _ ->
            val result = registry.dispatch(AgentCommand.CapturePhoto, context)
            ctx.setMetadata("captureResult", result.isSuccess.toString())
            
            // 直接解析 AgentAction 获取反馈
            result.getOrNull()?.let { action ->
                when (action) {
                    is AgentAction.Success -> ctx.addLog("Test", "拍照成功")
                    is AgentAction.Error -> ctx.addLog("Test", "拍照错误: ${action.message}")
                    is AgentAction.TextReply -> ctx.addLog("Test", "拍照回复: ${action.message}")
                }
            }
        }
        assertCommandSuccess("拍照命令执行成功")
    }

    step("验证 GPU 处理耗时") {
        action { ctx, _ ->
            // 等待处理完成，通过状态探针轮询
            val completed = probe.waitFor(
                condition = { probe.captureStateSnapshot().isProcessing == false },
                timeout = 5.seconds
            )
            ctx.setMetadata("processingCompleted", completed.toString())
        }
        assertState("GPU 处理已完成") { state ->
            state["isProcessing"] == false
        }
        assertPerformance("GPU 处理耗时 < 1000ms") { perf ->
            (perf["gpuProcessTimeMs"] as? Long)?.let { it < 1000 } == true
        }
    }

    step("截屏记录最终状态") {
        action { ctx, controller ->
            controller.takeScreenshot("after_capture_agent", ctx)
        }
    }

    output { ctx ->
        mapOf(
            "captureSuccess" to (ctx.getMetadata("captureResult") == "true"),
            "beautyApplied" to (ctx.getMetadata("beautyResult") == "true"),
            "screenshotCount" to ctx.screenshots.size
        )
    }
}

/**
 * Agent 命令执行成功断言
 */
fun TestStepBuilder.assertCommandSuccess(description: String) {
    assertions.add(TestAssertion { context ->
        val result = context.getMetadata("lastCommandResult")
        if (result == "success") {
            AssertionResult.Success
        } else {
            AssertionResult.Failure("命令执行未成功: $description")
        }
    })
}

/**
 * Agent 命令返回特定 Action 类型断言
 */
fun TestStepBuilder.assertActionType(
    description: String,
    expectedType: KClass<out AgentAction>
) {
    assertions.add(TestAssertion { context ->
        val typeName = context.getMetadata("lastActionType")
        if (typeName == expectedType.simpleName) {
            AssertionResult.Success
        } else {
            AssertionResult.Failure("期望 Action 类型 ${expectedType.simpleName}，实际为 $typeName")
        }
    })
}

/**
 * 性能指标断言
 */
fun TestStepBuilder.assertPerformance(
    description: String,
    check: (Map<String, Any>) -> Boolean
) {
    assertions.add(TestAssertion { context ->
        val perf = context.toSnapshot().metadata
            .filter { it.key.startsWith("perf_") }
            .mapKeys { it.key.removePrefix("perf_") }
        if (check(perf)) {
            AssertionResult.Success
        } else {
            AssertionResult.Failure("性能断言失败: $description")
        }
    })
}

/**
 * 场景断言
 */
fun TestStepBuilder.assertScene(expectedScene: SceneManager.Scene) {
    assertions.add(TestAssertion { context ->
        val current = context.getMetadata("currentScene")
        if (current == expectedScene.name) {
            AssertionResult.Success
        } else {
            AssertionResult.Failure("期望场景 ${expectedScene.name}，实际为 $current")
        }
    })
}

{
  "suiteName": "Camera-P0-Agent",
  "timestamp": 1717603200000,
  "totalCases": 5,
  "passedCount": 4,
  "failedCount": 1,
  "cases": [
    {
      "caseId": "TC-CAMERA-03-A",
      "caseName": "拍照与 GPU 后处理验证(Agent)",
      "status": "FAILED",
      "failedStep": 3,
      "steps": [
        {"index": 0, "description": "确保在相机页面", "status": "PASSED", "durationMs": 1200},
        {"index": 1, "description": "确保后置摄像头", "status": "PASSED", "durationMs": 800},
        {"index": 2, "description": "设置美颜参数", "status": "PASSED", "durationMs": 600},
        {"index": 3, "description": "触发拍照", "status": "FAILED", "durationMs": 5200, "reason": "命令返回 Error: 相机页面未激活"},
        {"index": 4, "description": "验证 GPU 处理耗时", "status": "SKIPPED", "reason": "前置步骤失败"}
      ],
      "agentActions": [
        {"step": 3, "command": "capture", "actionType": "Error", "message": "相机页面未激活，请先切换到相机页面"}
      ],
      "stateSnapshots": [
        {"step": 0, "scene": "GALLERY", "capabilities": ["GalleryCapability", "NavigationCapability"]},
        {"step": 3, "scene": "GALLERY", "capabilities": ["GalleryCapability", "NavigationCapability"]}
      ],
      "screenshots": [
        {"name": "after_capture_agent", "path": "/sdcard/.../after_capture_agent_123456.png"}
      ],
      "logs": [
        {"tag": "CapabilityRegistry", "message": "[CapturePhoto] Capability CameraCapability unavailable (delegate not bound)", "level": "INFO"}
      ],
      "diagnosis": {
        "rootCause": "相机页面未激活时执行拍照命令",
        "suggestion": "在步骤 0 中 navigateTo(camera) 后添加等待，确保 CameraCapability delegate 已绑定",
        "confidence": "HIGH"
      }
    }
  ]
}

/**
 * 失败自动诊断引擎
 */
object TestFailureDiagnosis {

    fun diagnose(failure: AgentTestResult.Failure<*>): Diagnosis {
        val step = failure.failedStep
        val reason = failure.reason
        val snapshots = failure.context.stateSnapshots
        val currentScene = snapshots.lastOrNull()?.state?.get("scene")

        return when {
            // 诊断 1: 场景不匹配
            reason.contains("未激活") || reason.contains("页面未") -> {
                Diagnosis(
                    rootCause = "目标页面未激活时执行命令",
                    suggestion = "在导航命令后添加 waitForCapabilityAvailable 等待",
                    confidence = DiagnosisConfidence.HIGH,
                    category = DiagnosisCategory.SCENE_MISMATCH
                )
            }

            // 诊断 2: Capability 未注册
            reason.contains("暂不支持") -> {
                Diagnosis(
                    rootCause = "Capability 未注册或命令映射错误",
                    suggestion = "检查 Application.onCreate 中是否注册了对应 Capability",
                    confidence = DiagnosisConfidence.HIGH,
                    category = DiagnosisCategory.CAPABILITY_MISSING
                )
            }

            // 诊断 3: 命令超时
            reason.contains("timed out") -> {
                Diagnosis(
                    rootCause = "命令执行超时",
                    suggestion = "检查是否有阻塞操作，或增加 timeout 配置",
                    confidence = DiagnosisConfidence.MEDIUM,
                    category = DiagnosisCategory.TIMEOUT
                )
            }

            // 诊断 4: GPU 处理超时
            reason.contains("GPU") && reason.contains("超过") -> {
                Diagnosis(
                    rootCause = "GPU 后处理性能不达标",
                    suggestion = "检查美颜参数是否过高，或检测模型是否降级到 CPU",
                    confidence = DiagnosisConfidence.MEDIUM,
                    category = DiagnosisCategory.PERF_REGRESSION
                )
            }

            else -> Diagnosis(
                rootCause = "未知原因: $reason",
                suggestion = "请查看完整日志和截图进行人工分析",
                confidence = DiagnosisConfidence.LOW,
                category = DiagnosisCategory.UNKNOWN
            )
        }
    }
}

/**
 * 测试专用 Capability
 *
 * 仅在测试模式下注册，提供生产环境不需要的诊断能力。
 */
class TestDiagnosticsCapability : Capability {
    override fun name(): String = "TestDiagnostics"
    override fun activeScenes(): List<SceneManager.Scene> = emptyList() // 全场景
    override fun supportedCommands(): List<String> = listOf(
        "get_internal_state",
        "trigger_gc",
        "dump_memory",
        "simulate_low_memory"
    )
    override fun execute(command: AgentCommand, context: AgentContext, pageContext: PageContext?): Result<AgentAction> {
        // 实现诊断命令
    }
}

./gradlew :app:installDebug --no-daemon

adb shell pm list packages | grep com.mamba.picme

adb shell settings put secure enabled_accessibility_services com.mamba.picme/.accessibility.PicMeAccessibilityService

adb shell settings get secure enabled_accessibility_services

adb shell am start -n com.mamba.picme/.MainActivity

adb forward tcp:27183 tcp:27183

adb forward --list

python3 scripts/ui_driver.py --help

python3 scripts/ui_driver.py dump

# 通过 contentDescription 点击搜索按钮
python3 scripts/ui_driver.py click --content-description "搜索照片"

# 通过文本点击（会匹配包含该文本的节点）
python3 scripts/ui_driver.py click --text "2026-07-02"

# 通过 bounds 点击（需要传入 JSON）
python3 scripts/ui_driver.py click --bounds '{"left":758,"top":205,"right":836,"bottom":283}'

python3 scripts/ui_driver.py long-click --content-description "搜索照片"

# 先点击搜索进入搜索模式
python3 scripts/ui_driver.py click --content-description "搜索照片"

# 通过 bounds 在搜索框输入文本（bounds 从 dump 输出中复制）
python3 scripts/ui_driver.py input \
  --bounds '{"left":325,"top":166,"right":1135,"bottom":322}' \
  --value "猫"

python3 scripts/ui_driver.py back

python3 scripts/ui_driver.py swipe \
  --start-x 600 --start-y 2000 \
  --end-x 600 --end-y 500 \
  --duration 300

python3 scripts/ui_driver.py find --content-description "关闭搜索"

python3 scripts/verify_ui_driver.py

# 1. 安装 debug APK
./gradlew :app:installDebug --no-daemon

# 2. 启用 AccessibilityService
adb shell settings put secure enabled_accessibility_services com.mamba.picme/.accessibility.PicMeAccessibilityService

# 3. 启动应用
adb shell am start -n com.mamba.picme/.MainActivity

# 4. 等待应用启动
sleep 3

# 5. 建立端口转发
adb forward tcp:27183 tcp:27183

# 6. 查看界面
python3 scripts/ui_driver.py dump

# 7. 执行集成验证
python3 scripts/verify_ui_driver.py

export PYTHONPATH="$(pwd)/scripts:$PYTHONPATH"
python3 scripts/verify_ui_driver.py