@@ -17,10 +17,11 @@ import tempfile
 
 import edgtest
 import edgtest.exec
+import edgtest.expectations
 import edgutil
 
 from datetime import datetime
-from typing import Dict, List, Optional, Tuple
+from typing import Dict, Iterable, List, Optional, Set, Tuple
 from pathlib import Path, PurePosixPath
 
 from edgutil import eprint
@@ -64,7 +65,7 @@ TOOL_PATH_PATCH = edgutil.RequiredToolPath('patch')
 
 def build_diff_files(diff_file: Path,
                      tmp_diffs_dir: Path) -> List[DiffFileDescr]:
-  diff_files = []
+  diff_files: List[DiffFileDescr] = []
 
   with contextlib.ExitStack() as exit_stack:
     diff_file_handle = exit_stack.enter_context(open(diff_file))
@@ -112,8 +113,8 @@ def build_diff_files(diff_file: Path,
 
 class TestChangeState:
   def __init__(self) -> None:
-    self.tests = set()
-    self.configs = set()
+    self.tests: Set[Path] = set()
+    self.configs: Set[str] = set()
 
 def collect_affected_tests(test_home: Path,
                            diff_files: List[DiffFileDescr]) -> TestChangeState:
@@ -159,9 +160,9 @@ def collect_affected_tests(test_home: Path,
             test_file_found = True
           else:
             # Look for all mft files that might be associated with this file.
-            for possible_test in posix_path.iterdir():
+            for possible_test in file_path.iterdir():
               if possible_test.suffixes[0] == '.mft':
-                result.tests.add(candidate_test_file)
+                result.tests.add(possible_test)
                 test_file_found = True
         # File not found, move on to the parent.
         file_path = file_path.parent
@@ -354,11 +355,8 @@ async def simulate_test(test_home: Path, config_run_dir: Path,
 
   while len(test_options) < num_cases:
     # This should only happen in the case of reduction of test cases.
-    # Use 's' (SKIP_TEST) as a placeholder mode.
-    test_options.append((
-      edgtest.runtest.test_type_to_string(edgtest.runtest.TestType.SKIP_TEST),
-      []
-    ))
+    # Use SKIP_TEST as a placeholder mode.
+    test_options.append((edgtest.runtest.TestType.SKIP_TEST, []))
 
   with tempfile.TemporaryDirectory() as tmp_dir_name:
     tmp_dir = Path(tmp_dir_name)
@@ -411,7 +409,7 @@ async def simulate_test(test_home: Path, config_run_dir: Path,
           await edgtest.exec.check_output_mismatch(
             old_rec,
             body_for_diff,
-            os.environ,
+            dict(os.environ),
             change_diff_path
           )
         )
@@ -500,15 +498,12 @@ async def simulate_test(test_home: Path, config_run_dir: Path,
         case_entry['matches'] = matches_metadata
       rt_metadata_cases.append(case_entry)
 
-      # Make test status lines.
-      if old_status != 'PASS':
-        test_status_lines.append(
-          f"- {relative_test_path.as_posix()} {test_details}{old_status}:\n"
-        )
-        test_status_lines.append(
-          f"+ {relative_test_path.as_posix()} {test_details}{new_status}:\n"
-        )
-      elif any_mismatch:
+      # Make test status lines (for the tests whose status changed).
+      if old_status != new_status:
+        if old_status != 'PASS':
+          test_status_lines.append(
+            f"- {relative_test_path.as_posix()} {test_details}{old_status}:\n"
+          )
         test_status_lines.append(
           f"+ {relative_test_path.as_posix()} {test_details}{new_status}:\n"
         )
@@ -527,53 +522,108 @@ async def simulate_test(test_home: Path, config_run_dir: Path,
 
   return test_status_lines
 
-def load_test_suite_expectations(all_expectations: Dict[str, List[str]],
-                                 suite_file: Path) -> None:
+def read_suite_expectation_lines(suite_file: Path) -> List[str]:
+  if not suite_file.exists():
+    return []
   with open(suite_file, 'r') as file_handle:
-    for line in file_handle:
-      test_name = f"{suite_file.stem}/{line.split(':')[0]}"
-      if test_name not in all_expectations:
-        all_expectations[test_name] = []
-      all_expectations[test_name].append(line.strip())
+    return file_handle.readlines()
+
+def load_test_suite_expectations(all_expectations: Dict[str, List[str]],
+                                 suite_name: str, expectations_dir: Path,
+                                 parent_expectations_dir: Optional[Path]
+                                 ) -> None:
+  '''Load the aggregate expectations of a suite.
+
+  A configuration that inherits expectations has the parent configuration's
+  expectations with its own applied on top, so its file's lines are resolved
+  into concrete expectations here.
+  '''
+  suite_file_name = f"{suite_name}.log"
+  lines = read_suite_expectation_lines(expectations_dir / suite_file_name)
+  if parent_expectations_dir is not None:
+    lines = edgtest.expectations.overlay_expectations(
+      read_suite_expectation_lines(parent_expectations_dir / suite_file_name),
+      lines
+    )
+
+  for expectation_line in lines:
+    line = expectation_line.strip()
+    test_name = f"{suite_name}/{line.split(':')[0]}"
+    if test_name not in all_expectations:
+      all_expectations[test_name] = []
+    all_expectations[test_name].append(line)
 
 async def simulate_config_testing(
                            loop: asyncio.AbstractEventLoop,
                            test_home: Path, new_run_dir: Path,
                            patched_tests_dir: Path, config: str,
                            diff_files: List[DiffFileDescr],
-                           tests: List[Path]) -> None:
+                           tests: Iterable[Path]) -> None:
   subtasks = []
 
   config_run_dir = new_run_dir / config
   config_run_dir.mkdir()
 
-  old_expectations = {}
-  new_expectations = {}
-  with tempfile.TemporaryDirectory() as tmp_dir:
-    src_expectations = test_home / 'expectations' / config
-    dst_expectations = Path(tmp_dir, 'expectations', config)
-    dst_expectations.mkdir(parents = True)
-
-    # Load the old expectations and copy the files to the tmp directory
-    # (important so that expectations files that weren't modified are still
-    # loaded and files that were modified are present to be patched).
-    for suite_file in src_expectations.iterdir():
-      load_test_suite_expectations(old_expectations, suite_file)
+  # Configurations other than the default configuration inherit the default
+  # configuration's expectations, so the default configuration's files (and the
+  # changes to them) are part of what the configuration's expectations are.
+  parent_config = edgtest.runtest.get_parent_config_name(config)
+  if (parent_config is not None and
+      not (test_home / 'expectations' / parent_config).is_dir()):
+    parent_config = None
 
-      shutil.copy2(suite_file, dst_expectations / suite_file.name)
-
-    # Overwrite/patch any modified expectations files.
-    await patch_files_with_prefix(
-      loop,
-      dst_expectations,
-      src_expectations,
-      f"tests/expectations/{config}/",
-      diff_files
-    )
+  old_expectations: Dict[str, List[str]] = {}
+  new_expectations: Dict[str, List[str]] = {}
+  with tempfile.TemporaryDirectory() as tmp_dir:
+    configs_to_load = [config]
+    if parent_config is not None:
+      configs_to_load.append(parent_config)
+
+    suite_names = set()
+    for config_to_load in configs_to_load:
+      src_expectations = test_home / 'expectations' / config_to_load
+      dst_expectations = Path(tmp_dir, 'expectations', config_to_load)
+      dst_expectations.mkdir(parents = True)
+
+      # Copy the files to the tmp directory (important so that expectations
+      # files that weren't modified are still loaded and files that were
+      # modified are present to be patched).
+      for suite_file in src_expectations.iterdir():
+        suite_names.add(suite_file.stem)
+        shutil.copy2(suite_file, dst_expectations / suite_file.name)
+
+      # Overwrite/patch any modified expectations files.
+      await patch_files_with_prefix(
+        loop,
+        dst_expectations,
+        src_expectations,
+        f"tests/expectations/{config_to_load}/",
+        diff_files
+      )
 
-    # Load the new expectations.
-    for suite_file in dst_expectations.iterdir():
-      load_test_suite_expectations(new_expectations, suite_file)
+    # Load the old expectations (from the repository) and the new expectations
+    # (from the patched copies).
+    old_expectations_dir = test_home / 'expectations'
+    new_expectations_dir = Path(tmp_dir, 'expectations')
+    old_parent_dir = None
+    new_parent_dir = None
+    if parent_config is not None:
+      old_parent_dir = old_expectations_dir / parent_config
+      new_parent_dir = new_expectations_dir / parent_config
+
+    for suite_name in suite_names:
+      load_test_suite_expectations(
+        old_expectations,
+        suite_name,
+        old_expectations_dir / config,
+        old_parent_dir
+      )
+      load_test_suite_expectations(
+        new_expectations,
+        suite_name,
+        new_expectations_dir / config,
+        new_parent_dir
+      )
 
   for test_path in tests:
     rel_test_path_str = str(