CMakeLists.txt

cmake_minimum_required(VERSION 3.16)
project(ECCE CXX C Fortran)

# ------------------------------------------------------------------------
# This replaces the wx-independent portion of the old build_ecce / recursive
# Makefile system (build/build_ecce, build/make/Makefile.*). It targets the
# distro-packaged versions of wxWidgets/Xerces-C/Mesa rather than building
# vendored copies from build/3rdparty-dists/ as the old system did.
#
# Status: covers src/util, src/tdat, src/dsm, src/viz, src/comm, src/inv
# (minus src/inv/wxinv, which needs wxWidgets and hasn't been ported to
# wx 3.2 yet). src/apps, src/wxgui, src/wxviz are not yet included here -
# they need the wx 2.8->3.2 port first. See
# claude/ecce-modernization-status.md in the project docs for full status.
# ------------------------------------------------------------------------

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
# Every .c (not .C) file in this tree (under src/inv/dbnodes,
# src/inv/flclient, src/inv/image, src/wxgui/wxplotctrl)
# is vendored ~1990s third-party C, riddled with K&R-style empty-parens
# forward declarations (e.g. `char *foo();`, later defined and called with
# real arguments) -- valid, unambiguous C when empty parens
# mean "unspecified arguments" (K&R/C89 through GNU's own default
# extensions), a hard error under newer C standard defaults where empty
# parens instead mean "takes no arguments". Confirmed via real Fedora CI
# build failures (newer default GCC) not reproducible on Debian/Ubuntu
# (older default GCC) -- pin C compilation tree-wide to gnu17 rather than
# rewriting decades-old third-party prototypes file by file as each one
# surfaces on whichever platform's default happens to be newest this
# month. Only affects .c compilation -- CMAKE_CXX_STANDARD above is
# separate and unaffected.
set(CMAKE_C_STANDARD 17)
set(CMAKE_C_STANDARD_REQUIRED ON)
set(CMAKE_C_EXTENSIONS ON)
set(CMAKE_POSITION_INDEPENDENT_CODE ON)

if(NOT CMAKE_BUILD_TYPE)
  set(CMAKE_BUILD_TYPE RelWithDebInfo)
endif()

# ------------------------------------------------------------------------
# Road to 9.0, step 1: split the single monolithic package into
# ecce-client (GUI apps, input generators/parsers, codereg dialogs, the
# job-side scripts the Launcher copies to compute hosts, the per-session
# gateway scripts, ecce-remote-setup) and ecce-server (the per-user
# or central WebDAV data server and its content, its mosquitto
# dependency). Every install() rule below carries a
# COMPONENT tag either way -- that costs nothing when this is OFF, since
# plain `cpack`/`cpack -G DEB` ignores COMPONENT entirely and produces
# one monolithic package exactly as before (CPACK_DEB_COMPONENT_INSTALL
# defaults OFF). Turning this ON is what makes CPack actually split them.
# ON from 9.0 (ecce-client and ecce-server); 8.x release branches are monolithic.
option(ECCE_SPLIT_PACKAGES "Package ecce-client and ecce-server as separate .deb/.rpm files instead of one monolithic package" ON)

add_compile_options(-Wall -Wno-deprecated -Wno-sign-compare -Wno-non-virtual-dtor)

find_package(XercesC REQUIRED)
find_package(OpenGL REQUIRED)
find_package(wxWidgets 3.2 REQUIRED COMPONENTS core base gl aui net html)
include(${wxWidgets_USE_FILE})
find_package(PkgConfig)
# X11/GLX/EGL are the viewer's window-system layer (GlPlatform) on Linux and
# the BSDs only; macOS and Windows use wx's own GL canvas (#232).
if(UNIX AND NOT APPLE)
  set(_ecce_gl_x11_default ON)
else()
  set(_ecce_gl_x11_default OFF)
endif()
option(ECCE_GL_X11 "Viewer GL through X11/GLX/EGL (GlPlatform); OFF on macOS/Windows" ${_ecce_gl_x11_default})
if(ECCE_GL_X11)
  find_package(X11 REQUIRED)
  set(ECCE_X11_LIBS X11::X11)
  add_compile_definitions(ECCE_GL_X11=1)
else()
  set(ECCE_X11_LIBS "")
  add_compile_definitions(ECCE_GL_X11=0)
endif()
# ESP grid evaluation runs on worker threads (ComputeMoCmd).
find_package(Threads REQUIRED)
link_libraries(Threads::Threads)
if(ECCE_GL_X11 AND NOT X11_Xt_FOUND)
  message(FATAL_ERROR "libXt (X Toolkit Intrinsics) headers not found - included by include/inv/SoWx/SoWxViewer.H")
endif()

# Old build used "-I/usr/include/freetype2/freetype" as a baseline include
# dir everywhere, because most FreeType headers this codebase includes
# unqualified (e.g. <ftoutln.h>) live one level below the freetype2 package's
# normal include root. Keep that same include shape rather than switching to
# find_package(Freetype), to stay behavior-identical to the verified Make
# build. (One file, flclient/flfreetype.c, also needs <ft2build.h> itself,
# which lives at the freetype2 root one level up - handled separately below,
# on just the ecceinv target, matching the old per-directory Makefile.)
# Homebrew's freetype2 package lands at /opt/homebrew (Apple Silicon) or
# /usr/local (Intel Mac) instead of /usr -- neither hardcoded Linux path
# above exists there at all, and find_path() silently returns
# "...-NOTFOUND" rather than erroring, which only surfaces later as a
# baffling "Found relative path while evaluating include directories"
# CMake generate-step error. Confirmed via a real macOS CI run.
# PATH_SUFFIXES covers prefixes such as MSYS2's /ucrt64 (#133).
find_path(FREETYPE_UNQUALIFIED_INCLUDE_DIR ftoutln.h
  PATH_SUFFIXES freetype2/freetype
  PATHS /usr/include/freetype2/freetype /usr/include/freetype
        /opt/homebrew/include/freetype2/freetype
        /usr/local/include/freetype2/freetype)
if(NOT FREETYPE_UNQUALIFIED_INCLUDE_DIR)
  message(FATAL_ERROR "FreeType's freetype/ include subdir (ftoutln.h) not found -- searched the usual Linux and Homebrew locations")
endif()

include_directories(
  ${CMAKE_SOURCE_DIR}/include
  ${FREETYPE_UNQUALIFIED_INCLUDE_DIR}
)

# #166: build against the system Coin3D instead of the
# vendored Inventor core in src/inv. <inv/X/Y.H> includes are forwarded to
# <Inventor/X/Y.h> by a generated overlay that is searched before include/.
option(ECCE_USE_COIN "Build against the system Coin3D (default). OFF builds the vendored Inventor core in src/inv, kept as a fallback for one release (#166)" ON)
if(ECCE_USE_COIN)
  file(GLOB _coin_scan LIST_DIRECTORIES true ${CMAKE_SOURCE_DIR}/src/*)
  list(FILTER _coin_scan EXCLUDE REGEX "/src/inv$")
  file(GLOB _coin_scan_inc LIST_DIRECTORIES true ${CMAKE_SOURCE_DIR}/include/*)
  list(FILTER _coin_scan_inc EXCLUDE REGEX "/include/inv$")
  list(APPEND _coin_scan ${_coin_scan_inc})
  # Coin 4.0.10 as packaged by EPEL/Fedora installs under include/Coin4, so
  # the directory holding Inventor/ is found, not assumed to be /usr/include.
  find_path(COIN_INCLUDE_DIR Inventor/SbString.h PATH_SUFFIXES Coin4 Coin3 Coin REQUIRED)
  execute_process(COMMAND python3 ${CMAKE_SOURCE_DIR}/tools/coin/gen_shim.py
                          ${CMAKE_SOURCE_DIR} ${CMAKE_BINARY_DIR}/coin-shim ${COIN_INCLUDE_DIR} ${_coin_scan}
                  RESULT_VARIABLE _shim_rc)
  if(NOT _shim_rc EQUAL 0)
    message(FATAL_ERROR "gen_shim.py failed")
  endif()
  include_directories(BEFORE ${CMAKE_BINARY_DIR}/coin-shim)
  if(NOT COIN_INCLUDE_DIR STREQUAL "/usr/include")
    include_directories(${COIN_INCLUDE_DIR})
  endif()
  add_compile_definitions(OIV_COIN)
  find_library(COIN_LIBRARY Coin REQUIRED)
endif()

if(WIN32)
  # MSYS2's Coin is a DLL; moiv is a static library of ours. GL/gl.h pulls in
  # <windows.h>, whose full form drags in rpcndr.h's `byte`, ambiguous with
  # std::byte under `using namespace std`; and its min/max macros break
  # std::min/std::max. _POSIX_THREAD_SAFE_FUNCTIONS declares gmtime_r and
  # localtime_r (#133).
  add_compile_definitions(COIN_DLL CHEMKIT_NOT_DLL WIN32_LEAN_AND_MEAN NOMINMAX
                          _POSIX_THREAD_SAFE_FUNCTIONS=200112L)
  # PosixCompat.H in every C++ file: it supplies the POSIX calls and strips
  # the windows.h macros (ERROR, OPAQUE, ...) that wx pulls in first.
  # win32compat/ stands in for the <sys/wait.h>-style headers MinGW lacks.
  add_compile_options("$<$<COMPILE_LANGUAGE:CXX>:SHELL:-include ${CMAKE_SOURCE_DIR}/include/util/PosixCompat.H>")
  include_directories(${CMAKE_SOURCE_DIR}/include/win32compat)
endif()

if(APPLE)
  # ~90 files across the tree spell OpenGL headers the Linux/X11 way
  # ("GL/gl.h", "GL/glu.h") -- Apple's own OpenGL framework headers live
  # under "OpenGL/" instead. A forwarding shim here (packaging/macos-
  # compat/GL/{gl,glu}.h) avoids editing every one of those call sites;
  # placed last so it never shadows a real GL/ dir if one somehow exists.
  include_directories(AFTER ${CMAKE_SOURCE_DIR}/packaging/macos-compat)
endif()

set(ECCE_VERSION_RAW "")
if(EXISTS ${CMAKE_SOURCE_DIR}/data/client/config/Version)
  file(STRINGS ${CMAKE_SOURCE_DIR}/data/client/config/Version ECCE_VERSION_RAW LIMIT_COUNT 1)
  # file(STRINGS ...) is a configure-time read, not a build dependency --
  # CMake won't notice this file changed on a later `cmake --build` alone.
  # Registering it here makes an edit to the Version file trigger an
  # automatic reconfigure the next time anything is built.
  set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS
    ${CMAKE_SOURCE_DIR}/data/client/config/Version)
endif()

# ------------------------------------------------------------------------
# Helper: define a static library from an explicit list of source
# directories (matches the old build's grouping of multiple src/<mod>/<sub>
# directories into one libecceXXX.a - see per-directory LIBRARY= lines in
# the old Makefiles for the mapping this replicates).
# ------------------------------------------------------------------------
function(ecce_library name)
  set(_srcs)
  foreach(dir ${ARGN})
    file(GLOB _dir_srcs CONFIGURE_DEPENDS
      ${CMAKE_SOURCE_DIR}/${dir}/*.C
      ${CMAKE_SOURCE_DIR}/${dir}/*.c)
    list(APPEND _srcs ${_dir_srcs})
  endforeach()
  add_library(${name} STATIC ${_srcs})
  target_include_directories(${name} PRIVATE ${XercesC_INCLUDE_DIRS})
  if(WIN32)
    # The libraries reference each other in cycles; GNU ld needs them repeated.
    set_target_properties(${name} PROPERTIES LINK_INTERFACE_MULTIPLICITY 3)
  endif()
endfunction()

# --- src/util -> libecceutil.a ---
ecce_library(ecceutil
  src/util/chemutil
  src/util/command
  src/util/events
  src/util/exceptions
  src/util/genutil
  src/util/jms
  src/util/units
)
target_compile_definitions(ecceutil PRIVATE ECCE_VERSION=\"${ECCE_VERSION_RAW}\")
# Messaging (src/util/jms) is MQTT 5 on libmosquitto.
pkg_check_modules(MOSQUITTO REQUIRED IMPORTED_TARGET libmosquitto)
target_link_libraries(ecceutil PUBLIC PkgConfig::MOSQUITTO)
if(WIN32)
  # POSIX regex (libtre) and Winsock, which libssh's callers use directly.
  target_link_libraries(ecceutil PUBLIC regex ws2_32)
endif()

# ------------------------------------------------------------------------
# Where an installed ECCE lives, and where its ecce-<app> wrappers go.
#
# Both default to what the .deb ships (/opt/ecce and /usr/bin), so packaging
# is unaffected. They are cache variables so that a developer can install to
# somewhere writable and skip sudo entirely:
#
#   cmake -B build-user -GNinja \
#         -DCMAKE_INSTALL_PREFIX=$HOME/.local/ecce \
#         -DECCE_HOME_DIR=$HOME/.local/ecce \
#         -DECCE_WRAPPER_DESTINATION=$HOME/.local/bin
#   cmake --build build-user --target install
#
# That matters for more than convenience: tests/apps can only exercise an
# INSTALLED build, so without this every test of a C++ change needs root.
# ------------------------------------------------------------------------
set(ECCE_HOME_DIR "/opt/ecce" CACHE PATH
    "Directory an installed ECCE runs from; wrappers export it as ECCE_HOME")
set(ECCE_WRAPPER_DESTINATION "/usr/bin" CACHE PATH
    "Where the ecce-<app> wrapper scripts are installed")
# A relocatable install (ECCE.app, which can be put anywhere) has wrappers
# that find ECCE_HOME relative to themselves; nothing from the build
# machine's paths may end up in it. Linux packages keep the fixed path.
option(ECCE_RELOCATABLE "Wrappers find ECCE_HOME relative to their own location" ${APPLE})
if(ECCE_RELOCATABLE)
  file(RELATIVE_PATH ECCE_HOME_REL "${ECCE_WRAPPER_DESTINATION}" "${ECCE_HOME_DIR}")
  file(READ ${CMAKE_SOURCE_DIR}/packaging/ecce-home.sh.in ECCE_HOME_SH)
  string(REPLACE "@ECCE_HOME_REL@" "${ECCE_HOME_REL}" ECCE_HOME_SH "${ECCE_HOME_SH}")
  string(STRIP "${ECCE_HOME_SH}" ECCE_HOME_SH)
else()
  set(ECCE_HOME_SH "export ECCE_HOME=\${ECCE_HOME:-${ECCE_HOME_DIR}}")
endif()


# --- src/tdat -> libeccetdat.a ---
ecce_library(eccetdat
  src/tdat/calcorg
  src/tdat/chemistry
  src/tdat/ffield
  src/tdat/nwmdtask
  src/tdat/properties
  src/tdat/reaction
  src/tdat/resources
)

# --- src/dsm -> 5 separate libraries, matching the old per-subdir mapping ---
ecce_library(eccexml    src/dsm/chemistry src/dsm/xml)
ecce_library(eccecipc   src/dsm/cipc)
if(WIN32)
  target_link_libraries(eccecipc PUBLIC ws2_32)
endif()
find_package(OpenSSL REQUIRED)
target_link_libraries(eccecipc PUBLIC OpenSSL::SSL OpenSSL::Crypto)
ecce_library(eccedav    src/dsm/dav)
ecce_library(eccedsi    src/dsm/edsiimpl)
ecce_library(eccefaces  src/dsm/faces)

# --- src/viz -> libeccevizsg.a ---
ecce_library(eccevizsg
  src/viz/atomnodes
  src/viz/nodes
  src/viz/propsgcommands
  src/viz/sgcommands
)

# --- src/comm -> 4 separate libraries ---
ecce_library(eccecomm   src/comm/commtools)
ecce_library(eccecommxt src/comm/commxt)
ecce_library(eccercmd   src/comm/rcommand)
# SshTransport needs libssh >= 0.10; without it the glob's copy is dropped
# and nothing else changes.
pkg_check_modules(LIBSSH IMPORTED_TARGET libssh>=0.10)
# ssh machines need libssh or the OpenSSH client; a build without libssh would
# only have the second, so configuration fails unless -DECCE_REQUIRE_LIBSSH=OFF.
option(ECCE_REQUIRE_LIBSSH "Fail configuration when libssh >= 0.10 is not found" ON)
if(ECCE_REQUIRE_LIBSSH AND NOT LIBSSH_FOUND)
  message(FATAL_ERROR "ECCE_REQUIRE_LIBSSH is ON but libssh >= 0.10 was not found (install libssh-dev / libssh-devel)")
endif()
if(LIBSSH_FOUND)
  target_link_libraries(eccercmd PUBLIC PkgConfig::LIBSSH)
  target_compile_definitions(eccercmd PUBLIC ECCE_HAVE_LIBSSH=1)
else()
  get_target_property(_rcmd_srcs eccercmd SOURCES)
  list(FILTER _rcmd_srcs EXCLUDE REGEX "/SshTransport\\.C$")
  set_property(TARGET eccercmd PROPERTY SOURCES ${_rcmd_srcs})
endif()
# --- src/inv -> libecceinv.a + libeccemoiv.a (libeccewxinv.a needs wx, TODO) ---
# Old build's src/inv/flclient/Makefile adds `pkg-config --cflags-only-I freetype2`
# on top of the baseline include dir: some FreeType headers (ft2build.h) live at
# the top of the freetype2 include tree, others (ftoutln.h etc, used elsewhere in
# this codebase) live one level down - both are needed.
# Same Homebrew-path gap as FREETYPE_UNQUALIFIED_INCLUDE_DIR above.
find_path(FREETYPE_ROOT_INCLUDE_DIR ft2build.h
  PATH_SUFFIXES freetype2
  PATHS /usr/include/freetype2 /usr/include
        /opt/homebrew/include/freetype2
        /usr/local/include/freetype2)
if(NOT FREETYPE_ROOT_INCLUDE_DIR)
  message(FATAL_ERROR "FreeType's ft2build.h not found -- searched the usual Linux and Homebrew locations")
endif()
if(ECCE_USE_COIN)
  # Only the FreeType font layer (flclient) is kept from the vendored core.
  ecce_library(ecceinv src/inv/flclient)
  target_compile_definitions(ecceinv PRIVATE NDEBUG)
  target_include_directories(ecceinv PRIVATE ${FREETYPE_ROOT_INCLUDE_DIR})
  target_link_libraries(ecceinv PUBLIC ${COIN_LIBRARY} OpenGL::GL OpenGL::GLU)
else()
  ecce_library(ecceinv
    src/inv/dbelements
    src/inv/dbengines
    src/inv/dbfields
    src/inv/dbnodes
    src/inv/dbsb
    src/inv/dbso
    src/inv/dbupgraders
    src/inv/flclient
    src/inv/image
    src/inv/interaction
    src/inv/nodekits
  )
  target_compile_definitions(ecceinv PRIVATE NDEBUG)
  target_link_libraries(ecceinv PRIVATE OpenGL::GL OpenGL::GLU)
  target_include_directories(ecceinv PRIVATE ${FREETYPE_ROOT_INCLUDE_DIR})
endif()
ecce_library(eccemoiv src/inv/moiv)
target_compile_definitions(eccemoiv PRIVATE NDEBUG)
target_link_libraries(eccemoiv PRIVATE OpenGL::GL OpenGL::GLU)

# ------------------------------------------------------------------------
# wxWidgets 2.8 -> 3.2 port (in progress). See
# claude/ecce-modernization-status.md in the project docs for what's done.
# ------------------------------------------------------------------------

# --- src/inv/wxinv -> libeccewxinv.a (Open Inventor / wxWidgets bridge) ---
ecce_library(eccewxinv src/inv/wxinv)
target_compile_definitions(eccewxinv PRIVATE NDEBUG ${wxWidgets_DEFINITIONS})
target_include_directories(eccewxinv PRIVATE ${wxWidgets_INCLUDE_DIRS})
target_link_libraries(eccewxinv PRIVATE ${wxWidgets_LIBRARIES} OpenGL::GL OpenGL::GLU)
if(ECCE_USE_COIN AND ECCE_GL_X11)
  find_package(OpenGL REQUIRED COMPONENTS EGL)
  target_link_libraries(eccewxinv PUBLIC OpenGL::EGL ${CMAKE_DL_LIBS})
endif()

# --- src/wxviz -> libeccewxviz.a ---
ecce_library(eccewxviz src/wxviz/viewer src/wxviz/viztools)
target_compile_definitions(eccewxviz PRIVATE ${wxWidgets_DEFINITIONS})
target_include_directories(eccewxviz PRIVATE ${wxWidgets_INCLUDE_DIRS})
target_link_libraries(eccewxviz PRIVATE ${wxWidgets_LIBRARIES} OpenGL::GL OpenGL::GLU)

# --- src/wxgui -> 5 separate libraries, matching the old per-subdir mapping ---
ecce_library(eccewxgui
  src/wxgui/ewxClasses
  src/wxgui/jms
  src/wxgui/pertable
  src/wxgui/wxdialogs
  src/wxgui/wxtools
)
target_compile_definitions(eccewxgui PRIVATE ${wxWidgets_DEFINITIONS})
target_include_directories(eccewxgui PRIVATE ${wxWidgets_INCLUDE_DIRS})
target_link_libraries(eccewxgui PRIVATE ${wxWidgets_LIBRARIES})

# ewxApp.C installs a g_log_set_writer_func() filter for a known-benign
# wxWidgets/GTK3 backend warning (see the comment there) -- needs GLib's
# own headers directly, which wxWidgets_INCLUDE_DIRS doesn't expose.
# GTK only: wx's macOS and Windows ports do not use GLib.
if(NOT APPLE)
  pkg_check_modules(GLIB2 REQUIRED glib-2.0)
  target_include_directories(eccewxgui PRIVATE ${GLIB2_INCLUDE_DIRS})
  target_link_libraries(eccewxgui PRIVATE ${GLIB2_LIBRARIES})
endif()

# ewxRaiseWindow() (ewxWindowUtils.C) calls gtk_window_present*() and, on an
# X11 display only, gdk_x11_get_server_time() (#120); needs gtk+-3.0 headers
# and library, same as eccewxplotctrl below.
pkg_check_modules(GTK3 QUIET gtk+-3.0)
if(GTK3_FOUND)
  target_include_directories(eccewxgui PRIVATE ${GTK3_INCLUDE_DIRS})
  target_link_libraries(eccewxgui PRIVATE ${GTK3_LIBRARIES})
endif()

# WindowShot.C reads a window back from the window server on macOS.
if(APPLE)
  target_link_libraries(eccewxgui PRIVATE "-framework ApplicationServices")
endif()

ecce_library(eccewxguicomm src/wxgui/comm)
target_compile_definitions(eccewxguicomm PRIVATE ${wxWidgets_DEFINITIONS})
target_include_directories(eccewxguicomm PRIVATE ${wxWidgets_INCLUDE_DIRS})
target_link_libraries(eccewxguicomm PRIVATE ${wxWidgets_LIBRARIES})

ecce_library(eccewxguimd src/wxgui/mdtools)
target_compile_definitions(eccewxguimd PRIVATE ${wxWidgets_DEFINITIONS})
target_include_directories(eccewxguimd PRIVATE ${wxWidgets_INCLUDE_DIRS})
target_link_libraries(eccewxguimd PRIVATE ${wxWidgets_LIBRARIES})

ecce_library(eccewxplotctrl src/wxgui/wxplotctrl)
target_compile_definitions(eccewxplotctrl PRIVATE ${wxWidgets_DEFINITIONS})
target_include_directories(eccewxplotctrl PRIVATE ${wxWidgets_INCLUDE_DIRS})
target_link_libraries(eccewxplotctrl PRIVATE ${wxWidgets_LIBRARIES})
# Old build's src/wxgui/wxplotctrl/Makefile adds `pkg-config --cflags-only-I
# gtk+-2.0` - this build targets wx3.2's GTK3 backend, so gtk+-3.0 is the
# equivalent (the old gtk+-2.0 dev package isn't even installed here).
pkg_check_modules(GTK3 QUIET gtk+-3.0)
if(GTK3_FOUND)
  target_include_directories(eccewxplotctrl PRIVATE ${GTK3_INCLUDE_DIRS})
endif()

ecce_library(eccewxthings src/wxgui/wxthings)
target_compile_definitions(eccewxthings PRIVATE ${wxWidgets_DEFINITIONS})
target_include_directories(eccewxthings PRIVATE ${wxWidgets_INCLUDE_DIRS})
target_link_libraries(eccewxthings PRIVATE ${wxWidgets_LIBRARIES})

# ------------------------------------------------------------------------
# src/apps -> the final executables. Each old src/apps/<name>/Makefile
# defined PROGRAMS (usually one, matching the directory name) built from
# every .C file in that directory, plus an ECCE_LIBS list of which of the
# static libraries above to link against - see src/apps/<name>/Makefile in
# git history for the exact old lists these were transcribed from. A few
# apps (davutils, ecmd, jobstore) never included Makefile.wx at all and
# have no wx dependency; the rest all do. builder and vizthumbnail also
# pull in Makefile.gl (they link the Open Inventor/visualization stack).
# ------------------------------------------------------------------------

# Helper: define an executable from every .C source file in one directory.
# link_libs are this app's own ECCE_LIBS list (as CMake target names, i.e.
# without the old "-l" prefix - note libecceedsi.a is the CMake target
# "eccedsi" here, not "ecceedsi", see the src/dsm section above).
function(ecce_app name dir)
  cmake_parse_arguments(ECCE_APP "WX;GL" "" "LINK" ${ARGN})
  file(GLOB _srcs CONFIGURE_DEPENDS ${CMAKE_SOURCE_DIR}/${dir}/*.C)
  add_executable(${name} ${_srcs})
  target_include_directories(${name} PRIVATE ${XercesC_INCLUDE_DIRS})
  if(ECCE_APP_WX)
    target_compile_definitions(${name} PRIVATE ${wxWidgets_DEFINITIONS})
    target_include_directories(${name} PRIVATE ${wxWidgets_INCLUDE_DIRS})
    target_link_libraries(${name} PRIVATE ${wxWidgets_LIBRARIES})
  endif()
  if(ECCE_APP_GL)
    target_link_libraries(${name} PRIVATE OpenGL::GL OpenGL::GLU)
  endif()
  if(WIN32)
    # The static libraries reference each other in cycles; GNU ld rescans a group.
    target_link_libraries(${name} PRIVATE
      "$<LINK_GROUP:RESCAN,${ECCE_APP_LINK}>" ${XercesC_LIBRARIES})
  else()
    target_link_libraries(${name} PRIVATE ${ECCE_APP_LINK} ${XercesC_LIBRARIES})
  endif()
endfunction()

# --- apps with no wx dependency ---
ecce_app(load_tgbs src/apps/davutils
  LINK eccedsi eccedav eccecipc eccefaces eccexml eccetdat ecceutil)
ecce_app(ecmd src/apps/ecmd
  LINK eccercmd eccedsi eccedav eccecipc eccefaces eccexml eccetdat ecceutil)
# jobstore builds two independent single-file programs from this directory,
# each with its own main() - not combined into one binary (matches the old
# Makefile's "multiple PROGRAMS -> each from its own matching .o" rule).
add_executable(eccejobmaster src/apps/jobstore/eccejobmaster.C)
target_include_directories(eccejobmaster PRIVATE ${XercesC_INCLUDE_DIRS})
target_link_libraries(eccejobmaster PRIVATE
  eccecommxt eccercmd eccedsi eccedav eccecipc eccefaces eccexml eccetdat ecceutil
  ${XercesC_LIBRARIES})
# The wrappers ask it which data mode a session is in (#216).
add_executable(ecce-localdata src/apps/localdata/ecce-localdata.C)
target_include_directories(ecce-localdata PRIVATE ${XercesC_INCLUDE_DIRS})
target_link_libraries(ecce-localdata PRIVATE ecceutil ${XercesC_LIBRARIES})
# An MO's atomic-orbital composition from a calculation folder (#161).
# Installed as bin/mocomp; its wrapper is ecce-mocomp like every CLI app's.
add_executable(mocomp src/apps/mocomp/mocomp.C)
target_include_directories(mocomp PRIVATE ${XercesC_INCLUDE_DIRS})
target_link_libraries(mocomp PRIVATE
  eccedsi eccedav eccecipc eccefaces eccexml eccetdat eccedsi eccexml ecceutil
  ${XercesC_LIBRARIES})
# flock(1) for the session scripts where util-linux is absent (macOS).
if(NOT WIN32)   # the Windows client has no session scripts (#133)
  add_executable(ecce-flock src/apps/flock/ecce-flock.c)
endif()
# The server half of "ecce -admin" on a -remote client (SiteRequest).
add_executable(ecce-site-admin src/apps/siteadmin/ecce-site-admin.C)
target_link_libraries(ecce-site-admin PRIVATE eccetdat ecceutil)
add_executable(eccejobstore src/apps/jobstore/eccejobstore.C)
target_include_directories(eccejobstore PRIVATE ${XercesC_INCLUDE_DIRS})
target_link_libraries(eccejobstore PRIVATE
  eccecommxt eccercmd eccedsi eccedav eccecipc eccefaces eccexml eccetdat ecceutil
  ${XercesC_LIBRARIES})

# --- wx apps ---
ecce_app(basistool src/apps/basistool WX
  LINK eccewxgui eccewxplotctrl eccewxthings eccedsi eccedav eccecipc eccefaces eccexml eccetdat ecceutil)
ecce_app(calced src/apps/calced WX
  LINK eccecomm eccercmd eccewxgui eccewxplotctrl eccewxthings eccedsi eccedav eccecipc eccefaces eccexml eccetdat ecceutil)
ecce_app(dirdyed src/apps/dirdyed WX
  LINK eccewxgui eccewxplotctrl eccewxthings eccedsi eccedav eccecipc eccefaces eccexml eccetdat ecceutil)
ecce_app(gateway src/apps/gateway WX
  LINK eccewxgui eccewxplotctrl eccewxthings eccedsi eccedav eccecipc eccefaces eccexml eccetdat ecceutil)
ecce_app(launcher src/apps/launcher WX
  LINK eccecommxt eccecomm eccercmd eccewxgui eccewxplotctrl eccewxthings eccedsi eccedav eccecipc eccefaces eccexml eccetdat ecceutil)
ecce_app(machbrowser src/apps/machbrowser WX
  LINK eccewxgui eccewxplotctrl eccewxthings eccedsi eccedav eccecipc eccefaces eccexml eccercmd eccetdat ecceutil)
ecce_app(machregister src/apps/machregister WX
  # eccercmd for RCommand::localityNote (#144), the same decision the launch makes.
  LINK eccewxgui eccewxplotctrl eccewxthings eccedsi eccedav eccecipc eccefaces eccexml eccercmd eccetdat ecceutil)
ecce_app(mddynamics src/apps/mddynamics WX
  LINK eccewxguimd eccewxgui eccewxplotctrl eccewxthings eccedsi eccedav eccecipc eccefaces eccexml eccetdat ecceutil)
ecce_app(mdenergy src/apps/mdenergy WX
  LINK eccewxguimd eccewxgui eccewxplotctrl eccewxthings eccedsi eccedav eccecipc eccefaces eccexml eccetdat ecceutil)
ecce_app(mdoptimize src/apps/mdoptimize WX
  LINK eccewxguimd eccewxgui eccewxplotctrl eccewxthings eccedsi eccedav eccecipc eccefaces eccexml eccetdat ecceutil)
ecce_app(mdprepare src/apps/mdprepare WX
  LINK eccewxgui eccewxplotctrl eccewxthings eccecommxt eccecomm eccercmd eccedsi eccedav eccecipc eccefaces eccexml eccetdat ecceutil)
ecce_app(msgdialog src/apps/messagedialog WX
  LINK eccewxgui eccewxplotctrl eccewxthings eccedsi eccedav eccecipc eccefaces eccexml eccetdat ecceutil)
ecce_app(metadyn src/apps/metadyn WX
  LINK eccecomm eccercmd eccewxgui eccewxplotctrl eccewxthings eccedsi eccedav eccecipc eccefaces eccexml eccetdat ecceutil)
ecce_app(organizer src/apps/organizer WX
  LINK eccewxguicomm eccecommxt eccecomm eccercmd eccewxgui eccewxplotctrl eccewxthings eccedsi eccedav eccecipc eccefaces eccexml eccetdat ecceutil)
ecce_app(hostkeydialog src/apps/hostkeydialog WX
  LINK eccewxgui eccewxplotctrl eccewxthings eccedsi eccedav eccecipc eccefaces eccexml eccetdat ecceutil)
ecce_app(passdialog src/apps/passdialog WX
  LINK eccewxgui eccewxplotctrl eccewxthings eccedsi eccedav eccecipc eccefaces eccexml eccetdat ecceutil)
ecce_app(pertable src/apps/pertable WX
  LINK eccewxgui eccewxplotctrl eccewxthings eccedsi eccedav eccecipc eccefaces eccexml eccetdat ecceutil)
ecce_app(polyed src/apps/polyrate WX
  LINK eccewxgui eccewxplotctrl eccewxthings eccedsi eccedav eccecipc eccefaces eccexml eccetdat ecceutil)
ecce_app(solvate src/apps/solvate WX
  LINK eccecomm eccercmd eccewxgui eccewxplotctrl eccewxthings eccedsi eccedav eccecipc eccefaces eccexml eccetdat ecceutil)

# Native replacement for the wxPython Details dialogs (pilot): reads the
# .dlg files next to scripts/codereg/*.py.  wx only, so it links nothing of
# ECCE's; JCode::getTheoryRunTypeEditorNames starts it when ECCE_NATIVE_DIALOGS
# is set.  Not in ECCE_GUI_APPS: no wrapper script, it is never run by hand.
add_executable(ecce-dialog src/apps/codereg-dialog/ecce-dialog.cpp)
target_compile_definitions(ecce-dialog PRIVATE ${wxWidgets_DEFINITIONS})
target_include_directories(ecce-dialog PRIVATE ${wxWidgets_INCLUDE_DIRS})
target_link_libraries(ecce-dialog PRIVATE ${wxWidgets_LIBRARIES})
if(WIN32)
  set_target_properties(ecce-dialog PROPERTIES WIN32_EXECUTABLE ON)
endif()
install(TARGETS ecce-dialog RUNTIME DESTINATION bin COMPONENT client)

# --- wx + GL apps ---
ecce_app(builder src/apps/builder WX GL
  LINK eccewxguicomm eccewxviz eccewxinv eccevizsg eccemoiv ecceinv eccecommxt eccecomm eccercmd 
       eccewxgui eccewxplotctrl eccewxthings eccedsi eccedav eccecipc eccefaces eccexml eccetdat ecceutil
       ${ECCE_X11_LIBS} jpeg freetype)
ecce_app(vizthumbnail src/apps/vizthumbnail WX GL
  LINK eccewxviz eccewxinv eccevizsg eccemoiv ecceinv eccewxgui eccewxplotctrl eccewxthings eccedsi eccedav eccecipc eccefaces eccexml eccetdat ecceutil ${ECCE_X11_LIBS} jpeg freetype)

# Headless scene renderer for comparing the vendored and Coin viewer builds
# (tools/coin/compare.sh); built only on request.
ecce_app(viewer-scenes tools/coin WX GL
  LINK eccewxviz eccewxinv eccevizsg eccemoiv ecceinv eccewxgui eccewxplotctrl eccewxthings eccedsi eccedav eccecipc eccefaces eccexml eccetdat ecceutil ${ECCE_X11_LIBS} jpeg freetype)
set_target_properties(viewer-scenes PROPERTIES EXCLUDE_FROM_ALL TRUE)

# Renders .rgb files through VizRender and converts them (tests/look/imageconv.py).
ecce_app(render-rgb tests/look/imageconv WX GL
  LINK eccewxviz eccewxinv eccevizsg eccemoiv ecceinv eccewxgui eccewxplotctrl eccewxthings eccedsi eccedav eccecipc eccefaces eccexml eccetdat ecceutil ${ECCE_X11_LIBS} jpeg freetype)
set_target_properties(render-rgb PROPERTIES EXCLUDE_FROM_ALL TRUE)

# Paints the spectrum canvas onto a bitmap (tests/spectrum, #214); `ninja
# spectrum-render`, needs a display (xvfb-run).
ecce_app(spectrum-render tools/spectrum WX LINK eccetdat ecceutil)
set_target_properties(spectrum-render PROPERTIES EXCLUDE_FROM_ALL TRUE)
target_include_directories(spectrum-render PRIVATE ${CMAKE_SOURCE_DIR}/src/apps/builder)

# Coin only: the EGL offscreen path with no wx and no display.
if(ECCE_USE_COIN)
  add_executable(offscreen-check EXCLUDE_FROM_ALL tools/coin/offscreen/offscreen-check.C)
  target_link_libraries(offscreen-check PRIVATE eccewxinv ${COIN_LIBRARY} ${wxWidgets_LIBRARIES} OpenGL::GL)
  target_include_directories(offscreen-check PRIVATE ${wxWidgets_INCLUDE_DIRS})
endif()
# Coin's glue display is the offscreen one, not an EGL X11 display (#237);
# ctest coin_egl_display. Exports eglglue_display, as an EGL-only Coin does.
if(ECCE_USE_COIN AND ECCE_GL_X11)
  add_executable(egl-display-check tools/coin/offscreen/egl-display-check.C)
  target_link_libraries(egl-display-check PRIVATE eccewxinv ${COIN_LIBRARY} ${wxWidgets_LIBRARIES} OpenGL::GL)
  target_include_directories(egl-display-check PRIVATE ${wxWidgets_INCLUDE_DIRS})
  set_target_properties(egl-display-check PROPERTIES ENABLE_EXPORTS ON)
endif()

# Frame-time benchmark for the molecule viewer (tools/viewer-bench); built
# only on request, by tools/viewer-bench/run.sh.
# It calls glX directly, so only where the viewer's GL is X11.
if(ECCE_GL_X11)
  ecce_app(viewer-bench tools/viewer-bench WX GL
    LINK eccewxviz eccewxinv eccevizsg eccemoiv ecceinv eccewxgui eccewxplotctrl eccewxthings eccedsi eccedav eccecipc eccefaces eccexml eccetdat ecceutil ${ECCE_X11_LIBS} jpeg freetype)
  set_target_properties(viewer-bench PROPERTIES EXCLUDE_FROM_ALL TRUE)
endif()

# --- src/apps/symmetry -> 5 standalone Fortran executables, no wx involvement.
# Mirrors the old Makefile's "default:" target exactly (testnames is a
# dev/test-only program the old default build skipped - left out here too).
# Each program links only the specific .f/.f90 object files its old Makefile
# rule listed, not every source file in the directory (unlike ecce_app(),
# which links a whole directory - this old Makefile was per-program instead).
function(ecce_fortran_app name)
  cmake_parse_arguments(ECCE_FAPP "" "" "SOURCES" ${ARGN})
  add_executable(${name} ${ECCE_FAPP_SOURCES})
  # Several of these programs independently compile the same spnames.f90 /
  # spgen.f90 module sources - give each target its own .mod output
  # directory so Ninja doesn't see two targets writing the same
  # spnames.mod/spgen.mod file (they're identical content, but CMake/Ninja
  # doesn't know that and refuses to build with a shared output).
  set_target_properties(${name} PROPERTIES
    Fortran_MODULE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${name}.mod)
  # The Fortran runtime comes with the compiler, not the OS: link it in
  # so the app bundles no libgfortran and its minimum macOS stays ours.
  if(APPLE)
    target_link_options(${name} PRIVATE -static-libgfortran -static-libgcc -static-libquadmath)
  endif()
endfunction()

set(_sym_dir ${CMAKE_SOURCE_DIR}/src/apps/symmetry)
ecce_fortran_app(autosym
  SOURCES ${_sym_dir}/autosym.f ${_sym_dir}/geom_hnd.f ${_sym_dir}/deter3.f ${_sym_dir}/errquit.f)
ecce_fortran_app(getfrag
  SOURCES ${_sym_dir}/getfrag.f ${_sym_dir}/findfrag.f ${_sym_dir}/spnames.f90 ${_sym_dir}/spgen.f90
          ${_sym_dir}/deter3.f ${_sym_dir}/dctr.f ${_sym_dir}/gensym.f ${_sym_dir}/errquit.f)
ecce_fortran_app(genmol
  SOURCES ${_sym_dir}/genmol.f ${_sym_dir}/dosymops.f ${_sym_dir}/spnames.f90 ${_sym_dir}/spgen.f90
          ${_sym_dir}/deter3.f ${_sym_dir}/dctr.f ${_sym_dir}/gensym.f ${_sym_dir}/errquit.f)
ecce_fortran_app(genmollat
  SOURCES ${_sym_dir}/genmollat.f ${_sym_dir}/dosymops.f ${_sym_dir}/spnames.f90 ${_sym_dir}/spgen.f90
          ${_sym_dir}/deter3.f ${_sym_dir}/dctr.f ${_sym_dir}/gensym.f ${_sym_dir}/errquit.f)
# Added for the symmetry analysis behind the MO diagrams (#132): gensym
# already turns a group name into its operation matrices, and nothing
# outside these Fortran tools could reach them.
ecce_fortran_app(symops
  SOURCES ${_sym_dir}/symops.f ${_sym_dir}/spnames.f90 ${_sym_dir}/spgen.f90
          ${_sym_dir}/deter3.f ${_sym_dir}/dctr.f ${_sym_dir}/gensym.f ${_sym_dir}/errquit.f)
ecce_fortran_app(cleansym
  SOURCES ${_sym_dir}/cleansym.f ${_sym_dir}/sym_avg.f ${_sym_dir}/spnames.f90 ${_sym_dir}/spgen.f90
          ${_sym_dir}/deter3.f ${_sym_dir}/dctr.f ${_sym_dir}/gensym.f ${_sym_dir}/errquit.f)

# ------------------------------------------------------------------------
# The messaging gateway: packaging/gateway/ecce-gateway-* start a per-user
# mosquitto on a Unix socket (or point the processes at a central or shared
# broker) and write the broker file src/util/jms/MqttLink.C reads. The
# broker is the distribution's mosquitto package; nothing is built here.
# ------------------------------------------------------------------------

# Help content: BrowserHelp::initialize() (src/util/genutil/BrowserHelp.C)
# throws NullPointerException -- uncaught, crashing the whole app -- if
# ECCE_HELP isn't set in the environment when any Help button is clicked.
# None of the app wrapper scripts set it (an old gap, not a regression --
# the old scripts/runtime_setup this replaces apparently did). Extract the
# vendored help content this package already ships
# (data/admin/dataserver/help/eccehelp.tar) into the layout help.urls'
# entries expect (an "EcceHelp/" subdirectory containing homepage.html,
# etc. -- confirmed against the tarball's actual contents and against
# BrowserHelp::initialize()'s own p_filePrefix construction, which is
# hardcoded to ecceDataPath()/client/WebHelp/), then point ECCE_HELP at it
# in the wrapper scripts below. ECCE_HELP is an http:// URL served by the
# data server's Apache instance (see packaging/dataserver/httpd.conf.ecce's
# "/EcceHelp" Alias), not a raw file:// path -- the help content's own HTML
# uses absolute paths like "/EcceHelp/media/foo.gif" for every image and
# many links, which only resolve correctly against an HTTP server where
# "/EcceHelp" is a real URL root; opened as file://, a browser resolves
# that same absolute path against the filesystem root instead, breaking
# every embedded image. Entries in help.urls that need the CGI help
# backend (cgi-bin/help/cshelp, toolhelp) now work too -- see the
# ecce_help_cgi_patch step below, which patches the vendored Perl scripts'
# shebang and hardcoded PNNL path for this install, and
# ecce-dataserver-start, which seeds them into the per-user cgi-bin/
# alongside the pre-existing (still-unimplemented) account-creation CGI
# slot.
set(_ecce_help_tarball ${CMAKE_SOURCE_DIR}/data/admin/dataserver/help/eccehelp.tar)
if(EXISTS ${_ecce_help_tarball})
  add_custom_command(
    OUTPUT ${CMAKE_BINARY_DIR}/ecce-help-extracted/EcceHelp/homepage.html
    COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR}/ecce-help-extracted/EcceHelp
    COMMAND ${CMAKE_COMMAND} -E chdir ${CMAKE_BINARY_DIR}/ecce-help-extracted/EcceHelp
            ${CMAKE_COMMAND} -E tar xf ${_ecce_help_tarball}
    # The vendored tarball itself ships 3 genuinely corrupt entries under
    # basis/ and builder/ -- filenames containing literal HTML markup
    # (quotes, "<", ">", spaces, e.g. `overview_top"> <!-- #begineditable
    # "title.html`), not real help pages. Confirmed via `tar tf` against
    # the tarball directly -- this is decades-old corruption in the
    # vendored PNNL content itself, not something this build introduced.
    # Harmless for a DEB build (dpkg-deb tolerates the odd filename) but
    # a real, reproducible CI failure for RPM packaging specifically
    # ("CPack Error: Problem compressing the directory" -- rpmbuild's
    # file-list handling rejects them outright), and not guaranteed safe
    # on every filesystem/locale a DEB build might run under either.
    # None of these 3 files are reachable from help.urls or any real
    # navigation path (their "content" is a stray HTML comment fragment,
    # not a page), so deleting them costs nothing.
    COMMAND bash -c "find '${CMAKE_BINARY_DIR}/ecce-help-extracted/EcceHelp' -name '*begineditable*' -delete"
    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
    COMMENT "Extracting vendored ECCE help content"
  )
  add_custom_target(ecce_help ALL
    DEPENDS ${CMAKE_BINARY_DIR}/ecce-help-extracted/EcceHelp/homepage.html)

  # The vendored toolhelp/cshelp CGI scripts (context-sensitive help,
  # invoked from within ECCE apps) hardcode PNNL's own 1990s server path
  # and Perl location. Neither script depends on CGI.pm (unlike the data
  # server's still-unported account-creation CGI) -- just the ancient but
  # still-bundled getopts.pl -- so patching these two values is enough to
  # make them work as-is against this install.
  set(_help_cgi_dir ${CMAKE_BINARY_DIR}/ecce-help-extracted/EcceHelp/cgi-bin)
  add_custom_command(
    OUTPUT ${CMAKE_BINARY_DIR}/ecce-help-extracted/.help-cgi-patched
    COMMAND bash ${CMAKE_SOURCE_DIR}/packaging/dataserver/patch-help-cgi.sh ${_help_cgi_dir}
    COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_BINARY_DIR}/ecce-help-extracted/.help-cgi-patched
    DEPENDS ${CMAKE_BINARY_DIR}/ecce-help-extracted/EcceHelp/homepage.html
            ${CMAKE_SOURCE_DIR}/packaging/dataserver/patch-help-cgi.sh
    COMMENT "Patching vendored help CGI scripts (shebang, help_dir) for this install"
  )
  add_custom_target(ecce_help_cgi_patch ALL
    DEPENDS ${CMAKE_BINARY_DIR}/ecce-help-extracted/.help-cgi-patched)

  # Client content: local mode (#216) opens these pages as files, with no
  # data server.  A server serves the same files (httpd.conf.ecce's
  # "/EcceHelp" Alias) and seeds its help CGIs from them, at this path,
  # and ecce-server depends on ecce-client, so it always has them.
  install(DIRECTORY ${CMAKE_BINARY_DIR}/ecce-help-extracted/EcceHelp
          DESTINATION data/client/WebHelp
          COMPONENT client)
  set(ECCE_HELP_AVAILABLE TRUE)
else()
  message(WARNING "No vendored help tarball at ${_ecce_help_tarball} - "
                   "Help will still work (won't crash) but ECCE_HELP will "
                   "point at a location with no content.")
  set(ECCE_HELP_AVAILABLE FALSE)
endif()

if(EXISTS ${CMAKE_SOURCE_DIR}/siteconfig/DataServers)
  file(READ ${CMAKE_SOURCE_DIR}/siteconfig/DataServers _dataservers_contents)
  # The checked-in template points at the
  # real PNNL production server; repoint it at the data server this
  # package installs and starts locally (see ecce-dataserver-start for
  # the matching port). Both the default <Url> and the <BasisSet> URL
  # share this hostname, and nothing else in the file does, so one
  # substring replace covers both.
  string(REPLACE "eccetera.emsl.pnl.gov" "localhost"
    _dataservers_contents "${_dataservers_contents}")
  file(WRITE ${CMAKE_BINARY_DIR}/siteconfig-local/DataServers "${_dataservers_contents}")
endif()

if(EXISTS ${CMAKE_SOURCE_DIR}/siteconfig/site_runtime)
  file(READ ${CMAKE_SOURCE_DIR}/siteconfig/site_runtime _site_runtime_contents)
  # ECCE_AUTO_ACCOUNTS drives EDSIServerCentral::checkServerSetup()'s
  # self-service account-creation POST against cgi-bin/ecce_accounts,
  # which this package doesn't install (the Perl CGI auto-provisioning
  # flow is deliberately deferred, see packaging/dataserver/ -- a missing
  # CGI degrades gracefully in the client, but there's no reason to
  # attempt a request that can never succeed). Flip it off; accounts are
  # created with ecce-dataserver-adduser instead.
  string(REGEX REPLACE
    "ECCE_AUTO_ACCOUNTS[ \t]+yes"
    "ECCE_AUTO_ACCOUNTS no"
    _site_runtime_contents "${_site_runtime_contents}")
  file(WRITE ${CMAKE_BINARY_DIR}/siteconfig-local/site_runtime "${_site_runtime_contents}")
endif()

# Single directory install for everything in siteconfig/ *except* the
# files rewritten above, which install from their resolved
# siteconfig-local/ copies instead. (Deliberately one combined
# install(DIRECTORY) rather than one per rewritten file above -- two
# separate install(DIRECTORY siteconfig/ ...) calls with different
# exclude sets would both run at install time and race on which version
# of the non-excluded files wins.)
# siteconfig/ is entirely client-side config: it tells a CLIENT install
# where to find servers (DataServers, RemoteServer/),
# what compute resources/queues exist (Machines, Queues, CONFIG-Examples),
# and how it should behave (site_runtime). Nothing under server/ reads
# any of it -- the data server and broker are configured from
# packaging/dataserver and packaging/gateway instead. So it goes whole
# into the client component with no split needed.
# The Windows and macOS clients do not ship the example "dummy" machine
# (manual submission to an unreachable cluster): a desktop install starts
# with localhost alone.
set(_siteconfig_excludes)
if(WIN32 OR APPLE)
  file(READ ${CMAKE_SOURCE_DIR}/siteconfig/Machines _machines)
  string(REGEX REPLACE "# A machine ECCE never contacts[^\n]*\n(#[^\n]*\n)*dummy\t[^\n]*\n" ""
         _machines "${_machines}")
  file(WRITE ${CMAKE_BINARY_DIR}/siteconfig-local/Machines "${_machines}")
  file(READ ${CMAKE_SOURCE_DIR}/siteconfig/Queues _queues)
  string(REPLACE "Queues: localhost dummy" "Queues: localhost" _queues "${_queues}")
  string(REGEX REPLACE "\ndummy\\|[^\n]*" "" _queues "${_queues}")
  file(WRITE ${CMAKE_BINARY_DIR}/siteconfig-local/Queues "${_queues}")
  install(FILES ${CMAKE_BINARY_DIR}/siteconfig-local/Machines
                ${CMAKE_BINARY_DIR}/siteconfig-local/Queues
          DESTINATION siteconfig COMPONENT client)
  set(_siteconfig_excludes PATTERN "Machines" EXCLUDE PATTERN "Queues" EXCLUDE
      PATTERN "CONFIG.dummy" EXCLUDE PATTERN "dummy.Q" EXCLUDE)
endif()
install(DIRECTORY ${CMAKE_SOURCE_DIR}/siteconfig/ DESTINATION siteconfig
        COMPONENT client
        PATTERN "RemoteServer" EXCLUDE
        PATTERN "DataServers" EXCLUDE
        PATTERN "site_runtime" EXCLUDE
        ${_siteconfig_excludes})
install(FILES ${CMAKE_BINARY_DIR}/siteconfig-local/DataServers
              ${CMAKE_BINARY_DIR}/siteconfig-local/site_runtime
        DESTINATION siteconfig
        COMPONENT client)

# ecce-gateway-{start,stop,status,reap}: start and stop the session's
# mosquitto broker and keep the broker files. Client-side, since a client
# on its own machine runs its own broker unless it uses -remote.
install(PROGRAMS
          ${CMAKE_SOURCE_DIR}/packaging/gateway/ecce-gateway-start
          ${CMAKE_SOURCE_DIR}/packaging/gateway/ecce-gateway-stop
          ${CMAKE_SOURCE_DIR}/packaging/gateway/ecce-gateway-status
          ${CMAKE_SOURCE_DIR}/packaging/gateway/ecce-gateway-reap
          ${CMAKE_SOURCE_DIR}/packaging/gateway/ecce-find-mosquitto
          ${CMAKE_SOURCE_DIR}/packaging/gateway/ecce-first-start
          ${CMAKE_SOURCE_DIR}/packaging/windows/ecce-broker-win
          ${CMAKE_SOURCE_DIR}/packaging/nwchem/ecce-nwchem-datadir
        DESTINATION bin
        COMPONENT client)
# Sourced by the scripts above, the wrappers and `ecce` (#233).
install(FILES ${CMAKE_SOURCE_DIR}/packaging/gateway/ecce-session-lib.sh
        DESTINATION bin
        COMPONENT client)
# Deployment mode 3, the site's shared broker (GETTING_STARTED.md,
# "Deployment modes"). ecce-broker-setup writes siteconfig/SharedBroker,
# which the clients read, so it goes with them; ecce-broker-run and the
# unit run the broker, so they go with its config. The unit is installed
# beside that config rather than into /usr/lib/systemd/system, so a
# non-root prefix install still works; ecce-broker-setup prints the
# `systemctl link` for it.
install(PROGRAMS ${CMAKE_SOURCE_DIR}/packaging/gateway/ecce-broker-setup
        DESTINATION bin
        COMPONENT client)
install(PROGRAMS ${CMAKE_SOURCE_DIR}/packaging/gateway/ecce-broker-run
        DESTINATION bin
        COMPONENT server)
if(NOT APPLE AND NOT WIN32)   # no systemd there
  configure_file(${CMAKE_SOURCE_DIR}/packaging/gateway/ecce-broker.service.in
                 ${CMAKE_BINARY_DIR}/systemd/ecce-broker.service @ONLY)
  install(FILES ${CMAKE_BINARY_DIR}/systemd/ecce-broker.service
          DESTINATION server/systemd
          COMPONENT server)
endif()
# The broker plugin that checks logins against the data server's users
# file (a central server's broker, ecce-gateway-start). Needs mosquitto's
# plugin header and apr-util, whose apr_password_validate reads htpasswd's
# hash formats.
if(NOT APPLE AND NOT WIN32)   # macOS and Windows run no central server
  pkg_check_modules(APRUTIL REQUIRED IMPORTED_TARGET apr-util-1)
  find_path(MOSQUITTO_PLUGIN_INCLUDE_DIR mosquitto_plugin.h REQUIRED)
  add_library(ecce_users_auth MODULE src/mqttauth/ecce_users_auth.c)
  set_target_properties(ecce_users_auth PROPERTIES PREFIX "")
  target_include_directories(ecce_users_auth PRIVATE ${MOSQUITTO_PLUGIN_INCLUDE_DIR})
  target_link_libraries(ecce_users_auth PRIVATE PkgConfig::APRUTIL)
  install(TARGETS ecce_users_auth LIBRARY DESTINATION server COMPONENT server)
endif()
# The per-user access rules of a mosquitto serving clients over TCP: the
# shared broker's and a central server's.
install(FILES ${CMAKE_SOURCE_DIR}/packaging/gateway/ecce-mosquitto.acl
        DESTINATION server RENAME mosquitto.acl
        COMPONENT server)
set(_bs_wrapper ${CMAKE_BINARY_DIR}/wrappers/ecce-broker-setup)
file(WRITE ${_bs_wrapper}
"#!/bin/bash
${ECCE_HOME_SH}
exec \"$ECCE_HOME/bin/ecce-broker-setup\" \"$@\"
")
install(PROGRAMS ${_bs_wrapper} DESTINATION ${ECCE_WRAPPER_DESTINATION} COMPONENT client)

# Also put the gateway control scripts on PATH directly (like the ecce-<app>
# wrappers) so `ecce-gateway-status` etc. work without needing $ECCE_HOME.
foreach(_gw start stop status reap)
  set(_gw_wrapper ${CMAKE_BINARY_DIR}/wrappers/ecce-gateway-${_gw})
  file(WRITE ${_gw_wrapper}
"#!/bin/bash
${ECCE_HOME_SH}
export ECCE_REALUSERHOME=\${ECCE_REALUSERHOME:-$HOME}
exec \"$ECCE_HOME/bin/ecce-gateway-${_gw}\" \"$@\"
")
  install(PROGRAMS ${_gw_wrapper} DESTINATION ${ECCE_WRAPPER_DESTINATION} COMPONENT client)
endforeach()

# ------------------------------------------------------------------------
# ECCE data server (EDSI/WebDAV) - the other half of old ECCE's server
# side, independent of the JMS gateway above. Runs as a per-user,
# non-root Debian apache2 instance under $ECCE_REALUSERHOME/.ECCE/
# dataserver -- see packaging/dataserver/httpd.conf.ecce and
# ecce-dataserver-start for the full rationale. Requires the apache2 and
# apache2-utils packages at runtime (see CPACK_DEBIAN_PACKAGE_DEPENDS
# below); nothing to vendor/extract here since both are ordinary Debian
# packages.
# ------------------------------------------------------------------------
# The dataserver's own start/stop/status/adduser: only meaningful on a
# machine actually running the Apache instance, so these -- and the
# Apache config they resolve -- are server-only.
install(PROGRAMS
          ${CMAKE_SOURCE_DIR}/packaging/dataserver/ecce-dataserver-start
          ${CMAKE_SOURCE_DIR}/packaging/dataserver/ecce-dataserver-stop
          ${CMAKE_SOURCE_DIR}/packaging/dataserver/ecce-dataserver-status
          ${CMAKE_SOURCE_DIR}/packaging/dataserver/ecce-dataserver-adduser
          ${CMAKE_SOURCE_DIR}/packaging/dataserver/ecce-site-publish
        DESTINATION bin
        COMPONENT server)
install(FILES ${CMAKE_SOURCE_DIR}/packaging/dataserver/httpd.conf.ecce
        DESTINATION server/httpd-conf
        COMPONENT server)
# ecce-remote-setup and ecce-diagnose, by contrast, run on and describe
# the CLIENT installation (ecce-remote-setup writes this client's own
# siteconfig/RemoteServer/; ecce-diagnose collects this install's own
# state) -- they belong with ecce-client even though they live under
# packaging/dataserver/ and packaging/ for historical reasons.
install(PROGRAMS
          ${CMAKE_SOURCE_DIR}/packaging/dataserver/ecce-remote-setup
          ${CMAKE_SOURCE_DIR}/packaging/ecce-diagnose
        DESTINATION bin
        COMPONENT client)

# ecce-site-publish is a server program too; ecce-site-admin ships with the
# client (a server has both) and must be on the PATH an ssh command gets.
set(_pub_wrapper ${CMAKE_BINARY_DIR}/wrappers/ecce-site-publish)
file(WRITE ${_pub_wrapper}
"#!/bin/bash
${ECCE_HOME_SH}
export ECCE_REALUSERHOME=\${ECCE_REALUSERHOME:-$HOME}
exec \"$ECCE_HOME/bin/ecce-site-publish\" \"$@\"
")
install(PROGRAMS ${_pub_wrapper} DESTINATION ${ECCE_WRAPPER_DESTINATION} COMPONENT server)
set(_sadm_wrapper ${CMAKE_BINARY_DIR}/wrappers/ecce-site-admin)
file(WRITE ${_sadm_wrapper}
"#!/bin/bash
${ECCE_HOME_SH}
export ECCE_REALUSERHOME=\${ECCE_REALUSERHOME:-$HOME}
exec \"$ECCE_HOME/bin/ecce-site-admin\" \"$@\"
")
install(PROGRAMS ${_sadm_wrapper} DESTINATION ${ECCE_WRAPPER_DESTINATION} COMPONENT client)
foreach(_ds start stop status adduser)
  set(_ds_wrapper ${CMAKE_BINARY_DIR}/wrappers/ecce-dataserver-${_ds})
  file(WRITE ${_ds_wrapper}
"#!/bin/bash
${ECCE_HOME_SH}
export ECCE_REALUSERHOME=\${ECCE_REALUSERHOME:-$HOME}
export ECCE_REALUSER=\${ECCE_REALUSER:-\$(id -un)}
exec \"$ECCE_HOME/bin/ecce-dataserver-${_ds}\" \"$@\"
")
  install(PROGRAMS ${_ds_wrapper} DESTINATION ${ECCE_WRAPPER_DESTINATION} COMPONENT server)
endforeach()

# The same wrapper for the central-server setup helper, so an
# administrator can type "ecce-remote-setup <host>" without knowing
# where the installation lives.
# Same for the diagnostic collector, which is only ever run by
# somebody who has already hit a problem and should not also have to
# find out where ECCE was installed.
set(_diag_wrapper ${CMAKE_BINARY_DIR}/wrappers/ecce-diagnose)
file(WRITE ${_diag_wrapper}
"#!/bin/bash
${ECCE_HOME_SH}
exec \"$ECCE_HOME/bin/ecce-diagnose\" \"$@\"
")
install(PROGRAMS ${_diag_wrapper} DESTINATION ${ECCE_WRAPPER_DESTINATION} COMPONENT client)

set(_remote_wrapper ${CMAKE_BINARY_DIR}/wrappers/ecce-remote-setup)
file(WRITE ${_remote_wrapper}
"#!/bin/bash
${ECCE_HOME_SH}
exec \"$ECCE_HOME/bin/ecce-remote-setup\" \"$@\"
")
install(PROGRAMS ${_remote_wrapper} DESTINATION ${ECCE_WRAPPER_DESTINATION} COMPONENT client)

# ------------------------------------------------------------------------
# Install rules. Everything installs under /opt/ecce (see
# CPACK_PACKAGING_INSTALL_PREFIX below) - the compiled apps still expect
# an ECCE_HOME pointing at a directory with bin/ and data/ as siblings
# (see src/util/genutil/Ecce.C, SFile.C's $ECCE_HOME expansion), which a
# split FHS layout (bin in /usr/bin, data in /usr/share/...) doesn't give
# them without a lot of path-handling surgery this session hasn't done.
# ------------------------------------------------------------------------
set(ECCE_GUI_APPS
  basistool calced dirdyed gateway launcher machbrowser machregister
  mddynamics mdenergy mdoptimize mdprepare msgdialog metadyn organizer
  passdialog hostkeydialog pertable polyed solvate builder vizthumbnail)
set(ECCE_CLI_APPS
  load_tgbs ecmd eccejobmaster eccejobstore ecce-localdata ecce-site-admin mocomp
  autosym getfrag genmol genmollat cleansym symops)
if(NOT WIN32)
  list(APPEND ECCE_CLI_APPS ecce-flock)
endif()

if(WIN32)
  # GUI subsystem: no console window opens behind the apps. The command-line
  # programs (ECCE_CLI_APPS, the parsers) keep theirs.
  # The icon Explorer, the Start menu shortcut and the MSI show.
  enable_language(RC)
  set_property(SOURCE ${CMAKE_SOURCE_DIR}/packaging/windows/ecce.rc APPEND PROPERTY
               COMPILE_OPTIONS "-I${CMAKE_SOURCE_DIR}/packaging/windows")
  foreach(_dir ${wxWidgets_INCLUDE_DIRS})
    set_property(SOURCE ${CMAKE_SOURCE_DIR}/packaging/windows/ecce.rc APPEND
                 PROPERTY COMPILE_OPTIONS "-I${_dir}")
  endforeach()
  foreach(_app ${ECCE_GUI_APPS})
    if(TARGET ${_app})
      set_target_properties(${_app} PROPERTIES WIN32_EXECUTABLE ON)
      target_sources(${_app} PRIVATE ${CMAKE_SOURCE_DIR}/packaging/windows/ecce.rc)
    endif()
  endforeach()
endif()

install(TARGETS ${ECCE_GUI_APPS} ${ECCE_CLI_APPS} RUNTIME DESTINATION bin
        COMPONENT client)
# data/ splits cleanly along its own top-level directories: data/client
# is exactly what the GUI apps/scripts above read locally via
# ecceDataPath() (edml manifests, templates, pixmaps, the local
# StructureLibrary browsed by New Structure -- see StructLib.C), so it
# is client content; data/admin is exclusively read by
# ecce-dataserver-start (basis-set seed, the data-server seed tar, the
# vendored help tarball/CGI source) to build the server's own document
# root, and nothing else ever opens it, so it is server content.
if(EXISTS ${CMAKE_SOURCE_DIR}/data/client)
  install(DIRECTORY ${CMAKE_SOURCE_DIR}/data/client DESTINATION data
          COMPONENT client)
endif()
if(EXISTS ${CMAKE_SOURCE_DIR}/data/admin)
  # The basis-set library is the exception: local mode (#216) reads it
  # from the install tree, so it ships with the client, at the same path
  # ecce-dataserver-start reads (ecce-server depends on ecce-client).
  install(DIRECTORY ${CMAKE_SOURCE_DIR}/data/admin DESTINATION data
          COMPONENT server
          PATTERN "basissets" EXCLUDE)
  install(DIRECTORY ${CMAKE_SOURCE_DIR}/data/admin/basissets
          DESTINATION data/admin COMPONENT client)
endif()

# scripts/parsers: per-code basis-set translation and I/O-format scripts
# (e.g. NWChem.edml's <BasisTranslationScript>std2NWChem</BasisTranslationScript>,
# looked up via JCode::getScript() -> TGBSConfig.C, which shells out to
# whichever one the active code needs). Genuinely modern, working Perl
# already (use strict, Getopt::Std, confirmed syntax-clean on this
# system's Perl 5.40) -- this was a pure packaging gap, not a porting
# job, unlike scripts/gbs* (real Python 2, still unported -- separate,
# not currently reachable via any wired-up UI path, left alone for now).
# Distinct from the scripts/ecce/ebuilder/eviewer-class launcher scripts
# deliberately not ported (see the wrapper comment below) -- this is
# actual calculation-setup logic, not a launcher.
if(EXISTS ${CMAKE_SOURCE_DIR}/scripts/parsers)
  install(DIRECTORY ${CMAKE_SOURCE_DIR}/scripts/parsers
          DESTINATION scripts
          USE_SOURCE_PERMISSIONS
          COMPONENT client)
endif()

# scripts/processmachine: Machine Registration's save handler
# (WxMachineRegister::machineChangeButtonClickedCB() shells out to
# $ECCE_HOME/scripts/processmachine, CGI-POST-style via stdin/
# CONTENT_LENGTH). Same story as scripts/parsers above: genuinely modern,
# syntactically clean Perl (no CGI.pm dependency, no hardcoded EMSL
# paths -- its one CVS/svn integration path is already commented out in
# the script itself), just never installed -- a pure packaging gap. Also
# already writes to the correct place for a non-admin user without any
# further changes: it branches on the "siteconfig" form field (site-wide
# vs per-user registration) between $ECCE_HOME/siteconfig (read-only,
# admin-only by design -- matches this build's other shared-vs-per-user
# split, e.g. the JMS broker/data server) and $ECCE_REALUSERHOME/.ECCE
# (always writable) -- Gateway's own "Machine Registration" tool invokes
# `machregister` with no `-admin` flag, so ordinary use already resolves
# to the writable per-user path.
if(EXISTS ${CMAKE_SOURCE_DIR}/scripts/processmachine)
  install(PROGRAMS ${CMAKE_SOURCE_DIR}/scripts/processmachine
          DESTINATION scripts
          COMPONENT client)
endif()

# scripts/gensub: job-submission-script generator, invoked as a bare
# command (Launch.C:2372, `p_localconn->execout("gensub -v  -p subParams",
# ...)`, relying entirely on $PATH -- unlike processmachine/std2NWChem
# above, this one has no full-path fallback at all, so it needs
# $ECCE_HOME/scripts (not just scripts/parsers) on PATH; see the wrapper
# template below. Same diligence as the other scripts/ fixes: perl -c
# clean, no hardcoded EMSL paths, reads only already-installed,
# already-readable package content ($ECCE_HOME/siteconfig,
# $ECCE_HOME/data/client/config/Version) -- a pure packaging gap, not a
# porting job.
if(EXISTS ${CMAKE_SOURCE_DIR}/scripts/gensub)
  install(PROGRAMS ${CMAKE_SOURCE_DIR}/scripts/gensub
          DESTINATION scripts
          COMPONENT client)
endif()


# scripts/eccejobmonitor: found via an audit of every "$ECCE_HOME/scripts/"
# reference in src/ after the gensub fix, prompted by hitting three of
# these packaging gaps in a row live (std2NWChem, processmachine,
# gensub) -- rather than wait to hit the next one, grepped for
# `"/scripts/` across the whole tree and checked every hit. This is the
# one other real gap: Launch.C's moveJobMonitoringFiles()/similar SCPs
# $ECCE_HOME/scripts/eccejobmonitor to the remote machine as part of job
# submission (a full-path reference, not $PATH-dependent, so no wrapper
# change needed) then runs `perl eccejobmonitor -configFile ...` there to
# report job progress/completion back to ECCE -- would have failed the
# same way gensub did, just one step later in the launch sequence.
# Confirmed portable: perl -c clean, only core modules (POSIX, Socket, no
# CPAN deps), no hardcoded EMSL paths despite being a large (4800+ line)
# legacy script.
#
# The rest of that audit came back clean: everything else under scripts/
# (ecce, ebuilder, eviewer, epmf, eprp, ecce_checks, ecce_env,
# runtime_setup*, sysdir, gbsDAVConverter, gbsNWChemConverter,
# gbsDescriber, pmf_gui.py, prp_gui.py) has zero references from any
# compiled C++ code -- they're either top-level launcher scripts this
# build's own ecce-<app> wrappers already supersede (documented rationale
# above), or manual/admin-only tooling invoked by a human, not by ECCE
# itself. scripts/codereg was wrongly written off in an earlier pass of
# this same audit as "a real Python 2/wxPython port, not a packaging
# gap" -- corrected below, it's actually the same packaging-gap shape as
# everything else here, just with one extra piece (a real apt
# dependency).
if(EXISTS ${CMAKE_SOURCE_DIR}/scripts/eccejobmonitor)
  install(PROGRAMS ${CMAKE_SOURCE_DIR}/scripts/eccejobmonitor
          DESTINATION scripts
          COMPONENT client)
endif()

# scripts/ecce-askpass: ssh's SSH_ASKPASS program, which RCommand hands to the
# OpenSSH backend so that opening a shared connection asks in ECCE's dialogs.
install(PROGRAMS ${CMAKE_SOURCE_DIR}/scripts/ecce-askpass
        DESTINATION scripts
        COMPONENT client)

# scripts/ecce-macos-terminal: the default terminal on macOS (UserEditor),
# which runs xterm's "-e command" in Terminal.app.
if(APPLE)
  install(PROGRAMS ${CMAKE_SOURCE_DIR}/scripts/ecce-macos-terminal
          DESTINATION scripts
          COMPONENT client)
endif()

# scripts/ecce-csh2sh and its rules module CshToSh.pm: converts the csh snippets
# in submit.site / CONFIG.* to the sh gensub now writes.  gensub `use`s
# CshToSh.pm from its own directory, so it travels with it; the launcher runs
# ecce-csh2sh once per user and version, and the package scripts run it
# (--check only) over the site files.  Both files are needed or gensub itself
# fails to compile.
install(PROGRAMS ${CMAKE_SOURCE_DIR}/scripts/ecce-csh2sh
        DESTINATION scripts
        COMPONENT client)
install(FILES ${CMAKE_SOURCE_DIR}/scripts/CshToSh.pm
        DESTINATION scripts
        COMPONENT client)
set(_c2s_wrapper ${CMAKE_BINARY_DIR}/wrappers/ecce-csh2sh)
file(WRITE ${_c2s_wrapper}
"#!/bin/bash
${ECCE_HOME_SH}
exec \"$ECCE_HOME/scripts/ecce-csh2sh\" \"$@\"
")
install(PROGRAMS ${_c2s_wrapper} DESTINATION ${ECCE_WRAPPER_DESTINATION} COMPONENT client)

# Read at runtime by Help > About ECCE (ewxApp::OnAbout).
install(FILES ${CMAKE_SOURCE_DIR}/LICENSE
        DESTINATION .
        COMPONENT client)

# The help (#219): help/src/*.md rendered to HTML at build time by
# help/render.py (Python 3 standard library only), opened by the Help
# window (WxHelpViewer) from <prefix>/doc/help.
find_program(PYTHON3_EXECUTABLE NAMES python3)
file(GLOB _help_sources CONFIGURE_DEPENDS ${CMAKE_SOURCE_DIR}/help/src/*.md
     ${CMAKE_SOURCE_DIR}/help/src/img/*)
add_custom_command(
  OUTPUT ${CMAKE_BINARY_DIR}/help-html/toc.txt
  COMMAND ${PYTHON3_EXECUTABLE} ${CMAKE_SOURCE_DIR}/help/render.py
          ${CMAKE_SOURCE_DIR}/help/src ${CMAKE_BINARY_DIR}/help-html
  DEPENDS ${_help_sources} ${CMAKE_SOURCE_DIR}/help/render.py
  COMMENT "Rendering the help pages")
add_custom_target(ecce_help_pages ALL
  DEPENDS ${CMAKE_BINARY_DIR}/help-html/toc.txt)
install(DIRECTORY ${CMAKE_BINARY_DIR}/help-html/
        DESTINATION doc/help
        COMPONENT client)

# Named by `ecce --help`, so it has to be on the machine.
install(FILES ${CMAKE_SOURCE_DIR}/docs/ENVIRONMENT.md
        DESTINATION doc
        COMPONENT client)

# scripts/codereg: Theory/Runtype "Details" dialogs (JCode::
# getTheoryRunTypeEditorNames(), src/dsm/xml/JCode.C). Wrongly assessed in
# an earlier pass of the audit above as unported Python 2/wxPython
# Classic and left alone -- actually already Python-3-ported by an
# earlier session (commit 32d2806: all 21 scripts/*.py files, including
# these, confirmed compiling clean under python3, `import wx` not the
# Classic `from wxPython.wx import *`). The two real gaps: (1) this
# directory was never installed (same shape as every other scripts/
# fix above), and (2) JCode.C hardcoded `python` (not `python3` -- fixed
# alongside this) plus a legacy `LD_LIBRARY_PATH=../3rdparty/...` prefix
# left over from the old vendored-3rdparty multi-platform layout, neither
# of which resolves to anything in this build's flat layout (also
# removed -- the distro's own python3-wxgtk4.0 package, added as a real
# apt dependency below, resolves its own shared-library deps normally).
# NOT verified against the actual wxPython Phoenix API surface inside
# these scripts -- python3-wxgtk4.0 isn't installed in this sandbox and
# can't be without sudo, so whether the dialog *logic* itself (not just
# imports) is Classic/Phoenix-compatible is still an open question the
# 32d2806 commit message already flagged and this pass couldn't close.
# PATTERN EXCLUDE __pycache__: install(DIRECTORY) takes whatever is in the
# source tree, so any developer who has run these scripts (or merely
# python3 -m py_compile on them, as a syntax check) leaves a __pycache__
# directory behind and its .pyc files get packaged into the .deb. They are
# interpreter-version-stamped (cpython-313 etc.) and serve no purpose in
# the package; exclude them so the package contents can't depend on
# whether the build host happened to byte-compile anything first.
if(EXISTS ${CMAKE_SOURCE_DIR}/scripts/codereg)
  install(DIRECTORY ${CMAKE_SOURCE_DIR}/scripts/codereg
          DESTINATION scripts
          USE_SOURCE_PERMISSIONS
          COMPONENT client
          PATTERN "__pycache__" EXCLUDE)
endif()

# Thin /usr/bin wrapper scripts for the 19 GUI apps, so they land on PATH
# and get ECCE_HOME set without the user having to source anything. These
# are NEW scripts written for this build's flat single-platform bin/
# layout - not a port of the old scripts/ecce, ebuilder, eviewer etc,
# which assume a vendored 3rdparty Python interpreter, multi-platform
# ECCE_SYSDIR subdirectories, and (for the top-level "ecce" launcher) the
# messaging gateway. Those, plus the Perl/Python helper
# scripts in scripts/ (gbs*, eccejobmonitor, processmachine, pmf_gui.py/
# prp_gui.py), are deliberately left out of this package for now - they're
# exactly the peripheral Perl/Python pieces Andy's own forks have already
# diverged on, so packaging this repo's copies would ship the wrong
# version. Named "ecce-<app>" (not the bare old names like "builder") to
# avoid colliding with unrelated commands already on a typical system's
# PATH.
# ECCE_REALUSER/ECCE_REALUSERHOME are required (fatal EE_RT_ASSERT if unset
# - see src/util/genutil/Ecce.C realUser()/realUserHome()) by every app, not
# just the messaging-using ones; the previous wrapper never set them, so
# every app would have aborted on first touching preferences/cache paths.
# HOST must also be exported: the broker file and the session topics are
# keyed by HOST and ECCE_SESSION_ID (ecce-session-lib.sh, Ecce::sessionKey,
# #233), and every program of the session must derive the same host.
# DISPLAY is defaulted only so that X programs start under cron or ssh; it
# is not part of the session (drop the default with #166).
set(ECCE_MESSAGING_APPS ${ECCE_GUI_APPS} eccejobmaster eccejobstore)

foreach(_app ${ECCE_GUI_APPS} ${ECCE_CLI_APPS})
  set(_wrapper ${CMAKE_BINARY_DIR}/wrappers/ecce-${_app})
  list(FIND ECCE_MESSAGING_APPS ${_app} _msg_idx)
  if(_msg_idx GREATER -1)
    # Started under -remote too: every app needs this session's relay, and
    # ecce-gateway-start itself skips the local broker in that mode (#167).
    # It fails only when there is no relay for this session, and every one
    # of these apps would then abort on the missing port file
    # (JMSMessage.C), so stop here with its message instead.
    # The session id (#233): inherited from `ecce` or the gateway that
    # started this app, else this app is a session of its own.
    set(_gateway_start ". \"$ECCE_HOME/bin/ecce-session-lib.sh\" || exit 1
ecce_session_ensure
if [ -z \"$ECCE_NO_MESSAGING\" ]; then
  \"$ECCE_HOME/bin/ecce-gateway-start\" || { _rc=$?; echo \"${_app}: not started -- no messaging relay for this session (see above)\" >&2; exit $_rc; }
fi")
    # Same app set as messaging: apps that need the JMS gateway also need
    # data-server (EDSI/WebDAV) access, per EDSIServerCentral::
    # checkServerSetup() -- see ecce-dataserver-start.
    # Split packaging (ECCE_SPLIT_PACKAGES): ecce-dataserver-start only
    # exists at all when the ecce-server package is installed alongside
    # this ecce-client one. A client-only install (talking to someone
    # else's central server, or none yet configured) must not try to
    # spawn it -- and must say clearly why not, rather than a bare
    # "No such file or directory" swallowed by the trailing `|| true`.
    # The user's own server choice (#240) makes this a -remote session.
    set(_usermode ". \"$ECCE_HOME/bin/ecce-session-lib.sh\" || exit 1
ecce_user_server_mode")
    set(_datamode "# Data mode for the whole session (#216): ECCE_LOCAL_DATA when set (empty
# means a data server), else the LocalData preference. Exported, so every
# app of a session uses one store and a preference change waits for the
# next start.
if [ -z \"\${ECCE_LOCAL_DATA+x}\" ] && [ -z \"$ECCE_REMOTE_SERVER\" ] && [ -x \"$ECCE_HOME/bin/ecce-localdata\" ]; then
  ECCE_LOCAL_DATA=$(\"$ECCE_HOME/bin/ecce-localdata\" 2>/dev/null) || ECCE_LOCAL_DATA=
  export ECCE_LOCAL_DATA
  if [ -n \"$ECCE_LOCAL_DATA\" ]; then export ECCE_LOCAL_DATA_FROM_PREF=1; fi
fi")
    # ECCE_LOCAL_DATA selects local mode (#216): data lives in that
    # folder and no data server is wanted.
    set(_dataserver_start "if [ -z \"$ECCE_NO_DATASERVER\" ] && [ -z \"$ECCE_REMOTE_SERVER\" ] && [ -z \"$ECCE_LOCAL_DATA\" ]; then
  if [ -x \"$ECCE_HOME/bin/ecce-dataserver-start\" ]; then
    \"$ECCE_HOME/bin/ecce-dataserver-start\" || true
  else
    echo \"${_app}: no local data server installed ($ECCE_HOME/bin/ecce-dataserver-start missing -- ecce-server not installed) and ECCE_REMOTE_SERVER is not set.\" >&2
    echo \"${_app}: install ecce-server for a local data server, or point this client at a central one (ecce-remote-setup, then 'ecce -remote').\" >&2
  fi
fi")
    # Issue #102: the app is run, not exec'd, so this wrapper shell
    # outlives it and its EXIT trap runs however the app terminated --
    # including the SIGABRT that stranded the broker
    # for ten days on beryllium. ecce-gateway-reap --if-idle does nothing
    # while any other ECCE app is still up on this display, so only the
    # last one out stops the display's session files, and the user's last session
    # stops a per-user broker (never a server's or the site's shared one).
    # The data server stays up until an explicit Quit and Stop Server.
    # bash's own "Terminated" report for a SIGTERM (Quit and Stop Server
    # ends the apps that way) is noise, so the shell's stderr is muted
    # around the app; any other signal is still reported, by name.
    set(_app_exec "trap 'ECCE_REAP_QUIET=1 \"$ECCE_HOME/bin/ecce-gateway-reap\" --if-idle >/dev/null 2>&1 || true' EXIT
exec 3>&2
{ \"$ECCE_HOME/bin/${_app}\" \"$@\" 2>&3 3>&-; } 2>/dev/null
_status=$?
_sig=
if [ $_status -gt 128 ] && [ $_status -ne 143 ]; then _sig=$(kill -l $((_status - 128)) 2>/dev/null); fi
if [ -n \"$_sig\" ]; then
  echo \"${_app}: ended by SIG$_sig\" >&2
fi
exit $_status")
  else()
    set(_usermode "")
    set(_datamode "")
    set(_gateway_start "")
    set(_dataserver_start "")
    set(_app_exec "exec \"$ECCE_HOME/bin/${_app}\" \"$@\"")
  endif()
  file(WRITE ${_wrapper}
"#!/bin/bash
${ECCE_HOME_SH}
export ECCE_REALUSER=\${ECCE_REALUSER:-$(id -un)}
export ECCE_REALUSERHOME=\${ECCE_REALUSERHOME:-$HOME}
export HOST=\${HOST:-$(hostname)}
export DISPLAY=\${DISPLAY:-:0}
export ECCE_HELP=\${ECCE_HELP:-http://localhost:8096/}
# Where NWChem's force-field data lives is a per-distribution decision,
# so it is resolved when the app starts rather than written into the
# package at configure time -- siteconfig/DataServers refers to it as
# $ECCE_NWCHEM_DATA and SFile expands any $VAR. Unset (no NWChem, or an
# unrecognised layout) leaves DataServers' paths visibly broken rather
# than pointing somewhere wrong, and `ecce-nwchem-datadir --verbose`
# says where it looked.
export ECCE_NWCHEM_DATA=\${ECCE_NWCHEM_DATA:-$(\"$ECCE_HOME/bin/ecce-nwchem-datadir\" 2>/dev/null)}
# wxWidgets 3.2's GTK3 backend was ported/tested against X11 window-
# sizing semantics (synchronous configure, geometry hints honored on
# first show); under a native GNOME Wayland session, GTK3's Wayland
# backend negotiates initial window size with the compositor
# asynchronously instead, and several of this app's frames (confirmed
# live: the Gateway launcher toolbar, the Authentication dialog) come
# up with a collapsed/garbled size as a result -- forcing XWayland
# (the same rootless X11 compat layer already used for DISPLAY=:0
# above) sidesteps it, same fix commonly used for other legacy GTK
# apps under Wayland. Only takes effect on an actual Wayland session;
# harmless no-op under a plain X11 session, and left overridable.
# GTK3 hides scroll bars until the pointer reaches a pane's edge; long
# panes (Verify, output, tables) should show that they scroll.
export GTK_OVERLAY_SCROLLING=\${GTK_OVERLAY_SCROLLING:-0}
if [ \"\$XDG_SESSION_TYPE\" = \"wayland\" ]; then
  export GDK_BACKEND=\${GDK_BACKEND:-x11}
  # Under XWayland, IBus holds typed text unshown until Enter in GTK3
  # entries; GTK's own input method draws it.  A user's choice stands.
  export GTK_IM_MODULE=\${GTK_IM_MODULE:-gtk-im-context-simple}
fi
export PATH=\"$ECCE_HOME/scripts:$ECCE_HOME/scripts/parsers:$PATH\"
# THE CENTRAL-SERVER MODEL.  ECCE was originally deployed with one
# server for a whole group -- a shared data server and broker that many
# clients and many users connect to -- and the old csh launcher selected
# it with \"-remote\", which set ECCE_REMOTE_SERVER and made the client
# read siteconfig/RemoteServer/{DataServers,site_runtime} instead of the
# local ones. The C++ side still honours that variable in full
# (Ecce::ecceAutoAccounts, ecceStoreTrajectories, EDSIServerCentral); it
# was only these wrappers that did not know about it, and they would
# start a per-user broker and Apache underneath a client that wanted
# neither: under -remote only the session relay starts, pointed at the
# central broker (#167). Recognised here so \"ecce -remote\" means what
# it always did.
for _arg in \"$@\"; do
  if [ \"$_arg\" = \"-remote\" ]; then export ECCE_REMOTE_SERVER=1; fi
done
${_usermode}
${_datamode}
${_gateway_start}
${_dataserver_start}
${_app_exec}
")
  install(PROGRAMS ${_wrapper} DESTINATION ${ECCE_WRAPPER_DESTINATION} COMPONENT client)
endforeach()

# Plain "ecce" is what people actually expect to type -- gateway is the
# top-level launcher every other app is meant to be reached through (see
# CLAUDE.md's "the two background services" section), but until now only
# "ecce-gateway" existed, named that way to dodge the PATH-collision risk
# every ecce-<app> wrapper above already guards against. This just execs
# that same wrapper, so it inherits its env setup rather than duplicating
# it.
set(_ecce_wrapper ${CMAKE_BINARY_DIR}/wrappers/ecce)
configure_file(${CMAKE_SOURCE_DIR}/packaging/ecce.in ${_ecce_wrapper} @ONLY)
install(PROGRAMS ${_ecce_wrapper} DESTINATION ${ECCE_WRAPPER_DESTINATION} COMPONENT client)

# Desktop entry and icon (#211): a menu and search entry for ECCE.  They go
# beside the wrapper's bin directory, so a ~/.local install gets
# ~/.local/share/applications rather than a system path it cannot write.
get_filename_component(_ecce_share ${ECCE_WRAPPER_DESTINATION} DIRECTORY)
set(_ecce_share ${_ecce_share}/share)
configure_file(${CMAKE_SOURCE_DIR}/packaging/desktop/ecce.desktop.in
               ${CMAKE_BINARY_DIR}/wrappers/ecce.desktop @ONLY)
install(FILES ${CMAKE_BINARY_DIR}/wrappers/ecce.desktop
        DESTINATION ${_ecce_share}/applications COMPONENT client)
# packaging/desktop/make-icon.py generates the icon files.
foreach(_size 48 64 128 256)
  install(FILES ${CMAKE_SOURCE_DIR}/packaging/desktop/ecce-${_size}.png
          DESTINATION ${_ecce_share}/icons/hicolor/${_size}x${_size}/apps
          RENAME ecce.png COMPONENT client)
endforeach()
install(FILES ${CMAKE_SOURCE_DIR}/packaging/desktop/ecce.svg
        DESTINATION ${_ecce_share}/icons/hicolor/scalable/apps
        COMPONENT client)

# "Viewer" isn't a separate build target -- the legacy scripts/viewer
# csh wrapper (not packaged, along with the rest of scripts/ -- see the
# ECCE_GUI_APPS wrapper comment above) just re-execs builder with two
# extra env vars that put it into a read-only/view-only mode. Gateway's
# "Viewer" toolbar button invokes this by name via ResourceDescriptor.xml's
# <InvokeArg>, which now points at ecce-viewer (not the legacy bare
# "viewer" -- avoids exactly the PATH-collision risk the ecce-<app>
# naming convention above already guards against; see ResourceDescriptor*
# .xml's InvokeArg edits alongside this).
set(_viewer_wrapper ${CMAKE_BINARY_DIR}/wrappers/ecce-viewer)
file(WRITE ${_viewer_wrapper}
"#!/bin/bash
${ECCE_HOME_SH}
export ECCE_REALUSER=\${ECCE_REALUSER:-$(id -un)}
export ECCE_REALUSERHOME=\${ECCE_REALUSERHOME:-$HOME}
export HOST=\${HOST:-$(hostname)}
export DISPLAY=\${DISPLAY:-:0}
export ECCE_HELP=\${ECCE_HELP:-http://localhost:8096/}
# See the ecce-<app> wrappers above: resolved at runtime because the
# location is a per-distribution decision.
export ECCE_NWCHEM_DATA=\${ECCE_NWCHEM_DATA:-$(\"$ECCE_HOME/bin/ecce-nwchem-datadir\" 2>/dev/null)}
export PATH=\"$ECCE_HOME/scripts:$ECCE_HOME/scripts/parsers:$PATH\"
export ECCE_INVOKE_VIEWER=1
export ECCE_INVOKE_FROMECCE=1
# Data mode for the whole session (#216): ECCE_LOCAL_DATA when set (empty
# means a data server), else the LocalData preference. Exported, so every
# app of a session uses one store and a preference change waits for the
# next start.
if [ -z \"\${ECCE_LOCAL_DATA+x}\" ] && [ -z \"$ECCE_REMOTE_SERVER\" ] && [ -x \"$ECCE_HOME/bin/ecce-localdata\" ]; then
  ECCE_LOCAL_DATA=$(\"$ECCE_HOME/bin/ecce-localdata\" 2>/dev/null) || ECCE_LOCAL_DATA=
  export ECCE_LOCAL_DATA
  if [ -n \"$ECCE_LOCAL_DATA\" ]; then export ECCE_LOCAL_DATA_FROM_PREF=1; fi
fi
. \"$ECCE_HOME/bin/ecce-session-lib.sh\" || exit 1
ecce_session_ensure
if [ -z \"$ECCE_NO_MESSAGING\" ]; then
  \"$ECCE_HOME/bin/ecce-gateway-start\" || { _rc=$?; echo \"ecce-viewer: not started -- no messaging relay for this session (see above)\" >&2; exit $_rc; }
fi
if [ -z \"$ECCE_NO_DATASERVER\" ] && [ -z \"$ECCE_REMOTE_SERVER\" ] && [ -z \"$ECCE_LOCAL_DATA\" ]; then
  if [ -x \"$ECCE_HOME/bin/ecce-dataserver-start\" ]; then
    \"$ECCE_HOME/bin/ecce-dataserver-start\" || true
  else
    echo \"ecce-viewer: no local data server installed (ecce-server not installed) and ECCE_REMOTE_SERVER is not set.\" >&2
  fi
fi
trap 'ECCE_REAP_QUIET=1 \"$ECCE_HOME/bin/ecce-gateway-reap\" --if-idle >/dev/null 2>&1 || true' EXIT
exec 3>&2
{ \"$ECCE_HOME/bin/builder\" \"$@\" 2>&3 3>&-; } 2>/dev/null
_status=$?
_sig=
if [ $_status -gt 128 ] && [ $_status -ne 143 ]; then _sig=$(kill -l $((_status - 128)) 2>/dev/null); fi
if [ -n \"$_sig\" ]; then
  echo \"ecce-viewer: ended by SIG$_sig\" >&2
fi
exit $_status
")
install(PROGRAMS ${_viewer_wrapper} DESTINATION ${ECCE_WRAPPER_DESTINATION} COMPONENT client)

# ------------------------------------------------------------------------
# CPack: build a .deb instead of the old install_ecce self-extracting
# installer. Run `cpack` (or `cpack -G DEB`) after building to produce it.
# Runtime library deps are auto-detected from the actual linked .so's via
# dpkg-shlibdeps (CPACK_DEBIAN_PACKAGE_SHLIBDEPS) rather than hand-listed,
# so this stays correct as the wx/Xerces/Mesa package versions change.
# ------------------------------------------------------------------------
string(REGEX REPLACE "^v" "" _ecce_deb_version "${ECCE_VERSION_RAW}")
string(REPLACE "-" "~" _ecce_deb_version "${_ecce_deb_version}")
if(_ecce_deb_version STREQUAL "")
  set(_ecce_deb_version "0.0.0")
endif()

set(CPACK_PACKAGE_NAME "ecce")
set(CPACK_PACKAGE_VERSION "${_ecce_deb_version}")
set(CPACK_PACKAGE_VENDOR "FriendsofECCE")
set(CPACK_PACKAGE_CONTACT "Andy <caohlin.umu@gmail.com>")
set(CPACK_PACKAGE_DESCRIPTION_SUMMARY
  "Extensible Computational Chemistry Environment - modeling/workflow GUI tools")
set(CPACK_PACKAGING_INSTALL_PREFIX "/opt/ecce")
set(CPACK_GENERATOR "DEB")
set(CPACK_DEBIAN_PACKAGE_MAINTAINER "${CPACK_PACKAGE_CONTACT}")
set(CPACK_DEBIAN_PACKAGE_SECTION "science")
set(CPACK_DEBIAN_PACKAGE_SHLIBDEPS ON)
# dpkg-shlibdeps only catches linked .so's, not a spawned subprocess --
# apache2 (the data server, see ecce-dataserver-start above) is invoked
# as an external binary, not linked, so it has to be listed explicitly.
# python3-wxgtk4.0 is the same story for scripts/codereg's Theory/Runtype
# Details dialogs (see the scripts/codereg install() block above) -- a
# spawned `python3 .../codereg/*.py`, not a linked dependency of any
# ECCE binary, so dpkg-shlibdeps can't see it either.
# perl: the whole job pipeline (ai.<code>, *.expt, gensub,
# eccejobmonitor, processmachine) is Perl, and Getopt::Std and
# Sys::Hostname are in perl-modules, which perl-base alone lacks.
# openssl: ecce-remote-setup --tls makes and checks certificates with the
# command line tool (#236); the libraries come from shlibdeps. Apache's
# mod_ssl is in the apache2 package on Debian but its own package on RPM.
# xterm: editing an input file with the default editor (vi) opens it in
# an xterm (UserEditor.C).
set(CPACK_DEBIAN_PACKAGE_DEPENDS "apache2, apache2-utils, python3-wxgtk4.0, mosquitto, libaprutil1, perl, xterm, openssl")
# NWChem is a real Debian package (confirmed working: /usr/bin/nwchem,
# symlinked to nwchem.openmpi by the package itself) and the auto-register-
# this-machine flow (RunMgmt::registerLocalMachine()) defaults new machine
# registrations to it -- Recommends (not Depends) so `apt-get install
# ecce`/`apt-get install -f` pulls it in by default, matching that
# auto-registration default, without unconditionally forcing NWChem +
# its MPI/Fortran runtime dependencies onto anyone who explicitly opts
# out via --no-install-recommends.
# openssh-client: RCommand drives ssh/scp/sftp for remote machines;
# a purely local install never uses it.
# www-browser: the Help menu (BrowserHelp.C).
set(CPACK_DEBIAN_PACKAGE_RECOMMENDS "nwchem, openssh-client")
set(CPACK_DEBIAN_PACKAGE_SUGGESTS "www-browser")
# RelWithDebInfo keeps -g everywhere (useful while porting - see the
# CMAKE_BUILD_TYPE default above), which makes for a needlessly huge .deb;
# strip debug symbols out of the packaged copies only, not the build tree.
set(CPACK_STRIP_FILES ON)
set(CPACK_DEBIAN_FILE_NAME DEB-DEFAULT)

# ---------------------------------------------------------------------------
#  RPM, for Fedora/RHEL/Rocky.  Built only when rpmbuild is present, so a
#  Debian box without it still packages exactly as before rather than
#  failing at the end of a long build.  Install it with `apt install rpm`.
#
#  The dependency list is NOT the Debian one with different spellings.
#  Real differences:
#
#    * apache2/apache2-utils are httpd/httpd-tools.
#    * python3-wxgtk4.0 is python3-wxpython4.
#    * mosquitto (broker and libmosquitto) is in Fedora and in EPEL for
#      RHEL/Rocky; one package covers both here.
#    * openssh-client is openssh-clients.
#
#  perl and xterm are Requires here for the same reasons given beside
#  the Debian CPACK_DEBIAN_PACKAGE_DEPENDS above (the scripts/ Perl
#  pipeline, and UserEditor.C's "vi" default running inside xterm) --
#  both package names are identical on Fedora/RHEL/Rocky.
#
#  nwchem is in Fedora but not in RHEL/Rocky without EPEL, so it stays a
#  weak dependency there too, matching the Debian Recommends.
#  firefox matches the Debian Suggests (BrowserHelp.C's Help-menu
#  fallback).
# The Coin viewer needs EPEL 9 / Fedora Coin4 at runtime (rpmbuild would also
# find it from the ELF, spelled out so the intent is visible).
set(_coin_rpm "")
if(ECCE_USE_COIN)
  set(_coin_rpm ", Coin4")
endif()
find_program(RPMBUILD_EXECUTABLE rpmbuild)
if(RPMBUILD_EXECUTABLE)
  list(APPEND CPACK_GENERATOR "RPM")
  set(CPACK_RPM_PACKAGE_LICENSE "ECL-2.0")
  set(CPACK_RPM_PACKAGE_GROUP "Applications/Engineering")
  set(CPACK_RPM_PACKAGE_URL "https://github.com/FriendsofECCE/ECCE")
  set(CPACK_RPM_PACKAGE_REQUIRES "httpd, httpd-tools, mod_ssl, openssl, python3-wxpython4, perl, xterm, mosquitto, apr-util${_coin_rpm}")
  set(CPACK_RPM_PACKAGE_SUGGESTS "nwchem, openssh-clients, firefox")
  set(CPACK_RPM_FILE_NAME RPM-DEFAULT)
  #  /opt/ecce is ours, but /opt itself is owned by filesystem(5).  Without
  #  this the package claims /opt and conflicts with it.
  set(CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION "/opt")
  #  Built on Debian, so let rpmbuild work out library requirements from
  #  the binaries rather than trusting a hand-written list that would be
  #  wrong on both distributions.
  set(CPACK_RPM_PACKAGE_AUTOREQ ON)
  set(CPACK_RPM_PACKAGE_AUTOPROV OFF)
  #  With AutoProv off, nothing provides what the package requires of
  #  itself: the scripts' own Perl files (perl(rdStandardGBS) ...) and
  #  config(ecce) for the %config files. dnf then refuses the install
  #  (#199). rpm adds the config() requirement itself, past any filter,
  #  so provide it; the Perl ones are dropped from the generated list.
  #  Brackets, not backslashes: rpm's macro expansion eats one level.
  set(CPACK_RPM_PACKAGE_PROVIDES "config(ecce) = %{version}-%{release}")
  file(GLOB_RECURSE _ecce_own_perl RELATIVE ${CMAKE_SOURCE_DIR}
       ${CMAKE_SOURCE_DIR}/scripts/*.pm ${CMAKE_SOURCE_DIR}/scripts/*.pl)
  set(_ecce_own_perl_names "")
  foreach(_p ${_ecce_own_perl})
    get_filename_component(_n ${_p} NAME)
    string(REGEX REPLACE "\\.pm$" "" _n "${_n}")
    string(REPLACE "." "[.]" _n "${_n}")
    list(APPEND _ecce_own_perl_names "${_n}")
  endforeach()
  list(REMOVE_DUPLICATES _ecce_own_perl_names)
  string(REPLACE ";" "|" _ecce_own_perl_names "${_ecce_own_perl_names}")
  set(CPACK_RPM_SPEC_MORE_DEFINE
      "%global __requires_exclude ^perl[(](${_ecce_own_perl_names})[)]")
  message(STATUS "rpmbuild found: cpack will also produce an .rpm")
else()
  message(STATUS "rpmbuild not found: cpack will produce a .deb only "
                 "(apt install rpm to enable RPM packaging)")
endif()

# The site configuration an admin edits (sudo ecce -admin, ecce-remote-
# setup's copy of a server's machine list, #188) must survive upgrades,
# so it is a Debian conffile / RPM %config(noreplace). 
set(_ecce_siteconfig_conffiles
  Machines Queues QueueManagers DataServers site_runtime
  submit.site AppColors StartupMessage NewUserMessage
  CONFIG.dummy dummy.Q example-slurm.Q
  CONFIG-Examples/CONFIG.loadleveler CONFIG-Examples/CONFIG.lsf
  CONFIG-Examples/CONFIG.mpp2 CONFIG-Examples/CONFIG.pbs
  CONFIG-Examples/CONFIG.sge CONFIG-Examples/CONFIG.workstation)
set(_ecce_conffiles_debian ${CMAKE_BINARY_DIR}/conffiles/conffiles)
set(_ecce_conffiles_content "")
set(_ecce_rpm_filelist "")
foreach(_f ${_ecce_siteconfig_conffiles})
  string(APPEND _ecce_conffiles_content
         "${CPACK_PACKAGING_INSTALL_PREFIX}/siteconfig/${_f}\n")
  list(APPEND _ecce_rpm_filelist
       "%config(noreplace) ${CPACK_PACKAGING_INSTALL_PREFIX}/siteconfig/${_f}")
endforeach()
file(WRITE ${_ecce_conffiles_debian} "${_ecce_conffiles_content}")
# The maintainer scripts only REPORT csh in the site job-script files (never
# touch a conffile): the admin converts with `sudo ecce-csh2sh --convert --siteconfig`.
configure_file(${CMAKE_SOURCE_DIR}/packaging/postinst.in
               ${CMAKE_BINARY_DIR}/conffiles/postinst @ONLY)
configure_file(${CMAKE_SOURCE_DIR}/packaging/rpm-post.sh.in
               ${CMAKE_BINARY_DIR}/conffiles/rpm-post.sh @ONLY)
set(CPACK_DEBIAN_PACKAGE_CONTROL_STRICT_PERMISSION TRUE)
set(CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA
    "${_ecce_conffiles_debian};${CMAKE_BINARY_DIR}/conffiles/postinst")
set(CPACK_RPM_POST_INSTALL_SCRIPT_FILE ${CMAKE_BINARY_DIR}/conffiles/rpm-post.sh)
set(CPACK_RPM_USER_FILELIST "${_ecce_rpm_filelist}")
# siteconfig/ is all client-side, so under the split it goes with ecce-client.
set(CPACK_DEBIAN_CLIENT_PACKAGE_CONTROL_EXTRA
    "${_ecce_conffiles_debian};${CMAKE_BINARY_DIR}/conffiles/postinst")
set(CPACK_RPM_CLIENT_POST_INSTALL_SCRIPT_FILE ${CMAKE_BINARY_DIR}/conffiles/rpm-post.sh)
set(CPACK_RPM_CLIENT_USER_FILELIST "${_ecce_rpm_filelist}")

# ---------------------------------------------------------------------------
# Split packaging (ECCE_SPLIT_PACKAGES). Every install() rule above already
# carries COMPONENT client/server; this block only decides whether CPack
# acts on those tags at all, and what each resulting package's own
# metadata is. No ecce-common component: auditing every install() rule
# above by which side reads it, nothing was needed by both -- siteconfig/
# and scripts/ are entirely client-read, data/admin and the Apache/broker
# config are entirely server-read. A common package would have shipped
# empty, so there isn't one.
# ---------------------------------------------------------------------------
if(ECCE_SPLIT_PACKAGES)
  # The version boundary below which a plain "ecce" install is the OLD
  # monolithic package -- ecce-client/ecce-server each Break+Replace it
  # so dpkg can upgrade one straight into the split pair instead of
  # refusing with a file-already-owned-by-another-package conflict. Kept
  # as its own variable (rather than reusing _ecce_deb_version directly
  # in the Breaks string) because the branch is still versioned 8.17.0 --
  # whichever release first ships split packages is the real boundary,
  # and that is a decision for whoever cuts that release, not something
  # to hardcode here now.
  # Not a cache variable: a cached default froze at the version of the
  # build directory's first configure (8.17.0), so an 8.17.x install was
  # not replaced and the upgrade stopped on file conflicts.
  if(NOT ECCE_MONOLITHIC_BREAK_VERSION_OVERRIDE)
    set(ECCE_MONOLITHIC_BREAK_VERSION "${_ecce_deb_version}")
  else()
    set(ECCE_MONOLITHIC_BREAK_VERSION "${ECCE_MONOLITHIC_BREAK_VERSION_OVERRIDE}")
  endif()

  # CPack falls back to the monolithic-build globals below (Depends,
  # Recommends, Suggests) for any component that doesn't set its own --
  # confirmed live: without this, ecce-server
  # picked up "Recommends: nwchem" from CPACK_DEBIAN_PACKAGE_RECOMMENDS
  # above, which is wrong for a headless server box.
  # CPACK_DEBIAN_PACKAGE_SUGGESTS ("www-browser" --
  # client-only, the Help menu) leaks
  # the same way if left unset: it showed up as a Suggests on ecce-server, found the same way as the Recommends
  # case above. Clear all three globals here so every component's
  # metadata is exactly what this block sets and nothing leaks in from
  # the monolithic settings above.
  unset(CPACK_DEBIAN_PACKAGE_DEPENDS)
  unset(CPACK_DEBIAN_PACKAGE_RECOMMENDS)
  unset(CPACK_DEBIAN_PACKAGE_SUGGESTS)

  set(CPACK_DEB_COMPONENT_INSTALL ON)
  set(CPACK_COMPONENTS_ALL client server)
  # Each component becomes its own independently installable package
  # rather than CPack's default of one combined "unspecified"-grouped
  # archive; auto-shlibdeps and auto-provides/requires run separately per
  # component package (so e.g. only ecce-client ends up depending on
  # wxWidgets/Xerces, since only its ELF binaries link them).
  set(CPACK_DEB_COMPONENT_INSTALL ON)
  set(CPACK_COMPONENTS_GROUPING IGNORE)
  set(CPACK_DEBIAN_ENABLE_COMPONENT_DEPENDS ON)
  set(CPACK_RPM_COMPONENT_INSTALL ON)

  set(CPACK_DEBIAN_CLIENT_PACKAGE_NAME "ecce-client")
  set(CPACK_DEBIAN_CLIENT_FILE_NAME DEB-DEFAULT)
  set(CPACK_DEBIAN_CLIENT_PACKAGE_DESCRIPTION
    "Extensible Computational Chemistry Environment - client (GUI apps, input generators/parsers, job-launch tooling)")
  # apache2/apache2-utils move to ecce-server; everything else is needed
  # here (python3-wxgtk4.0 for scripts/codereg, perl/xterm for the reasons
  # given beside the monolithic set above).
  #
  # libmosquitto1 is what every messaging process links. The gateway
  # scripts that start a per-user broker live here too, so a local-mode
  # client needs the mosquitto package; it is a Recommends because a
  # -remote client only needs the library, and the package's own system
  # service is of no use to it.
  set(CPACK_DEBIAN_CLIENT_PACKAGE_DEPENDS
      "python3-wxgtk4.0, perl, xterm, libmosquitto1, curl, openssl")
  # A client on the SAME machine as a server benefits from it (the
  # default "everything on one box" case this project still ships), but
  # a client of an already-central server (#167/#138 -- the teaching
  # deployment) has no use for a local data server or broker at all, so
  # this is Recommends, not Depends, matching the design brief.
  set(CPACK_DEBIAN_CLIENT_PACKAGE_RECOMMENDS "ecce-server, mosquitto, nwchem, openssh-client")
  set(CPACK_DEBIAN_CLIENT_PACKAGE_SUGGESTS "www-browser")
  # Lets dpkg upgrade a monolithic 8.x "ecce" straight into ecce-client:
  # without this, installing ecce-client while the old ecce package still
  # owns e.g. /opt/ecce/bin/organizer is a file-already-owned conflict,
  # not an upgrade.
  set(CPACK_DEBIAN_CLIENT_PACKAGE_BREAKS "ecce (<< ${ECCE_MONOLITHIC_BREAK_VERSION})")
  set(CPACK_DEBIAN_CLIENT_PACKAGE_REPLACES "ecce (<< ${ECCE_MONOLITHIC_BREAK_VERSION})")

  set(CPACK_DEBIAN_SERVER_PACKAGE_NAME "ecce-server")
  set(CPACK_DEBIAN_SERVER_FILE_NAME DEB-DEFAULT)
  set(CPACK_DEBIAN_SERVER_PACKAGE_DESCRIPTION
    "Extensible Computational Chemistry Environment - server (WebDAV data server, message broker)")
  # The gateway scripts, ecce-remote-setup and the GUI-free job agent
  # (launchjob, eccejobmaster, eccejobstore) ship in ecce-client, and a server
  # needs them, so the server brings the client -- GUI libraries included,
  # unused on a headless box. Accepted rather than a third package.
  set(CPACK_DEBIAN_SERVER_PACKAGE_DEPENDS "apache2, apache2-utils, mosquitto, libaprutil1, openssl, ecce-client (= ${_ecce_deb_version})")
  set(CPACK_DEBIAN_SERVER_PACKAGE_BREAKS "ecce (<< ${ECCE_MONOLITHIC_BREAK_VERSION})")
  set(CPACK_DEBIAN_SERVER_PACKAGE_REPLACES "ecce (<< ${ECCE_MONOLITHIC_BREAK_VERSION})")

  # No "ecce" metapackage (Andy, 2026-09-30): ECCE ships as loose files, not
  # from an apt/dnf repository, so it would never pull the halves in on an
  # upgrade, and its unpack removed the monolithic files first.

  if(RPMBUILD_EXECUTABLE)
    set(CPACK_RPM_CLIENT_PACKAGE_NAME "ecce-client")
    set(CPACK_RPM_CLIENT_FILE_NAME RPM-DEFAULT)
    # mosquitto provides both the library and the broker on RPM distros.
    set(CPACK_RPM_CLIENT_PACKAGE_REQUIRES
        "python3-wxpython4, perl, xterm, mosquitto, curl, openssl${_coin_rpm}")
    set(CPACK_RPM_CLIENT_PACKAGE_SUGGESTS
        "ecce-server, nwchem, openssh-clients, firefox")
    # RPM has no direct Breaks/Replaces pair; Obsoletes+Provides is the
    # idiomatic equivalent for "this package supersedes an older one
    # that owned the same paths", and Conflicts blocks the two from
    # being installed side by side (the old monolithic package is
    # exactly what ecce-client+ecce-server now provide between them, so
    # letting both stay installed would leave stale duplicate files).
    set(CPACK_RPM_CLIENT_PACKAGE_OBSOLETES "ecce < ${ECCE_MONOLITHIC_BREAK_VERSION}")
    set(CPACK_RPM_CLIENT_PACKAGE_CONFLICTS "ecce < ${ECCE_MONOLITHIC_BREAK_VERSION}")
    set(CPACK_RPM_SERVER_PACKAGE_NAME "ecce-server")
    set(CPACK_RPM_SERVER_FILE_NAME RPM-DEFAULT)
    set(CPACK_RPM_SERVER_PACKAGE_REQUIRES "httpd, httpd-tools, mod_ssl, openssl, mosquitto, apr-util, ecce-client = ${_ecce_deb_version}")
    set(CPACK_RPM_SERVER_PACKAGE_OBSOLETES "ecce < ${ECCE_MONOLITHIC_BREAK_VERSION}")
    set(CPACK_RPM_SERVER_PACKAGE_CONFLICTS "ecce < ${ECCE_MONOLITHIC_BREAK_VERSION}")
    set(CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION "/opt")
    set(CPACK_RPM_CLIENT_PACKAGE_AUTOREQ ON)
    set(CPACK_RPM_CLIENT_PACKAGE_PROVIDES "config(ecce-client) = %{version}-%{release}")
    set(CPACK_RPM_SERVER_PACKAGE_AUTOREQ ON)
    set(CPACK_RPM_PACKAGE_AUTOPROV OFF)
  endif()
endif()

include(CPack)

# ---------------------------------------------------------------------------
# Tests
#
# tests/parsers is a standalone, script-level regression suite for the
# parser / property pipeline: it replays checked-in chemistry-code output
# through the real .desc Begin/Skip/Lines/End/Frequency algorithm and the
# real scripts/parsers/* scripts and diffs the extracted properties against
# checked-in expected output.  It needs only python3 and perl -- no build,
# no GUI, no ECCE services, no chemistry codes -- so it is registered here
# purely so `ctest` picks it up; nothing else in the build depends on it,
# and the fixtures are deliberately NOT installed into the package.
#
#     cd build-cmake && ctest -R parsers --output-on-failure
# ---------------------------------------------------------------------------
enable_testing()
find_program(PYTHON3_EXECUTABLE NAMES python3)

# tests/exceptions -- which exceptions print a "Throw Log" when thrown.
add_executable(throwlog_test tests/exceptions/throwlog_test.C)
target_link_libraries(throwlog_test PRIVATE ecceutil)
add_test(NAME throwlog COMMAND throwlog_test)
add_test(NAME throwlog-all COMMAND throwlog_test all)

# tests/releasecheck -- version order and release-line choice of the update
# check (#273), on canned GitHub JSON.
add_executable(releasecheck_test tests/releasecheck/releasecheck_test.C)
target_link_libraries(releasecheck_test PRIVATE ecceutil)
add_test(NAME releasecheck COMMAND releasecheck_test)

# tests/systemfolder -- the Organizer's Local data node is a system folder (#288).
add_executable(systemfolder_test tests/systemfolder/systemfolder_test.C)
target_link_libraries(systemfolder_test PRIVATE ecceutil)
add_test(NAME systemfolder COMMAND systemfolder_test)

# The ECCE_HIDE_MO_DIAGRAM site setting (#280).
add_executable(sitehide_test tests/systemfolder/sitehide_test.C)
target_link_libraries(sitehide_test PRIVATE ecceutil)
add_test(NAME sitehide COMMAND sitehide_test)

# Preferences > Advanced switches reach started programs' environment (#307).
add_executable(envswitches_test tests/envswitches/envswitches_test.C)
target_link_libraries(envswitches_test PRIVATE ecceutil)
add_test(NAME envswitches COMMAND envswitches_test)

# tests/formula -- the Hill-order formula shown in the Organizer.
add_executable(formula_test tests/formula/formula_test.C)
target_link_libraries(formula_test PRIVATE eccetdat ecceutil)
add_test(NAME formula COMMAND formula_test)

# tests/dummy_atoms (#298): dummy atom X is not an element for basis/formula.
add_executable(dummy_fragment_test tests/dummy_atoms/dummy_fragment_test.C)
target_link_libraries(dummy_fragment_test PRIVATE eccetdat ecceutil)
add_test(NAME dummy_fragment COMMAND dummy_fragment_test)
set_tests_properties(dummy_fragment PROPERTIES
  ENVIRONMENT "ECCE_HOME=${CMAKE_SOURCE_DIR};ECCE_REALUSER=fragreaders;ECCE_REALUSERHOME=${CMAKE_BINARY_DIR}/fragreaders-home")
add_test(NAME dummy_atoms_decks
  COMMAND python3 ${CMAKE_SOURCE_DIR}/tests/dummy_atoms/run_tests.py)

# #297: which NWChem module each MP2/CC theory is written for (decks only;
# add --run to compare real nwchem energies).
add_test(NAME nwchem_cc_decks
  COMMAND python3 ${CMAKE_SOURCE_DIR}/tests/nwchem_cc/run_tests.py)

# tests/spectrum -- the wx-free IR/Raman spectrum model (#214): ticks, axis
# reversal and zoom, broadening, sticks.
add_executable(vibspectrum_test tests/spectrum/vibspectrum_test.C)
target_link_libraries(vibspectrum_test PRIVATE eccetdat ecceutil)
add_test(NAME vibspectrum COMMAND vibspectrum_test)
# The canvas painted onto a bitmap (tools/spectrum/render) from the numbers
# the codes printed; needs wx, g++ and xvfb-run, SKIPs without them.
find_program(PYTHON3_FOR_SPECTRUM NAMES python3)
if(PYTHON3_FOR_SPECTRUM)
  add_test(NAME spectrum_canvas
           COMMAND ${PYTHON3_FOR_SPECTRUM}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/spectrum/run_tests.py
                   ${CMAKE_BINARY_DIR}/spectrum-render)
  set_tests_properties(spectrum_canvas PROPERTIES TIMEOUT 600
                       SKIP_RETURN_CODE 77)
endif()

# tests/gridview -- Ctrl/Shift+click selection in WxGridView (#290); needs a
# display, so ctest runs it under xvfb-run.
add_executable(gridview_select_test
               tests/gridview/gridview_select_test.C)
target_compile_definitions(gridview_select_test PRIVATE ${wxWidgets_DEFINITIONS})
target_include_directories(gridview_select_test PRIVATE
                           ${wxWidgets_INCLUDE_DIRS} ${XercesC_INCLUDE_DIRS})
target_link_libraries(gridview_select_test PRIVATE eccewxgui
  ${wxWidgets_LIBRARIES} eccedsi eccedav eccecipc eccefaces eccexml eccetdat
  ecceutil ${XercesC_LIBRARIES})
find_program(XVFB_RUN_FOR_GRIDVIEW NAMES xvfb-run)
if(XVFB_RUN_FOR_GRIDVIEW)
  add_test(NAME gridview-select
           COMMAND ${XVFB_RUN_FOR_GRIDVIEW} -a $<TARGET_FILE:gridview_select_test>)
  set_tests_properties(gridview-select PROPERTIES ENVIRONMENT
    "ECCE_HOME=${CMAKE_SOURCE_DIR};ECCE_REALUSERHOME=${CMAKE_BINARY_DIR}")
endif()

# tests/progress -- the job progress snapshot and the Progress box's lines
# (#284), without wx; the monitor's [PROGRESS] handling over a real output.
add_executable(progress_test tests/progress/progress_test.C)
target_link_libraries(progress_test PRIVATE ecceutil)
add_test(NAME progress COMMAND progress_test)
if(PYTHON3_FOR_SPECTRUM)
  add_test(NAME progress-monitor
           COMMAND ${PYTHON3_FOR_SPECTRUM}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/progress/monitor_test.py)
  set_tests_properties(progress-monitor PROPERTIES SKIP_RETURN_CODE 77)
  # each code's [PROGRESS] entries over real output of that code
  add_test(NAME progress-codes
           COMMAND ${PYTHON3_FOR_SPECTRUM}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/progress/codes_test.py)
  set_tests_properties(progress-codes PROPERTIES SKIP_RETURN_CODE 77)
endif()

# tests/session -- the session id and key (#233): shell and C++ derivations
# agree, and both generators make well-formed, distinct ids.
add_executable(session_key_test tests/session/session_key_test.C)
target_link_libraries(session_key_test PRIVATE ecceutil)
add_test(NAME session-key COMMAND session_key_test
         ${CMAKE_SOURCE_DIR}/packaging/gateway/ecce-session-lib.sh)
if(NOT WIN32)   # POSIX-only test programs
add_executable(session_lease_test tests/session/session_lease_test.C)
target_link_libraries(session_lease_test PRIVATE ecceutil)
add_test(NAME session-lease COMMAND session_lease_test
         ${CMAKE_SOURCE_DIR}/packaging/gateway/ecce-session-lib.sh)
endif()
add_test(NAME session-display-gate COMMAND bash
         ${CMAKE_SOURCE_DIR}/tests/session/display_gate.sh ${CMAKE_SOURCE_DIR})
set_tests_properties(session-display-gate PROPERTIES SKIP_RETURN_CODE 77)

# tests/gromacs_md -- GROMACS MD study tasks.  gromacs_structure checks the
# .gro reader of the Inputs page against gmx editconf; gromacs_md runs the
# study's scripts (md.gmxtask, gromacs.launchpp, gensub, the monitor and
# parsers) on real gmx, task after task.  Both SKIP without gmx.
# See docs/GROMACS.md.
add_executable(gromacs_groconv tests/gromacs_md/groconv.C
               src/dsm/chemistry/GromacsStructure.C)
add_test(NAME gromacs_structure
         COMMAND ${PYTHON3_EXECUTABLE}
                 ${CMAKE_SOURCE_DIR}/tests/gromacs_md/groconv_test.py
                 $<TARGET_FILE:gromacs_groconv>)
set_tests_properties(gromacs_structure PROPERTIES SKIP_RETURN_CODE 77)
add_executable(gromacs_includes tests/gromacs_md/includes.C
               src/dsm/chemistry/GromacsIncludes.C)
add_test(NAME gromacs_md
         COMMAND ${PYTHON3_EXECUTABLE}
                 ${CMAKE_SOURCE_DIR}/tests/gromacs_md/run_tests.py
                 --includes-bin $<TARGET_FILE:gromacs_includes>)
set_tests_properties(gromacs_md PROPERTIES TIMEOUT 900 SKIP_RETURN_CODE 77)

# tests/mqtt -- the messaging library against a private mosquitto on a Unix
# socket; checks delivery, not just acknowledgement.  "auth" is the same on
# a TCP broker with two accounts and the shipped access rules.  SKIPs (77)
# without the mosquitto binary.
if(NOT WIN32)
add_executable(mqtt_test tests/mqtt/mqtt_test.C)
target_include_directories(mqtt_test PRIVATE ${XercesC_INCLUDE_DIRS})
target_link_libraries(mqtt_test PRIVATE ecceutil ${XercesC_LIBRARIES})
add_test(NAME mqtt COMMAND mqtt_test ${CMAKE_SOURCE_DIR})
add_test(NAME mqtt-auth COMMAND mqtt_test auth ${CMAKE_SOURCE_DIR})
if(TARGET ecce_users_auth)
  add_test(NAME mqtt-auth-plugin
           COMMAND mqtt_test auth ${CMAKE_SOURCE_DIR} $<TARGET_FILE:ecce_users_auth>)
  set_tests_properties(mqtt-auth-plugin PROPERTIES TIMEOUT 120 SKIP_RETURN_CODE 77)
endif()
set_tests_properties(mqtt mqtt-auth PROPERTIES TIMEOUT 120 SKIP_RETURN_CODE 77)
endif()

# tests/tls -- https data-server client (#236): pinned certificate, CA mode
# with host-name check, certificate rejection, no fallback to plain http.
# Needs python3 and the openssl command line; SKIPs (77) without them.
add_executable(tls_client_test tests/tls/tls_client_test.C)
target_include_directories(tls_client_test PRIVATE ${XercesC_INCLUDE_DIRS})
target_link_libraries(tls_client_test PRIVATE
  eccedsi eccedav eccecipc eccefaces eccexml eccetdat ecceutil ${XercesC_LIBRARIES})
add_test(NAME tls_client
         COMMAND ${PYTHON3_EXECUTABLE} ${CMAKE_SOURCE_DIR}/tests/tls/run_tests.py
                 $<TARGET_FILE:tls_client_test> ${CMAKE_BINARY_DIR}/tls-test)
set_tests_properties(tls_client PROPERTIES TIMEOUT 120 SKIP_RETURN_CODE 77)
# The first-start window's connection step and when the question is asked (#240).
add_test(NAME tls_first_connect
         COMMAND ${PYTHON3_EXECUTABLE} ${CMAKE_SOURCE_DIR}/tests/tls/first_connect_test.py
                 ${CMAKE_BINARY_DIR}/tls-first-connect)
set_tests_properties(tls_first_connect PROPERTIES TIMEOUT 120 SKIP_RETURN_CODE 77)
add_test(NAME first_start_question
         COMMAND ${PYTHON3_EXECUTABLE} ${CMAKE_SOURCE_DIR}/tests/apps/first_start_test.py
                 $<TARGET_FILE:ecce-localdata> ${CMAKE_BINARY_DIR}/first-start-test)
set_tests_properties(first_start_question PROPERTIES TIMEOUT 60)

# The central server over TLS (#236): the real data server and broker scripts
# on loopback with a fresh certificate, then the clients with and without
# the right pin.
add_executable(tls_broker_test tests/tls/tls_broker_test.C)
target_include_directories(tls_broker_test PRIVATE ${XercesC_INCLUDE_DIRS})
target_link_libraries(tls_broker_test PRIVATE ecceutil ${XercesC_LIBRARIES})
add_test(NAME tls_server
         COMMAND ${PYTHON3_EXECUTABLE} ${CMAKE_SOURCE_DIR}/tests/tls/server_tls.py
                 $<TARGET_FILE:tls_client_test> $<TARGET_FILE:tls_broker_test>
                 ${CMAKE_BINARY_DIR} ${CMAKE_BINARY_DIR}/tls-server-test)
set_tests_properties(tls_server PROPERTIES TIMEOUT 300 SKIP_RETURN_CODE 77)
if(PYTHON3_EXECUTABLE)
  add_test(NAME parsers
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/parsers/run_tests.py
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/parsers)

  # The stored geometry and the normal modes are in one frame (#312).
  add_test(NAME parsers_vib_frame
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/parsers/vib_frame_test.py
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/parsers)

  # The same fixtures cut off part-way, through the real eccejobmonitor and
  # parser scripts (#107 part B).
  add_test(NAME parsers_partial
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/parsers/partial_replay.py
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/parsers)
  set_tests_properties(parsers_partial PROPERTIES TIMEOUT 600)

  # tests/dialogs -- the GUI-side sibling of the above: runs the real
  # scripts/codereg dialogs headlessly (broadwayd, GTK3's displayless
  # backend; falls back to xvfb; SKIPs cleanly with neither) and diffs what
  # each dialog offers against what the matching ai.<code> generator
  # recognises, in both directions.  Needs python3 + wxPython, no build and
  # no ECCE services.  See tests/dialogs/README.md.
  #
  #     cd build-cmake && ctest -R dialogs --output-on-failure
  add_test(NAME dialogs
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/dialogs/run_tests.py
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/dialogs)

  # The native ecce-dialog against the wxPython dialog for ECCE-QM Theory
  # Details: same settings sent, same pixels (tests/dialogs/native_test.py).
  add_test(NAME dialogs_native
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/dialogs/native_test.py
                   --dialog $<TARGET_FILE:ecce-dialog>)
  set_tests_properties(dialogs_native PROPERTIES SKIP_RETURN_CODE 77
                       TIMEOUT 900)

  # tests/verify -- the input-deck checker (#148).  Runs the real
  # scripts/parsers/verifyinput over decks captured from real runs and
  # checks what it says about each.  Weighted against FALSE ALARMS
  # rather than against misses: a user told their working deck is
  # broken stops believing the light, including the time it is right.
  # Needs only python3 and perl.
  #
  #     cd build-cmake && ctest -R verify --output-on-failure
  add_test(NAME verify
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/verify/run_tests.py
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/verify)

  # An EGL-only Coin gets the surfaceless display, not an EGL X11 one (#237).
  if(ECCE_USE_COIN AND ECCE_GL_X11)
    add_test(NAME coin_egl_display COMMAND egl-display-check)
    set_tests_properties(coin_egl_display PROPERTIES SKIP_RETURN_CODE 77 TIMEOUT 60)
  endif()

  # tests/look -- the colours that carry meaning (run states, checker
  # status) reach 4.5:1 against light and dark theme backgrounds (#210).
  #
  #     cd build-cmake && ctest -R look --output-on-failure
  add_test(NAME look_contrast
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/look/contrast.py)

  # Text in a window that has lost focus keeps its contrast (GTK :backdrop),
  # and disabled text still looks disabled (#210).  Compiles
  # tests/look/backdrop.C against this build; SKIPs without Xvfb or PIL.
  add_test(NAME look_backdrop
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/look/login_backdrop.py
                   backdrop ${CMAKE_BINARY_DIR}/look-backdrop
                   --libdir ${CMAKE_BINARY_DIR} --tag after)
  set_tests_properties(look_backdrop PROPERTIES SKIP_RETURN_CODE 77 TIMEOUT 300)

  # The offscreen renderer's .rgb output against ImageMagick and PIL (#231).
  # Needs `ninja render-rgb`, Xvfb, convert and PIL; SKIPs without them.
  add_test(NAME look_imageconv
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/look/imageconv.py
                   ${CMAKE_BINARY_DIR}/render-rgb)
  set_tests_properties(look_imageconv PROPERTIES SKIP_RETURN_CODE 77 TIMEOUT 300)

  # Thumbnail / Save As renders shade an ESP surface like the canvas.
  # Needs `ninja viewer-scenes`, Xvfb and PIL; SKIPs without them.
  add_test(NAME look_offscreen_shading
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/look/offscreen_shading.py
                   ${CMAKE_BINARY_DIR}/viewer-scenes)
  set_tests_properties(look_offscreen_shading PROPERTIES SKIP_RETURN_CODE 77 TIMEOUT 300)

  # Sticks are thinner while normal-mode arrows are shown, normal again
  # when they are hidden (#227).  Needs `ninja viewer-scenes` and Xvfb.
  add_test(NAME look_nm_sticks
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/look/nm_sticks.py
                   ${CMAKE_BINARY_DIR}/viewer-scenes)
  set_tests_properties(look_nm_sticks PROPERTIES SKIP_RETURN_CODE 77 TIMEOUT 300)

  # At content scale 2 the viewer fills the canvas and wx clicks pick the
  # atom aimed at (#133, Retina).  Needs `ninja viewer-scenes` and Xvfb.
  add_test(NAME look_hidpi
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/look/hidpi.py
                   ${CMAKE_BINARY_DIR}/viewer-scenes)
  set_tests_properties(look_hidpi PROPERTIES SKIP_RETURN_CODE 77 TIMEOUT 300)

  # Per-pixel lighting of atoms and bonds changes the shading only: same
  # covered pixels, wireframe, selection, offscreen and MO blending (#210).
  # Needs `ninja viewer-scenes`, Xvfb and PIL; SKIPs in the vendored build.
  add_test(NAME look_perpixel
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/look/perpixel.py
                   ${CMAKE_BINARY_DIR}/viewer-scenes)
  set_tests_properties(look_perpixel PROPERTIES SKIP_RETURN_CODE 77 TIMEOUT 300)

  # The saved DefaultStyle moves from the old default once (#227).
  add_test(NAME look_default_style
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/look/default_style.py)
  set_tests_properties(look_default_style PROPERTIES SKIP_RETURN_CODE 77 TIMEOUT 300)

  # Preferences > Colours: Jmol or classic element colours, the saved choice.
  add_test(NAME look_element_colours
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/look/elementcolours.py
                   --libdir ${CMAKE_BINARY_DIR})
  set_tests_properties(look_element_colours PROPERTIES TIMEOUT 300)

  # The MO diagram's column headings do not overlap at docked widths.
  add_test(NAME look_modiagram_heads
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/look/modiagramheads.py
                   --libdir ${CMAKE_BINARY_DIR})
  set_tests_properties(look_modiagram_heads PROPERTIES TIMEOUT 300)

  # tests/guivalues -- memory sizes saved before the GB-everywhere change
  # (Megawords, Megabytes) are converted by GUIValues::load() before a
  # dialog or a generator reads them.  Needs g++ and libecceutil.a.
  #
  #     cd build-cmake && ctest -R guivalues --output-on-failure
  add_test(NAME guivalues
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/guivalues/run_tests.py
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/guivalues)

  # tests/apps -- the third tier: starts every INSTALLED wx-linked ECCE app
  # on a headless X server with software OpenGL (Xvfb + llvmpipe; broadway
  # cannot be used here because these apps link GLX for the Open Inventor
  # viewer), waits for a window, and watches it for a few seconds.  That is
  # the shape of the wx3.2/GTK3 bugs this port keeps hitting -- #78 crashed
  # during construction, the layout-reentrancy class crashes after Show()
  # returns -- and nothing else in the tree notices either.
  #
  # This one tests /opt/ecce, NOT the build tree, so package and install
  # before trusting a green run.  It SKIPs with nothing installed, no Xvfb,
  # or an install whose Version differs from this tree's.  See tests/apps/README.md.
  #
  #     cd build-cmake && ctest -R apps --output-on-failure
  add_test(NAME apps
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps/run_tests.py
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps)
  # Generous: 20 apps x (window wait + settle), plus broker startup.
  set_tests_properties(apps PROPERTIES TIMEOUT 1800 SKIP_RETURN_CODE 77)
  # Builder Add Structure from File on PDB/XYZ/CAR and on missing paths,
  # through the installed builder's ECCE_TEST_IMPORT hook.
  add_test(NAME apps_import
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps/import_test.py
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps)
  set_tests_properties(apps_import PROPERTIES TIMEOUT 900 SKIP_RETURN_CODE 77)
  # Builder > Tools > Dock Floating Panels returns panels to an emptied dock
  # (#53), through the builder's ECCE_TEST_DOCK hook.
  add_test(NAME apps_dock
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps/dock_test.py
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps)
  set_tests_properties(apps_dock PROPERTIES TIMEOUT 600 SKIP_RETURN_CODE 77)
  # Organizer Import Calculation from Output File, ECCE_TEST_CALCIMPORT hook.
  add_test(NAME apps_calcimport
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps/calcimport_test.py
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps)
  set_tests_properties(apps_calcimport PROPERTIES TIMEOUT 1200
                       SKIP_RETURN_CODE 77)
  # Organizer File > Open Example Calculations: the shipped examples import
  # with their properties; ECCE_TEST_ORGANIZER "examples".
  add_test(NAME apps_examples
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps/examples_test.py
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps)
  set_tests_properties(apps_examples PROPERTIES TIMEOUT 900
                       SKIP_RETURN_CODE 77)
  # Structure Library > Ligands attach to a metal's nub in the Builder
  # (ECCE_BUILDER_SCRIPT select/selectnub/libatom/bonds).
  add_test(NAME apps_ligands
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps/ligands_test.py
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps)
  set_tests_properties(apps_ligands PROPERTIES TIMEOUT 900
                       SKIP_RETURN_CODE 77)
  # Geometry Constraints in the Builder, Ctrl+click, dummy atoms (#306).
  add_test(NAME apps_builder_constraints
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps/builder_constraints_test.py
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps)
  set_tests_properties(apps_builder_constraints PROPERTIES TIMEOUT 1500
                       SKIP_RETURN_CODE 77)
  # The Calculation Editor is not frozen (no black areas) while the Code
  # Change question is open (#308).
  add_test(NAME apps_calced_code_change
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps/calced_code_change_test.py
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps)
  set_tests_properties(apps_calced_code_change PROPERTIES TIMEOUT 900
                       SKIP_RETURN_CODE 77)
  # A finished calculation without ecce:progress gets one from its stored
  # output (#284): CalcMgr::backfillProgress.
  add_test(NAME apps_progress_backfill
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps/progress_backfill_test.py
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps)
  set_tests_properties(apps_progress_backfill PROPERTIES TIMEOUT 900
                       SKIP_RETURN_CODE 77)
  # Preferences > Advanced switches reach started programs (#307).
  add_test(NAME apps_advanced_prefs
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps/advanced_prefs_test.py
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps)
  set_tests_properties(apps_advanced_prefs PROPERTIES TIMEOUT 600
                       SKIP_RETURN_CODE 77)
  # Organizer summary panel: molecule and basis fields of a data-server
  # and of a local-data calculation, ECCE_TEST_ORGANIZER "summary".
  add_test(NAME apps_summary
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps/summary_test.py
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps)
  set_tests_properties(apps_summary PROPERTIES TIMEOUT 900
                       SKIP_RETURN_CODE 77)
  # The summary's Progress box (#284): running from the stored snapshot and
  # from a live one, completed, never launched; ECCE_TEST_ORGANIZER.
  add_test(NAME apps_progress_box
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps/progress_box_test.py
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps)
  set_tests_properties(apps_progress_box PROPERTIES TIMEOUT 900
                       SKIP_RETURN_CODE 77)
  # Two close requests before the Quit dialog is answered (#291).
  add_test(NAME apps_organizer_close
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps/organizer_close_test.py
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps)
  set_tests_properties(apps_organizer_close PROPERTIES TIMEOUT 600
                       SKIP_RETURN_CODE 77)
  # The project table's Progress column (#284): stored and live snapshots.
  add_test(NAME apps_progress_table
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps/progress_table_test.py
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps)
  set_tests_properties(apps_progress_table PROPERTIES TIMEOUT 900
                       SKIP_RETURN_CODE 77)
  # Out of contact and the folding Progress box (#284): state icons, the
  # greyed box and its actions, the amber table cell, the remembered fold.
  add_test(NAME apps_progress_contact
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps/progress_contact_test.py
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps)
  set_tests_properties(apps_progress_contact PROPERTIES TIMEOUT 900
                       SKIP_RETURN_CODE 77)

  # The Quantum ESPRESSO tutorial (help/src/qe-first-calculation.md) replayed
  # in the real apps: silicon scf and a water relax, run by pw.x through the
  # Launcher and the job monitor, checked against pw.x on a hand-written deck.
  add_test(NAME apps_qe_walkthrough
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps/qe_walkthrough_test.py
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps)
  set_tests_properties(apps_qe_walkthrough PROPERTIES TIMEOUT 3000
                       SKIP_RETURN_CODE 77)

  # The Builder with a calculation's MOs panel open in every panel layout,
  # on a 1366x768 screen: viewer and panel on screen and inside the window.
  add_test(NAME apps_panel_layouts
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps/panel_layouts_test.py
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps)
  set_tests_properties(apps_panel_layouts PROPERTIES TIMEOUT 900
                       SKIP_RETURN_CODE 77)

  # The Builder on an ECCE-QM calculation (fixture from the bundled engine):
  # MOs panel present, MO Diagram not offered; an ORCA calculation as control.
  add_test(NAME apps_ecceqm_builder
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps/ecceqm_builder_test.py
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps)
  set_tests_properties(apps_ecceqm_builder PROPERTIES TIMEOUT 900
                       SKIP_RETURN_CODE 77)

  # ORCA orbitals in the MOs panel (#239): a 24-function cc-pVDZ water run
  # draws; a 23-function one gives one plain dialog; the pane fits its rows.
  add_test(NAME apps_orca_mo
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps/orca_mo_test.py
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps)
  set_tests_properties(apps_orca_mo PROPERTIES TIMEOUT 1200
                       SKIP_RETURN_CODE 77)

  # The Periodic Builder pane (docked, closable, reopenable in every panel
  # layout) and the layout choice for run and not-yet-run calculations.
  add_test(NAME apps_pbc_ux
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps/pbc_ux_test.py
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps)
  set_tests_properties(apps_pbc_ux PROPERTIES TIMEOUT 900
                       SKIP_RETURN_CODE 77)

  # The default tool panes of a calculation not yet run (Symmetry last) stay
  # docked, clear of the viewer, at 1024x600, 1366x768 and 1400x900.
  add_test(NAME apps_tool_column
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps/tool_column_test.py
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps)
  set_tests_properties(apps_tool_column PROPERTIES TIMEOUT 900
                       SKIP_RETURN_CODE 77)

  # Every app's main window and every codereg Theory/Runtype dialog fits a
  # small screen (#189): measured on private Xvfb screens, no window may
  # extend past the screen.  Same installed tree and isolation as `apps`.
  foreach(size 1024x768 1024x600)
    add_test(NAME apps_smallscreen_${size}
             COMMAND ${PYTHON3_EXECUTABLE}
                     ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps/smallscreen_test.py
                     --size ${size}
             WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps)
    set_tests_properties(apps_smallscreen_${size} PROPERTIES TIMEOUT 1800
                         SKIP_RETURN_CODE 77)
  endforeach()

  # No control is cut off (tests/apps/clip_test.py): every app window, every
  # Builder panel in every layout and every codereg dialog, at the default
  # and at a small screen.  Same installed tree as `apps`.
  foreach(size 1920x1080 1366x768 1024x600)
    add_test(NAME apps_clip_${size}
             COMMAND ${PYTHON3_EXECUTABLE}
                     ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps/clip_test.py
                     --size ${size}
             WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps)
    set_tests_properties(apps_clip_${size} PROPERTIES TIMEOUT 3000
                         SKIP_RETURN_CODE 77)
  endforeach()

  # tests/filedsi -- FileEDSI (file:// storage, no Apache, #216) against a
  # temp directory, linked from the static libraries of build-cmake.
  #
  #     cd build-cmake && ctest -R filedsi --output-on-failure
  add_test(NAME filedsi
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/filedsi/run_tests.py
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/filedsi)
  set_tests_properties(filedsi PROPERTIES TIMEOUT 300)

  # tests/transport -- DirectTransport against a real /bin/sh (#204).
  if(NOT WIN32)
    add_executable(testTransport tests/transport/testTransport.C)
    target_link_libraries(testTransport PRIVATE eccercmd ecceutil)
    add_test(NAME transport COMMAND testTransport)
    set_tests_properties(transport PROPERTIES TIMEOUT 120)
  endif()

  # Process launch (POSIX fork/exec and the Windows CreateProcess path, #133).
  add_executable(testWinProcess tests/transport/testWinProcess.C)
  target_link_libraries(testWinProcess PRIVATE eccercmd ecceutil)
  add_test(NAME transport_process COMMAND testWinProcess)
  set_tests_properties(transport_process PROPERTIES TIMEOUT 180)

  # RCommand on a local machine against results recorded from the old pty
  # path (#204).
  add_executable(testRCommandDirect tests/transport/testRCommandDirect.C)
  target_link_libraries(testRCommandDirect PRIVATE
    eccercmd eccedsi eccedav eccecipc eccefaces eccexml eccetdat
    ecceutil ${XercesC_LIBRARIES})
  add_test(NAME transport_rcommand COMMAND testRCommandDirect)
  set_tests_properties(transport_rcommand PROPERTIES TIMEOUT 120)

  # The machine's sourceFile on a local machine, against recorded results.
  add_executable(testRCommandSource tests/transport/testRCommandSource.C)
  target_link_libraries(testRCommandSource PRIVATE
    eccercmd eccedsi eccedav eccecipc eccefaces eccexml eccetdat
    ecceutil ${XercesC_LIBRARIES})
  add_test(NAME transport_source COMMAND testRCommandSource)
  set_tests_properties(transport_source PROPERTIES TIMEOUT 240)

  # telnet, Globus and Globus-ssh were removed; a machine still registered
  # with one must fail with a message, not a spawn.
  add_executable(testRemovedShells tests/transport/testRemovedShells.C)
  target_link_libraries(testRemovedShells PRIVATE
    eccercmd eccedsi eccedav eccecipc eccefaces eccexml eccetdat
    ecceutil ${XercesC_LIBRARIES})
  add_test(NAME transport_removed_shells COMMAND testRemovedShells)
  set_tests_properties(transport_removed_shells PROPERTIES TIMEOUT 120)

  # EcceShell's local terminal for an ssh machine (#204): command line and
  # argv with stub terminals, no connection.
  add_executable(testTerminalArgv tests/transport/testTerminalArgv.C)
  target_link_libraries(testTerminalArgv PRIVATE
    eccecomm eccercmd eccedsi eccedav eccecipc eccefaces eccexml
    eccetdat ecceutil ${XercesC_LIBRARIES})
  add_test(NAME transport_terminal COMMAND testTerminalArgv)
  set_tests_properties(transport_terminal PROPERTIES TIMEOUT 60)

  # EcceShell on a local machine: the configured terminal, its directory
  # options and quoting, with stub terminals and no display.
  add_executable(testLocalTerminal tests/transport/testLocalTerminal.C)
  target_compile_definitions(testLocalTerminal PRIVATE
    ECCE_SOURCE_DIR="${CMAKE_SOURCE_DIR}")
  target_link_libraries(testLocalTerminal PRIVATE
    eccecomm eccercmd eccedsi eccedav eccecipc eccefaces eccexml
    eccetdat ecceutil ${XercesC_LIBRARIES})
  add_test(NAME transport_local_terminal COMMAND testLocalTerminal)
  set_tests_properties(transport_local_terminal PROPERTIES TIMEOUT 60)

  # The editor command (UserEditor) per platform, and macOS open(1) waiting
  # for its own copy; ecce-macos-terminal with a stub open (#133).
  add_executable(testEditorCommand tests/transport/testEditorCommand.C)
  target_link_libraries(testEditorCommand PRIVATE
    eccecomm eccercmd eccedsi eccedav eccecipc eccefaces eccexml
    eccetdat ecceutil ${XercesC_LIBRARIES})
  add_test(NAME editor_command COMMAND testEditorCommand)
  set_tests_properties(editor_command PROPERTIES TIMEOUT 60)
  add_test(NAME macos_terminal
    COMMAND sh ${CMAKE_SOURCE_DIR}/tests/transport/macos_terminal_test.sh
            ${CMAKE_SOURCE_DIR})
  set_tests_properties(macos_terminal PROPERTIES TIMEOUT 60)

  # Run Management's Tail (TailSource) on a local machine; the same program
  # runs against the test sshd from tests/transport/sshd/tail_test.sh.
  add_executable(testTail tests/transport/testTail.C)
  target_compile_definitions(testTail PRIVATE
    ECCE_SOURCE_DIR="${CMAKE_SOURCE_DIR}")
  target_link_libraries(testTail PRIVATE
    eccecomm eccercmd eccedsi eccedav eccecipc eccefaces eccexml
    eccetdat ecceutil ${XercesC_LIBRARIES})
  add_test(NAME transport_tail COMMAND testTail)
  set_tests_properties(transport_tail PROPERTIES TIMEOUT 120)

  # The Tail window itself on Xvfb, local machine (tail_window_test.sh).
  add_executable(tailwindow tests/transport/tailwindow.C)
  target_compile_definitions(tailwindow PRIVATE ${wxWidgets_DEFINITIONS})
  target_include_directories(tailwindow PRIVATE ${wxWidgets_INCLUDE_DIRS}
    ${XercesC_INCLUDE_DIRS})
  target_link_libraries(tailwindow PRIVATE
    eccewxguicomm eccewxgui eccecomm eccercmd eccedsi eccedav eccecipc
    eccefaces eccexml eccetdat ecceutil ${wxWidgets_LIBRARIES}
    ${XercesC_LIBRARIES})
  if(WIN32)   # GNU ld resolves static libraries in order (#133)
    target_link_libraries(tailwindow PRIVATE "$<LINK_GROUP:RESCAN,eccewxguicomm;eccewxgui;eccecomm;eccercmd;eccedsi;eccedav;eccecipc;eccefaces;eccexml;eccetdat;ecceutil>" ${XercesC_LIBRARIES})
  endif()
  add_test(NAME transport_tail_window
           COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/tests/transport/tail_window_test.sh
                   $<TARGET_FILE:tailwindow> ${CMAKE_CURRENT_SOURCE_DIR})
  set_tests_properties(transport_tail_window PROPERTIES TIMEOUT 120
                       SKIP_RETURN_CODE 77)

  # OpenSshTransport against a stand-in ssh script and the real `ssh -G`:
  # process handling, file copies, streams, messages, backend choice.
  add_executable(testOpenSshTransport tests/transport/testOpenSshTransport.C)
  target_link_libraries(testOpenSshTransport PRIVATE eccercmd ecceutil)
  add_test(NAME transport_openssh COMMAND testOpenSshTransport)
  set_tests_properties(transport_openssh PROPERTIES TIMEOUT 180)

  # SshTransport against tests/transport/sshd; needs that sshd running, so
  # not a ctest.  tests/transport/sshd/build_test.sh builds it in a container.
  if(LIBSSH_FOUND)
    add_executable(testSshTransport tests/transport/testSshTransport.C)
    target_link_libraries(testSshTransport PRIVATE eccercmd ecceutil)

    # RCommand over ssh against recorded results; same sshd, run by
    # tests/transport/sshd/rcommand_test.sh, so not a ctest either.
    add_executable(testRCommandSsh tests/transport/testRCommandSsh.C)
    target_link_libraries(testRCommandSsh PRIVATE
      eccercmd eccedsi eccedav eccecipc eccefaces eccexml eccetdat
      ecceutil ${XercesC_LIBRARIES})

    # The same through a front end; tests/transport/sshd/frontend_test.sh.
    add_executable(testRCommandFrontend tests/transport/testRCommandFrontend.C)
    target_link_libraries(testRCommandFrontend PRIVATE
      eccercmd eccedsi eccedav eccecipc eccefaces eccexml eccetdat
      ecceutil ${XercesC_LIBRARIES})

    # EcceShell's terminals over ssh; tests/transport/sshd/terminal_test.sh.
    add_executable(testTerminal tests/transport/testTerminal.C)
    target_link_libraries(testTerminal PRIVATE
      eccecomm eccercmd eccedsi eccedav eccecipc eccefaces eccexml
      eccetdat ecceutil ${XercesC_LIBRARIES})

    # A shared ssh connection that goes away; controlmaster_test.sh.
    add_executable(testControlMasterLoss tests/transport/testControlMasterLoss.C)
    target_link_libraries(testControlMasterLoss PRIVATE
      eccercmd eccedsi eccedav eccecipc eccefaces eccexml eccetdat
      ecceutil ${XercesC_LIBRARIES})

    # bgcommand -> ecmd -> command; tests/transport/sshd/bgcommand_test.sh.
    add_executable(testBgcommand tests/transport/testBgcommand.C)
    target_link_libraries(testBgcommand PRIVATE
      eccercmd eccedsi eccedav eccecipc eccefaces eccexml eccetdat
      ecceutil ${XercesC_LIBRARIES})
  endif()

  # tests/launch -- submit real jobs on localhost/Shell through the real
  # Launch class and assert they reach "completed".  launchjob is a test
  # driver and is not installed.  The suites SKIP (77) when a prerequisite
  # is absent.
  add_executable(launchjob tests/launch/launchjob.C)
  target_include_directories(launchjob PRIVATE ${XercesC_INCLUDE_DIRS})
  target_link_libraries(launchjob PRIVATE
    eccecommxt eccecomm eccercmd eccedsi eccedav eccecipc eccefaces eccexml
    eccetdat ecceutil ${XercesC_LIBRARIES})
  # tests/queues/configdump: RefMachine::config() for config_test.py.
  add_executable(configdump tests/queues/configdump.C)
  target_link_libraries(configdump PRIVATE eccetdat ecceutil)
  # tests/queues/configedit: ConfigFile, MachineConfigDraft and MiniJson.
  add_executable(configedit tests/queues/configedit.C)
  target_link_libraries(configedit PRIVATE eccetdat ecceutil)
  # tests/queues/pmform: the GUI's processmachine form encoder.
  add_executable(pmform tests/queues/pmform.C)
  target_link_libraries(pmform PRIVATE ecceutil)
  # tests/queues/pmrun: ProcessMachine::run against the real script.
  add_executable(pmrun tests/queues/pmrun.C)
  target_link_libraries(pmrun PRIVATE ecceutil)
  add_test(NAME queues_pmrun
           COMMAND pmrun ${CMAKE_CURRENT_SOURCE_DIR}/scripts/processmachine)
  set_tests_properties(queues_pmrun PROPERTIES TIMEOUT 60)
  # tests/fragreaders: PDB/XYZ/CAR import through FragUtil::load, as the
  # Builder's Add Structure from File does.
  add_executable(fragreaders tests/fragreaders/fragreaders.C)
  target_link_libraries(fragreaders PRIVATE eccetdat ecceutil)
  # tests/structlib: every Teaching > Diatomics entry of the Structure Library
  # loads with its stored bond length (and the library agrees with
  # tests/qm/diatomic_order_test.py).
  add_executable(structlib_diatomics tests/structlib/diatomics.C)
  target_link_libraries(structlib_diatomics PRIVATE eccetdat ecceutil)
  # tests/importcode: the code Import Calculation picks for an output file.
  add_executable(importcode tests/importcode/importcode.C)
  target_include_directories(importcode PRIVATE ${XercesC_INCLUDE_DIRS})
  target_link_libraries(importcode PRIVATE
    eccecommxt eccecomm eccercmd eccedsi eccedav eccecipc eccefaces eccexml
    eccetdat ecceutil ${XercesC_LIBRARIES})
  set(_pf ${CMAKE_CURRENT_SOURCE_DIR}/tests/parsers/fixtures)
  add_test(NAME importcode
           COMMAND importcode -v
                   ${_pf}/nwchem/h2o_opt_stdout.out=NWChem
                   ${_pf}/gaussian-16/co_freq.log=Gaussian-16
                   ${_pf}/orca/h2o_sym.out=ORCA
                   ${_pf}/mopac/ch4_opt.out=MOPAC
                   ${_pf}/gromacs/water_md.log=-
                   ${_pf}/qe/h2o_gamma.pwout=-)
  set_tests_properties(importcode PROPERTIES ENVIRONMENT
    "ECCE_HOME=${CMAKE_SOURCE_DIR};ECCE_REALUSER=fragreaders;ECCE_REALUSERHOME=${CMAKE_BINARY_DIR}/fragreaders-home")
  # tests/importcode/importmeta: the metadata an imported calculation gets
  # (#235), checked against values read from the output files themselves.
  add_executable(importmeta tests/importcode/importmeta.C)
  target_include_directories(importmeta PRIVATE ${XercesC_INCLUDE_DIRS})
  target_link_libraries(importmeta PRIVATE
    eccecommxt eccecomm eccercmd eccedsi eccedav eccecipc eccefaces eccexml
    eccetdat ecceutil ${XercesC_LIBRARIES})
  add_test(NAME importmeta
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/importcode/importmeta_test.py
                   $<TARGET_FILE:importmeta>)
  set_tests_properties(importmeta PROPERTIES TIMEOUT 300 ENVIRONMENT
    "ECCE_HOME=${CMAKE_SOURCE_DIR};ECCE_REALUSER=fragreaders")
  # tests/basis/testCoordSys: the spherical/Cartesian convention recorded
  # for a basis, per code (ORCA is spherical-only).
  add_executable(gbscoordsys tests/basis/testCoordSys.C)
  target_include_directories(gbscoordsys PRIVATE ${XercesC_INCLUDE_DIRS})
  #  The data-model libraries refer to each other in a cycle that the
  #  code under test does not happen to pull in the right order.
  set(_gbs_libs eccecommxt eccecomm eccercmd eccedsi eccedav eccecipc
    eccefaces eccexml eccetdat ecceutil)
  if(APPLE)   # ld64 rescans archives itself and rejects --start-group
    target_link_libraries(gbscoordsys PRIVATE ${_gbs_libs} ${XercesC_LIBRARIES})
  else()
    target_link_libraries(gbscoordsys PRIVATE
      "$<LINK_GROUP:RESCAN,${_gbs_libs}>" ${XercesC_LIBRARIES})
  endif()
  add_test(NAME gbscoordsys
           COMMAND gbscoordsys ${CMAKE_CURRENT_SOURCE_DIR}/data/admin/basissets)
  set_tests_properties(gbscoordsys PROPERTIES ENVIRONMENT
    "ECCE_HOME=${CMAKE_SOURCE_DIR};ECCE_REALUSER=fragreaders;ECCE_REALUSERHOME=${CMAKE_BINARY_DIR}/fragreaders-home")
  # tests/mocomp: ecce-mocomp's Mulliken and c^2 compositions against
  # checked-in Multiwfn numbers (#161); re-derives them where Multiwfn is
  # installed (MULTIWFN, or Multiwfn_noGUI on PATH).
  add_test(NAME mocomp
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/mocomp/run_tests.py
                   ${CMAKE_BINARY_DIR})
  set_tests_properties(mocomp PROPERTIES TIMEOUT 300)
  add_test(NAME fragreaders
           COMMAND fragreaders ${CMAKE_CURRENT_SOURCE_DIR}/tests/fragreaders/data)
  file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/fragreaders-home)
  set_tests_properties(fragreaders PROPERTIES ENVIRONMENT
    "ECCE_HOME=${CMAKE_SOURCE_DIR};ECCE_REALUSER=fragreaders;ECCE_REALUSERHOME=${CMAKE_BINARY_DIR}/fragreaders-home")
  add_test(NAME structlib_diatomics
           COMMAND structlib_diatomics
                   ${CMAKE_CURRENT_SOURCE_DIR}/data/client/StructureLibrary/Teaching/Diatomics)
  set_tests_properties(structlib_diatomics PROPERTIES ENVIRONMENT
    "ECCE_HOME=${CMAKE_SOURCE_DIR};ECCE_REALUSER=fragreaders;ECCE_REALUSERHOME=${CMAKE_BINARY_DIR}/fragreaders-home")
  # Same under a decimal-comma locale; skipped (77) where it is not installed.
  add_test(NAME fragreaders_de
           COMMAND fragreaders ${CMAKE_CURRENT_SOURCE_DIR}/tests/fragreaders/data)
  set_tests_properties(fragreaders_de PROPERTIES SKIP_RETURN_CODE 77 ENVIRONMENT
    "LC_ALL=de_DE.utf8;ECCE_HOME=${CMAKE_SOURCE_DIR};ECCE_REALUSER=fragreaders;ECCE_REALUSERHOME=${CMAKE_BINARY_DIR}/fragreaders-home")

  add_test(NAME launch
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/launch/run_tests.py
                   --build ${CMAKE_BINARY_DIR}
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/launch)
  set_tests_properties(launch PROPERTIES TIMEOUT 900 SKIP_RETURN_CODE 77)
  add_test(NAME launch_socketcomms
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/launch/run_tests.py
                   --build ${CMAKE_BINARY_DIR} --job-comms socket
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/launch)
  set_tests_properties(launch_socketcomms PROPERTIES TIMEOUT 900
                       SKIP_RETURN_CODE 77)
  # #216: the same job with the data in a local folder, no data server.
  add_test(NAME launch_local
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/launch/run_tests.py
                   --build ${CMAKE_BINARY_DIR} --local
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/launch)
  set_tests_properties(launch_local PROPERTIES TIMEOUT 900 SKIP_RETURN_CODE 77)
  # ECCE-QM, the bundled engine: water and triplet O2 created, run through
  # Launch in a local data folder, energies against ORCA, MOs normalised.
  if(ECCE_BUILD_QM)
    add_test(NAME launch_ecceqm
             COMMAND ${PYTHON3_EXECUTABLE}
                     ${CMAKE_CURRENT_SOURCE_DIR}/tests/launch/ecceqm_test.py
                     --build ${CMAKE_BINARY_DIR}
             WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/launch)
    set_tests_properties(launch_ecceqm PROPERTIES TIMEOUT 1800 SKIP_RETURN_CODE 77)
    # #284: a stopped job monitor makes the job "out of contact", never
    # failed; a killed engine is reported gone by the machine check and is
    # final only from its output; silence past the reconnect time reconnects
    # with the job still running.
    add_test(NAME launch_contact
             COMMAND ${PYTHON3_EXECUTABLE}
                     ${CMAKE_CURRENT_SOURCE_DIR}/tests/launch/contact_test.py
                     --build ${CMAKE_BINARY_DIR}
             WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/launch)
    set_tests_properties(launch_contact PROPERTIES TIMEOUT 1200 SKIP_RETURN_CODE 77)
  endif()

  # A GROMACS MD study through the real editors (private Xvfb), launches and
  # results; skipped (77) without gmx or Xvfb.  Needs the GUI apps built.
  add_test(NAME launch_gromacs
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/launch/gromacs_test.py
                   --build ${CMAKE_BINARY_DIR}
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/launch)
  set_tests_properties(launch_gromacs PROPERTIES TIMEOUT 1200 SKIP_RETURN_CODE 77)
  # The MD Optimize editor and the Organizer's editor button for a GROMACS
  # and an NWChem MD study (private Xvfb); skipped (77) without Xvfb.
  add_test(NAME launch_md_editors
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/launch/md_editors_test.py
                   --build ${CMAKE_BINARY_DIR}
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/launch)
  set_tests_properties(launch_md_editors PROPERTIES TIMEOUT 600 SKIP_RETURN_CODE 77)
  # Builder overlays, the Organizer thumbnail and New of MD studies, through
  # the controls' own event paths (private Xvfb); skipped (77) without Xvfb,
  # ImageMagick's import or python3-pil.
  add_test(NAME apps_builder_overlay
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps/builder_overlay_test.py
                   --build ${CMAKE_BINARY_DIR}
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps)
  set_tests_properties(apps_builder_overlay PROPERTIES TIMEOUT 1200
                       SKIP_RETURN_CODE 77)
  # ECCE-QM Geometry and Vibration runs of water in the Builder: the IR
  # spectrum's sticks against the engine's output, the geometry trace.
  add_test(NAME apps_ecceqm_vib_builder
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps/ecceqm_vib_builder_test.py
                   --build ${CMAKE_BINARY_DIR}
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps)
  set_tests_properties(apps_ecceqm_vib_builder PROPERTIES TIMEOUT 900
                       SKIP_RETURN_CODE 77)
  # The Energies panel's groups and their fold state (#283).
  add_test(NAME apps_energies_groups
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps/energies_groups_test.py
                   --build ${CMAKE_BINARY_DIR}
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps)
  set_tests_properties(apps_energies_groups PROPERTIES TIMEOUT 900
                       SKIP_RETURN_CODE 77)
  # verifyinput's ecce-qm keyword list must match src/qm/input.cpp (#148).
  add_test(NAME ecceqm_checker_keywords
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/ecceqm/keywords_test.py)
  # Launch warns before a large ECCE-QM run, never blocks (#248).
  add_test(NAME apps_ecceqm_size_warning
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps/ecceqm_size_warning_test.py
                   --build ${CMAKE_BINARY_DIR}
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/apps)
  set_tests_properties(apps_ecceqm_size_warning PROPERTIES TIMEOUT 900
                       SKIP_RETURN_CODE 77)
  # An 8.x eccejobmaster exports ECCE_TRANSPORT=pty; it must be ignored.
  add_test(NAME launch_legacy_transport
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/launch/run_tests.py
                   --build ${CMAKE_BINARY_DIR} --legacy-transport pty
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/launch)
  set_tests_properties(launch_legacy_transport PROPERTIES TIMEOUT 900
                       SKIP_RETURN_CODE 77)
  add_test(NAME launch_jobwait
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/launch/jobwait_test.py --control
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/launch)
  set_tests_properties(launch_jobwait PROPERTIES TIMEOUT 120 SKIP_RETURN_CODE 77)
  add_test(NAME launch_cancel
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/launch/cancel_test.py
                   --build ${CMAKE_BINARY_DIR}
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/launch)
  set_tests_properties(launch_cancel PROPERTIES TIMEOUT 900 SKIP_RETURN_CODE 77)
  add_test(NAME launch_cancel_local
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/launch/cancel_test.py
                   --build ${CMAKE_BINARY_DIR} --local
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/launch)
  set_tests_properties(launch_cancel_local PROPERTIES TIMEOUT 900
                       SKIP_RETURN_CODE 77)
  # Needs NWChem; skipped (77) without it.
  add_test(NAME launch_nwchem_restart_local
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/launch/run_tests.py
                   --build ${CMAKE_BINARY_DIR} --local --nwchem-restart
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/launch)
  set_tests_properties(launch_nwchem_restart_local PROPERTIES TIMEOUT 900
                       SKIP_RETURN_CODE 77)
  add_test(NAME launch_waiting
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/launch/waiting_test.py
                   --build ${CMAKE_BINARY_DIR}
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/launch)
  set_tests_properties(launch_waiting PROPERTIES TIMEOUT 1200 SKIP_RETURN_CODE 77)
  add_test(NAME launch_filewait
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/launch/filewait_test.py
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/launch)
  set_tests_properties(launch_filewait PROPERTIES TIMEOUT 120 SKIP_RETURN_CODE 77)
  add_test(NAME launch_machines
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/launch/machines_test.py
                   --build ${CMAKE_BINARY_DIR}
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/launch)
  set_tests_properties(launch_machines PROPERTIES TIMEOUT 60 SKIP_RETURN_CODE 77)

  # tests/teaching -- introductory chemistry teaching calculations run end
  # to end through Launch, with NWChem, and checked against known answers.
  add_test(NAME teaching
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/teaching/run_tests.py
                   --build ${CMAKE_BINARY_DIR} --jobs 4
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/teaching)
  set_tests_properties(teaching PROPERTIES TIMEOUT 7200 SKIP_RETURN_CODE 77)

  # tests/csh2sh -- ecce-csh2sh and the csh rules gensub shares with it: fixtures
  # converted and reported, converted snippets run under dash against tcsh's own
  # environment, backups and idempotence, and the launcher's once-per-version
  # run.  Needs perl; the tcsh comparisons skip without tcsh.
  add_test(NAME csh2sh
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/csh2sh/run_tests.py
                   --build ${CMAKE_BINARY_DIR}
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/csh2sh)
  set_tests_properties(csh2sh PROPERTIES TIMEOUT 300)

  # tests/queues -- batch-queue support.  "queues" needs no scheduler: gensub
  # scripts against golden files, and PBS/LSF/Moab against stand-in clients.
  # "queues_slurm", "queues_sge" and "queues_htcondor" use this machine's real
  # scheduler and SKIP without one.
  add_test(NAME queues
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/queues/run_tests.py
                   --build ${CMAKE_BINARY_DIR} --suite local
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/queues)
  set_tests_properties(queues PROPERTIES TIMEOUT 1800 SKIP_RETURN_CODE 77)
  # CONFIG precedence (C++ against gensub), processmachine's writer, and what
  # a central server publishes to -remote clients; needs only perl and curl.
  add_test(NAME queues_config
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/queues/config_test.py
                   --build ${CMAKE_BINARY_DIR}
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/queues)
  set_tests_properties(queues_config PROPERTIES TIMEOUT 300 SKIP_RETURN_CODE 77)
  # Which layer a machine comes from (user, server, install) and localhost.
  add_test(NAME queues_layers
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/queues/layers_test.py
                   --build ${CMAKE_BINARY_DIR}
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/queues)
  set_tests_properties(queues_layers PROPERTIES TIMEOUT 300 SKIP_RETURN_CODE 77)
  add_test(NAME queues_configedit
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/queues/configedit_test.py
                   --build ${CMAKE_BINARY_DIR}
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/queues)
  set_tests_properties(queues_configedit PROPERTIES TIMEOUT 300
                       SKIP_RETURN_CODE 77)
  # Register Machines through its real window under Xvfb (test hook), user,
  # -remote and -admin; SKIPs without Xvfb.
  add_test(NAME machregister_gui
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/machregister/gui_test.py
                   --build ${CMAKE_BINARY_DIR}
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/machregister)
  set_tests_properties(machregister_gui PROPERTIES TIMEOUT 600
                       SKIP_RETURN_CODE 77)
  # The Launcher's "Machine settings..." button and its reload after a save.
  add_test(NAME help_pages
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/help/check.py
                   ${CMAKE_CURRENT_SOURCE_DIR}/help/src
                   ${CMAKE_BINARY_DIR}/help-check)
  add_test(NAME machregister_launcher
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/machregister/launcher_test.py
                   --build ${CMAKE_BINARY_DIR}
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/machregister)
  set_tests_properties(machregister_launcher PROPERTIES TIMEOUT 300
                       SKIP_RETURN_CODE 77)
  # The Machine Browser's "Machine settings..." button (#234).
  add_test(NAME machregister_browser
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/machregister/browser_test.py
                   --build ${CMAKE_BINARY_DIR}
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/machregister)
  set_tests_properties(machregister_browser PROPERTIES TIMEOUT 300
                       SKIP_RETURN_CODE 77)
  add_test(NAME queues_publish
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/queues/publish_test.py
                   --build ${CMAKE_BINARY_DIR}
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/queues)
  set_tests_properties(queues_publish PROPERTIES TIMEOUT 300 SKIP_RETURN_CODE 77)
  # ecce -admin on a -remote client: ecce-site-admin on a simulated central
  # server, publishing, and the client's ecce-remote-setup --refresh (#234).
  add_test(NAME queues_siteadmin
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/queues/siteadmin_test.py
                   --build ${CMAKE_BINARY_DIR}
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/queues)
  set_tests_properties(queues_siteadmin PROPERTIES TIMEOUT 120 SKIP_RETURN_CODE 77)
  add_test(NAME queues_slurm
           COMMAND ${PYTHON3_EXECUTABLE}
                   ${CMAKE_CURRENT_SOURCE_DIR}/tests/queues/run_tests.py
                   --build ${CMAKE_BINARY_DIR} --suite slurm
           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/queues)
  set_tests_properties(queues_slurm PROPERTIES TIMEOUT 1200 SKIP_RETURN_CODE 77)
  foreach(qm sge htcondor)
    add_test(NAME queues_${qm}
             COMMAND ${PYTHON3_EXECUTABLE}
                     ${CMAKE_CURRENT_SOURCE_DIR}/tests/queues/run_tests.py
                     --build ${CMAKE_BINARY_DIR} --suite ${qm}
             WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/queues)
    set_tests_properties(queues_${qm} PROPERTIES TIMEOUT 1200 SKIP_RETURN_CODE 77)
  endforeach()
endif()

# ecce-qm: the small built-in HF/DFT engine (src/qm), registered as the code
# "ECCE-QM" (data/client/cap/ECCE-QM.edml).  On by default, in every package.
# It fetches libcint (always), and libxc and Eigen unless the system has them
# (Debian: libxc-dev libeigen3-dev as build dependencies), at configure time.
# See docs/qm/README.md.
option(ECCE_BUILD_QM "Build ecce-qm, the built-in HF/DFT engine" ON)
if(ECCE_BUILD_QM)
  add_subdirectory(src/qm)
  install(TARGETS ecce-qm RUNTIME DESTINATION bin COMPONENT client)
endif()