From a14b9bc18431c6aed8441261d28b6ff20bd25935 Mon Sep 17 00:00:00 2001
From: Boris Kolpackov <boris@codesynthesis.com>
Date: Thu, 11 Apr 2019 14:44:32 +0200
Subject: Initial take on header unit and include translation support

---
 tests/cc/modules/buildfile          |   2 +-
 tests/cc/modules/common.testscript  |  49 +++++
 tests/cc/modules/headers.testscript |  31 +++
 tests/cc/modules/modules.testscript | 340 ++++++++++++++++++++++++++++++++
 tests/cc/modules/testscript         | 377 ------------------------------------
 tests/cc/preprocessed/testscript    |   6 +-
 6 files changed, 424 insertions(+), 381 deletions(-)
 create mode 100644 tests/cc/modules/common.testscript
 create mode 100644 tests/cc/modules/headers.testscript
 create mode 100644 tests/cc/modules/modules.testscript
 delete mode 100644 tests/cc/modules/testscript

(limited to 'tests/cc')

diff --git a/tests/cc/modules/buildfile b/tests/cc/modules/buildfile
index 1c998f4..9136224 100644
--- a/tests/cc/modules/buildfile
+++ b/tests/cc/modules/buildfile
@@ -5,4 +5,4 @@
 # Test C++ modules support.
 #
 
-./: testscript $b
+./: testscript{* -common} file{common.testscript} $b
diff --git a/tests/cc/modules/common.testscript b/tests/cc/modules/common.testscript
new file mode 100644
index 0000000..4f043c9
--- /dev/null
+++ b/tests/cc/modules/common.testscript
@@ -0,0 +1,49 @@
+# file      : tests/cc/modules/common.testscript
+# copyright : Copyright (c) 2014-2019 Code Synthesis Ltd
+# license   : MIT; see accompanying LICENSE file
+
+crosstest = false
+test.arguments = config.cxx="$recall($cxx.path)"
+
+.include ../../common.testscript
+
++cat <<EOI >+build/bootstrap.build
+using test
+EOI
+
++cat <<EOI >=build/root.build
+cxx.std = experimental
+
+cxx.features.symexport = true
+
+# Force modules.
+#
+cxx.features.modules = true
+
+using cxx
+
+# We forced modules but for VC we need at least 15u5 (19.12). So "unforce"
+# them in this case.
+#
+if ($cxx.id == 'msvc' && $cxx.version.major == 19 && $cxx.version.minor < 12)
+  cxx.features.modules = false
+
+hxx{*}: extension = hxx
+mxx{*}: extension = mxx
+cxx{*}: extension = cxx
+
+if ($cxx.target.class == 'windows')
+  bmis{*}: cxx.poptions += '-DLIBFOO_EXPORT=__declspec(dllexport)'
+
+exe{*}: test = true
+EOI
+
+# Determine if we have modules and header units support.
+#
++$* noop <<EOI | set modules
+print $cxx.features.modules
+EOI
+
++$* noop <<EOI | set headers
+print ($cxx.features.modules && $cxx.id == 'gcc')
+EOI
diff --git a/tests/cc/modules/headers.testscript b/tests/cc/modules/headers.testscript
new file mode 100644
index 0000000..43a200e
--- /dev/null
+++ b/tests/cc/modules/headers.testscript
@@ -0,0 +1,31 @@
+# file      : tests/cc/modules/headers.testscript
+# copyright : Copyright (c) 2014-2019 Code Synthesis Ltd
+# license   : MIT; see accompanying LICENSE file
+
+# Test header units.
+#
+
+.include common.testscript
+
++$headers || exit
+
+: include-translation
+:
+cat <<EOI >=core.hxx;
+  #ifdef CORE_IN
+  #  error macro isolation
+  #endif
+  #define CORE_OUT 1
+  inline int f () {return 1;}
+  EOI
+cat <<EOI >=driver.cxx;
+  #define CORE_IN 1
+  #include "core.hxx"
+  #ifndef CORE_OUT
+  #  error macro export
+  #endif
+  int main () {return f () - 1 /* CORE_OUT */;}
+  EOI
+$* test clean config.cxx.header_units="$~/core.hxx" &$~/../build/cc/*** <<EOI
+  exe{test}: cxx{driver}
+  EOI
diff --git a/tests/cc/modules/modules.testscript b/tests/cc/modules/modules.testscript
new file mode 100644
index 0000000..87b104d
--- /dev/null
+++ b/tests/cc/modules/modules.testscript
@@ -0,0 +1,340 @@
+# file      : tests/cc/modules/modules.testscript
+# copyright : Copyright (c) 2014-2019 Code Synthesis Ltd
+# license   : MIT; see accompanying LICENSE file
+
+# Test modules proper.
+#
+
+.include common.testscript
+
++$modules || exit
+
+# Common source files that are symlinked in the test directories if used.
+#
++cat <<EOI >=core.mxx
+#ifndef LIBFOO_EXPORT
+#  define LIBFOO_EXPORT
+#endif
+
+export module foo.core;
+export LIBFOO_EXPORT int f (int);
+EOI
+
++cat <<EOI >=core.cxx
+module foo.core;
+int f (int i) {return i - 1;}
+EOI
+
++cat <<EOI >=driver.cxx
+import foo.core;
+int main (int argc, char*[]) {return f (argc);}
+EOI
+
+: bmi-combined
+:
+: Test combined interface/implementation unit specified as bmi{}.
+:
+cp ../core.mxx ./ && cat >+core.mxx <<EOI;
+  int f (int i) {return i - 1;}
+  EOI
+ln -s ../driver.cxx ./;
+$* test clean <<EOI
+  exe{test}: cxx{driver} bmi{core}
+  bmi{core}: mxx{core}
+  EOI
+
+: mxx-combined
+:
+: Test combined interface/implementation unit specified as mxx{}.
+:
+cp ../core.mxx ./ && cat >+core.mxx <<EOI;
+  int f (int i) {return i - 1;}
+  EOI
+ln -s ../driver.cxx ./;
+$* test clean <<EOI
+  exe{test}: cxx{driver} mxx{core}
+  EOI
+
+: bmi-separate
+:
+: Test separate interface/implementation unit specified as bmi{}.
+:
+ln -s ../core.mxx ../core.cxx ../driver.cxx ./;
+$* test clean <<EOI
+  exe{test}: cxx{driver} {bmi cxx}{core}
+  bmi{core}: mxx{core}
+  EOI
+
+: mxx-separate
+:
+: Test separate interface/implementation unit specified as mxx{}.
+:
+ln -s ../core.mxx ../core.cxx ../driver.cxx ./;
+$* test clean <<EOI
+  exe{test}: cxx{driver} {mxx cxx}{core}
+  EOI
+
+: name-match
+:
+: Test fuzzy/explicit match between module name and file name.
+:
+{
+  # "Bad" match which we should better.
+  #
+  +cat <<EOI >=core.mxx
+    export module bar.core;
+    EOI
+
+  : separator
+  :
+  : Test separator equivalence.
+  :
+  ln -s ../../core.mxx foo-core.mxx;
+  ln -s ../core.mxx ../../core.cxx ../../driver.cxx ./;
+  $* test clean <'exe{test}: cxx{driver core} mxx{core foo-core}'
+
+  : case
+  :
+  : Test case-insensitivity and case-change as a separator.
+  :
+  ln -s ../../core.mxx FooCore.mxx;
+  ln -s ../core.mxx ../../core.cxx ../../driver.cxx ./;
+  $* test clean <'exe{test}: cxx{driver core} mxx{core FooCore}'
+
+  : dir
+  :
+  : Test subdirectory.
+  :
+  mkdir foo;
+  ln -s ../../core.mxx foo/core.mxx;
+  ln -s ../core.mxx ../../core.cxx ../../driver.cxx ./;
+  $* test clean <'exe{test}: cxx{driver core} mxx{core} foo/mxx{core}'
+
+  : explicit
+  :
+  : Explicit module name.
+  :
+  ln -s ../../core.mxx baz.mxx;
+  ln -s ../core.mxx ../../core.cxx ../../driver.cxx ./;
+  $* test clean <<EOO
+    exe{test}: cxx{driver core} mxx{core baz}
+    mxx{baz}@./: cxx.module_name = foo.core
+    EOO
+}
+
+: unresolved
+:
+ln -s ../driver.cxx ./;
+$* test &*.d <'exe{test}: cxx{driver}' 2>>EOE != 0
+  driver.cxx: error: unable to resolve module foo.core
+  EOE
+
+: misguessed
+:
+ln -s ../core.mxx ./;
+cat <'import bar.core;' >=driver.cxx;
+$* test &*.d &?*.ii <'exe{test}: cxx{driver} mxx{core}' 2>>EOE != 0
+  driver.cxx: error: failed to correctly guess module name from mxx{core}
+    info: guessed: bar.core
+    info: actual:  foo.core
+    info: consider adjusting module interface file names or
+    info: consider specifying module name with cxx.module_name
+  EOE
+
+: library
+:
+: Test importing a module from a library.
+:
+ln -s ../core.mxx ../core.cxx ../driver.cxx ./;
+$* test clean <<EOI
+  ./: lib{foo} exe{test} # Full build.
+  exe{test}: cxx{driver} lib{foo}
+  lib{foo}: {mxx cxx}{core}
+  EOI
+
+: module-marker
+:
+: Test global module fragment/leading module marker (module;).
+:
+cat <<EOI >=g.hxx;
+void g ();
+EOI
+cat <<EOI >=core.mxx;
+#if __cpp_modules >= 201804
+module;
+#endif
+
+#include "g.hxx"
+EOI
+cat <<<../core.mxx >+core.mxx;
+ln -s ../core.cxx ../driver.cxx ./;
+$* test clean <<EOI
+  exe{test}: cxx{driver} {mxx cxx}{core}
+  EOI
+
+: re-export
+:
+: Test module re-exporting (export import M;)
+:
+{
+  +cat <<EOI >=base.mxx
+    export module foo.base;
+    export import foo.core;
+    EOI
+
+  +cat <<EOI >=extra.mxx
+    #ifndef LIBFOO_EXPORT
+    #  define LIBFOO_EXPORT
+    #endif
+
+    export module foo.extra;
+
+    export import foo.base; // Note: cannot be combined with the below.
+
+    export
+    {
+      // VC appears to require dll-export of inline functions.
+      //
+      LIBFOO_EXPORT inline int g (int i) {return i != 0 ? i : -1;}
+    }
+    EOI
+
+  +cat <<EOI >=foo.mxx
+    export module foo;
+
+    export import foo.core;
+    export import foo.base;
+    export import foo.extra;
+    EOI
+
+  : basic
+  :
+  ln -s ../base.mxx ../../core.mxx ../../core.cxx ./;
+  cat <<EOI >=driver.cxx;
+    import foo.base;
+    int main (int argc, char*[]) {return f (argc);}
+    EOI
+  $* test clean <'exe{test}: cxx{driver core} mxx{core base}'
+
+  : recursive
+  :
+  ln -s ../base.mxx ../extra.mxx ../../core.mxx ../../core.cxx ./;
+  cat <<EOI >=driver.cxx;
+    import foo.extra;
+    int main (int argc, char*[]) {return f (g (argc));}
+    EOI
+  $* test clean <'exe{test}: cxx{driver core} mxx{core base extra}'
+
+  : duplicate
+  :
+  ln -s ../base.mxx ../extra.mxx ../foo.mxx ../../core.mxx ../../core.cxx ./;
+  cat <<EOI >=driver.cxx;
+    import foo;
+    int main (int argc, char*[]) {return f (g (argc));}
+    EOI
+  $* test clean <'exe{test}: cxx{driver core} mxx{core base extra foo}'
+
+  : library
+  :
+  ln -s ../base.mxx ../extra.mxx ../foo.mxx ../../core.mxx ../../core.cxx ./;
+  cat <<EOI >=driver.cxx;
+    import foo;
+    int main (int argc, char*[]) {return f (g (argc));}
+    EOI
+  $* test clean <<EOI
+    exe{test}: cxx{driver} mxx{foo} lib{foo}
+    lib{foo}: mxx{core base extra} cxx{core}
+    EOI
+}
+
+: import
+:
+: Test module import. Currently, all the implementation require access to the
+: entire, recursively-explored list of BMIs.
+:
+{
+  +cat <<EOI >=base.mxx
+    export module foo.base;
+    import foo.core;
+    export int g (int i) {return f (i);}
+    EOI
+
+  +cat <<EOI >=extra.mxx
+    export module foo.extra;
+    import foo.base;
+    export int h (int i) {return g (i);}
+    EOI
+
+  : basic
+  :
+  ln -s ../base.mxx ../../core.mxx ../../core.cxx ./;
+  cat <<EOI >=driver.cxx;
+    import foo.base;
+    int main (int argc, char*[]) {return g (argc);}
+    EOI
+  $* test clean <'exe{test}: cxx{driver core} mxx{core base}'
+
+  : recursive
+  :
+  ln -s ../base.mxx ../extra.mxx ../../core.mxx ../../core.cxx ./;
+  cat <<EOI >=driver.cxx;
+    import foo.extra;
+    int main (int argc, char*[]) {return h (argc);}
+    EOI
+  $* test clean <'exe{test}: cxx{driver core} mxx{core base extra}'
+}
+
+: resolve-change
+:
+: Test detection of module name to BMI resolution change.
+:
+ln -s ../core.mxx ../core.cxx ../driver.cxx ./;
+cat <<EOI >=foo-core.mxx;
+  export module foo.core;
+  export inline int f (int i) {return i - 2;}
+  EOI
+$* update <<EOI;
+  ./: exe{test} bmie{foo-core}
+  exe{test}: cxx{driver} {mxx cxx}{core}
+  bmie{foo-core}: mxx{foo-core}
+  EOI
+$* test --verbose 1 <<EOI 2>>EOE;
+  exe{test}: cxx{driver} {mxx}{foo-core}
+  exe{test}: test.arguments = two
+  EOI
+  c++ cxx{driver}
+  ld exe{test}
+  test exe{test}
+  EOE
+$* test clean <<EOI
+  ./: exe{test} bmie{foo-core}
+  exe{test}: cxx{driver} {mxx cxx}{core}
+  bmie{foo-core}: mxx{foo-core}
+  EOI
+
+: symexport
+:
+: Test the __symexport feature.
+:
+cat <<EOI >=core.mxx;
+  export module foo.core;
+
+  export __symexport int f (int);
+
+  __symexport int g_impl (int i) {return i - 1;}
+  export __symexport inline int g (int i) {return g_impl (i);}
+  EOI
+ln -s ../core.cxx core-f.cxx;
+cat <<EOI >=core-g.cxx;
+  module foo.core;
+  int g_impl (int i) {return i - 1;}
+  EOI
+cat <<EOI >=driver.cxx;
+  import foo.core;
+  int main (int argc, char*[]) {return f (argc) + g (argc);}
+  EOI
+$* test clean <<EOI
+  ./: lib{foo} exe{test} # Full build.
+  exe{test}: cxx{driver} lib{foo}
+  lib{foo}: mxx{core} cxx{core-f} # @@ VC: core-g
+  EOI
diff --git a/tests/cc/modules/testscript b/tests/cc/modules/testscript
deleted file mode 100644
index b5b94c1..0000000
--- a/tests/cc/modules/testscript
+++ /dev/null
@@ -1,377 +0,0 @@
-# file      : tests/cc/modules/testscript
-# copyright : Copyright (c) 2014-2019 Code Synthesis Ltd
-# license   : MIT; see accompanying LICENSE file
-
-crosstest = false
-test.arguments = config.cxx="$recall($cxx.path)"
-
-.include ../../common.testscript
-
-+cat <<EOI >+build/bootstrap.build
-using test
-EOI
-
-+cat <<EOI >=build/root.build
-cxx.std = experimental
-
-cxx.features.symexport = true
-
-# Force modules.
-#
-cxx.features.modules = true
-
-using cxx
-
-# We forced modules but for VC we need at least 15u5 (19.12). So "unforce"
-# them in this case.
-#
-if ($cxx.id == 'msvc' && $cxx.version.major == 19 && $cxx.version.minor < 12)
-  cxx.features.modules = false
-
-hxx{*}: extension = hxx
-mxx{*}: extension = mxx
-cxx{*}: extension = cxx
-
-if ($cxx.target.class == 'windows')
-  bmis{*}: cxx.poptions += '-DLIBFOO_EXPORT=__declspec(dllexport)'
-
-exe{*}: test = true
-EOI
-
-# Determine if we have module support.
-#
-+$* noop <<EOI | set modules
-print $cxx.features.modules
-EOI
-
-+$modules || exit
-
-# Common source files that are symlinked in the test directories if used.
-#
-+cat <<EOI >=core.mxx
-#ifndef LIBFOO_EXPORT
-#  define LIBFOO_EXPORT
-#endif
-
-export module foo.core;
-export LIBFOO_EXPORT int f (int);
-EOI
-
-+cat <<EOI >=core.cxx
-module foo.core;
-int f (int i) {return i - 1;}
-EOI
-
-+cat <<EOI >=driver.cxx
-import foo.core;
-int main (int argc, char*[]) {return f (argc);}
-EOI
-
-: bmi-combined
-:
-: Test combined interface/implementation unit specified as bmi{}.
-:
-cp ../core.mxx ./ && cat >+core.mxx <<EOI;
-  int f (int i) {return i - 1;}
-  EOI
-ln -s ../driver.cxx ./;
-$* test clean <<EOI
-  exe{test}: cxx{driver} bmi{core}
-  bmi{core}: mxx{core}
-  EOI
-
-: mxx-combined
-:
-: Test combined interface/implementation unit specified as mxx{}.
-:
-cp ../core.mxx ./ && cat >+core.mxx <<EOI;
-  int f (int i) {return i - 1;}
-  EOI
-ln -s ../driver.cxx ./;
-$* test clean <<EOI
-  exe{test}: cxx{driver} mxx{core}
-  EOI
-
-: bmi-separate
-:
-: Test separate interface/implementation unit specified as bmi{}.
-:
-ln -s ../core.mxx ../core.cxx ../driver.cxx ./;
-$* test clean <<EOI
-  exe{test}: cxx{driver} {bmi cxx}{core}
-  bmi{core}: mxx{core}
-  EOI
-
-: mxx-separate
-:
-: Test separate interface/implementation unit specified as mxx{}.
-:
-ln -s ../core.mxx ../core.cxx ../driver.cxx ./;
-$* test clean <<EOI
-  exe{test}: cxx{driver} {mxx cxx}{core}
-  EOI
-
-: name-match
-:
-: Test fuzzy/explicit match between module name and file name.
-:
-{
-  # "Bad" match which we should better.
-  #
-  +cat <<EOI >=core.mxx
-    export module bar.core;
-    EOI
-
-  : separator
-  :
-  : Test separator equivalence.
-  :
-  ln -s ../../core.mxx foo-core.mxx;
-  ln -s ../core.mxx ../../core.cxx ../../driver.cxx ./;
-  $* test clean <'exe{test}: cxx{driver core} mxx{core foo-core}'
-
-  : case
-  :
-  : Test case-insensitivity and case-change as a separator.
-  :
-  ln -s ../../core.mxx FooCore.mxx;
-  ln -s ../core.mxx ../../core.cxx ../../driver.cxx ./;
-  $* test clean <'exe{test}: cxx{driver core} mxx{core FooCore}'
-
-  : dir
-  :
-  : Test subdirectory.
-  :
-  mkdir foo;
-  ln -s ../../core.mxx foo/core.mxx;
-  ln -s ../core.mxx ../../core.cxx ../../driver.cxx ./;
-  $* test clean <'exe{test}: cxx{driver core} mxx{core} foo/mxx{core}'
-
-  : explicit
-  :
-  : Explicit module name.
-  :
-  ln -s ../../core.mxx baz.mxx;
-  ln -s ../core.mxx ../../core.cxx ../../driver.cxx ./;
-  $* test clean <<EOO
-    exe{test}: cxx{driver core} mxx{core baz}
-    mxx{baz}@./: cxx.module_name = foo.core
-    EOO
-}
-
-: unresolved
-:
-ln -s ../driver.cxx ./;
-$* test &*.d <'exe{test}: cxx{driver}' 2>>EOE != 0
-  driver.cxx: error: unable to resolve module foo.core
-  EOE
-
-: misguessed
-:
-ln -s ../core.mxx ./;
-cat <'import bar.core;' >=driver.cxx;
-$* test &*.d &?*.ii <'exe{test}: cxx{driver} mxx{core}' 2>>EOE != 0
-  driver.cxx: error: failed to correctly guess module name from mxx{core}
-    info: guessed: bar.core
-    info: actual:  foo.core
-    info: consider adjusting module interface file names or
-    info: consider specifying module name with cxx.module_name
-  EOE
-
-: library
-:
-: Test importing a module from a library.
-:
-ln -s ../core.mxx ../core.cxx ../driver.cxx ./;
-$* test clean <<EOI
-  ./: lib{foo} exe{test} # Full build.
-  exe{test}: cxx{driver} lib{foo}
-  lib{foo}: {mxx cxx}{core}
-  EOI
-
-: module-marker
-:
-: Test global module fragment/leading module marker (module;).
-:
-cat <<EOI >=g.hxx;
-void g ();
-EOI
-cat <<EOI >=core.mxx;
-#if __cpp_modules >= 201804
-module;
-#endif
-
-#include "g.hxx"
-EOI
-cat <<<../core.mxx >+core.mxx;
-ln -s ../core.cxx ../driver.cxx ./;
-$* test clean <<EOI
-  exe{test}: cxx{driver} {mxx cxx}{core}
-  EOI
-
-: re-export
-:
-: Test module re-exporting (export import M;)
-:
-{
-  +cat <<EOI >=base.mxx
-    export module foo.base;
-    export import foo.core;
-    EOI
-
-  +cat <<EOI >=extra.mxx
-    #ifndef LIBFOO_EXPORT
-    #  define LIBFOO_EXPORT
-    #endif
-
-    export module foo.extra;
-
-    export import foo.base; // Note: cannot be combined with the below.
-
-    export
-    {
-      // VC appears to require dll-export of inline functions.
-      //
-      LIBFOO_EXPORT inline int g (int i) {return i != 0 ? i : -1;}
-    }
-    EOI
-
-  +cat <<EOI >=foo.mxx
-    export module foo;
-
-    export import foo.core;
-    export import foo.base;
-    export import foo.extra;
-    EOI
-
-  : basic
-  :
-  ln -s ../base.mxx ../../core.mxx ../../core.cxx ./;
-  cat <<EOI >=driver.cxx;
-    import foo.base;
-    int main (int argc, char*[]) {return f (argc);}
-    EOI
-  $* test clean <'exe{test}: cxx{driver core} mxx{core base}'
-
-  : recursive
-  :
-  ln -s ../base.mxx ../extra.mxx ../../core.mxx ../../core.cxx ./;
-  cat <<EOI >=driver.cxx;
-    import foo.extra;
-    int main (int argc, char*[]) {return f (g (argc));}
-    EOI
-  $* test clean <'exe{test}: cxx{driver core} mxx{core base extra}'
-
-  : duplicate
-  :
-  ln -s ../base.mxx ../extra.mxx ../foo.mxx ../../core.mxx ../../core.cxx ./;
-  cat <<EOI >=driver.cxx;
-    import foo;
-    int main (int argc, char*[]) {return f (g (argc));}
-    EOI
-  $* test clean <'exe{test}: cxx{driver core} mxx{core base extra foo}'
-
-  : library
-  :
-  ln -s ../base.mxx ../extra.mxx ../foo.mxx ../../core.mxx ../../core.cxx ./;
-  cat <<EOI >=driver.cxx;
-    import foo;
-    int main (int argc, char*[]) {return f (g (argc));}
-    EOI
-  $* test clean <<EOI
-    exe{test}: cxx{driver} mxx{foo} lib{foo}
-    lib{foo}: mxx{core base extra} cxx{core}
-    EOI
-}
-
-: import
-:
-: Test module import. Currently, all the implementation require access to the
-: entire, recursively-explored list of BMIs.
-:
-{
-  +cat <<EOI >=base.mxx
-    export module foo.base;
-    import foo.core;
-    export int g (int i) {return f (i);}
-    EOI
-
-  +cat <<EOI >=extra.mxx
-    export module foo.extra;
-    import foo.base;
-    export int h (int i) {return g (i);}
-    EOI
-
-  : basic
-  :
-  ln -s ../base.mxx ../../core.mxx ../../core.cxx ./;
-  cat <<EOI >=driver.cxx;
-    import foo.base;
-    int main (int argc, char*[]) {return g (argc);}
-    EOI
-  $* test clean <'exe{test}: cxx{driver core} mxx{core base}'
-
-  : recursive
-  :
-  ln -s ../base.mxx ../extra.mxx ../../core.mxx ../../core.cxx ./;
-  cat <<EOI >=driver.cxx;
-    import foo.extra;
-    int main (int argc, char*[]) {return h (argc);}
-    EOI
-  $* test clean <'exe{test}: cxx{driver core} mxx{core base extra}'
-}
-
-: resolve-change
-:
-: Test detection of module name to BMI resolution change.
-:
-ln -s ../core.mxx ../core.cxx ../driver.cxx ./;
-cat <<EOI >=foo-core.mxx;
-  export module foo.core;
-  export inline int f (int i) {return i - 2;}
-  EOI
-$* update <<EOI;
-  ./: exe{test} bmie{foo-core}
-  exe{test}: cxx{driver} {mxx cxx}{core}
-  bmie{foo-core}: mxx{foo-core}
-  EOI
-$* test --verbose 1 <<EOI 2>>EOE;
-  exe{test}: cxx{driver} {mxx}{foo-core}
-  exe{test}: test.arguments = two
-  EOI
-  c++ cxx{driver}
-  ld exe{test}
-  test exe{test}
-  EOE
-$* test clean <<EOI
-  ./: exe{test} bmie{foo-core}
-  exe{test}: cxx{driver} {mxx cxx}{core}
-  bmie{foo-core}: mxx{foo-core}
-  EOI
-
-: symexport
-:
-: Test the __symexport feature.
-:
-cat <<EOI >=core.mxx;
-  export module foo.core;
-
-  export __symexport int f (int);
-
-  __symexport int g_impl (int i) {return i - 1;}
-  export __symexport inline int g (int i) {return g_impl (i);}
-  EOI
-ln -s ../core.cxx core-f.cxx;
-cat <<EOI >=core-g.cxx;
-  module foo.core;
-  int g_impl (int i) {return i - 1;}
-  EOI
-cat <<EOI >=driver.cxx;
-  import foo.core;
-  int main (int argc, char*[]) {return f (argc) + g (argc);}
-  EOI
-$* test clean <<EOI
-  ./: lib{foo} exe{test} # Full build.
-  exe{test}: cxx{driver} lib{foo}
-  lib{foo}: mxx{core} cxx{core-f} # @@ VC: core-g
-  EOI
diff --git a/tests/cc/preprocessed/testscript b/tests/cc/preprocessed/testscript
index 8e36b2d..844e140 100644
--- a/tests/cc/preprocessed/testscript
+++ b/tests/cc/preprocessed/testscript
@@ -9,10 +9,10 @@ test.arguments = config.cxx="$recall($cxx.path)" update
 
 # Trace filter.
 #
-# trace: cxx::compile::extract_(headers|modules): target: .../obje{(test).o...}
+# trace: cxx::compile::apply extracting (headers|modules) from: .../obje{(test).o...}
 #
 filter = sed -n -e \
-  \''s/^trace: cxx::compile_rule::extract_([^:]+): target:[^{]+\{([^.]+).*/\1 \2/p'\'
+  \''s/^trace: cxx::compile_rule::apply: extracting ([^ ]+) from[^{]+\{([^.]+).*/\1 \2/p'\'
 
 +cat <<EOI >=build/root.build
 cxx.std = latest
@@ -98,7 +98,7 @@ $* &test* <<EOI 2>>EOE != 0
   cxx.preprocessed = modules
   exe{test}: cxx{test}
   EOI
-  test.cxx: error: modules support not available or not enabled
+  error: modules support required by cxx{test}
   EOE
 
 : all
-- 
cgit v1.1