cmake_minimum_required(VERSION 3.20)
project(HanIME_Device_Adaptation LANGUAGES CXX)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)
option(SANITIZE "Adapter ASan/UBSan" OFF)
option(DRAFTOR_PUBLIC_VALIDATION "Run portable public checks; excludes six private historical replay checks" OFF)
if(NOT DRAFTOR_PUBLIC_VALIDATION AND NOT EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/../tools/ble_read_test/run.py")
 message(FATAL_ERROR "Private historical replay tools are absent. Use DRAFTOR_PUBLIC_VALIDATION=ON for the documented public subset; this is not the internal 230-test regression.")
endif()
option(DRAFTOR_USB_ENABLED "Enable USB document transfer product entry" ON)
option(HANIME_SAVE_SUBSTAGE_DIAGNOSTIC "Enable bounded save substage observer" OFF)
set(HANIME_OUTPUT_PROFILE "2" CACHE STRING "0=off, 1=balanced, 2=reuse with original shared quotas; formal profile2; profile0 internal comparison; balanced diagnostics")
if(NOT HANIME_OUTPUT_PROFILE MATCHES "^[012]$")
 message(FATAL_ERROR "Unknown HANIME_OUTPUT_PROFILE")
endif()
get_filename_component(WORKSPACE "${CMAKE_CURRENT_SOURCE_DIR}/../.." ABSOLUTE)
if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/common")
 set(DEPS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies")
 set(COMMON "${DEPS}/common")
 set(CORE "${DEPS}/core")
 set(EXTENSION "${DEPS}/extension")
 set(BASELINE "${DEPS}/s3")
else()
 set(COMMON "${WORKSPACE}/Draftor_EditorCore_v0_1/common")
 set(CORE "${WORKSPACE}/HANIME_Independent_Core")
 set(EXTENSION "${WORKSPACE}/HANIME_Input_Extension")
 set(BASELINE "${WORKSPACE}/Draftor_EditorCore_v0_1/platforms/s3/HANIME_ESP32S3_EnglishWriting_v0_6_SharedCore")
endif()
find_package(Python3 COMPONENTS Interpreter REQUIRED)
execute_process(COMMAND "${Python3_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/scripts/verify_dependencies.py" "${WORKSPACE}" "${CMAKE_CURRENT_SOURCE_DIR}" COMMAND_ERROR_IS_FATAL ANY)
if(SANITIZE)
 add_compile_options(-fsanitize=address,undefined -fno-omit-frame-pointer)
 add_link_options(-fsanitize=address,undefined)
endif()
add_compile_options(-Wall -Wextra -Wpedantic -Werror -fexceptions)
set(HANIME_BASE_ORDER_LOCATE_ENTRIES "8" CACHE STRING "Fixed accepted locate capacity" FORCE)
set(HANIME_BUILD_HOST_ADAPTERS OFF CACHE BOOL "" FORCE)
set(HANIME_BUILD_TESTS OFF CACHE BOOL "" FORCE)
set(HANIME_BUILD_TOOLS OFF CACHE BOOL "" FORCE)
set(HANIME_BUILD_FIXTURES OFF CACHE BOOL "" FORCE)
add_subdirectory("${CORE}" "core")
add_library(extension STATIC "${EXTENSION}/src/composition.cpp" "${EXTENSION}/src/submission.cpp" "${EXTENSION}/src/navigation.cpp" "${EXTENSION}/src/segment_planner.cpp")
target_include_directories(extension PUBLIC "${EXTENSION}/include")
target_link_libraries(extension PUBLIC HanIME::Core)
file(GLOB DOCS CONFIGURE_DEPENDS "${COMMON}/src/hanime_document/*.cpp")
set(COMMON_FILES find_session find_input find_controller find_highlight find_view_model hanime_document_adapter text_stats document body_editor utf8 layout visual_cursor_navigator selection_highlight hanime_document_editor_port body_key_repeat input_router)
set(PLATFORM_FILES runtime_findings_diag stability_diagnostics core_memory operation_profile hanime_document_sd_storage s3_vfs hid_keyboard hid_product_key_adapter font_port menu_font writing_app writing_readers)
set(WRITING ${DOCS})
foreach(n IN LISTS COMMON_FILES)
 list(APPEND WRITING "${COMMON}/${n}.cpp")
endforeach()
foreach(n IN LISTS PLATFORM_FILES)
 list(APPEND WRITING "platform/${n}.cpp")
endforeach()
file(GLOB ADAPTER CONFIGURE_DEPENDS src/*.cpp)
add_library(device_adapter STATIC ${WRITING} ${ADAPTER})
add_subdirectory("${CMAKE_CURRENT_SOURCE_DIR}/../qr" qr)
target_link_libraries(device_adapter PUBLIC draftor_qr)
target_include_directories(device_adapter PUBLIC platform src "${COMMON}" PRIVATE "${CMAKE_CURRENT_BINARY_DIR}" "${DEPS}/release_resources")
target_include_directories(device_adapter PRIVATE "${WORKSPACE}/TestBuilds/menu-font")
target_compile_definitions(device_adapter PUBLIC HANIME_SAVE_SUBSTAGE_DIAGNOSTIC=$<BOOL:${HANIME_SAVE_SUBSTAGE_DIAGNOSTIC}> HANIME_METADATA_CACHE_ENTRIES=128 ASSET_ROOT="${CMAKE_CURRENT_SOURCE_DIR}/assets")
target_compile_definitions(device_adapter PUBLIC HANIME_OUTPUT_PROFILE=${HANIME_OUTPUT_PROFILE})
add_library(wubi_decoder STATIC "${DEPS}/wubi/src/wubi.cpp")
target_include_directories(wubi_decoder PUBLIC "${DEPS}/wubi/include")
target_link_libraries(wubi_decoder PUBLIC HanIME::Core)
target_link_libraries(device_adapter PUBLIC extension wubi_decoder)
option(DRAFTOR_RELEASE_BUILD "Use release identity and disable measurement output" OFF)
target_compile_definitions(device_adapter PUBLIC DRAFTOR_RELEASE_BUILD=$<BOOL:${DRAFTOR_RELEASE_BUILD}>)
set(DRAFTOR_TELEMETRY_PROFILE "0" CACHE STRING "Boot-fixed privacy: 0 OFF, 1 BASIC, 2 DETAILED")
set(DRAFTOR_TELEMETRY_CAPTURE "0" CACHE STRING "Option A ordinary-output gate")
target_compile_definitions(device_adapter PUBLIC DRAFTOR_TELEMETRY_PROFILE=${DRAFTOR_TELEMETRY_PROFILE} DRAFTOR_TELEMETRY_CAPTURE=${DRAFTOR_TELEMETRY_CAPTURE})
if(NOT DRAFTOR_TELEMETRY_PROFILE STREQUAL "0")
 add_subdirectory("${CMAKE_CURRENT_SOURCE_DIR}/../telemetry" telemetry)
 target_link_libraries(device_adapter PUBLIC draftor_telemetry)
endif()
# Host-only fixture publication uses the core-maintained full validator.
add_library(adapter_fixture_publisher STATIC "${CORE}/src/resource_publisher.cpp" "${CORE}/src/host_resource_file.cpp" "${CORE}/src/base_order_build.cpp" "${CORE}/src/base_order_paged_build.cpp" "${CORE}/src/packed_auth_build.cpp")
target_link_libraries(adapter_fixture_publisher PUBLIC HanIME::Core)
add_executable(build_wubi_resource ../tools/build_wubi_resource.cpp src/wubi_auto_safe.cpp)
target_include_directories(build_wubi_resource PRIVATE "${CORE}/src" "${DEPS}/release_resources" src)
target_link_libraries(build_wubi_resource PRIVATE adapter_fixture_publisher)
add_executable(verify_wubi_resource ../tools/verify_wubi_resource.cpp)
target_include_directories(verify_wubi_resource PRIVATE "${CORE}/src")
target_link_libraries(verify_wubi_resource PRIVATE adapter_fixture_publisher)
set(HANIME_RESOURCE_ROOT "" CACHE PATH "Explicit legacy logical fixtures (Host only)")
set(HANIME_INDEX_ROOT "" CACHE PATH "Complete RC staged resources (Host only)")
if(NOT HANIME_RESOURCE_ROOT OR NOT HANIME_INDEX_ROOT)
 message(FATAL_ERROR "Explicit Host resource and index roots required")
endif()
enable_testing()
foreach(case export_editing boundaries export_boundary invalid filenames current_restart disconnect receipt_loss faults cycles start_failure admission protocol)
 add_test(NAME wifi_${case} COMMAND wifi_product_flow ${case})
endforeach()
foreach(test port_risks editing_051 menus_053)
 if(test STREQUAL "port_risks")
  set(testfile host_tests)
 else()
  set(testfile ${test})
 endif()
 file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/${test}_owned.cpp" "#include \"app_test_access.hpp\"\n#include <cstdlib>\n#include <unistd.h>\n#include <cstring>\ninline char* adapter_mkdtemp(char* p){if(std::strncmp(p,\"/tmp/hanime-s3-port-tests-\",25)==0)std::memmove(p,p+5,std::strlen(p+5)+1);return ::mkdtemp(p); }\n#define mkdtemp adapter_mkdtemp\n#include \"${BASELINE}/tests/${testfile}.cpp\"\n")
 add_executable(${test} "${CMAKE_CURRENT_BINARY_DIR}/${test}_owned.cpp")
 target_link_libraries(${test} device_adapter)
 target_include_directories(${test} PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/tests/support")
 add_test(NAME ${test} COMMAND ${test})
endforeach()
file(GLOB ADAPTER_TESTS CONFIGURE_DEPENDS tests/*.cpp)
foreach(testfile IN LISTS ADAPTER_TESTS)
 get_filename_component(test ${testfile} NAME_WE)
 if(NOT DRAFTOR_USB_ENABLED AND test MATCHES "^usb_")
  continue()
 endif()
 add_executable(${test} ${testfile})
 if(test STREQUAL "adapter_tests")
  target_sources(${test} PRIVATE tests/support/allocation_probe.cpp)
  target_link_libraries(${test} adapter_fixture_publisher)
 endif()
 target_link_libraries(${test} device_adapter)
 if(test STREQUAL "presentation_geometry_regression" OR test STREQUAL "presentation_r3" OR test STREQUAL "convergence_r2")
  # Legacy switch fixtures now traverse WB using the frozen build222 bundle.
  target_compile_definitions(${test} PRIVATE RESOURCE_ROOT="${CMAKE_CURRENT_SOURCE_DIR}/../resources/staged" INDEX_ROOT="${CMAKE_CURRENT_SOURCE_DIR}/../resources/staged")
 else()
 target_compile_definitions(${test} PRIVATE RESOURCE_ROOT="${HANIME_RESOURCE_ROOT}" INDEX_ROOT="${HANIME_INDEX_ROOT}")
 endif()
 if(test STREQUAL "behavior_device")
  target_sources(${test} PRIVATE tests/support/switch_allocation_probe.cpp)
  if(NOT DRAFTOR_TELEMETRY_PROFILE STREQUAL "0")
  add_test(NAME behavior_device_pipeline COMMAND behavior_device "${CMAKE_CURRENT_BINARY_DIR}/behavior_host.bin")
  add_test(NAME behavior_device_overload COMMAND behavior_device "${CMAKE_CURRENT_BINARY_DIR}/behavior_overload.bin" overload)
  endif()
 elseif(test STREQUAL "presentation_repair_r1" OR test STREQUAL "convergence_r2")
  target_sources(${test} PRIVATE tests/support/switch_allocation_probe.cpp)
  # Individually registered below.
 elseif(test STREQUAL "presentation_r3")
  target_sources(${test} PRIVATE tests/support/switch_allocation_probe.cpp)
  foreach(case T01 T02 T03 T04 T05 T06 T07 T08 T09 T10 T11 T12 T13 T14 T15 T16 T17 T18 T19 T20 T21)
   add_test(NAME phase2c_r3_${case} COMMAND ${test} ${case})
  endforeach()
 elseif(test STREQUAL "persistent_ime_r2")
  target_sources(${test} PRIVATE tests/support/switch_allocation_probe.cpp)
  foreach(case P1 P2 P3 P4 P5 P6 P7 P8 P9 P10)
   add_test(NAME phase2c_r2_${case} COMMAND ${test} ${case})
  endforeach()
 elseif(test STREQUAL "runtime_layout_2c")
  target_sources(${test} PRIVATE tests/support/switch_allocation_probe.cpp)
  foreach(case S1 S2 S3 S4 S5 S6 S7 S8 S9 S10 S11 S12 S13 S14 S15 S16 S17 S18)
   add_test(NAME phase2c_${case} COMMAND ${test} ${case})
  endforeach()
 elseif(test STREQUAL "vertical_2b")
  foreach(case V1 V2 V3 V4 V5 V6 V7 V8 V9 V10 V11 V12 V13 V14)
   add_test(NAME phase2b_${case} COMMAND ${test} ${case})
  endforeach()
 elseif(test STREQUAL "wifi_product_flow")
  # Registered above with explicit risk scenarios.
 elseif(test STREQUAL "wifi_qr_product")
  target_sources(${test} PRIVATE platform/ST7306_OsptekLpm8.cpp)
  target_include_directories(${test} PRIVATE tests/display_stubs)
  foreach(case lifecycle allocation content screen routing_save)
   add_test(NAME wifi_qr_${case} COMMAND ${test} ${case})
  endforeach()
 elseif(test STREQUAL "shared_boundary_2a")
  target_include_directories(${test} PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/tests")
  foreach(case T1 T2 T3 T4 T5 T6 T7)
   add_test(NAME phase2a_${case} COMMAND ${test} ${case})
  endforeach()
 else()
  add_test(NAME ${test} COMMAND ${test})
 endif()
endforeach()

# Exercise the task-owned SD protocol loops with deterministic faulted SPI/VFS.
foreach(joint_test find_chinese find_session_cases rename_t05 r2_document_menu file_feedback joint_find_menu joint_catalog_diagnostic j04_f2_reentry menu_measure_regression)
 if(TARGET ${joint_test})
  file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/fixtures/${joint_test}")
  set_tests_properties(${joint_test} PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/fixtures/${joint_test}")
 endif()
endforeach()

# unsigned char matches the Xtensa target; these timings are a Host fault model.
add_executable(sd_fault_driver tests/support/sd_fault/driver_probe.cpp libraries/SD/src/sd_diskio.cpp)
target_include_directories(sd_fault_driver PRIVATE tests/support/sd_fault libraries/SD/src platform)
target_compile_options(sd_fault_driver PRIVATE -funsigned-char)
add_test(NAME sd_fault_driver COMMAND sd_fault_driver)

# Accepted P23 event fixtures; no alternate Core/Host or private runtime.
add_executable(ic1_events "${CMAKE_CURRENT_SOURCE_DIR}/../fixtures/ic1_events.cpp")
target_link_libraries(ic1_events device_adapter)
target_include_directories(ic1_events PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/tests")
target_compile_definitions(ic1_events PRIVATE LC1_DIAGNOSTIC_TEST=1 RESOURCE_ROOT="${HANIME_RESOURCE_ROOT}" INDEX_ROOT="${HANIME_INDEX_ROOT}")
add_test(NAME ic1_events COMMAND ic1_events)
add_executable(edit_reselection_ic1 "${CMAKE_CURRENT_SOURCE_DIR}/../fixtures/edit_reselection_ic1.cpp")
target_link_libraries(edit_reselection_ic1 device_adapter)
target_include_directories(edit_reselection_ic1 PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/tests")
target_compile_definitions(edit_reselection_ic1 PRIVATE LC1_DIAGNOSTIC_TEST=1 RESOURCE_ROOT="${CMAKE_CURRENT_SOURCE_DIR}/../resources/staged" INDEX_ROOT="${CMAKE_CURRENT_SOURCE_DIR}/../resources/staged")
add_test(NAME edit_reselection_ic1 COMMAND edit_reselection_ic1)
add_executable(py1_ic1 "${CMAKE_CURRENT_SOURCE_DIR}/../fixtures/py1_ic1.cpp")
target_link_libraries(py1_ic1 device_adapter)
target_include_directories(py1_ic1 PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/tests")
target_compile_definitions(py1_ic1 PRIVATE LC1_DIAGNOSTIC_TEST=1 RESOURCE_ROOT="${HANIME_RESOURCE_ROOT}" INDEX_ROOT="${HANIME_INDEX_ROOT}")
add_test(NAME py1_ic1 COMMAND py1_ic1)
add_executable(mem1_ic1 "${CMAKE_CURRENT_SOURCE_DIR}/../fixtures/mem1_ic1.cpp")
target_link_libraries(mem1_ic1 device_adapter)
target_include_directories(mem1_ic1 PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/tests")
target_compile_definitions(mem1_ic1 PRIVATE LC1_DIAGNOSTIC_TEST=1 RESOURCE_ROOT="${HANIME_RESOURCE_ROOT}" INDEX_ROOT="${HANIME_INDEX_ROOT}")
add_test(NAME mem1_ic1 COMMAND mem1_ic1)
add_executable(lc1_replay "${CMAKE_CURRENT_SOURCE_DIR}/../fixtures/lc1_replay.cpp")
target_link_libraries(lc1_replay device_adapter)
target_include_directories(lc1_replay PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/tests")
target_compile_definitions(lc1_replay PRIVATE LC1_DIAGNOSTIC_TEST=1 RESOURCE_ROOT="${HANIME_RESOURCE_ROOT}" INDEX_ROOT="${HANIME_INDEX_ROOT}")
add_test(NAME lc1_replay COMMAND lc1_replay)
add_executable(lc1_window "${CMAKE_CURRENT_SOURCE_DIR}/../fixtures/lc1_window.cpp")
target_link_libraries(lc1_window device_adapter)
target_include_directories(lc1_window PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/tests")
target_compile_definitions(lc1_window PRIVATE LC1_DIAGNOSTIC_TEST=1 RESOURCE_ROOT="${HANIME_RESOURCE_ROOT}" INDEX_ROOT="${HANIME_INDEX_ROOT}")
add_test(NAME lc1_window COMMAND lc1_window)
add_executable(lc1_owner "${CMAKE_CURRENT_SOURCE_DIR}/../fixtures/lc1_owner.cpp")
target_link_libraries(lc1_owner device_adapter)
target_include_directories(lc1_owner PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/tests")
target_compile_definitions(lc1_owner PRIVATE LC1_DIAGNOSTIC_TEST=1 RESOURCE_ROOT="${HANIME_RESOURCE_ROOT}" INDEX_ROOT="${HANIME_INDEX_ROOT}")
add_test(NAME lc1_owner COMMAND lc1_owner)
add_executable(text512 "${CMAKE_CURRENT_SOURCE_DIR}/../fixtures/text512.cpp")
target_link_libraries(text512 device_adapter)
target_include_directories(text512 PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/tests")
target_compile_definitions(text512 PRIVATE LC1_DIAGNOSTIC_TEST=1 RESOURCE_ROOT="${HANIME_RESOURCE_ROOT}" INDEX_ROOT="${HANIME_INDEX_ROOT}")
add_test(NAME text512 COMMAND text512)
add_executable(continuous_input_ic1 "${CMAKE_CURRENT_SOURCE_DIR}/../fixtures/continuous_input_ic1.cpp")
target_link_libraries(continuous_input_ic1 device_adapter)
target_include_directories(continuous_input_ic1 PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/tests")
target_compile_definitions(continuous_input_ic1 PRIVATE LC1_DIAGNOSTIC_TEST=1 RESOURCE_ROOT="${HANIME_RESOURCE_ROOT}" INDEX_ROOT="${HANIME_INDEX_ROOT}")
add_test(NAME continuous_input_ic1 COMMAND continuous_input_ic1)
add_executable(input_trace_ic1 "${CMAKE_CURRENT_SOURCE_DIR}/../fixtures/input_trace_ic1.cpp")
target_link_libraries(input_trace_ic1 device_adapter)
target_include_directories(input_trace_ic1 PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/tests")
target_compile_definitions(input_trace_ic1 PRIVATE LC1_DIAGNOSTIC_TEST=1 RESOURCE_ROOT="${HANIME_RESOURCE_ROOT}" INDEX_ROOT="${HANIME_INDEX_ROOT}")
add_test(NAME input_trace_ic1 COMMAND input_trace_ic1)
add_executable(punctuation_successor_ic1 "${CMAKE_CURRENT_SOURCE_DIR}/../fixtures/punctuation_successor_ic1.cpp")
target_link_libraries(punctuation_successor_ic1 device_adapter)
target_include_directories(punctuation_successor_ic1 PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/tests")
target_compile_definitions(punctuation_successor_ic1 PRIVATE LC1_DIAGNOSTIC_TEST=1 RESOURCE_ROOT="${HANIME_RESOURCE_ROOT}" INDEX_ROOT="${HANIME_INDEX_ROOT}")
add_test(NAME punctuation_successor_ic1 COMMAND punctuation_successor_ic1)
add_executable(space_commit_ic1 "${CMAKE_CURRENT_SOURCE_DIR}/../fixtures/space_commit_ic1.cpp")
target_link_libraries(space_commit_ic1 device_adapter)
target_include_directories(space_commit_ic1 PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/tests")
target_compile_definitions(space_commit_ic1 PRIVATE LC1_DIAGNOSTIC_TEST=1 RESOURCE_ROOT="${HANIME_RESOURCE_ROOT}" INDEX_ROOT="${HANIME_INDEX_ROOT}")
add_test(NAME space_commit_ic1 COMMAND space_commit_ic1)
add_executable(capacity_lifecycle_ic1 "${CMAKE_CURRENT_SOURCE_DIR}/../fixtures/capacity_lifecycle_ic1.cpp")
target_link_libraries(capacity_lifecycle_ic1 device_adapter)
target_include_directories(capacity_lifecycle_ic1 PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/tests")
target_compile_definitions(capacity_lifecycle_ic1 PRIVATE LC1_DIAGNOSTIC_TEST=1 RESOURCE_ROOT="${HANIME_RESOURCE_ROOT}" INDEX_ROOT="${HANIME_INDEX_ROOT}")
add_test(NAME capacity_lifecycle_ic1 COMMAND capacity_lifecycle_ic1)
add_executable(current_edit_ic1 "${CMAKE_CURRENT_SOURCE_DIR}/../fixtures/current_edit_ic1.cpp")
target_link_libraries(current_edit_ic1 device_adapter)
target_include_directories(current_edit_ic1 PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/tests")
target_compile_definitions(current_edit_ic1 PRIVATE LC1_DIAGNOSTIC_TEST=1 RESOURCE_ROOT="${HANIME_RESOURCE_ROOT}" INDEX_ROOT="${HANIME_INDEX_ROOT}")
add_test(NAME current_edit_ic1 COMMAND current_edit_ic1)
add_executable(admission_choice_ic1 "${CMAKE_CURRENT_SOURCE_DIR}/../fixtures/admission_choice_ic1.cpp")
target_link_libraries(admission_choice_ic1 device_adapter)
target_include_directories(admission_choice_ic1 PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/tests")
target_compile_definitions(admission_choice_ic1 PRIVATE LC1_DIAGNOSTIC_TEST=1 RESOURCE_ROOT="${HANIME_RESOURCE_ROOT}" INDEX_ROOT="${HANIME_INDEX_ROOT}")
add_test(NAME admission_choice_ic1 COMMAND admission_choice_ic1)
add_executable(hidden_display_ic1 "${CMAKE_CURRENT_SOURCE_DIR}/../fixtures/hidden_display_ic1.cpp")
target_link_libraries(hidden_display_ic1 device_adapter)
target_include_directories(hidden_display_ic1 PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/tests")
target_compile_definitions(hidden_display_ic1 PRIVATE LC1_DIAGNOSTIC_TEST=1 RESOURCE_ROOT="${HANIME_RESOURCE_ROOT}" INDEX_ROOT="${HANIME_INDEX_ROOT}")
add_test(NAME hidden_display_ic1 COMMAND hidden_display_ic1)
add_executable(intent_gap_navigation_ic1 "${CMAKE_CURRENT_SOURCE_DIR}/../fixtures/intent_gap_navigation_ic1.cpp")
target_link_libraries(intent_gap_navigation_ic1 device_adapter)
target_include_directories(intent_gap_navigation_ic1 PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/tests")
target_compile_definitions(intent_gap_navigation_ic1 PRIVATE LC1_DIAGNOSTIC_TEST=1 RESOURCE_ROOT="${HANIME_RESOURCE_ROOT}" INDEX_ROOT="${HANIME_INDEX_ROOT}")
add_test(NAME intent_gap_navigation_ic1 COMMAND intent_gap_navigation_ic1)
add_executable(frame_consistency_ic1 "${CMAKE_CURRENT_SOURCE_DIR}/../fixtures/frame_consistency_ic1.cpp")
target_link_libraries(frame_consistency_ic1 device_adapter)
target_include_directories(frame_consistency_ic1 PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/tests")
target_compile_definitions(frame_consistency_ic1 PRIVATE LC1_DIAGNOSTIC_TEST=1 RESOURCE_ROOT="${HANIME_RESOURCE_ROOT}" INDEX_ROOT="${HANIME_INDEX_ROOT}")
add_test(NAME frame_consistency_ic1 COMMAND frame_consistency_ic1)
add_executable(selection_timing_ic1 "${CMAKE_CURRENT_SOURCE_DIR}/../fixtures/selection_timing_ic1.cpp")
target_link_libraries(selection_timing_ic1 device_adapter)
target_include_directories(selection_timing_ic1 PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/tests")
target_compile_definitions(selection_timing_ic1 PRIVATE LC1_DIAGNOSTIC_TEST=1 RESOURCE_ROOT="${HANIME_RESOURCE_ROOT}" INDEX_ROOT="${HANIME_INDEX_ROOT}")
add_test(NAME selection_timing_ic1 COMMAND selection_timing_ic1)

add_executable(display_reset_r1 tests/display_stubs/probe.cpp platform/ST7306_OsptekLpm8.cpp)
target_include_directories(display_reset_r1 PRIVATE tests/display_stubs platform)
target_compile_options(display_reset_r1 PRIVATE -Wall -Wextra -Werror)
add_test(NAME display_reset_r1 COMMAND display_reset_r1)

foreach(case R01 R02 R03 R04 R05 R06 R07 R08 R09 R10 R11 R12 R13 R14 R15 R16 R17 R18)
 add_test(NAME phase2c_r3_r1_${case} COMMAND presentation_repair_r1 ${case})
endforeach()

foreach(case R-A1 R-A2 R-S1 R-B1 R-B2 R-B3 R-C1 R-C2 R-C3 R-G1 R-N1 R-F1 R-D1 R-E1 R-V1)
 add_test(NAME phase2c_r3_r2_${case} COMMAND convergence_r2 ${case})
endforeach()

# Core-frozen product integration; original regression list is retained.
add_executable(wubi_product "${CMAKE_CURRENT_SOURCE_DIR}/../fixtures/wubi_product.cpp")
target_link_libraries(wubi_product PRIVATE device_adapter adapter_fixture_publisher)
add_test(NAME wubi_product COMMAND wubi_product)
add_executable(wubi_raw_edit "${CMAKE_CURRENT_SOURCE_DIR}/../fixtures/wubi_raw_edit.cpp")
target_link_libraries(wubi_raw_edit PRIVATE device_adapter adapter_fixture_publisher)
add_test(NAME wubi_raw_insert_h COMMAND wubi_raw_edit 101)
add_test(NAME wubi_raw_insert_v COMMAND wubi_raw_edit 102)
add_test(NAME wubi_raw_delete_recovery_h COMMAND wubi_raw_edit 103)
add_test(NAME wubi_raw_delete_recovery_v COMMAND wubi_raw_edit 104)
add_test(NAME wubi_raw_reject_boundary_h COMMAND wubi_raw_edit 105)
add_test(NAME wubi_raw_reject_boundary_v COMMAND wubi_raw_edit 106)
add_test(NAME wubi_raw_pending_auto COMMAND wubi_raw_edit 107)
add_executable(wubi_real_resource ../fixtures/wubi_real_resource.cpp tests/support/switch_allocation_probe.cpp)
target_link_libraries(wubi_real_resource PRIVATE device_adapter adapter_fixture_publisher)
target_compile_definitions(wubi_real_resource PRIVATE
 REAL_RESOURCES="${CMAKE_CURRENT_SOURCE_DIR}/../resources/staged"
 REAL_EVIDENCE="${CMAKE_CURRENT_SOURCE_DIR}/../evidence"
 REAL_COST_OUTPUT="${CMAKE_CURRENT_BINARY_DIR}/wubi_real_cost.ndjson")
add_test(NAME wubi_real_resource COMMAND wubi_real_resource)

# Step 3: common product events with the exact build222 real resource.
add_executable(wubi_step3 ../fixtures/wubi_step3.cpp tests/support/switch_allocation_probe.cpp)
target_link_libraries(wubi_step3 PRIVATE device_adapter adapter_fixture_publisher)
target_compile_definitions(wubi_step3 PRIVATE REAL_RESOURCES="${CMAKE_CURRENT_SOURCE_DIR}/../resources/staged")
add_test(NAME wubi_step3_common_h COMMAND wubi_step3 501)
add_test(NAME wubi_step3_common_v COMMAND wubi_step3 502)
add_test(NAME wubi_step3_cycle COMMAND wubi_step3 503)
add_test(NAME wubi_step3_resource_failure COMMAND wubi_step3 504)
add_test(NAME wubi_step3_retry_switch COMMAND wubi_step3 507)

# Step 3R: Host-only generation lifetime proof, reusing repaired legacy ingress.
add_executable(host_owner_generation ../fixtures/host_owner_generation.cpp tests/support/switch_allocation_probe.cpp)
target_include_directories(host_owner_generation PRIVATE tests)
target_link_libraries(host_owner_generation PRIVATE device_adapter)
target_compile_definitions(host_owner_generation PRIVATE
 RESOURCE_ROOT="${CMAKE_CURRENT_SOURCE_DIR}/../resources/staged"
 INDEX_ROOT="${CMAKE_CURRENT_SOURCE_DIR}/../resources/staged")
add_test(NAME host_owner_generation COMMAND host_owner_generation)

# R5 product-event diagnostic / acceptance consumer; no product compile flags.
add_executable(vertical_raw_r5 ../fixtures/vertical_raw_r5.cpp)
target_link_libraries(vertical_raw_r5 PRIVATE device_adapter adapter_fixture_publisher)
target_compile_definitions(vertical_raw_r5 PRIVATE REAL_RESOURCES="${CMAKE_CURRENT_SOURCE_DIR}/../resources/staged")

# build234 physical-key contract: separate runner preserves OFF177 membership.
add_executable(vertical_raw_entry ../fixtures/vertical_raw_entry.cpp)
target_link_libraries(vertical_raw_entry PRIVATE device_adapter adapter_fixture_publisher)
target_compile_definitions(vertical_raw_entry PRIVATE REAL_RESOURCES="${CMAKE_CURRENT_SOURCE_DIR}/../resources/staged")

# build235 isolated Esc runner; OFF membership remains177.
add_executable(esc_lifecycle ../fixtures/esc_lifecycle.cpp)
target_link_libraries(esc_lifecycle PRIVATE device_adapter adapter_fixture_publisher)
target_compile_definitions(esc_lifecycle PRIVATE REAL_RESOURCES="${CMAKE_CURRENT_SOURCE_DIR}/../resources/staged")

add_executable(directexact_reentry ../fixtures/directexact_reentry.cpp)
target_link_libraries(directexact_reentry PRIVATE device_adapter adapter_fixture_publisher)
target_compile_definitions(directexact_reentry PRIVATE REAL_RESOURCES="${CMAKE_CURRENT_SOURCE_DIR}/../resources/staged")

# USB candidate: one shared TXT/session source and the real product owners.
if(DRAFTOR_USB_ENABLED)
 set(EXCHANGE_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/../shared" CACHE PATH "Candidate shared transfer source" FORCE)
 add_subdirectory("${CMAKE_CURRENT_SOURCE_DIR}/../module" usb_module)
 target_sources(device_adapter PRIVATE platform/usb_export_owner.cpp platform/usb_document_import.cpp platform/usb_transfer.cpp platform/wifi_transfer.cpp platform/wifi_qr.cpp)
 target_link_libraries(device_adapter PUBLIC draftor_usb)
 target_compile_definitions(device_adapter PUBLIC DRAFTOR_USB_ENABLED=1)
else()
 target_compile_definitions(device_adapter PUBLIC DRAFTOR_USB_ENABLED=0)
endif()

# Stability A: real TinyUsbMsc implementation with a narrow SDK Host shim.
if(DRAFTOR_USB_ENABLED)
 target_sources(usb_first_init PRIVATE ../module/platform/esp32s3/tinyusb_msc.cpp)
 target_include_directories(usb_first_init PRIVATE tests/support/usb_endpoint ../module/platform/esp32s3 ../module/platform/shared)
 add_test(NAME usb_first_init_guard_failure COMMAND usb_first_init guard-failure)
endif()

if(NOT DRAFTOR_PUBLIC_VALIDATION)
# Stability B1: execute the actual pinned readValue/callback source with Host I/O seams.
add_test(NAME ble_async_read_lifetime
 COMMAND "${Python3_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/../tools/ble_read_test/run.py"
 --mode $<IF:$<BOOL:${SANITIZE}>,sanitize,normal>)
set_tests_properties(ble_async_read_lifetime PROPERTIES TIMEOUT 120 RUN_SERIAL TRUE)

endif()

if(NOT DRAFTOR_PUBLIC_VALIDATION)
# A02: actual target capture and stopped UART function bodies, Host API seams.
add_test(NAME heap_diagnostic_integrity
 COMMAND "${Python3_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/../tools/heap_integrity_test/run.py"
 --mode $<IF:$<BOOL:${SANITIZE}>,sanitize,normal>)
set_tests_properties(heap_diagnostic_integrity PROPERTIES TIMEOUT 120 RUN_SERIAL TRUE)

# B01: original independent counterexample + actual shared-slot BLE successors.
add_test(NAME ble_notification_handoff
 COMMAND "${Python3_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/../tools/ble_notification_test/run.py"
 --mode $<IF:$<BOOL:${SANITIZE}>,sanitize,normal>)
set_tests_properties(ble_notification_handoff PROPERTIES TIMEOUT 180 RUN_SERIAL TRUE)

# A02: actual complete product scheduler with real App/writer.
add_test(NAME heap_stop_scheduler
 COMMAND "${Python3_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/../tools/heap_stop_test/run.py"
 --candidate-only
 --candidate "${CMAKE_CURRENT_SOURCE_DIR}/.."
 --output "${CMAKE_CURRENT_SOURCE_DIR}/../evidence/heap_stop_scheduler"
 --build-tree "${CMAKE_CURRENT_BINARY_DIR}"
 --mode $<IF:$<BOOL:${SANITIZE}>,sanitize,normal>)
set_tests_properties(heap_stop_scheduler PROPERTIES TIMEOUT 180 RUN_SERIAL TRUE)

endif()

# T01 exact descriptor fallback, real WString successors, runner and periodic gate.
if(NOT DRAFTOR_PUBLIC_VALIDATION)
add_test(NAME descriptor_fallback_case2 COMMAND "${Python3_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/../tools/descriptor_test/replay_case2.py" --mode $<IF:$<BOOL:${SANITIZE}>,sanitize,normal>)
add_test(NAME descriptor_lifecycle COMMAND "${Python3_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/../tools/ble_notification_test/run.py" --descriptor --mode $<IF:$<BOOL:${SANITIZE}>,sanitize,normal>)
set_tests_properties(descriptor_fallback_case2 descriptor_lifecycle PROPERTIES TIMEOUT 180 RUN_SERIAL TRUE)
endif()
add_test(NAME ble_runner_rejection COMMAND "${Python3_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/../tools/ble_notification_test/result_gate.py")
add_test(NAME memory_periodic COMMAND "${Python3_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/../tools/memory_periodic_test/run.py" --mode $<IF:$<BOOL:${SANITIZE}>,sanitize,normal>)
set_tests_properties(ble_runner_rejection memory_periodic PROPERTIES TIMEOUT 180 RUN_SERIAL TRUE)

add_test(NAME memory_capture_parser COMMAND "${Python3_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/../tools/parse_memory_capture.py" --self-test)

# T04: actual S3 admission body and PsramDisk with a controlled Host heap.
add_test(NAME usb_inbox_admission COMMAND "${Python3_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/../tools/inbox_admission_test/run.py" --mode $<IF:$<BOOL:${SANITIZE}>,sanitize,normal>)
set_tests_properties(usb_inbox_admission PROPERTIES TIMEOUT 60 RUN_SERIAL TRUE)

# Waveshare port checks reuse actual product owners, not a second persistence model.
add_executable(ws_namespace ../../tools/ws_checks/namespace_contract.cpp platform/board_namespace.cpp)
target_include_directories(ws_namespace PRIVATE ../../tools/ws_checks)
target_link_libraries(ws_namespace device_adapter)
target_compile_definitions(ws_namespace PRIVATE RESOURCE_ROOT="${HANIME_RESOURCE_ROOT}")
add_executable(ws_preview ../../tools/ws_checks/ui_preview.cpp)
target_include_directories(ws_preview PRIVATE ../../tools/ws_checks)
target_link_libraries(ws_preview device_adapter)
target_compile_definitions(ws_preview PRIVATE DRAFTOR_BOARD=WAVESHARE_RLCD42 RESOURCE_ROOT="${HANIME_RESOURCE_ROOT}" INDEX_ROOT="${HANIME_INDEX_ROOT}")
add_executable(ws_storage_regression ../../tools/ws_checks/storage_regression.cpp)
target_link_libraries(ws_storage_regression device_adapter)
target_include_directories(ws_storage_regression PRIVATE tests/support)

# A3 runtime findings R1: exact product F9 block with heap outcome seam.
foreach(r1_test usb_key menu)
 add_executable(runtime_r1_${r1_test} ../../tools/runtime_r1/${r1_test}.cpp)
 target_link_libraries(runtime_r1_${r1_test} PRIVATE device_adapter)
endforeach()

add_executable(runtime_r1_footer ../../tools/runtime_r1/footer_preview.cpp)
target_link_libraries(runtime_r1_footer PRIVATE device_adapter adapter_fixture_publisher)
target_compile_definitions(runtime_r1_footer PRIVATE DRAFTOR_BOARD=WAVESHARE_RLCD42 RESOURCE_ROOT="${HANIME_RESOURCE_ROOT}" INDEX_ROOT="${HANIME_INDEX_ROOT}")

# R5 normal product entry, generated from the actual device block.
add_executable(product_r5_usb_key ../../tools/product_r5/usb_key.cpp)
target_link_libraries(product_r5_usb_key PRIVATE device_adapter)
