TestHarness.cpp

/*
Copyright © 2019, 2020, 2021, 2022 HackEDA, Inc.
Licensed under the WiPhone Public License v.1.0 (the "License"); you
may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://wiphone.io/WiPhone_Public_License_v1.0.txt.
*/

#include "TestHarness.h"

#ifdef WIPHONE_TEST_HARNESS

#include "GUI.h"
#include "Hardware.h"
#include "src/system_benchmark/SystemBenchmarkKernels.h"
#include "src/system_benchmark/SystemBenchmarkProfile.h"
#include "src/system_benchmark/SystemBenchmarkStore.h"
#include "esp_heap_caps.h"
#include "driver/uart.h"

#include <stdarg.h>

extern "C" unsigned D_DoomStage(void);
extern "C" void WiPhoneDoomAudioTelemetry(uint32_t* mixedBlocks,
                                          uint32_t* submittedBlocks,
                                          uint32_t* writeFailures,
                                          uint32_t* activeChannels,
                                          int* running);
extern "C" uint32_t WiPhoneDoomAudioReadPeak(uint32_t frames, uint32_t timeoutMs);
extern "C" void WiPhoneDoomMusicDiag(int *ready, int *songActive,
                                     uint32_t *renderPeak);

namespace {

struct HarnessKey {
  const char* name;
  char code;
  uint32_t mask;
};

const HarnessKey HARNESS_KEYS[] = {
  { "0", '0', WIPHONE_KEY_MASK_0 },
  { "1", '1', WIPHONE_KEY_MASK_1 },
  { "2", '2', WIPHONE_KEY_MASK_2 },
  { "3", '3', WIPHONE_KEY_MASK_3 },
  { "4", '4', WIPHONE_KEY_MASK_4 },
  { "5", '5', WIPHONE_KEY_MASK_5 },
  { "6", '6', WIPHONE_KEY_MASK_6 },
  { "7", '7', WIPHONE_KEY_MASK_7 },
  { "8", '8', WIPHONE_KEY_MASK_8 },
  { "9", '9', WIPHONE_KEY_MASK_9 },
  { "STAR", '*', WIPHONE_KEY_MASK_ASTERISK },
  { "HASH", '#', WIPHONE_KEY_MASK_HASH },
  { "UP", WIPHONE_KEY_UP, WIPHONE_KEY_MASK_UP },
  { "DOWN", WIPHONE_KEY_DOWN, WIPHONE_KEY_MASK_DOWN },
  { "LEFT", WIPHONE_KEY_LEFT, WIPHONE_KEY_MASK_LEFT },
  { "RIGHT", WIPHONE_KEY_RIGHT, WIPHONE_KEY_MASK_RIFHT },
  { "OK", WIPHONE_KEY_OK, WIPHONE_KEY_MASK_OK },
  { "BACK", WIPHONE_KEY_BACK, WIPHONE_KEY_MASK_BACK },
  { "SELECT", WIPHONE_KEY_SELECT, WIPHONE_KEY_MASK_SELECT },
  { "CALL", WIPHONE_KEY_CALL, WIPHONE_KEY_MASK_CALL },
  { "END", WIPHONE_KEY_END, WIPHONE_KEY_MASK_END },
  { "F1", WIPHONE_KEY_F1, WIPHONE_KEY_MASK_F1 },
  { "F2", WIPHONE_KEY_F2, WIPHONE_KEY_MASK_F2 },
  { "F3", WIPHONE_KEY_F3, WIPHONE_KEY_MASK_F3 },
  { "F4", WIPHONE_KEY_F4, WIPHONE_KEY_MASK_F4 },
};

bool appendFormat(char* output, size_t capacity, size_t& length,
                  const char* format, ...) {
  if (length >= capacity) {
    return false;
  }
  va_list arguments;
  va_start(arguments, format);
  int written = vsnprintf(output + length, capacity - length, format, arguments);
  va_end(arguments);
  if (written < 0 || static_cast<size_t>(written) >= capacity - length) {
    return false;
  }
  length += static_cast<size_t>(written);
  return true;
}

bool parseCanonicalMask(const char* text, uint32_t& mask) {
  if (text == NULL || strlen(text) != 8u) {
    return false;
  }
  uint32_t value = 0u;
  for (const char* cursor = text; *cursor != '\0'; ++cursor) {
    uint8_t digit;
    if (*cursor >= '0' && *cursor <= '9') {
      digit = static_cast<uint8_t>(*cursor - '0');
    } else if (*cursor >= 'A' && *cursor <= 'F') {
      digit = static_cast<uint8_t>(*cursor - 'A' + 10);
    } else {
      return false;
    }
    value = (value << 4) | digit;
  }
  mask = value;
  return true;
}

uint8_t completedTestPrefix(const SystemBenchmarkRunResult& run) {
  uint8_t count = 0u;
  while (count < SYSTEM_BENCHMARK_TEST_COUNT &&
         run.tests[count].medianUs != 0u) {
    ++count;
  }
  return count;
}

bool standardResultIsOfficial(const SystemBenchmarkRunResult& run) {
  if (!systemBenchmarkProfileAllowsOfficialPass() || !run.safeCleanup ||
      run.status != SYSTEM_BENCHMARK_PASS || run.globalScore == 0u ||
      completedTestPrefix(run) != SYSTEM_BENCHMARK_TEST_COUNT) {
    return false;
  }
  for (uint8_t index = 0u; index < SYSTEM_BENCHMARK_TEST_COUNT; ++index) {
    if (run.tests[index].status != SYSTEM_BENCHMARK_PASS ||
        run.tests[index].actualCrc != run.tests[index].expectedCrc ||
        run.tests[index].score == 0u) {
      return false;
    }
  }
  for (uint8_t index = 0u; index < SYSTEM_BENCHMARK_DOMAIN_COUNT; ++index) {
    if (run.domains[index].status != SYSTEM_BENCHMARK_PASS ||
        run.domains[index].score == 0u) {
      return false;
    }
  }
  return true;
}

const char* systemBenchmarkRunStatus(
    const SystemBenchmarkRunResult& run, bool extended) {
  if (!run.safeCleanup || run.status == SYSTEM_BENCHMARK_UNSAFE) {
    return "UNSAFE";
  }
  switch (run.status) {
    case SYSTEM_BENCHMARK_PASS:
      break;
    case SYSTEM_BENCHMARK_CALIBRATION:
      return "CALIBRATION";
    case SYSTEM_BENCHMARK_INVALID:
      return "INVALID";
    case SYSTEM_BENCHMARK_BLOCKED:
      return "BLOCKED";
    case SYSTEM_BENCHMARK_CANCELLED:
      return "CANCELLED";
    case SYSTEM_BENCHMARK_FAIL:
      return "FAIL";
    default:
      return "FAIL";
  }
  if (!extended) {
    return "PASS";
  }

  bool anyPass = false;
  bool anyFailure = false;
  bool anyUnsafe = false;
  for (uint8_t index = 0u;
       index < run.extended.diagnosticCount; ++index) {
    SystemBenchmarkDiagnosticStatus status = run.extended.diagnostics[index].status;
    anyPass = anyPass || status == SYSTEM_BENCHMARK_DIAGNOSTIC_PASS;
    anyFailure = anyFailure || status == SYSTEM_BENCHMARK_DIAGNOSTIC_FAIL;
    anyUnsafe = anyUnsafe || status == SYSTEM_BENCHMARK_DIAGNOSTIC_UNSAFE;
  }
  if (anyUnsafe) {
    return "UNSAFE";
  }
  if (anyFailure) {
    return "DIAG_FAIL";
  }
  return anyPass ? "PASS" : "SKIP";
}

char diagnosticWireStatus(SystemBenchmarkDiagnosticStatus status) {
  switch (status) {
    case SYSTEM_BENCHMARK_DIAGNOSTIC_PASS: return 'P';
    case SYSTEM_BENCHMARK_DIAGNOSTIC_FAIL: return 'F';
    case SYSTEM_BENCHMARK_DIAGNOSTIC_UNSAFE: return 'U';
    case SYSTEM_BENCHMARK_DIAGNOSTIC_NOT_RUN:
    case SYSTEM_BENCHMARK_DIAGNOSTIC_SKIP:
    default: return 'S';
  }
}

} // namespace

WiPhoneTestHarness::WiPhoneTestHarness()
  : lineLength(0), droppingLine(false), frame(NULL), frameWidth(0), frameHeight(0),
    tilesAcross(0), tilesDown(0), nextTile(0), frameNumber(0), frameCrc(0),
    responseSequence(0), heldMask(0), sendingFrame(false),
    systemBenchmarkSequence(0), systemBenchmarkMask(0),
    systemBenchmarkActive(false), systemBenchmarkExtended(false)
#ifdef BUILD_GAMES
    , benchmarkSequence(0), gameFpsSequence(0), gameFpsActive(false)
#endif
{
  line[0] = '\0';
}

WiPhoneTestHarness::~WiPhoneTestHarness() {
  if (frame) {
    heap_caps_free(frame);
  }
}

void WiPhoneTestHarness::begin() {
  int length = snprintf(tx, sizeof(tx), "@WP1,0,READY,%s,%u,%u\r\n",
                        FIRMWARE_VERSION, (unsigned)TFT_WIDTH, (unsigned)TFT_HEIGHT);
  if (length > 0 && (size_t)length < sizeof(tx)) {
    writeTx(length);
  }
}

void WiPhoneTestHarness::poll(GUI& gui, RingBuffer<char>& keypadBuffer) {
  if (systemBenchmarkActive) {
    serviceSystemBenchmark(gui, keypadBuffer);
    return;
  }
  pollInput(gui, keypadBuffer);
  serviceGameFps(gui);
  if (sendingFrame) {
    sendNextTile();
  }
}

void WiPhoneTestHarness::serviceGameFps(GUI& gui) {
#ifdef BUILD_GAMES
  if (!gameFpsActive) {
    return;
  }

  bool ready = false;
  bool passed = false;
  const char* error = "APP_ENDED";
  uint32_t intervals = 0;
  uint32_t frames = 0;
  uint32_t wallUs = 0;
  uint32_t renderCount = 0;
  uint64_t renderSumUs = 0;
  uint32_t renderMinUs = 0;
  uint32_t renderMaxUs = 0;
  uint32_t lcdCount = 0;
  uint64_t lcdSumUs = 0;
  uint32_t lcdMinUs = 0;
  uint32_t lcdMaxUs = 0;
  uint32_t lateCount = 0;
  uint64_t lateSumUs = 0;
  uint32_t lateMaxUs = 0;
  uint32_t totalCompletions = 0;

  bool available = gui.gravityPerformanceForTest(
      ready, passed, error, intervals, frames, wallUs,
      renderCount, renderSumUs, renderMinUs, renderMaxUs,
      lcdCount, lcdSumUs, lcdMinUs, lcdMaxUs,
      lateCount, lateSumUs, lateMaxUs, totalCompletions);
  if (available && !ready) {
    return;
  }
  if (!available) {
    ready = true;
    passed = false;
    error = "APP_ENDED";
  }

  int length = snprintf(
      tx, sizeof(tx),
      "@WP1,%u,GAME_FPS,GRAVITY,V2,%s,%s,%u,%u,%u,"
      "%u,%llu,%u,%u,%u,%llu,%u,%u,%u,%llu,%u,%u\r\n",
      (unsigned)gameFpsSequence, passed ? "PASS" : "FAIL",
      error != NULL ? error : "UNKNOWN", (unsigned)intervals,
      (unsigned)frames, (unsigned)wallUs, (unsigned)renderCount,
      (unsigned long long)renderSumUs, (unsigned)renderMinUs,
      (unsigned)renderMaxUs, (unsigned)lcdCount,
      (unsigned long long)lcdSumUs, (unsigned)lcdMinUs,
      (unsigned)lcdMaxUs, (unsigned)lateCount,
      (unsigned long long)lateSumUs, (unsigned)lateMaxUs,
      (unsigned)totalCompletions);
  if (length > 0 && (size_t)length < sizeof(tx)) {
    writeTx(length);
  } else {
    writeResponse(gameFpsSequence, "ERR", "REPORT_OVERFLOW");
  }
  gui.clearGravityPerformanceForTest();
  gameFpsActive = false;
#endif
}

void WiPhoneTestHarness::serviceSystemBenchmark(
    GUI& gui, RingBuffer<char>& keypadBuffer) {
  const SystemBenchmarkRunResult* run = NULL;
  uint64_t totalUs = 0u;
  uint32_t offset = 0u;
  const char* error = NULL;
  bool available = gui.systemBenchmarkResultForTest(
      run, totalUs, offset, error);
  (void)offset;
  if (available && run == NULL) {
    return;
  }

  resetQueuedInput(keypadBuffer);
  if (!available) {
    writeResponse(systemBenchmarkSequence, "ERR",
                  error != NULL ? error : "SYSTEM_BENCH_APP_ENDED");
    systemBenchmarkActive = false;
    return;
  }

  ReportFormatStatus format = formatSystemBenchmarkReport(gui, *run, totalUs);
  if (format == REPORT_FORMAT_OK) {
    writeTx(strlen(tx));
  } else {
    writeResponse(systemBenchmarkSequence, "ERR",
                  format == REPORT_FORMAT_OVERFLOW
                      ? "REPORT_OVERFLOW" : "REPORT_INVALID");
  }
  systemBenchmarkActive = false;
}

WiPhoneTestHarness::ReportFormatStatus
WiPhoneTestHarness::formatSystemBenchmarkReport(
    GUI& gui, const SystemBenchmarkRunResult& run, uint64_t totalUs) {
  static_assert(SYSTEM_BENCHMARK_DIAGNOSTIC_COUNT == 6,
                "SYSEXT240V1 report requires six diagnostics");
  if (totalUs == 0u || run.profileId[0] == '\0' || run.buildId[0] == '\0') {
    return REPORT_FORMAT_INVALID;
  }

  uint8_t completed = completedTestPrefix(run);
  for (uint8_t index = completed;
       index < SYSTEM_BENCHMARK_TEST_COUNT; ++index) {
    if (run.tests[index].medianUs != 0u) {
      return REPORT_FORMAT_INVALID;
    }
  }

  const char* wireRun = systemBenchmarkRunStatus(run, systemBenchmarkExtended);
  char extendedCrc[9] = "-";
  if (systemBenchmarkExtended) {
    snprintf(extendedCrc, sizeof(extendedCrc), "%08X",
             static_cast<unsigned>(SYSTEM_BENCHMARK_EXTENDED_PROFILE.crc));
  }
  bool official = standardResultIsOfficial(run) &&
      strcmp(wireRun, "UNSAFE") != 0 && strcmp(wireRun, "FAIL") != 0 &&
      strcmp(wireRun, "INVALID") != 0 && strcmp(wireRun, "BLOCKED") != 0;
  bool goldenMatch = systemBenchmarkProfileAllowsOfficialPass() &&
                     completed == SYSTEM_BENCHMARK_TEST_COUNT;
  for (uint8_t index = 0u; goldenMatch &&
       index < SYSTEM_BENCHMARK_TEST_COUNT; ++index) {
    goldenMatch = run.tests[index].actualCrc == run.tests[index].expectedCrc;
  }
  uint32_t workCrc = completed != 0u
      ? systemBenchmarkWorkCrc(run.tests, completed) : 0u;
  const SystemBenchmarkTestDescriptor* failureDescriptor = NULL;
  bool goldenFailure = run.firstFailure.testId != 0;
  if (goldenFailure) {
    failureDescriptor = systemBenchmarkFindTest(run.firstFailure.testId);
    if (failureDescriptor == NULL || run.firstFailure.actualCrc == 0u ||
        run.firstFailure.actualCrc == run.firstFailure.expectedCrc ||
        run.firstFailure.expectedCrc != failureDescriptor->expectedCrc ||
        (run.status != SYSTEM_BENCHMARK_INVALID &&
         strcmp(wireRun, "UNSAFE") != 0)) {
      return REPORT_FORMAT_INVALID;
    }
  } else if (run.status == SYSTEM_BENCHMARK_INVALID) {
    return REPORT_FORMAT_INVALID;
  }
  if (official && (!goldenMatch || workCrc != run.workCrc)) {
    return REPORT_FORMAT_INVALID;
  }

  uint8_t baselineStatus = 0u;
  uint32_t baselineGlobalScore = 0u;
  int32_t baselineDeltaBasisPoints = 0;
  if (!gui.systemBenchmarkBaselineForTest(
          baselineStatus, baselineGlobalScore, baselineDeltaBasisPoints)) {
    baselineStatus = static_cast<uint8_t>(
        SystemBenchmarkStore::BASELINE_NONE);
  }
  bool compatibleBaseline = official &&
      baselineStatus == static_cast<uint8_t>(
          SystemBenchmarkStore::BASELINE_MATCH) &&
      baselineGlobalScore != 0u;
  const char* baselineWire = compatibleBaseline ? "COMPATIBLE" :
      (baselineStatus == static_cast<uint8_t>(
           SystemBenchmarkStore::BASELINE_NONE) ? "NONE" : "INCOMPATIBLE");

  size_t length = 0u;
  tx[0] = '\0';
  if (!appendFormat(tx, sizeof(tx), length,
                    "@WP1,%u,SYSTEM_BENCH,V1,run=%s,off=%u,safe=%u,"
                    "p=%s,pid=%s,xid=%s,bid=%s,fw=%s,pc=%08X,xc=%s,"
                    "hw=%08X,gold=",
                    static_cast<unsigned>(systemBenchmarkSequence), wireRun,
                    official ? 1u : 0u, run.safeCleanup ? 1u : 0u,
                    systemBenchmarkExtended ? "EXTENDED" : "STANDARD",
                    run.profileId,
                    systemBenchmarkExtended
                        ? SYSTEM_BENCHMARK_EXTENDED_PROFILE.id : "-",
                    run.buildId, FIRMWARE_VERSION,
                    static_cast<unsigned>(run.profileCrc),
                    extendedCrc,
                    static_cast<unsigned>(run.hardwareCrc))) {
    return REPORT_FORMAT_OVERFLOW;
  }

  if (goldenFailure) {
    if (!appendFormat(tx, sizeof(tx), length, "0")) {
      return REPORT_FORMAT_OVERFLOW;
    }
  } else if (goldenMatch) {
    if (!appendFormat(tx, sizeof(tx), length, "1")) {
      return REPORT_FORMAT_OVERFLOW;
    }
  } else if (!appendFormat(tx, sizeof(tx), length, "-")) {
    return REPORT_FORMAT_OVERFLOW;
  }

  if (!appendFormat(tx, sizeof(tx), length, ",wc=")) {
    return REPORT_FORMAT_OVERFLOW;
  }
  if (completed != 0u) {
    if (!appendFormat(tx, sizeof(tx), length, "%08X",
                      static_cast<unsigned>(workCrc))) {
      return REPORT_FORMAT_OVERFLOW;
    }
  } else if (!appendFormat(tx, sizeof(tx), length, "-")) {
    return REPORT_FORMAT_OVERFLOW;
  }

  if (!appendFormat(tx, sizeof(tx), length, ",ac=")) {
    return REPORT_FORMAT_OVERFLOW;
  }
  for (uint8_t index = 0u; index < SYSTEM_BENCHMARK_TEST_COUNT; ++index) {
    if (index != 0u && !appendFormat(tx, sizeof(tx), length, ";")) {
      return REPORT_FORMAT_OVERFLOW;
    }
    if (index < completed) {
      if (!appendFormat(tx, sizeof(tx), length, "%08X",
                        static_cast<unsigned>(run.tests[index].actualCrc))) {
        return REPORT_FORMAT_OVERFLOW;
      }
    } else if (!appendFormat(tx, sizeof(tx), length, "-")) {
      return REPORT_FORMAT_OVERFLOW;
    }
  }

  if (!appendFormat(tx, sizeof(tx), length, ",fail=")) {
    return REPORT_FORMAT_OVERFLOW;
  }
  if (goldenFailure) {
    if (!appendFormat(tx, sizeof(tx), length, "%s:%08X:%08X",
                      failureDescriptor->name,
                      static_cast<unsigned>(run.firstFailure.expectedCrc),
                      static_cast<unsigned>(run.firstFailure.actualCrc))) {
      return REPORT_FORMAT_OVERFLOW;
    }
  } else if (!appendFormat(tx, sizeof(tx), length, "-")) {
    return REPORT_FORMAT_OVERFLOW;
  }

  if (!appendFormat(tx, sizeof(tx), length, ",n=")) {
    return REPORT_FORMAT_OVERFLOW;
  }
  for (uint8_t index = 0u; index < SYSTEM_BENCHMARK_TEST_COUNT; ++index) {
    if (!appendFormat(tx, sizeof(tx), length, "%s%u",
                      index == 0u ? "" : ";",
                      index < completed
                          ? SYSTEM_BENCHMARK_REPETITION_COUNT : 0u)) {
      return REPORT_FORMAT_OVERFLOW;
    }
  }

  if (!appendFormat(tx, sizeof(tx), length, ",med=")) {
    return REPORT_FORMAT_OVERFLOW;
  }
  for (uint8_t index = 0u; index < SYSTEM_BENCHMARK_TEST_COUNT; ++index) {
    if (index != 0u && !appendFormat(tx, sizeof(tx), length, ";")) {
      return REPORT_FORMAT_OVERFLOW;
    }
    if (index < completed) {
      if (!appendFormat(tx, sizeof(tx), length, "%u",
                        static_cast<unsigned>(run.tests[index].medianUs))) {
        return REPORT_FORMAT_OVERFLOW;
      }
    } else if (!appendFormat(tx, sizeof(tx), length, "-")) {
      return REPORT_FORMAT_OVERFLOW;
    }
  }

  if (!appendFormat(tx, sizeof(tx), length, ",ss=")) {
    return REPORT_FORMAT_OVERFLOW;
  }
  for (uint8_t index = 0u; index < SYSTEM_BENCHMARK_TEST_COUNT; ++index) {
    if (!appendFormat(tx, sizeof(tx), length, "%s",
                      index == 0u ? "" : ";")) {
      return REPORT_FORMAT_OVERFLOW;
    }
    if (official) {
      if (!appendFormat(tx, sizeof(tx), length, "%u",
                        static_cast<unsigned>(run.tests[index].score))) {
        return REPORT_FORMAT_OVERFLOW;
      }
    } else if (!appendFormat(tx, sizeof(tx), length, "-")) {
      return REPORT_FORMAT_OVERFLOW;
    }
  }

  if (!appendFormat(tx, sizeof(tx), length, ",ds=")) {
    return REPORT_FORMAT_OVERFLOW;
  }
  for (uint8_t index = 0u; index < SYSTEM_BENCHMARK_DOMAIN_COUNT; ++index) {
    if (!appendFormat(tx, sizeof(tx), length, "%s",
                      index == 0u ? "" : ";")) {
      return REPORT_FORMAT_OVERFLOW;
    }
    if (official) {
      if (!appendFormat(tx, sizeof(tx), length, "%u",
                        static_cast<unsigned>(run.domains[index].score))) {
        return REPORT_FORMAT_OVERFLOW;
      }
    } else if (!appendFormat(tx, sizeof(tx), length, "-")) {
      return REPORT_FORMAT_OVERFLOW;
    }
  }

  if (!appendFormat(tx, sizeof(tx), length, ",gs=")) {
    return REPORT_FORMAT_OVERFLOW;
  }
  if (official) {
    if (!appendFormat(tx, sizeof(tx), length, "%u",
                      static_cast<unsigned>(run.globalScore))) {
      return REPORT_FORMAT_OVERFLOW;
    }
  } else if (!appendFormat(tx, sizeof(tx), length, "-")) {
    return REPORT_FORMAT_OVERFLOW;
  }

  if (!appendFormat(tx, sizeof(tx), length, ",bl=%s,bg=",
                    baselineWire)) {
    return REPORT_FORMAT_OVERFLOW;
  }
  if (compatibleBaseline) {
    if (!appendFormat(tx, sizeof(tx), length, "%u",
                      static_cast<unsigned>(baselineGlobalScore))) {
      return REPORT_FORMAT_OVERFLOW;
    }
  } else if (!appendFormat(tx, sizeof(tx), length, "-")) {
    return REPORT_FORMAT_OVERFLOW;
  }
  if (!appendFormat(tx, sizeof(tx), length, ",bd=")) {
    return REPORT_FORMAT_OVERFLOW;
  }
  if (compatibleBaseline) {
    if (!appendFormat(tx, sizeof(tx), length, "%ld",
                      static_cast<long>(baselineDeltaBasisPoints))) {
      return REPORT_FORMAT_OVERFLOW;
    }
  } else if (!appendFormat(tx, sizeof(tx), length, "-")) {
    return REPORT_FORMAT_OVERFLOW;
  }

  if (!appendFormat(tx, sizeof(tx), length, ",xm=%08X,xd=",
                    static_cast<unsigned>(systemBenchmarkExtended
                        ? systemBenchmarkMask : 0u))) {
    return REPORT_FORMAT_OVERFLOW;
  }
  if (!systemBenchmarkExtended) {
    if (!appendFormat(tx, sizeof(tx), length, "-")) {
      return REPORT_FORMAT_OVERFLOW;
    }
  } else {
    if (run.extended.diagnosticCount != SYSTEM_BENCHMARK_DIAGNOSTIC_COUNT) {
      return REPORT_FORMAT_INVALID;
    }
    for (uint8_t index = 0u;
         index < SYSTEM_BENCHMARK_DIAGNOSTIC_COUNT; ++index) {
      const SystemBenchmarkDiagnosticResult& diagnostic =
          run.extended.diagnostics[index];
      const SystemBenchmarkExtendedDiagnosticDescriptor& descriptor =
          SYSTEM_BENCHMARK_EXTENDED_PROFILE.diagnostics[index];
      bool selected = descriptor.maskBit == 0u ||
                      (systemBenchmarkMask & descriptor.maskBit) != 0u;
      bool skipped = diagnostic.status ==
                         SYSTEM_BENCHMARK_DIAGNOSTIC_NOT_RUN ||
                     diagnostic.status == SYSTEM_BENCHMARK_DIAGNOSTIC_SKIP;
      if ((!selected && !skipped) ||
          (skipped && (diagnostic.bytes != 0u ||
                       diagnostic.durationUs != 0u)) ||
          (!skipped && diagnostic.durationUs == 0u) ||
          (diagnostic.status == SYSTEM_BENCHMARK_DIAGNOSTIC_PASS &&
           descriptor.reportsBytes && diagnostic.bytes == 0u)) {
        return REPORT_FORMAT_INVALID;
      }
      if (!appendFormat(tx, sizeof(tx), length, "%s%c:%u:%u",
                        index == 0u ? "" : ";",
                        diagnosticWireStatus(diagnostic.status),
                        skipped ? 0u : static_cast<unsigned>(diagnostic.bytes),
                        skipped ? 0u :
                            static_cast<unsigned>(diagnostic.durationUs))) {
        return REPORT_FORMAT_OVERFLOW;
      }
    }
  }

  if (!appendFormat(tx, sizeof(tx), length, ",tm=%llu\r\n",
                    static_cast<unsigned long long>(totalUs))) {
    return REPORT_FORMAT_OVERFLOW;
  }
  return REPORT_FORMAT_OK;
}

void WiPhoneTestHarness::resetQueuedInput(
    RingBuffer<char>& keypadBuffer) {
  uart_flush_input(UART_NUM_0);
  lineLength = 0u;
  droppingLine = false;
  heldMask = 0u;
  while (!keypadBuffer.empty()) {
    keypadBuffer.get();
  }
}

bool WiPhoneTestHarness::isBenchmarkExclusive() const {
#ifdef BUILD_GAMES
  return benchmark.isActive() || benchmark.hasResult();
#else
  return false;
#endif
}

void WiPhoneTestHarness::serviceBenchmark(
    GUI& gui, RingBuffer<char>& keypadBuffer) {
#ifdef BUILD_GAMES
  benchmark.service(gui);
  if (!benchmark.hasResult()) {
    return;
  }

  uart_flush_input(UART_NUM_0);
  lineLength = 0;
  droppingLine = false;
  heldMask = 0;
  while (!keypadBuffer.empty()) {
    keypadBuffer.get();
  }

  const GravityBenchmarkResult& result = benchmark.getResult();
  int length = snprintf(
      tx, sizeof(tx),
      "@WP1,%u,BENCH,GRAVITY,V2,%s,%s,%s,%s,240,320,RGB565,%u,%u,%08X,"
      "%u,%u,%u,%u,%u,%llu,%d,%u,%08X,%08X,"
      "%u,%llu,%u,%u,%u,%llu,%u,%u,%u,%llu,%u,%u,%u,%llu,%u\r\n",
      (unsigned)benchmarkSequence,
      result.passed ? "PASS" : "FAIL", result.error,
      GravityBenchmark::PROFILE, FIRMWARE_VERSION,
      (unsigned)GRAVITY_DISPLAY_SPI_FREQUENCY, (unsigned)result.cpuMHz,
      (unsigned)result.profileCrc,
      (unsigned)result.steps, (unsigned)result.simulationMs,
      (unsigned)result.gameMs, (unsigned)result.frames,
      (unsigned)result.pushes, (unsigned long long)result.wallUs,
      result.finishResult, (unsigned)result.finishStep,
      (unsigned)result.workCrc, (unsigned)result.frameCrc,
      (unsigned)result.physics.count,
      (unsigned long long)result.physics.sumUs,
      (unsigned)result.physics.reportedMin(),
      (unsigned)result.physics.maxUs,
      (unsigned)result.render.count,
      (unsigned long long)result.render.sumUs,
      (unsigned)result.render.reportedMin(),
      (unsigned)result.render.maxUs,
      (unsigned)result.lcd.count,
      (unsigned long long)result.lcd.sumUs,
      (unsigned)result.lcd.reportedMin(),
      (unsigned)result.lcd.maxUs,
      (unsigned)result.lateFrames,
      (unsigned long long)result.lateSumUs,
      (unsigned)result.lateMaxUs);
  if (length > 0 && (size_t)length < sizeof(tx)) {
    writeTx(length);
  } else {
    writeResponse(benchmarkSequence, "ERR", "REPORT_OVERFLOW");
  }
  benchmark.clearResult();
#endif
}

void WiPhoneTestHarness::pollInput(GUI& gui, RingBuffer<char>& keypadBuffer) {
  uint8_t input;
  while (uart_read_bytes(UART_NUM_0, &input, 1, 0) == 1) {
    char ch = (char)input;
    if (ch == '\r' || ch == '\n') {
      if (droppingLine) {
        droppingLine = false;
        lineLength = 0;
        writeResponse(0, "ERR", "LINE_TOO_LONG");
        return;
      }
      if (lineLength) {
        line[lineLength] = '\0';
        processLine(gui, keypadBuffer);
        lineLength = 0;
        return;
      }
      continue;
    }

    if (droppingLine) {
      continue;
    }
    if (lineLength + 1 >= sizeof(line)) {
      droppingLine = true;
      continue;
    }
    line[lineLength++] = ch;
  }
}

void WiPhoneTestHarness::processLine(GUI& gui, RingBuffer<char>& keypadBuffer) {
  static const size_t MAX_FIELDS = 6;
  char* fields[MAX_FIELDS];
  size_t fieldCount = 1;
  fields[0] = line;

  for (char* cursor = line; *cursor; ++cursor) {
    if (*cursor == ',') {
      *cursor = '\0';
      if (fieldCount >= MAX_FIELDS) {
        writeResponse(0, "ERR", "BAD_COMMAND");
        return;
      }
      fields[fieldCount++] = cursor + 1;
    }
  }

  uint32_t sequence;
  if (fieldCount < 3 || strcmp(fields[0], "@WP1") ||
      !parseSequence(fields[1], sequence) || !fields[2][0]) {
    writeResponse(0, "ERR", "BAD_COMMAND");
    return;
  }

  const char* command = fields[2];
  if (!strcmp(command, "PING")) {
    if (fieldCount != 3) {
      writeResponse(sequence, "ERR", "BAD_PING_COMMAND");
      return;
    }
    writeResponse(sequence, "OK", "PONG");
    return;
  }

  if (!strcmp(command, "INFO")) {
    if (fieldCount != 3) {
      writeResponse(sequence, "ERR", "BAD_INFO_COMMAND");
      return;
    }
    int length = snprintf(tx, sizeof(tx),
                          "@WP1,%u,INFO,%s,%u,%u,%u,%u,%08X\r\n",
                          (unsigned)sequence, FIRMWARE_VERSION,
                          (unsigned)TFT_WIDTH, (unsigned)TFT_HEIGHT,
                          (unsigned)ESP.getFreeHeap(),
                          (unsigned)ESP.getFreePsram(),
                          (unsigned)heldMask);
    if (length > 0 && (size_t)length < sizeof(tx)) {
      writeTx(length);
    }
    return;
  }

  if (gui.systemBenchmarkIsRunningForTest() && strcmp(command, "STATE")) {
    writeResponse(sequence, "ERR", "SYSTEM_BENCH_BUSY");
    return;
  }

  if (!strcmp(command, "SYSTEM_BENCH_START")) {
    bool extended = false;
    uint32_t diagnosticMask = 0u;
    if (fieldCount == 4u && !strcmp(fields[3], "STANDARD")) {
      extended = false;
    } else if (fieldCount == 5u && !strcmp(fields[3], "EXTENDED") &&
               parseCanonicalMask(fields[4], diagnosticMask)) {
      extended = true;
    } else {
      writeResponse(sequence, "ERR", "BAD_SYSTEM_BENCH_START_COMMAND");
      return;
    }

    uint32_t allowedMask = 0u;
    for (uint8_t index = 0u;
         index < SYSTEM_BENCHMARK_EXTENDED_PROFILE.diagnosticCount; ++index) {
      allowedMask |= SYSTEM_BENCHMARK_EXTENDED_PROFILE.diagnostics[index].maskBit;
    }
    if ((!extended && diagnosticMask != 0u) ||
        (diagnosticMask & ~allowedMask) != 0u) {
      writeResponse(sequence, "ERR", "SYSTEM_BENCH_BAD_MASK");
      return;
    }
    if (systemBenchmarkActive || gui.systemBenchmarkIsRunningForTest()) {
      writeResponse(sequence, "ERR", "SYSTEM_BENCH_BUSY");
      return;
    }
#ifdef BUILD_GAMES
    if (benchmark.isActive() || benchmark.hasResult()) {
      writeResponse(sequence, "ERR", "BENCH_BUSY");
      return;
    }
    if (gameFpsActive) {
      writeResponse(sequence, "ERR", "GAME_FPS_BUSY");
      return;
    }
#endif
    if (sendingFrame) {
      writeResponse(sequence, "ERR", "FRAME_BUSY");
      return;
    }
    if (gui.state.locked) {
      writeResponse(sequence, "ERR", "PHONE_LOCKED");
      return;
    }

    const char* error = NULL;
    if (!gui.startSystemBenchmarkForTest(error) ||
        !gui.startSystemBenchmarkRunForTest(
            extended, diagnosticMask, error)) {
      writeResponse(sequence, "ERR",
                    error != NULL ? error : "SYSTEM_BENCH_INIT_FAILED");
      return;
    }
    if (frame != NULL) {
      heap_caps_free(frame);
      frame = NULL;
    }
    heldMask = 0u;
    while (!keypadBuffer.empty()) {
      keypadBuffer.get();
    }
    systemBenchmarkSequence = sequence;
    systemBenchmarkMask = diagnosticMask;
    systemBenchmarkExtended = extended;
    systemBenchmarkActive = true;
    return;
  }

  if (!strcmp(command, "BENCH_START")) {
    if (fieldCount != 3) {
      writeResponse(sequence, "ERR", "BAD_BENCH_START_COMMAND");
      return;
    }
    if (systemBenchmarkActive || gui.systemBenchmarkIsRunningForTest()) {
      writeResponse(sequence, "ERR", "SYSTEM_BENCH_BUSY");
      return;
    }
#ifdef BUILD_GAMES
    if (benchmark.isActive() || benchmark.hasResult()) {
      writeResponse(sequence, "ERR", "BENCH_BUSY");
      return;
    }
    if (gameFpsActive) {
      writeResponse(sequence, "ERR", "GAME_FPS_BUSY");
      return;
    }
    if (sendingFrame) {
      writeResponse(sequence, "ERR", "FRAME_BUSY");
      return;
    }
    if (gui.state.locked) {
      writeResponse(sequence, "ERR", "PHONE_LOCKED");
      return;
    }
    if (frame != NULL) {
      heap_caps_free(frame);
      frame = NULL;
    }
    heldMask = 0;
    while (!keypadBuffer.empty()) {
      keypadBuffer.get();
    }
    const char* error = NULL;
    if (!benchmark.start(gui, error)) {
      writeResponse(sequence, "ERR", error != NULL ? error : "BENCH_INIT_FAILED");
      return;
    }
    benchmarkSequence = sequence;
#else
    writeResponse(sequence, "ERR", "BENCH_UNAVAILABLE");
#endif
    return;
  }

  if (!strcmp(command, "GAME_FPS_START")) {
    if (fieldCount != 3) {
      writeResponse(sequence, "ERR", "BAD_GAME_FPS_START_COMMAND");
      return;
    }
    if (systemBenchmarkActive || gui.systemBenchmarkIsRunningForTest()) {
      writeResponse(sequence, "ERR", "SYSTEM_BENCH_BUSY");
      return;
    }
#ifdef BUILD_GAMES
    if (gameFpsActive) {
      writeResponse(sequence, "ERR", "GAME_FPS_BUSY");
      return;
    }
    if (sendingFrame) {
      writeResponse(sequence, "ERR", "FRAME_BUSY");
      return;
    }
    if (benchmark.isActive() || benchmark.hasResult()) {
      writeResponse(sequence, "ERR", "BENCH_BUSY");
      return;
    }
    const char* error = NULL;
    if (!gui.startGravityPerformanceForTest(error)) {
      writeResponse(sequence, "ERR",
                    error != NULL ? error : "GAME_FPS_INIT_FAILED");
      return;
    }
    gameFpsSequence = sequence;
    gameFpsActive = true;
#else
    writeResponse(sequence, "ERR", "GAME_FPS_UNAVAILABLE");
#endif
    return;
  }

  if (!strcmp(command, "STATE")) {
    if (fieldCount != 3) {
      writeResponse(sequence, "ERR", "BAD_STATE_COMMAND");
      return;
    }
    int length = snprintf(tx, sizeof(tx),
                          "@WP1,%u,STATE,%u,%u,%u\r\n",
                          (unsigned)sequence,
                          gui.state.locked ? 1u : 0u,
                          (unsigned)gui.currentAppForTest(),
                          (unsigned)gui.currentMenuForTest());
    if (length > 0 && (size_t)length < sizeof(tx)) {
      writeTx(length);
    }
    return;
  }

  if (!strcmp(command, "GAME")) {
    if (fieldCount != 3) {
      writeResponse(sequence, "ERR", "BAD_GAME_COMMAND");
      return;
    }
    uint8_t appView;
    uint8_t sessionState;
    int8_t set;
    int8_t track;
    int8_t league;
    int8_t openTrack;
    int8_t openLeague;
    uint32_t elapsedMs;
    if (!gui.gravityStateForTest(appView, sessionState, set, track, league,
                                 openTrack, openLeague, elapsedMs)) {
      writeResponse(sequence, "ERR", "GRAVITY_NOT_RUNNING");
      return;
    }
    int length = snprintf(tx, sizeof(tx),
                          "@WP1,%u,GAME,GRAVITY,%u,%u,%d,%d,%d,%d,%d,%u\r\n",
                          (unsigned)sequence, (unsigned)appView,
                          (unsigned)sessionState, (int)set, (int)track,
                          (int)league, (int)openTrack, (int)openLeague,
                          (unsigned)elapsedMs);
    if (length > 0 && (size_t)length < sizeof(tx)) {
      writeTx(length);
    }
    return;
  }

#ifdef BUILD_GAMES
  if (!strcmp(command, "DOOM")) {
    if (fieldCount != 3) {
      writeResponse(sequence, "ERR", "BAD_DOOM_COMMAND");
      return;
    }
    bool active;
    bool runtimeRunning;
    bool runtimeFailed;
    size_t stackFree;
    uint32_t displayReadyCalls;
    uint32_t submittedFrames;
    uint32_t completedFrames;
    uint64_t completionSpanUs;
    uint32_t lastTransferDurationUs;
    bool framebufferGuardsValid;
    uint32_t frameCrc;
    uint32_t paletteCrc;
    uint16_t uniqueIndexes;
    uint32_t dominantPixels;
    const char* error;
    if (!gui.doomStateForTest(active, runtimeRunning, runtimeFailed,
                              stackFree, displayReadyCalls, submittedFrames,
                              completedFrames, completionSpanUs,
                              lastTransferDurationUs, framebufferGuardsValid,
                              frameCrc, paletteCrc, uniqueIndexes,
                              dominantPixels, error)) {
      writeResponse(sequence, "ERR", "DOOM_NOT_RUNNING");
      return;
    }
    int length = snprintf(
        tx, sizeof(tx),
        "@WP1,%u,DOOM,%u,%u,%u,%u,%u,%u,%u,%llu,%u,%u,%u,%08X,%08X,%u,%u,%s\r\n",
        (unsigned)sequence, active ? 1u : 0u,
        runtimeRunning ? 1u : 0u, runtimeFailed ? 1u : 0u,
        (unsigned)stackFree, (unsigned)displayReadyCalls,
        (unsigned)submittedFrames, (unsigned)completedFrames,
        (unsigned long long)completionSpanUs,
        (unsigned)lastTransferDurationUs, D_DoomStage(),
        framebufferGuardsValid ? 1u : 0u, (unsigned)frameCrc,
        (unsigned)paletteCrc, (unsigned)uniqueIndexes,
        (unsigned)dominantPixels, error != NULL ? error : "-");
    if (length > 0 && (size_t)length < sizeof(tx)) {
      writeTx(length);
    }
    return;
  }

  if (!strcmp(command, "DOOM_AUDIO")) {
    if (fieldCount != 3) {
      writeResponse(sequence, "ERR", "BAD_DOOM_AUDIO_COMMAND");
      return;
    }
    uint32_t mixedBlocks = 0;
    uint32_t submittedBlocks = 0;
    uint32_t writeFailures = 0;
    uint32_t activeChannels = 0;
    int running = 0;
    WiPhoneDoomAudioTelemetry(&mixedBlocks, &submittedBlocks, &writeFailures,
                              &activeChannels, &running);
    // Sample the microphone for ~90 ms to capture acoustic output from the
    // loudspeaker (objective end-to-end check of the analog path).
    uint32_t micPeak = WiPhoneDoomAudioReadPeak(1024u, 90u);
    int musicReady = 0;
    int musicSongActive = 0;
    uint32_t musicPeak = 0;
    WiPhoneDoomMusicDiag(&musicReady, &musicSongActive, &musicPeak);
    int length = snprintf(
        tx, sizeof(tx), "@WP1,%u,DOOM_AUDIO,%u,%u,%u,%u,%u,%u,%u,%u,%u\r\n",
        (unsigned)sequence, running ? 1u : 0u, (unsigned)mixedBlocks,
        (unsigned)submittedBlocks, (unsigned)writeFailures,
        (unsigned)activeChannels, (unsigned)micPeak, musicReady ? 1u : 0u,
        musicSongActive ? 1u : 0u, (unsigned)musicPeak);
    if (length > 0 && (size_t)length < sizeof(tx)) {
      writeTx(length);
    }
    return;
  }
#endif  // BUILD_GAMES

  if (!strcmp(command, "GAME_START")) {
    uint8_t set;
    uint8_t track;
    uint8_t league;
    if (fieldCount != 6 || !parseIndex(fields[3], 2, set) ||
        !parseIndex(fields[4], 63, track) ||
        !parseIndex(fields[5], 3, league)) {
      writeResponse(sequence, "ERR", "BAD_GAME_START_COMMAND");
      return;
    }
    if (gui.state.locked) {
      writeResponse(sequence, "ERR", "PHONE_LOCKED");
      return;
    }
    if (!gui.startGravityLevelForTest(set, track, league)) {
      writeResponse(sequence, "ERR", "GAME_START_FAILED");
      return;
    }
    writeResponse(sequence, "OK", "GAME_STARTED");
    return;
  }

  if (!strcmp(command, "APP")) {
    if (fieldCount != 4) {
      writeResponse(sequence, "ERR", "BAD_APP_COMMAND");
      return;
    }
    if (gui.state.locked) {
      writeResponse(sequence, "ERR", "PHONE_LOCKED");
      return;
    }
    bool started = false;
    if (!strcmp(fields[3], "GRAVITY")) {
      started = gui.startGravityForTest();
    } else if (!strcmp(fields[3], "DOOM")) {
      started = gui.startDoomForTest();
    } else {
      writeResponse(sequence, "ERR", "BAD_APP_COMMAND");
      return;
    }
    if (!started) {
      writeResponse(sequence, "ERR", "APP_START_FAILED");
      return;
    }
    writeResponse(sequence, "OK", fields[3]);
    return;
  }

  if (!strcmp(command, "KEY")) {
    if (fieldCount != 5 || !fields[3][0] || !fields[4][0]) {
      writeResponse(sequence, "ERR", "BAD_KEY_COMMAND");
      return;
    }
    processKey(sequence, fields[3], fields[4], keypadBuffer);
    return;
  }

  if (!strcmp(command, "SYNC")) {
    if (fieldCount != 3) {
      writeResponse(sequence, "ERR", "BAD_SYNC_COMMAND");
      return;
    }
    heldMask = 0;
    writeResponse(sequence, "OK", "SYNCED");
    return;
  }

  if (!strcmp(command, "FB_GET")) {
    if (fieldCount != 4 || strcmp(fields[3], "AUTO")) {
      writeResponse(sequence, "ERR", "BAD_FB_COMMAND");
      return;
    }
    requestFrame(sequence, gui);
    return;
  }

  writeResponse(sequence, "ERR", "UNKNOWN_COMMAND");
}

void WiPhoneTestHarness::processKey(uint32_t sequence, const char* action, const char* name,
                                    RingBuffer<char>& keypadBuffer) {
  char code;
  uint32_t mask;
  if (!lookupKey(name, code, mask)) {
    writeResponse(sequence, "ERR", "UNKNOWN_KEY");
    return;
  }

  if (!strcmp(action, "TAP")) {
    if (keypadBuffer.full()) {
      writeResponse(sequence, "ERR", "KEY_BUFFER_FULL");
      return;
    }
    keypadBuffer.put(code);
  } else if (!strcmp(action, "KD")) {
    if (!(heldMask & mask)) {
      if (keypadBuffer.full()) {
        writeResponse(sequence, "ERR", "KEY_BUFFER_FULL");
        return;
      }
      heldMask |= mask;
      keypadBuffer.put(code);
    }
  } else if (!strcmp(action, "KU")) {
    heldMask &= ~mask;
  } else {
    writeResponse(sequence, "ERR", "UNKNOWN_KEY_ACTION");
    return;
  }

  int length = snprintf(tx, sizeof(tx), "@WP1,%u,OK,KEY,%s,%s,%08X\r\n",
                        (unsigned)sequence, action, name, (unsigned)heldMask);
  if (length > 0 && (size_t)length < sizeof(tx)) {
    writeTx(length);
  }
}

void WiPhoneTestHarness::requestFrame(uint32_t sequence, GUI& gui) {
  if (systemBenchmarkActive) {
    writeResponse(sequence, "ERR", "SYSTEM_BENCH_BUSY");
    return;
  }
#ifdef BUILD_GAMES
  if (gameFpsActive) {
    writeResponse(sequence, "ERR", "GAME_FPS_BUSY");
    return;
  }
#endif
  if (sendingFrame) {
    writeResponse(sequence, "ERR", "FRAME_BUSY");
    return;
  }

  if (!frame) {
    frame = static_cast<uint8_t*>(heap_caps_malloc(MAX_FRAME_BYTES,
                                                   MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT));
    if (!frame) {
      writeResponse(sequence, "ERR", "NO_FRAME_MEMORY");
      return;
    }
  }

  if (!gui.copyFrameBufferRgb565Be(frame, MAX_FRAME_BYTES, frameWidth, frameHeight)) {
    writeResponse(sequence, "ERR", "FRAME_CAPTURE_FAILED");
    return;
  }

  size_t frameBytes = (size_t)frameWidth * frameHeight * sizeof(uint16_t);
  frameCrc = crc32(frame, frameBytes);
  ++frameNumber;
  responseSequence = sequence;
  tilesAcross = (frameWidth + TILE_SIZE - 1) / TILE_SIZE;
  tilesDown = (frameHeight + TILE_SIZE - 1) / TILE_SIZE;
  nextTile = 0;
  sendingFrame = true;

  int length = snprintf(tx, sizeof(tx),
                        "@WP1,%u,FB_BEGIN,%u,%u,%u,RGB565BE,%u\r\n",
                        (unsigned)responseSequence, (unsigned)frameNumber,
                        (unsigned)frameWidth, (unsigned)frameHeight,
                        (unsigned)(tilesAcross * tilesDown));
  if (length > 0 && (size_t)length < sizeof(tx)) {
    writeTx(length);
  }
}

void WiPhoneTestHarness::sendNextTile() {
  static const size_t MAX_BURST_BYTES = 16 * 1024;
  uint16_t totalTiles = tilesAcross * tilesDown;
  size_t burstBytes = 0;

  while (sendingFrame) {
    if (nextTile >= totalTiles) {
      int length = snprintf(tx, sizeof(tx), "@WP1,%u,FB_END,%u,%08X\r\n",
                            (unsigned)responseSequence, (unsigned)frameNumber,
                            (unsigned)frameCrc);
      if (length > 0 && (size_t)length < sizeof(tx)) {
        writeTx(length);
      }
      sendingFrame = false;
      return;
    }
    if (burstBytes >= MAX_BURST_BYTES) {
      return;
    }

    uint16_t tileX = nextTile % tilesAcross;
    uint16_t tileY = nextTile / tilesAcross;
    uint16_t x = tileX * TILE_SIZE;
    uint16_t y = tileY * TILE_SIZE;
    uint16_t width = min<uint16_t>(TILE_SIZE, frameWidth - x);
    uint16_t height = min<uint16_t>(TILE_SIZE, frameHeight - y);
    size_t rowBytes = width * sizeof(uint16_t);
    size_t tileBytes = rowBytes * height;

    for (uint16_t row = 0; row < height; ++row) {
      memcpy(tile + (size_t)row * rowBytes,
             frame + ((size_t)(y + row) * frameWidth + x) * sizeof(uint16_t),
             rowBytes);
    }

    uint32_t tileCrc = crc32(tile, tileBytes);
    int prefix = snprintf(tx, sizeof(tx),
                          "@WP1,%u,FB_TILE,%u,%u,%u,%u,%u,%u,",
                          (unsigned)responseSequence, (unsigned)frameNumber,
                          (unsigned)nextTile, (unsigned)x, (unsigned)y,
                          (unsigned)width, (unsigned)height);
    if (prefix <= 0 || (size_t)prefix >= sizeof(tx)) {
      sendingFrame = false;
      return;
    }

    size_t encoded = encodeBase64(tile, tileBytes, tx + prefix,
                                  sizeof(tx) - prefix - 12);
    if (!encoded) {
      sendingFrame = false;
      writeResponse(responseSequence, "ERR", "FRAME_ENCODING_FAILED");
      return;
    }

    int suffix = snprintf(tx + prefix + encoded, sizeof(tx) - prefix - encoded,
                          ",%08X\r\n", (unsigned)tileCrc);
    if (suffix <= 0 || (size_t)suffix >= sizeof(tx) - prefix - encoded) {
      sendingFrame = false;
      return;
    }

    size_t packetBytes = prefix + encoded + suffix;
    writeTx(packetBytes);
    burstBytes += packetBytes;
    ++nextTile;
  }
}

void WiPhoneTestHarness::writeResponse(uint32_t sequence, const char* status, const char* detail) {
  int length = snprintf(tx, sizeof(tx), "@WP1,%u,%s,%s\r\n",
                        (unsigned)sequence, status, detail);
  if (length > 0 && (size_t)length < sizeof(tx)) {
    writeTx(length);
  }
}

void WiPhoneTestHarness::writeTx(size_t length) {
  uart_write_bytes(UART_NUM_0, tx, length);
}

bool WiPhoneTestHarness::parseSequence(const char* text, uint32_t& sequence) {
  if (!text || !*text) {
    return false;
  }

  uint32_t value = 0;
  for (const char* cursor = text; *cursor; ++cursor) {
    if (*cursor < '0' || *cursor > '9') {
      return false;
    }
    uint32_t digit = (uint32_t)(*cursor - '0');
    if (value > (UINT32_MAX - digit) / 10u) {
      return false;
    }
    value = value * 10u + digit;
  }
  if (!value) {
    return false;
  }

  sequence = value;
  return true;
}

bool WiPhoneTestHarness::parseIndex(const char* text, uint8_t maximum,
                                    uint8_t& value) {
  if (!text || !*text) {
    return false;
  }
  uint16_t parsed = 0;
  for (const char* cursor = text; *cursor; ++cursor) {
    if (*cursor < '0' || *cursor > '9') {
      return false;
    }
    parsed = parsed * 10u + (uint16_t)(*cursor - '0');
    if (parsed > maximum) {
      return false;
    }
  }
  value = (uint8_t)parsed;
  return true;
}

bool WiPhoneTestHarness::lookupKey(const char* name, char& code, uint32_t& mask) {
  for (size_t i = 0; i < sizeof(HARNESS_KEYS) / sizeof(HARNESS_KEYS[0]); ++i) {
    if (!strcasecmp(name, HARNESS_KEYS[i].name)) {
      code = HARNESS_KEYS[i].code;
      mask = HARNESS_KEYS[i].mask;
      return true;
    }
  }
  return false;
}

uint32_t WiPhoneTestHarness::crc32(const uint8_t* data, size_t length) {
  uint32_t crc = 0xFFFFFFFFu;
  while (length--) {
    crc ^= *data++;
    for (uint8_t bit = 0; bit < 8; ++bit) {
      crc = (crc >> 1) ^ (0xEDB88320u & (uint32_t)-(int32_t)(crc & 1));
    }
  }
  return ~crc;
}

size_t WiPhoneTestHarness::encodeBase64(const uint8_t* data, size_t length,
                                        char* output, size_t capacity) {
  static const char alphabet[] =
    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  size_t required = ((length + 2) / 3) * 4;
  if (capacity < required) {
    return 0;
  }

  size_t input = 0;
  size_t written = 0;
  while (input + 3 <= length) {
    uint32_t value = ((uint32_t)data[input] << 16) |
                     ((uint32_t)data[input + 1] << 8) |
                     data[input + 2];
    output[written++] = alphabet[(value >> 18) & 0x3F];
    output[written++] = alphabet[(value >> 12) & 0x3F];
    output[written++] = alphabet[(value >> 6) & 0x3F];
    output[written++] = alphabet[value & 0x3F];
    input += 3;
  }

  if (input < length) {
    uint32_t value = (uint32_t)data[input] << 16;
    output[written++] = alphabet[(value >> 18) & 0x3F];
    if (input + 1 < length) {
      value |= (uint32_t)data[input + 1] << 8;
      output[written++] = alphabet[(value >> 12) & 0x3F];
      output[written++] = alphabet[(value >> 6) & 0x3F];
      output[written++] = '=';
    } else {
      output[written++] = alphabet[(value >> 12) & 0x3F];
      output[written++] = '=';
      output[written++] = '=';
    }
  }

  return written;
}

#endif // WIPHONE_TEST_HARNESS