diff --git a/t/subcommands/build.t b/t/subcommands/build.t
index db5978d..5cdb7be 100644
--- a/t/subcommands/build.t
+++ b/t/subcommands/build.t
@@ -38,60 +38,62 @@ plan 31;
 
 given $core {
     # [T] Build a project: Succeed.
-    is .state-of('fetched'), fetched, "State before: 'fetched'";
+    is .state-of('fetched'), 'fetched', "State before: 'fetched'";
     is .build(<fetched>), success, "Building project succeeded";
-    is .state-of('fetched'), built, "State after: 'built'";
+    is .state-of('fetched'), 'built', "State after: 'built'";
 
     # [T] Build an unfetched project: Fetch, build.
     @actions = ();
-    is .state-of('unfetched'), gone, "State before: 'gone'";
+    is .state-of('unfetched'), 'gone', "State before: 'gone'";
     is .build(<unfetched>), success, "Building unfetched project succeeded";
     is ~@actions, 'fetch[unfeched] build[unfetched]',
         "Fetched the project before building it";
-    is .state-of('unfetched'), built, "State after of unfetched: 'built'";
+    is .state-of('unfetched'), 'built', "State after of unfetched: 'built'";
 
     # [T] Build an unfetched project; fetch fails. Fail.
     @actions = ();
     is .build(<won't-fetch>), failure, "Won't build if fetch fails"; # "
     is ~@actions, "fetch[won't-fetch]", "Didn't try building";
-    is .state-of("won't-fetch"), gone, "State after of won't-fetch: unchanged";
+    is .state-of("won't-fetch"), 'gone',
+        "State after of won't-fetch: unchanged";
 
     # [T] Build a project; a build error occurs: Fail.
     @actions = ();
     is .build(<won't-build>), failure, "Won't build if build fails"; # "
     is ~@actions, "fetch[won't-build] build[won't build]", "Tried building";
-    is .state-of("won't-build"), gone, "State after of won't-build: unchanged";
+    is .state-of("won't-build"), 'gone',
+        "State after of won't-build: unchanged";
 
     # [T] Build a project with dependencies: Build dependencies first.
     @actions = ();
-    is .build(<has-deps>), success, "Building project with deps succeeds";
+    is .build(<has-deps>), 'success', "Building project with deps succeeds";
     is ~@actions, "fetch[C] build[A] build[C] build[D] build[has-deps]",
         "Fetch before build, build with postorder traversal";
-    is .state-of('has-deps'), built, "State after of has-deps: built";
+    is .state-of('has-deps'), 'built', "State after of has-deps: built";
     for <A B C D> -> $dep {
-        is .state-of($dep), built, "State after of $dep: built";
+        is .state-of($dep), 'built', "State after of $dep: built";
     }
 
     # [T] Build a project with circular dependencies: Fail.
     @actions = ();
     is .build(<circ-deps>), failure, "Building project with circ deps fails";
     is ~@actions, "", "Didn't even try to build anything";
-    is .state-of('circ-deps'), fetched, "State after of circ-deps: unchanged";
-    is .state-of('E'), fetched;
+    is .state-of('circ-deps'), 'fetched', "State after of circ-deps: unchanged";
+    is .state-of('E'), 'fetched';
 
     # [T] Build a project whose direct dependency fails: Fail.
     is .build(<dirdep-fails>), failure, "Fail when direct dep fails to build";
-    is .state-of('dirdep-fails'), fetched,
+    is .state-of('dirdep-fails'), 'fetched',
         "State after of dirdep-fails: unchanged";
-    is .state-of('will-fail'), fetched,
+    is .state-of('will-fail'), 'fetched',
         "State after of will-fail: unchanged";
 
     # [T] Build a project whose indirect dependency fails: Fail.
     is .build(<indir-fails>), failure, "Fail when indirect dep fails to build";
-    is .state-of('indir-fails'), fetched,
+    is .state-of('indir-fails'), 'fetched',
         "State after of indir-fails: unchanged";
-    is .state-of('dirdep-fails'), fetched,
+    is .state-of('dirdep-fails'), 'fetched',
         "State after of dirdep-fails: unchanged";
-    is .state-of('will-fail'), fetched,
+    is .state-of('will-fail'), 'fetched',
         "State after of will-fail: unchanged";
 }
diff --git a/t/subcommands/fetch.t b/t/subcommands/fetch.t
index 789af25..b0f8b02 100644
--- a/t/subcommands/fetch.t
+++ b/t/subcommands/fetch.t
@@ -30,36 +30,36 @@ plan 24;
 
 given $core {
     # [T] Fetch a project: Succeed.
-    is .state-of('will-succeed'), gone, "State is now 'gone'";
+    is .state-of('will-succeed'), 'gone', "State is now 'gone'";
     is .fetch(<will-succeed>), success, "Fetch a project: Succeed";
-    is .state-of('will-succeed'), fetched, "State after: 'fetched'";
+    is .state-of('will-succeed'), 'fetched', "State after: 'fetched'";
 
     # [T] Fetch a project; an unexpected error occurs: Fail.
     is .fetch(<will-fail>), failure, "Fetch a project: Fail";
-    is .state-of('will-fail'), gone, "State after: 'gone'";
+    is .state-of('will-fail'), 'gone', "State after: 'gone'";
 
     # [T] Fetch a project with dependencies: Fetch dependencies too.
     for <A B C D> -> $dep {
-        is .state-of($dep), gone, "State before of $dep: 'gone'";
+        is .state-of($dep), 'gone', "State before of $dep: 'gone'";
     }
     is .fetch(<has-deps>), success, "Fetch project's dependencies, too";
     for <A B C D> -> $dep {
-        is .state-of($dep), fetched, "State after of $dep: 'fetched'";
+        is .state-of($dep), 'fetched', "State after of $dep: 'fetched'";
     }
 
     # [T] Fetch a project with circular dependencies: Fail.
     is .fetch(<circ-deps>), failure, "Fetch a project with circ deps: fail";
-    is .state-of('circ-deps'), gone, "State after of circ-deps: 'gone'";
-    is .state-of('E'), gone, "State after of E: 'gone'";
+    is .state-of('circ-deps'), 'gone', "State after of circ-deps: 'gone'";
+    is .state-of('E'), 'gone', "State after of E: 'gone'";
 
     # [T] Fetch a project whose direct dependency fails: Fail.
     is .fetch(<dirdep-fails>), failure, "Fail on direct dependency failure";
-    is .state-of('dirdep-fails'), gone, "State after of dirdep-fails: 'gone'";
-    is .state-of('will-fail'), gone, "State after of will-fail: 'gone'";
+    is .state-of('dirdep-fails'), 'gone', "State after of dirdep-fails: 'gone'";
+    is .state-of('will-fail'), 'gone', "State after of will-fail: 'gone'";
 
     # [T] Fetch a project whose indirect dependency fails: Fail.
     is .fetch(<indir-fails>), failure, "Fail on indirect dependency failure";
-    is .state-of('indir-fails'), gone, "State after of indir-fails: 'gone'";
-    is .state-of('dirdep-fails'), gone, "State after of dirdep-fails: 'gone'";
-    is .state-of('will-fail'), gone, "State after of will-fail: 'gone'";
+    is .state-of('indir-fails'), 'gone', "State after of indir-fails: 'gone'";
+    is .state-of('dirdep-fails'), 'gone', "State after of dirdep-fails: 'gone'";
+    is .state-of('will-fail'), 'gone', "State after of will-fail: 'gone'";
 }
diff --git a/t/subcommands/install-skip-tests.t b/t/subcommands/install-skip-tests.t
index 1f52de8..a4db850 100644
--- a/t/subcommands/install-skip-tests.t
+++ b/t/subcommands/install-skip-tests.t
@@ -63,20 +63,20 @@ given $core {
     is .install(<won't-test>, :skip-test), success, #'
         "Tests are never run, go directly to install";
     is ~@actions, "install[won't-test]", "Tests skipped, installed";
-    is .state-of("won't test"), installed, "State after: 'installed'";
+    is .state-of("won't test"), 'installed', "State after: 'installed'";
 
     # [T] Install-ST an unbuilt project: Build, don't test, install.
     @actions = ();
     is .install(<unbuilt>, :skip-test), success, "Build, skip test, install";
     is ~@actions, 'build[unbuilt] install[unbuilt]', "Didn't run the tests";
-    is .state-of("unbuilt"), installed, "State after: 'installed'";
+    is .state-of("unbuilt"), 'installed', "State after: 'installed'";
 
     # [T] Install-ST an unbuilt project; build fails. Fail.
     @actions = ();
     is .install(<won't-build>, :force), failure, #'
         "Build fails, won't install";
     is ~@actions, "build[won't-build]", "Didn't try to install";
-    is .state-of("won't-build"), fetched, "State after: unchanged";
+    is .state-of("won't-build"), 'fetched', "State after: unchanged";
 
     # [T] Install-ST an unfetched project: Fetch, build, don't test, install.
     @actions = ();
@@ -84,14 +84,14 @@ given $core {
         "Fetch, build, skip test, install";
     is ~@actions, 'fetch[unfetched] build[unfetched] install[unfetched]',
         "Didn't run the tests";
-    is .state-of("unfetched"), installed, "State after: 'installed'";
+    is .state-of("unfetched"), 'installed', "State after: 'installed'";
 
     # [T] Install-ST an unfetched project; fetch fails. Fail.
     @actions = ();
     is .install(<won't-fetch>, :skip-test), failure, #'
         "Fetching fails, won't install";
     is ~@actions, "fetch[won't-fetch]", "Tried to fetch, not build etc";
-    is .state-of("won't-fetch"), gone, "State after: unchanged";
+    is .state-of("won't-fetch"), 'gone', "State after: unchanged";
 
     # [T] Install-ST an unfetched project; build fails. Fail.
     @actions = ();
@@ -99,7 +99,7 @@ given $core {
         "Build fails, won't install";
     is ~@actions, "fetch[won't-build-2] build[won't-build-2]",
         "Tried to fetch and build, not test etc";
-    is .state-of("won't-build-2"), fetched, "State after: 'fetched'";
+    is .state-of("won't-build-2"), 'fetched', "State after: 'fetched'";
 
     # [T] Install-ST a project with dependencies: Install-ST dependencies too.
     @actions = ();
@@ -108,10 +108,10 @@ given $core {
     is ~@actions, 'fetch[C] build[C] build[has-deps] '
                   ~ 'install[C] install[D] install[B] install[has-deps]',
         "fetch, build and install (all postorder and by need). no test.";
-    is .state-of("has-deps"), installed,
+    is .state-of("has-deps"), 'installed',
         "State after of has-deps: 'installed'";
     for <A B C D> -> $dep {
-        is .state-of($dep), installed, "State after of $dep: 'installed'";
+        is .state-of($dep), 'installed', "State after of $dep: 'installed'";
     }
 
     # [T] Install-ST a project with circular dependencies: Fail.
@@ -119,8 +119,8 @@ given $core {
     is .install(<circ-deps>, :skip-test), failure,
         "Circular dependency install: fail";
     is ~@actions, '', "Nothing was done";
-    is .state-of("circ-deps"), tested, "State after of circ-deps: unchanged";
-    is .state-of("E"), tested, "State after of E: unchanged";
+    is .state-of("circ-deps"), 'tested', "State after of circ-deps: unchanged";
+    is .state-of("E"), 'tested', "State after of E: unchanged";
 
     # [T] Install-ST a project whose direct dependency fails: Fail.
     @actions = ();
@@ -128,9 +128,9 @@ given $core {
         "Direct dependency fails: fail";
     is ~@actions, "install[won't-install]",
         "Install fails on first project, doesn't proceed";
-    is .state-of("won't-install"), built,
+    is .state-of("won't-install"), 'built',
         "State after of won't-install: unchanged";
-    is .state-of("dirdep-fails"), built,
+    is .state-of("dirdep-fails"), 'built',
         "State after of dirdep-fails: unchanged";
 
     # [T] Install-ST a project whose indirect dependency fails: Fail.
@@ -139,10 +139,10 @@ given $core {
         "Indirect dependency fails: fail";
     is ~@actions, "install[won't-install]",
         "Installation fails on first project, doesn't proceed";
-    is .state-of("won't-install"), built, "State after: unchanged";
+    is .state-of("won't-install"), 'built', "State after: unchanged";
     for <F G H> -> $dep {
-        is .state-of($dep), built, "State after of $dep: unchanged";
+        is .state-of($dep), 'built', "State after of $dep: unchanged";
     }
-    is .state-of("indir-fails"), built,
+    is .state-of("indir-fails"), 'built',
         "State after of indir-fails: unchanged";
 }
diff --git a/t/subcommands/install-with-force.t b/t/subcommands/install-with-force.t
index b17c983..7800650 100644
--- a/t/subcommands/install-with-force.t
+++ b/t/subcommands/install-with-force.t
@@ -54,14 +54,14 @@ given $core {
     is .install(<won't-test>, :force), forced-success, #'
         "Testing fails, install anyway";
     is ~@actions, "test[won't-test] install[won't-test]", "Tested, installed";
-    is .state-of("won't test"), installed, "State after: 'installed'";
+    is .state-of("won't test"), 'installed', "State after: 'installed'";
 
     # [T] Force install an unbuilt project; build fails. Fail.
     @actions = ();
     is .install(<won't-build>, :force), failure, #'
         "Build fails, won't install";
     is ~@actions, "build[won't-build]", "Didn't try to install";
-    is .state-of("won't-build"), fetched, "State after: unchanged";
+    is .state-of("won't-build"), 'fetched', "State after: unchanged";
 
     # [T] Force install an unbuilt project; testing fails. Install anyway.
     @actions = ();
@@ -70,14 +70,14 @@ given $core {
     is ~@actions, "build[won't-test-2] test[won't-test-2] "
                   ~ "install[won't-test-2]",
         "Built, tested and installed";
-    is .state-of("won't-test-2"), installed, "State after: 'installed'";
+    is .state-of("won't-test-2"), 'installed', "State after: 'installed'";
 
     # [T] Force install an unfetched project; fetch fails. Fail.
     @actions = ();
     is .install(<won't-fetch>, :force), failure, #'
         "Fetching fails, won't install";
     is ~@actions, "fetch[won't-fetch]", "Tried to fetch, not build etc";
-    is .state-of("won't-fetch"), gone, "State after: unchanged";
+    is .state-of("won't-fetch"), 'gone', "State after: unchanged";
 
     # [T] Force install an unfetched project; build fails. Fail.
     @actions = ();
@@ -85,7 +85,7 @@ given $core {
         "Build fails, won't install";
     is ~@actions, "fetch[won't-build-2] build[won't-build-2]",
         "Tried to fetch and build, not test etc";
-    is .state-of("won't-build-2"), fetched, "State after: 'fetched'";
+    is .state-of("won't-build-2"), 'fetched', "State after: 'fetched'";
 
     # [T] Force install an unfetched project; testing fails. Install anyway.
     @actions = ();
@@ -94,7 +94,7 @@ given $core {
     is ~@actions, "fetch[won't-test-3] build[won't-test-3] test[won't-test-3] "
                   ~ "install[won't-test-3]",
         "Fetch, build, test and install";
-    is .state-of("won't-test-3"), built, "State after: 'built'";
+    is .state-of("won't-test-3"), 'built', "State after: 'built'";
 
     # [T] Force install a project with dependencies: Install dependencies too.
     @actions = ();
@@ -104,10 +104,10 @@ given $core {
                   ~ 'test[C] test[D] test[B] test[has-deps] '
                   ~ 'install[C] install[D] install[B] install[has-deps]',
         "fetch, build, test and install (all postorder and by need)";
-    is .state-of("has-deps"), installed,
+    is .state-of("has-deps"), 'installed',
         "State after of has-deps: 'installed'";
     for <A B C D> -> $dep {
-        is .state-of($dep), installed, "State after of $dep: 'installed'";
+        is .state-of($dep), 'installed', "State after of $dep: 'installed'";
     }
 
     # [T] Force install a project with circular dependencies: Fail.
@@ -115,8 +115,8 @@ given $core {
     is .install(<circ-deps>, :force), failure,
         "Circular dependency install: fail";
     is ~@actions, '', "Nothing was done";
-    is .state-of("circ-deps"), tested, "State after of circ-deps: unchanged";
-    is .state-of("E"), tested, "State after of E: unchanged";
+    is .state-of("circ-deps"), 'tested', "State after of circ-deps: unchanged";
+    is .state-of("E"), 'tested', "State after of E: unchanged";
 
     # [T] Froce install a project whose direct dependency fails:
     #     Install anyway.
@@ -125,9 +125,9 @@ given $core {
         "Direct dependency fails but project itself succeds: succeed";
     is ~@actions, "install[won't-install] install[dirdep-fails]",
         "Install proceeds even after failure";
-    is .state-of("won't-install"), tested,
+    is .state-of("won't-install"), 'tested',
         "State after of won't-install: unchanged";
-    is .state-of("dirdep-fails"), installed,
+    is .state-of("dirdep-fails"), 'installed',
         "State after of dirdep-fails: 'installed'";
 
     # [T] Force install a project whose indirect dependency fails:
@@ -138,10 +138,10 @@ given $core {
     is ~@actions, "install[won't-install] install[G] install[H] install[F] "
                   ~ "install[indir-fails]",
         "Installation of all projects are made, though the first fails";
-    is .state-of("won't-install"), tested, "State after: unchanged";
+    is .state-of("won't-install"), 'tested', "State after: unchanged";
     for <F G H> -> $dep {
-        is .state-of($dep), installed, "State after of $dep: 'installed'";
+        is .state-of($dep), 'installed', "State after of $dep: 'installed'";
     }
-    is .state-of("indir-fails"), installed,
+    is .state-of("indir-fails"), 'installed',
         "State after of indir-fails: 'installed'";
 }
diff --git a/t/subcommands/install-with-test.t b/t/subcommands/install-with-test.t
index d00c4e5..88f892b 100644
--- a/t/subcommands/install-with-test.t
+++ b/t/subcommands/install-with-test.t
@@ -52,47 +52,47 @@ plan 51;
 
 given $core {
     # [T] Install a tested project: Succeed.
-    is .state-of("uninstalled"), tested, "State before: 'tested'";
+    is .state-of("uninstalled"), 'tested', "State before: 'tested'";
     is .install(<uninstalled>), success, "Install of tested project succeeded";
-    is .state-of("uninstalled"), installed, "State after: 'installed'";
+    is .state-of("uninstalled"), 'installed', "State after: 'installed'";
 
     # [T] Install a tested project whose install fails: Fail.
-    is .state-of("won't-install"), tested, "State before: 'tested'";
+    is .state-of("won't-install"), 'tested', "State before: 'tested'";
     is .install(<won't-install>), failure, "An install that fails"; #'
-    is .state-of("won't-install"), tested, "State after: unchanged";
+    is .state-of("won't-install"), 'tested', "State after: unchanged";
 
     # [T] Install an untested project: Test, install.
     @actions = ();
-    is .state-of("untested"), built, "State before: 'built'";
+    is .state-of("untested"), 'built', "State before: 'built'";
     is .install(<untested>), success, "Test, then install succeeds.";
     is ~@actions, 'test[untested] install[untested]', "Correct order";
-    is .state-of("untested"), installed, "State after: 'installed'";
+    is .state-of("untested"), 'installed', "State after: 'installed'";
 
     # [T] Install an untested project; testing fails. Fail.
     @actions = ();
     is .install(<won't-test>), failure, "Testing fails, won't install"; #"
     is ~@actions, "test[won't-test]", "Tested, didn't install";
-    is .state-of("won't test"), built, "State after: unchanged";
+    is .state-of("won't test"), 'built', "State after: unchanged";
 
     # [T] Install an unbuilt project: Build, test, install.
     @actions = ();
     is .install(<unbuilt>), success, "Build, test, install";
     is ~@actions, 'build[unbuilt] test[unbuilt] install[unbuilt]',
         "Order is correct";
-    is .state-of("unbuilt"), installed, "State after: 'installed'";
+    is .state-of("unbuilt"), 'installed', "State after: 'installed'";
 
     # [T] Install an unbuilt project; build fails. Fail.
     @actions = ();
     is .install(<won't-build>), failure, "Build fails, won't install"; #"
     is ~@actions, "build[won't-build]", "Didn't try to install";
-    is .state-of("won't-build"), fetched, "State after: unchanged";
+    is .state-of("won't-build"), 'fetched', "State after: unchanged";
 
     # [T] Install an unbuilt project; testing fails. Fail.
     @actions = ();
     is .install(<won't-test-2>), failure, "Testing fails, won't install"; #"
     is ~@actions, "build[won't-test-2] test[won't-test-2]",
         "Built and tested, but didn't try to install";
-    is .state-of("won't-test-2"), built, "State after: 'built'";
+    is .state-of("won't-test-2"), 'built', "State after: 'built'";
 
     # [T] Install an unfetched project: Fetch, build, test, install.
     @actions = ();
@@ -100,27 +100,27 @@ given $core {
     is ~@actions,
         'fetch[unfetched] build[unfetched] test[unfetched] install[unfected]',
         "Correct order";
-    is .state-of("unfetched"), installed, "State after: 'installed'";
+    is .state-of("unfetched"), 'installed', "State after: 'installed'";
 
     # [T] Install an unfetched project; fetch fails. Fail.
     @actions = ();
     is .install(<won't-fetch>), failure, "Fetching fails, won't install"; #"
     is ~@actions, "fetch[won't-fetch]", "Tried to fetch, not build etc";
-    is .state-of("won't-fetch"), gone, "State after: unchanged";
+    is .state-of("won't-fetch"), 'gone', "State after: unchanged";
 
     # [T] Install an unfetched project; build fails. Fail.
     @actions = ();
     is .install(<won't-build-2>), failure, "Build fails, won't install"; #"
     is ~@actions, "fetch[won't-build-2] build[won't-build-2]",
         "Tried to fetch and build, not test etc";
-    is .state-of("won't-build-2"), fetched, "State after: 'fetched'";
+    is .state-of("won't-build-2"), 'fetched', "State after: 'fetched'";
 
     # [T] Install an unfetched project; testing fails. Fail.
     @actions = ();
     is .install(<won't-test-3>), failure, "Test fails, won't install"; #"
     is ~@actions, "fetch[won't-test-3] build[won't-test-3] test[won't-test-3]",
         "Tried to fetch, build and test, not install";
-    is .state-of("won't-test-3"), built, "State after: 'built'";
+    is .state-of("won't-test-3"), 'built', "State after: 'built'";
 
     # [T] Install a project with dependencies: Install dependencies too.
     @actions = ();
@@ -129,28 +129,28 @@ given $core {
                   ~ 'test[C] test[D] test[B] test[has-deps] '
                   ~ 'install[C] install[D] install[B] install[has-deps]',
         "fetch, build, test and install (all postorder and by need)";
-    is .state-of("has-deps"), installed,
+    is .state-of("has-deps"), 'installed',
         "State after of has-deps: 'installed'";
     for <A B C D> -> $dep {
-        is .state-of($dep), installed, "State after of $dep: 'installed'";
+        is .state-of($dep), 'installed', "State after of $dep: 'installed'";
     }
 
     # [T] Install a project with circular dependencies: Fail.
     @actions = ();
     is .install(<circ-deps>), failure, "Circular dependency install: fail";
     is ~@actions, '', "Nothing was done";
-    is .state-of("circ-deps"), tested, "State after of circ-deps: unchanged";
-    is .state-of("E"), tested, "State after of E: unchanged";
+    is .state-of("circ-deps"), 'tested', "State after of circ-deps: unchanged";
+    is .state-of("E"), 'tested', "State after of E: unchanged";
 
     # [T] Install a project whose direct dependency fails: Fail.
     @actions = ();
     is .install(<dirdep-fails>), failure, "Direct dependency fails: fail";
     is ~@actions, "install[won't-install]", "Still, an install was attempted";
-    is .state-of("won't-install"), tested, "State after: unchanged";
+    is .state-of("won't-install"), 'tested', "State after: unchanged";
 
     # [T] Install a project whose indirect dependency fails: Fail.
     @actions = ();
     is .install(<indir-fails>), failure, "Indirect dependency fails: fail";
     is ~@actions, "install[won't-install]", "Still, an install was attempted";
-    is .state-of("won't-install"), tested, "State after: unchanged";
+    is .state-of("won't-install"), 'tested', "State after: unchanged";
 }
diff --git a/t/subcommands/test.t b/t/subcommands/test.t
index c7eed23..c8cd5be 100644
--- a/t/subcommands/test.t
+++ b/t/subcommands/test.t
@@ -45,46 +45,46 @@ plan 34;
 
 given $core {
     # [T] Test a project: Succeed.
-    is .state-of("untested"), built, "State before: 'built'";
+    is .state-of("untested"), 'built', "State before: 'built'";
     is .test(<untested>), success, "Testing the project succeeds";
-    is .state-of("untested"), tested, "State after: 'tested'";
+    is .state-of("untested"), 'tested', "State after: 'tested'";
 
     # [T] Test an unbuilt project: Build, test.
     @actions = ();
-    is .state-of("unbuilt"), fetched, "State before: 'fetched'";
+    is .state-of("unbuilt"), 'fetched', "State before: 'fetched'";
     is .test(<unbuilt>), success, "Build and test succeeds";
     is ~@actions, 'build[unbuilt] test[unbuilt]', "Order is correct";
-    is .state-of("unbuilt"), tested, "State after: 'tested'";
+    is .state-of("unbuilt"), 'tested', "State after: 'tested'";
 
     # [T] Test an unbuilt project; build fails. Fail.
     @actions = ();
     is .test(<won't-build>), failure, "Won't build, and thus won't test"; #'
     is ~@actions, "build[won't-build]", "Tried building, not testing";
-    is .state-of("won't-build"), fetched, "State after: unchanged";
+    is .state-of("won't-build"), 'fetched', "State after: unchanged";
 
     # [T] Test an unfetched project: Fetch, build, test.
     @actions = ();
     is .test(<unfetched>), success, "Fetch, build and test succeeds";
     is ~@actions, 'fetch[unfetched] build[unfetched] test[unfetched]',
         "Order is correct";
-    is .state-of("unfetched"), tested, "State after: 'tested'";
+    is .state-of("unfetched"), 'tested', "State after: 'tested'";
 
     # [T] Test an unfetched project; fetch fails. Fail.
     is .test(<won't-fetch>), failure, "Won't fetch and thus won't test"; #'
     is ~@actions, "fetch[won't-fetch]",
         "Tried fetching, not building or testing";
-    is .state-of("won't-fetch"), gone, "State after: unchanged";
+    is .state-of("won't-fetch"), 'gone', "State after: unchanged";
 
     # [T] Test an unfetched project; build fails. Fail.
     @actions = ();
     is .test(<won't-build-2>), failure, "Won't build, and thus won't test"; #'
     is ~@actions, "fetch[won't-build-2] build[won't-build-2]",
         "Order is correct";
-    is .state-of("won't-build-2"), fetched, "State after: 'fetched'";
+    is .state-of("won't-build-2"), 'fetched', "State after: 'fetched'";
 
     # [T] Test a project whose tests fail: Fail.
     is .test(<won't-test>), failure, "Won't test"; #"
-    is .state-of("won't-test"), built, "State after: 'built'";
+    is .state-of("won't-test"), 'built', "State after: 'built'";
 
     # [T] Test a project with dependencies: fetch, build, test dependencies
     @actions = ();
@@ -93,9 +93,9 @@ given $core {
         'fetch[C] build[D] build[B] '
         ~ 'test[A] test[C] test[D] test[B] test[has-deps]',
         "Fetch first, then build (postorder), then test (postorder)";
-    is .state-of("has-deps"), tested, "State after of has-deps: 'tested'";
+    is .state-of("has-deps"), 'tested', "State after of has-deps: 'tested'";
     for <A B C D> -> $dep {
-        is .state-of($dep), tested, "State after of $dep: 'tested'";
+        is .state-of($dep), 'tested', "State after of $dep: 'tested'";
     }
 
     # [T] Test a projects with dependencies, but explicitly ignoring the
@@ -103,8 +103,8 @@ given $core {
     @actions = ();
     is .test(<ignore-deps>, :ignore-deps), success, "Test-ignore-deps works";
     is ~@actions, 'test[ignore-deps]', "Only ignore-deps is tested";
-    is .state-of("ignore-deps"), tested, "State after: 'tested'";
-    is .state-of("E"), gone, "State after of E: unchanged";
-    is .state-of("F"), fetched, "State after of F: unchanged";
-    is .state-of("G"), built, "State after of G: unchanged";
+    is .state-of("ignore-deps"), 'tested', "State after: 'tested'";
+    is .state-of("E"), 'gone', "State after of E: unchanged";
+    is .state-of("F"), 'fetched', "State after of F: unchanged";
+    is .state-of("G"), 'built', "State after of G: unchanged";
 }