@@ -255,15 +255,36 @@ def load_edgy_config(args: argparse.Namespace, test_home: Path) -> EdgyConfig:
     )
 
     test_suites = config_file_dict.get('test_suites', {})
+    primary_test_suites = test_suites.get('primary', [])
+    secondary_test_suites = test_suites.get('secondary', [])
+    _validate_configured_suites(
+      config_file_path,
+      [*primary_test_suites, *secondary_test_suites]
+    )
     config_sets = config_file_dict.get('config_sets', {})
     return EdgyConfig(
       test_home,
       loaded_configs,
       config_sets,
-      test_suites.get('primary', []),
-      test_suites.get('secondary', [])
+      primary_test_suites,
+      secondary_test_suites
     )
 
+def _validate_configured_suites(config_file_path: Path,
+                                test_suite_names: List[Any]) -> None:
+  '''Exit unless every suite ``config_file_path`` lists has a valid name.'''
+  invalid_test_suite_encountered = False
+  for test_suite in test_suite_names:
+    if not (isinstance(test_suite, str) and
+            edgtest.is_valid_suite_name(test_suite)):
+      edgutil.eprint(f"Invalid test suite name {test_suite!r} in "
+                     f"{config_file_path} (expected 1-64 of A-Z, a-z, "
+                     "0-9, _ and -).")
+      invalid_test_suite_encountered = True
+
+  if invalid_test_suite_encountered:
+    sys.exit(1)
+
 def get_expectation_path(run_config: TestRunConfig,
                          test_suite_name: str) -> Path:
   return Path(run_config.expectations_dir, f"{test_suite_name}.log")
 
@@ -41,8 +41,11 @@
 from pathlib import Path, PurePosixPath
 from typing import Iterable, Optional, Sequence
 
+import edgtest
+
 from edgacknowledg.forge import Forge, PullRequestInfo
 from edgacknowledg.forge.runner.roles import BUILD_STAGING_DIR, REVIEWS_DIR
+from edgtest.runtest import get_bare_name
 
 _log = logging.getLogger(__name__)
 
@@ -57,12 +60,12 @@
 
 BENCH_BASELINE_PATTERNS = ('/benchmarks/baselines/',)
 
-# The longest file name (in bytes) a test can have; a longer one names no
-# file, so it needs no pattern (and its patterns would be quadratic in its
-# length, one per dot, each as long as the name).
-_NAME_MAX = 255
 # The most sparse-checkout patterns a checkout may have: matching costs
-# patterns x paths, and they are built from pull request content.
+# patterns x paths, and they are built from pull request content. Their
+# total size must also stay within a small multiple of the diff's (see
+# MAX_DIFF_BYTES): a test gets at most two patterns, each about as long as
+# its path, and the only text that is part of many patterns, a suite's
+# name, is short.
 MAX_PATTERNS = 20_000
 # The largest diff (of tests/, in bytes) a pull request may have: it is
 # held in memory, and copied and split into lines more than once.
@@ -94,28 +97,21 @@ def _escape_pattern(path: str) -> str:
   return re.sub(r'([\\*?\[\]!#])', r'\\\1', path)
 
 
-def _test_base_names(file_name: str) -> list[str]:
-  '''Return the candidate base names of a test file (for its '.<base>.rto'
-  recordings directory), e.g. 'a.b.sft.cpp' -> ['a.b.sft', 'a.b', 'a'].
-  '''
-  parts = file_name.split('.')
-  return ['.'.join(parts[:count]) for count in range(len(parts) - 1, 0, -1)]
-
-
 def patterns_for_test(test_path: PurePosixPath) -> list[str]:
   '''Sparse-checkout patterns for one test (a repository-relative path such
-  as 'tests/tests/suite/dir/name.sft.cpp'): the test file and its recordings,
-  or the whole directory of a multi-file test.
+  as 'tests/tests/suite/dir/name.sft.cpp'): the test file and its recordings
+  (where the test runner keeps them, '.<bare name>.rto'), or the whole
+  directory of a multi-file test. At most two, each about as long as the
+  path, however it is named (see MAX_PATTERNS).
   '''
-  if len(test_path.name.encode()) > _NAME_MAX:
-    return []
   directory = _escape_pattern(str(test_path.parent))
   if '.mft.' in test_path.name:
     return [f"/{directory}/"]
-  patterns = [f"/{_escape_pattern(str(test_path))}"]
-  for base_name in _test_base_names(test_path.name):
-    patterns.append(f"/{directory}/.{_escape_pattern(base_name)}.rto/")
-  return patterns
+  bare_name = _escape_pattern(get_bare_name(test_path))
+  return [
+    f"/{_escape_pattern(str(test_path))}",
+    f"/{directory}/.{bare_name}.rto/",
+  ]
 
 
 def _patterns_for_changed_test_file(path: PurePosixPath) -> list[str]:
@@ -163,8 +159,11 @@ def changes_patterns(diff: str) -> list[str]:
         _add_patterns(patterns, _patterns_for_changed_test_file(path))
       elif (path.parts[:2] == ('tests', 'expectations') and
             path.suffix == '.log'):
-        # Expectation lines name tests relative to the suite.
-        current_suite = path.stem
+        # Expectation lines name tests relative to the suite, so its name is
+        # part of the patterns of each (see MAX_PATTERNS). A file whose name
+        # no suite may have (e.g. too long) names no tests.
+        if edgtest.is_valid_suite_name(path.stem):
+          current_suite = path.stem
       continue
     if current_suite is None or line.startswith(('---', '+++')):
       continue
 
@@ -204,6 +204,15 @@ def load_test_suite_env(test_suite_dir: Path) -> Dict[str, str]:
   {'sft.cpp', 'sft.c', 'mft.cpp', 'mft.c'}
 )
 
+# What a test suite (a directory of the test home's tests/) may be named.
+# Tools taking suite names from untrusted input (e.g. the AcknowlEDG Forge,
+# from expectation file names) rely on it to bound them.
+_SUITE_NAME_REGEX = re.compile(r'[A-Za-z0-9_-]{1,64}')
+
+def is_valid_suite_name(name: str) -> bool:
+  '''Return whether ``name`` may name a test suite.'''
+  return _SUITE_NAME_REGEX.fullmatch(name) is not None
+
 def test_extensions_for_suite(test_home: Path,
                               suite_name: str) -> Set[str]:
   '''Return a list of file extensions that should be considered when searching
 
@@ -25,7 +25,7 @@
 
 from enum import IntEnum
 from collections import OrderedDict
-from pathlib import Path
+from pathlib import Path, PurePath
 from typing import (
   Any, Callable, Dict, IO, Iterator, List, Mapping, NamedTuple, Optional,
   Pattern, Set, Tuple, cast
@@ -83,7 +83,7 @@ def get_matches_possible_names(test_suite_env: Dict[str, str],
   results.append(f"default.{case_number}.matches.txt")
   return results
 
-def get_bare_name(test_file_path: Path) -> str:
+def get_bare_name(test_file_path: PurePath) -> str:
   '''Return the test name without the file extension.'''
   return test_file_path.name.split('.')[0]
 
 
@@ -179,9 +179,10 @@ def test_ensure_real_directory_refuses_symlinks(tmp_path: Path) -> None:
 
 
 def test_test_patterns() -> None:
+  # Recordings are where the test runner keeps them: named for the part of
+  # the test's name before its first dot.
   assert patterns_for_test(PurePosixPath('tests/tests/s/d/a.sft.cpp')) == [
     '/tests/tests/s/d/a.sft.cpp',
-    '/tests/tests/s/d/.a.sft.rto/',
     '/tests/tests/s/d/.a.rto/',
   ]
   # Multi-file tests own their directory.
@@ -216,10 +217,31 @@ def test_changes_patterns_cover_recordings_and_expectations() -> None:
   assert not any(p.startswith('/dev_tools/') for p in patterns)
 
 
-def test_long_test_names_need_no_patterns() -> None:
-  # No file has such a name; its patterns would be quadratic in its length.
-  name = '.'.join(['x'] * 200) + '.sft.cpp'
-  assert patterns_for_test(PurePosixPath('tests/tests/s', name)) == []
+def test_test_patterns_are_linear_in_the_path() -> None:
+  # Two, however many dots its name has.
+  name = '.'.join(['x'] * 2100) + '.sft.cpp'
+  assert patterns_for_test(PurePosixPath('tests/tests/s', name)) == [
+    f"/tests/tests/s/{name}",
+    '/tests/tests/s/.x.rto/',
+  ]
+
+
+def test_changes_patterns_skip_suites_no_suite_may_be_named() -> None:
+  # A suite is in the patterns of every test its expectation file names.
+  def expectations(suite: str) -> str:
+    log = f"tests/expectations/edg_x86_64/{suite}.log"
+    return '\n'.join([
+      f"diff --git a/{log} b/{log}",
+      f"--- a/{log}",
+      f"+++ b/{log}",
+      '+a.sft.cpp: PASS',
+    ])
+
+  assert '/tests/tests/cwg/a.sft.cpp' in changes_patterns(expectations('cwg'))
+  for suite in ['s' * 65, 'a.b', 'a b']:
+    assert changes_patterns(expectations(suite)) == [
+      '/tests/.edgy/', '/tests/expectations/',
+    ]
 
 
 def test_patterns_are_capped() -> None:
 
@@ -0,0 +1,42 @@
+# Part of the EDG Compiler Project, under the Apache License v2.0 with LLVM
+# Exceptions.
+# See https://edgcpp.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+'''Tests for the test suite names edgtest accepts (which edgy checks on
+loading .edgy/config.json).
+
+Run with: python3 -m unittest discover -s dev_tools/tests
+(with dev_tools/pylibs on PYTHONPATH).
+'''
+
+import json
+import unittest
+
+import edgtest
+
+from pathlib import Path
+
+REPO_DIR = Path(__file__).resolve().parents[2]
+
+class SuiteNameTests(unittest.TestCase):
+  def test_valid_names(self) -> None:
+    for name in ['cwg', 'edg_x86', 'cpp-23', 'A1', 's' * 64]:
+      with self.subTest(name = name):
+        self.assertTrue(edgtest.is_valid_suite_name(name))
+
+  def test_invalid_names(self) -> None:
+    for name in ['', 's' * 65, 'a.b', 'a/b', '..', 'a b', 'café',
+                 'cwg\n']:
+      with self.subTest(name = name):
+        self.assertFalse(edgtest.is_valid_suite_name(name))
+
+  def test_the_test_homes_suites_are_valid(self) -> None:
+    config_path = REPO_DIR / 'tests' / '.edgy' / 'config.json'
+    test_suites = json.loads(config_path.read_text())['test_suites']
+    for name in [*test_suites['primary'], *test_suites['secondary']]:
+      with self.subTest(name = name):
+        self.assertTrue(edgtest.is_valid_suite_name(name))
+
+if __name__ == '__main__':
+  unittest.main()