diff --git a/src/core/atomic.d b/src/core/atomic.d
index b00d5545b4..80a7c1e843 100644
--- a/src/core/atomic.d
+++ b/src/core/atomic.d
@@ -819,7 +819,7 @@ private
 ////////////////////////////////////////////////////////////////////////////////
 
 
-version (unittest)
+version (CoreUnittest)
 {
     void testXCHG(T)(T val) pure nothrow @nogc @trusted
     in
diff --git a/src/core/internal/array/operations.d b/src/core/internal/array/operations.d
index 9ba741aabe..e874aa246f 100644
--- a/src/core/internal/array/operations.d
+++ b/src/core/internal/array/operations.d
@@ -449,12 +449,12 @@ bool contains(T)(const scope T[] ary, const scope T[] vals...)
 
 // tests
 
-version (unittest) template TT(T...)
+version (CoreUnittest) template TT(T...)
 {
     alias TT = T;
 }
 
-version (unittest) template _arrayOp(Args...)
+version (CoreUnittest) template _arrayOp(Args...)
 {
     alias _arrayOp = arrayOp!Args;
 }
diff --git a/src/core/internal/parseoptions.d b/src/core/internal/parseoptions.d
index 4ed616f3bd..ca66ae9580 100644
--- a/src/core/internal/parseoptions.d
+++ b/src/core/internal/parseoptions.d
@@ -78,7 +78,7 @@ bool parseOptions(CFG)(ref CFG cfg, string opt)
         static if (is(typeof(__traits(getMember, CFG, "help"))))
             if (name == "help")
             {
-                version (unittest) {} else
+                version (CoreUnittest) {} else
                 cfg.help();
                 opt = skip!isspace(tail);
                 continue;
@@ -135,7 +135,7 @@ private:
 
 bool optError(const scope char[] msg, const scope char[] name, const(char)[] errName)
 {
-    version (unittest) if (inUnittest) return false;
+    version (CoreUnittest) if (inUnittest) return false;
 
     fprintf(stderr, "%.*s %.*s option '%.*s'.\n",
             cast(int)msg.length, msg.ptr,
@@ -242,7 +242,7 @@ do
 
 bool parseError(const scope char[] exp, const scope char[] opt, const scope char[] got, const(char)[] errName)
 {
-    version (unittest) if (inUnittest) return false;
+    version (CoreUnittest) if (inUnittest) return false;
 
     fprintf(stderr, "Expecting %.*s as argument for %.*s option '%.*s', got '%.*s' instead.\n",
             cast(int)exp.length, exp.ptr,
@@ -254,7 +254,7 @@ bool parseError(const scope char[] exp, const scope char[] opt, const scope char
 
 size_t min(size_t a, size_t b) { return a <= b ? a : b; }
 
-version (unittest) __gshared bool inUnittest;
+version (CoreUnittest) __gshared bool inUnittest;
 
 unittest
 {
diff --git a/src/core/internal/traits.d b/src/core/internal/traits.d
index 0662b457f3..d7d9a436dd 100644
--- a/src/core/internal/traits.d
+++ b/src/core/internal/traits.d
@@ -157,6 +157,7 @@ template staticIota(int beg, int end)
 }
 
 private struct __InoutWorkaroundStruct {}
+@property T rvalueOf(T)(T val) { return val; }
 @property T rvalueOf(T)(inout __InoutWorkaroundStruct = __InoutWorkaroundStruct.init);
 @property ref T lvalueOf(T)(inout __InoutWorkaroundStruct = __InoutWorkaroundStruct.init);
 
@@ -466,7 +467,7 @@ template staticMap(alias F, T...)
 }
 
 // std.exception.assertCTFEable
-version (unittest) package(core)
+version (CoreUnittest) package(core)
 void assertCTFEable(alias dg)()
 {
     static assert({ cast(void) dg(); return true; }());
diff --git a/src/core/lifetime.d b/src/core/lifetime.d
index 56af89d03b..e8f70f92c3 100644
--- a/src/core/lifetime.d
+++ b/src/core/lifetime.d
@@ -752,7 +752,7 @@ T* emplace(T, Args...)(void[] chunk, auto ref Args args)
     }
 }
 
-version (unittest)
+version (CoreUnittest)
 {
     //Ambiguity
     private struct __std_conv_S
diff --git a/src/core/sys/windows/basetsd.d b/src/core/sys/windows/basetsd.d
index 8efacd0da7..5f78cf2d48 100644
--- a/src/core/sys/windows/basetsd.d
+++ b/src/core/sys/windows/basetsd.d
@@ -58,7 +58,7 @@ package mixin template AlignedStr(int alignVal, string name, string memberlist,
     mixin( _alignSpec ~ " struct " ~ name ~" { " ~ _alignSpec ~":"~ memberlist~" }" );
 }
 
-version (unittest) {
+version (CoreUnittest) {
     private mixin AlignedStr!(16, "_Test_Aligned_Str", q{char a; char b;});
     private mixin AlignedStr!(0, "_Test_NoAligned_Str", q{char a; char b;});
 }
diff --git a/src/core/thread/fiber.d b/src/core/thread/fiber.d
index 4db297dde6..715ef006e4 100644
--- a/src/core/thread/fiber.d
+++ b/src/core/thread/fiber.d
@@ -1594,7 +1594,7 @@ unittest {
     assert( composed.state == Fiber.State.TERM );
 }
 
-version (unittest)
+version (CoreUnittest)
 {
     class TestFiber : Fiber
     {
diff --git a/src/core/time.d b/src/core/time.d
index e4d74405ee..6e3fe9ecea 100644
--- a/src/core/time.d
+++ b/src/core/time.d
@@ -116,13 +116,6 @@ ulong mach_absolute_time();
 
 }
 
-//To verify that an lvalue isn't required.
-version (unittest) private T copy(T)(T t)
-{
-    return t;
-}
-
-
 /++
     What type of clock to use with $(LREF MonoTime) / $(LREF MonoTimeImpl) or
     $(D std.datetime.Clock.currTime). They default to $(D ClockType.normal),
@@ -524,7 +517,7 @@ public:
       +/
     static @property nothrow @nogc Duration min() { return Duration(long.min); }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         assert(zero == dur!"seconds"(0));
         assert(Duration.max == Duration(long.max));
@@ -556,8 +549,9 @@ public:
         return 0;
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
+        import core.internal.traits : rvalueOf;
         foreach (T; AliasSeq!(Duration, const Duration, immutable Duration))
         {
             foreach (U; AliasSeq!(Duration, const Duration, immutable Duration))
@@ -569,8 +563,8 @@ public:
                 else
                     U u = t;
                 assert(t == u);
-                assert(copy(t) == u);
-                assert(t == copy(u));
+                assert(rvalueOf(t) == u);
+                assert(t == rvalueOf(u));
             }
         }
 
@@ -587,23 +581,23 @@ public:
                 assert((cast(D)Duration(12)).opCmp(cast(E)Duration(10)) > 0);
                 assert((cast(D)Duration(12)).opCmp(cast(E)Duration(-12)) > 0);
 
-                assert(copy(cast(D)Duration(12)).opCmp(cast(E)Duration(12)) == 0);
-                assert(copy(cast(D)Duration(-12)).opCmp(cast(E)Duration(-12)) == 0);
+                assert(rvalueOf(cast(D)Duration(12)).opCmp(cast(E)Duration(12)) == 0);
+                assert(rvalueOf(cast(D)Duration(-12)).opCmp(cast(E)Duration(-12)) == 0);
 
-                assert(copy(cast(D)Duration(10)).opCmp(cast(E)Duration(12)) < 0);
-                assert(copy(cast(D)Duration(-12)).opCmp(cast(E)Duration(12)) < 0);
+                assert(rvalueOf(cast(D)Duration(10)).opCmp(cast(E)Duration(12)) < 0);
+                assert(rvalueOf(cast(D)Duration(-12)).opCmp(cast(E)Duration(12)) < 0);
 
-                assert(copy(cast(D)Duration(12)).opCmp(cast(E)Duration(10)) > 0);
-                assert(copy(cast(D)Duration(12)).opCmp(cast(E)Duration(-12)) > 0);
+                assert(rvalueOf(cast(D)Duration(12)).opCmp(cast(E)Duration(10)) > 0);
+                assert(rvalueOf(cast(D)Duration(12)).opCmp(cast(E)Duration(-12)) > 0);
 
-                assert((cast(D)Duration(12)).opCmp(copy(cast(E)Duration(12))) == 0);
-                assert((cast(D)Duration(-12)).opCmp(copy(cast(E)Duration(-12))) == 0);
+                assert((cast(D)Duration(12)).opCmp(rvalueOf(cast(E)Duration(12))) == 0);
+                assert((cast(D)Duration(-12)).opCmp(rvalueOf(cast(E)Duration(-12))) == 0);
 
-                assert((cast(D)Duration(10)).opCmp(copy(cast(E)Duration(12))) < 0);
-                assert((cast(D)Duration(-12)).opCmp(copy(cast(E)Duration(12))) < 0);
+                assert((cast(D)Duration(10)).opCmp(rvalueOf(cast(E)Duration(12))) < 0);
+                assert((cast(D)Duration(-12)).opCmp(rvalueOf(cast(E)Duration(12))) < 0);
 
-                assert((cast(D)Duration(12)).opCmp(copy(cast(E)Duration(10))) > 0);
-                assert((cast(D)Duration(12)).opCmp(copy(cast(E)Duration(-12))) > 0);
+                assert((cast(D)Duration(12)).opCmp(rvalueOf(cast(E)Duration(10))) > 0);
+                assert((cast(D)Duration(12)).opCmp(rvalueOf(cast(E)Duration(-12))) > 0);
             }
         }
     }
@@ -635,7 +629,7 @@ public:
             return Duration(mixin("_hnsecs " ~ op ~ " rhs.hnsecs"));
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         foreach (D; AliasSeq!(Duration, const Duration, immutable Duration))
         {
@@ -717,7 +711,7 @@ public:
         return Duration(mixin("lhs.hnsecs " ~ op ~ " _hnsecs"));
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         foreach (D; AliasSeq!(Duration, const Duration, immutable Duration))
         {
@@ -775,7 +769,7 @@ public:
         return this;
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         static void test1(string op, E)(Duration actual, in E rhs, Duration expected, size_t line = __LINE__)
         {
@@ -880,7 +874,7 @@ public:
         mixin("return Duration(_hnsecs " ~ op ~ " value);");
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         foreach (D; AliasSeq!(Duration, const Duration, immutable Duration))
         {
@@ -901,7 +895,7 @@ public:
         }
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         foreach (D; AliasSeq!(Duration, const Duration, immutable Duration))
         {
@@ -942,7 +936,7 @@ public:
         return this;
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         static void test(D)(D actual, long value, Duration expected, size_t line = __LINE__)
         {
@@ -974,7 +968,7 @@ public:
         static assert(!__traits(compiles, idur *= 12));
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         static void test(Duration actual, long value, Duration expected, size_t line = __LINE__)
         {
@@ -1022,7 +1016,7 @@ public:
         return _hnsecs / rhs._hnsecs;
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         assert(Duration(5) / Duration(7) == 0);
         assert(Duration(7) / Duration(5) == 1);
@@ -1061,7 +1055,7 @@ public:
         return opBinary!op(value);
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         foreach (D; AliasSeq!(Duration, const Duration, immutable Duration))
         {
@@ -1092,7 +1086,7 @@ public:
         return Duration(-_hnsecs);
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         foreach (D; AliasSeq!(Duration, const Duration, immutable Duration))
         {
@@ -1118,7 +1112,7 @@ public:
         return TickDuration.from!"hnsecs"(_hnsecs);
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         foreach (D; AliasSeq!(Duration, const Duration, immutable Duration))
         {
@@ -1157,7 +1151,7 @@ public:
         return _hnsecs != 0;
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         auto d = 10.minutes;
         assert(d);
@@ -1291,7 +1285,7 @@ public:
                 enum allAreMutableIntegralTypes = allAreMutableIntegralTypes!(Args[1 .. $]);
         }
 
-        unittest
+        version (CoreUnittest) unittest
         {
             foreach (T; AliasSeq!(long, int, short, byte, ulong, uint, ushort, ubyte))
                 static assert(allAreMutableIntegralTypes!T);
@@ -1358,7 +1352,7 @@ public:
         }
     }
 
-    pure nothrow unittest
+    version (CoreUnittest) pure nothrow unittest
     {
         foreach (D; AliasSeq!(const Duration, immutable Duration))
         {
@@ -1535,7 +1529,7 @@ public:
         assert(dur!"nsecs"(2007).total!"nsecs" == 2000);
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         foreach (D; AliasSeq!(const Duration, immutable Duration))
         {
@@ -1641,7 +1635,7 @@ public:
         assert(usecs(-5239492).toString() == "-5 secs, -239 ms, and -492 μs");
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         foreach (D; AliasSeq!(Duration, const Duration, immutable Duration))
         {
@@ -1699,7 +1693,7 @@ public:
         return _hnsecs < 0;
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         foreach (D; AliasSeq!(Duration, const Duration, immutable Duration))
         {
@@ -2085,7 +2079,7 @@ struct MonoTimeImpl(ClockType clockType)
         static assert(0, "Unsupported platform");
 
     // POD value, test mutable/const/immutable conversion
-    unittest
+    version (CoreUnittest) unittest
     {
         MonoTimeImpl m;
         const MonoTimeImpl cm = m;
@@ -2168,7 +2162,7 @@ struct MonoTimeImpl(ClockType clockType)
     MonoTimeImpl min() { return MonoTimeImpl(long.min); }
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         assert(MonoTimeImpl.zero == MonoTimeImpl(0));
         assert(MonoTimeImpl.max == MonoTimeImpl(long.max));
@@ -2196,23 +2190,25 @@ struct MonoTimeImpl(ClockType clockType)
         return _ticks > rhs._ticks ? 1 : 0;
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
+        import core.internal.traits : rvalueOf;
         const t = MonoTimeImpl.currTime;
-        assert(t == copy(t));
+        assert(t == rvalueOf(t));
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
+        import core.internal.traits : rvalueOf;
         const before = MonoTimeImpl.currTime;
         auto after = MonoTimeImpl(before._ticks + 42);
         assert(before < after);
-        assert(copy(before) <= before);
-        assert(copy(after) > before);
-        assert(after >= copy(after));
+        assert(rvalueOf(before) <= before);
+        assert(rvalueOf(after) > before);
+        assert(after >= rvalueOf(after));
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         const currTime = MonoTimeImpl.currTime;
         assert(MonoTimeImpl(long.max) > MonoTimeImpl(0));
@@ -2266,14 +2262,15 @@ assert(before + timeElapsed == after);
         return Duration(convClockFreq(diff , ticksPerSecond, hnsecsPer!"seconds"));
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
+        import core.internal.traits : rvalueOf;
         const t = MonoTimeImpl.currTime;
-        assert(t - copy(t) == Duration.zero);
+        assert(t - rvalueOf(t) == Duration.zero);
         static assert(!__traits(compiles, t + t));
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         static void test(const scope MonoTimeImpl before, const scope MonoTimeImpl after, const scope Duration min)
         {
@@ -2304,14 +2301,14 @@ assert(before + timeElapsed == after);
         mixin("return MonoTimeImpl(_ticks " ~ op ~ " rhsConverted);");
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         const t = MonoTimeImpl.currTime;
         assert(t + Duration(0) == t);
         assert(t - Duration(0) == t);
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         const t = MonoTimeImpl.currTime;
 
@@ -2337,7 +2334,7 @@ assert(before + timeElapsed == after);
         return this;
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         auto mt = MonoTimeImpl.currTime;
         const initial = mt;
@@ -2378,7 +2375,7 @@ assert(before + timeElapsed == after);
         return _ticks;
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         const mt = MonoTimeImpl.currTime;
         assert(mt.ticks == mt._ticks);
@@ -2397,7 +2394,7 @@ assert(before + timeElapsed == after);
         return _ticksPerSecond[_clockIdx];
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         assert(MonoTimeImpl.ticksPerSecond == _ticksPerSecond[_clockIdx]);
     }
@@ -2413,7 +2410,7 @@ assert(before + timeElapsed == after);
                    signedToTempString(ticksPerSecond, 10) ~ " ticks per second)";
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         static min(T)(T a, T b) { return a < b ? a : b; }
 
@@ -2440,7 +2437,7 @@ private:
 
     // static immutable long _ticksPerSecond;
 
-    unittest
+    version (CoreUnittest) unittest
     {
         assert(_ticksPerSecond[_clockIdx]);
     }
@@ -2791,7 +2788,7 @@ struct TickDuration
     TickDuration min() { return TickDuration(long.min); }
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         assert(zero == TickDuration(0));
         assert(TickDuration.max == TickDuration(long.max));
@@ -2842,7 +2839,7 @@ struct TickDuration
             appOrigin = TickDuration.currSystemTick;
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         assert(ticksPerSec);
     }
@@ -2865,7 +2862,7 @@ struct TickDuration
         return this.to!("seconds", long)();
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         foreach (T; AliasSeq!(TickDuration, const TickDuration, immutable TickDuration))
         {
@@ -2936,7 +2933,7 @@ struct TickDuration
         return TickDuration(cast(long)(length * (ticksPerSec / cast(real)unitsPerSec)));
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         foreach (units; AliasSeq!("seconds", "msecs", "usecs", "nsecs"))
         {
@@ -2966,7 +2963,7 @@ struct TickDuration
         return Duration(hnsecs);
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         foreach (D; AliasSeq!(Duration, const Duration, immutable Duration))
         {
@@ -3016,7 +3013,7 @@ struct TickDuration
         return this;
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         foreach (T; AliasSeq!(TickDuration, const TickDuration, immutable TickDuration))
         {
@@ -3061,7 +3058,7 @@ struct TickDuration
         return TickDuration(mixin("length " ~ op ~ " rhs.length"));
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         foreach (T; AliasSeq!(TickDuration, const TickDuration, immutable TickDuration))
         {
@@ -3082,7 +3079,7 @@ struct TickDuration
         return TickDuration(-length);
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         foreach (T; AliasSeq!(TickDuration, const TickDuration, immutable TickDuration))
         {
@@ -3103,8 +3100,9 @@ struct TickDuration
         return length < rhs.length ? -1 : (length == rhs.length ? 0 : 1);
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
+        import core.internal.traits : rvalueOf;
         foreach (T; AliasSeq!(TickDuration, const TickDuration, immutable TickDuration))
         {
             foreach (U; AliasSeq!(TickDuration, const TickDuration, immutable TickDuration))
@@ -3112,8 +3110,8 @@ struct TickDuration
                 T t = TickDuration.currSystemTick;
                 U u = t;
                 assert(t == u);
-                assert(copy(t) == u);
-                assert(t == copy(u));
+                assert(rvalueOf(t) == u);
+                assert(t == rvalueOf(u));
             }
         }
 
@@ -3128,15 +3126,15 @@ struct TickDuration
                 assert(u > t);
                 assert(u >= u);
 
-                assert(copy(t) < u);
-                assert(copy(t) <= t);
-                assert(copy(u) > t);
-                assert(copy(u) >= u);
+                assert(rvalueOf(t) < u);
+                assert(rvalueOf(t) <= t);
+                assert(rvalueOf(u) > t);
+                assert(rvalueOf(u) >= u);
 
-                assert(t < copy(u));
-                assert(t <= copy(t));
-                assert(u > copy(t));
-                assert(u >= copy(u));
+                assert(t < rvalueOf(u));
+                assert(t <= rvalueOf(t));
+                assert(u > rvalueOf(t));
+                assert(u >= rvalueOf(u));
             }
         }
     }
@@ -3161,7 +3159,7 @@ struct TickDuration
         length = cast(long)(length * value);
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         immutable curr = TickDuration.currSystemTick;
         TickDuration t1 = curr;
@@ -3212,7 +3210,7 @@ struct TickDuration
         length = cast(long)(length / value);
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         immutable curr = TickDuration.currSystemTick;
         immutable t1 = curr;
@@ -3259,7 +3257,7 @@ struct TickDuration
         return TickDuration(cast(long)(length * value));
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         foreach (T; AliasSeq!(TickDuration, const TickDuration, immutable TickDuration))
         {
@@ -3298,7 +3296,7 @@ struct TickDuration
         return TickDuration(cast(long)(length / value));
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         foreach (T; AliasSeq!(TickDuration, const TickDuration, immutable TickDuration))
         {
@@ -3323,7 +3321,7 @@ struct TickDuration
         this.length = ticks;
     }
 
-    unittest
+    version (CoreUnittest) unittest
     {
         foreach (i; [-42, 0, 42])
             assert(TickDuration(i).length == i);
@@ -3405,7 +3403,7 @@ struct TickDuration
         }
     }
 
-    @safe nothrow unittest
+    version (CoreUnittest) @safe nothrow unittest
     {
         assert(TickDuration.currSystemTick.length > 0);
     }
@@ -3968,7 +3966,7 @@ double _abs(double val) @safe pure nothrow @nogc
 }
 
 
-version (unittest)
+version (CoreUnittest)
 string doubleToString(double value) @safe pure nothrow
 {
     string result;
@@ -3999,7 +3997,7 @@ unittest
     assert(aStr == "-0.337", aStr);
 }
 
-version (unittest) const(char)* numToStringz()(long value) @trusted pure nothrow
+version (CoreUnittest) const(char)* numToStringz()(long value) @trusted pure nothrow
 {
     return (signedToTempString(value, 10) ~ "\0").ptr;
 }
@@ -4009,7 +4007,7 @@ import core.internal.traits : AliasSeq;
 
 
 /+ An adjusted copy of std.exception.assertThrown. +/
-version (unittest) void _assertThrown(T : Throwable = Exception, E)
+version (CoreUnittest) void _assertThrown(T : Throwable = Exception, E)
                                     (lazy E expression,
                                      string msg = null,
                                      string file = __FILE__,
@@ -4104,7 +4102,7 @@ unittest
 }
 
 
-version (unittest) void assertApprox(D, E)(D actual,
+version (CoreUnittest) void assertApprox(D, E)(D actual,
                                           E lower,
                                           E upper,
                                           string msg = "unittest failure",
@@ -4117,7 +4115,7 @@ version (unittest) void assertApprox(D, E)(D actual,
         throw new AssertError(msg ~ ": upper: " ~ actual.toString(), __FILE__, line);
 }
 
-version (unittest) void assertApprox(D, E)(D actual,
+version (CoreUnittest) void assertApprox(D, E)(D actual,
                                           E lower,
                                           E upper,
                                           string msg = "unittest failure",
@@ -4133,7 +4131,7 @@ version (unittest) void assertApprox(D, E)(D actual,
     }
 }
 
-version (unittest) void assertApprox(MT)(MT actual,
+version (CoreUnittest) void assertApprox(MT)(MT actual,
                                         MT lower,
                                         MT upper,
                                         string msg = "unittest failure",
@@ -4143,7 +4141,7 @@ version (unittest) void assertApprox(MT)(MT actual,
     assertApprox(actual._ticks, lower._ticks, upper._ticks, msg, line);
 }
 
-version (unittest) void assertApprox()(long actual,
+version (CoreUnittest) void assertApprox()(long actual,
                                       long lower,
                                       long upper,
                                       string msg = "unittest failure",
diff --git a/src/rt/lifetime.d b/src/rt/lifetime.d
index 69db4c1f0f..a76c8568bc 100644
--- a/src/rt/lifetime.d
+++ b/src/rt/lifetime.d
@@ -2423,7 +2423,7 @@ unittest
 }
 
 // cannot define structs inside unit test block, or they become nested structs.
-version (unittest)
+version (CoreUnittest)
 {
     struct S1
     {
diff --git a/src/rt/util/container/common.d b/src/rt/util/container/common.d
index abf1be3fbc..412a4d4a76 100644
--- a/src/rt/util/container/common.d
+++ b/src/rt/util/container/common.d
@@ -58,7 +58,7 @@ void initialize(T)(ref T t) if (!is(T == struct))
     t = T.init;
 }
 
-version (unittest) struct RC()
+version (CoreUnittest) struct RC()
 {
 nothrow:
     this(size_t* cnt) { ++*(_cnt = cnt); }
diff --git a/src/rt/util/container/treap.d b/src/rt/util/container/treap.d
index 722c4a5161..cdd556b26a 100644
--- a/src/rt/util/container/treap.d
+++ b/src/rt/util/container/treap.d
@@ -52,7 +52,7 @@ nothrow:
         return opApplyHelper(root, dg);
     }
 
-    version (unittest)
+    version (CoreUnittest)
     bool opEquals(E[] elements)
     {
         size_t i;
@@ -72,7 +72,7 @@ nothrow:
         root = null;
     }
 
-    version (unittest)
+    version (CoreUnittest)
     bool valid()
     {
         return valid(root);
@@ -224,7 +224,7 @@ static:
         return opApplyHelper(node.right, dg);
     }
 
-    version (unittest)
+    version (CoreUnittest)
     bool valid(Node* node)
     {
         if (!node)
diff --git a/src/rt/util/typeinfo.d b/src/rt/util/typeinfo.d
index 2cc1c236c1..641c721716 100644
--- a/src/rt/util/typeinfo.d
+++ b/src/rt/util/typeinfo.d
@@ -104,7 +104,7 @@ if (is(T ==  float) || is(T ==  double) || is(T ==  real) ||
     public alias hashOf = core.internal.hash.hashOf;
 }
 
-version (unittest)
+version (CoreUnittest)
 {
     alias TypeTuple(T...) = T;
 }
diff --git a/test/allocations/Makefile b/test/allocations/Makefile
index aea249be58..204b12b18b 100644
--- a/test/allocations/Makefile
+++ b/test/allocations/Makefile
@@ -15,7 +15,7 @@ $(ROOT)/%.done: $(ROOT)/%
 	$(NEGATE) $(QUIET)$(TIMELIMIT)$(ROOT)/$* $(RUN_ARGS) 2>&1 1>/dev/null | head -n 1 | grep -qF $(STDERR_EXP)
 	@touch $@
 
-$(ROOT)/unittest_assert: DFLAGS+=-unittest
+$(ROOT)/unittest_assert: DFLAGS+=-unittest -version=CoreUnittest
 $(ROOT)/%: $(SRC)/%.d
 	$(QUIET)$(DMD) $(DFLAGS) -of$@ $<
 
diff --git a/test/exceptions/Makefile b/test/exceptions/Makefile
index 0f226b25b0..88ba7dbd9c 100644
--- a/test/exceptions/Makefile
+++ b/test/exceptions/Makefile
@@ -94,7 +94,7 @@ $(ROOT)/refcounted.done: $(ROOT)/refcounted
 	$(QUIET) $<
 	@touch $@
 
-$(ROOT)/unittest_assert: DFLAGS+=-unittest
+$(ROOT)/unittest_assert: DFLAGS+=-unittest -version=CoreUnittest
 $(ROOT)/line_trace: DFLAGS+=$(LINE_TRACE_DFLAGS)
 $(ROOT)/rt_trap_exceptions_drt: DFLAGS+=-g
 $(ROOT)/assert_fail: DFLAGS+=-checkaction=context
diff --git a/test/gc/Makefile b/test/gc/Makefile
index 8384e06366..72498689d7 100644
--- a/test/gc/Makefile
+++ b/test/gc/Makefile
@@ -5,7 +5,7 @@ TESTS := sentinel printf memstomp invariant logging precise precisegc forkgc for
 SRC_GC = ../../src/gc/impl/conservative/gc.d
 SRC = $(SRC_GC) ../../src/rt/lifetime.d
 # ../../src/object.d causes duplicate symbols
-UDFLAGS = $(DFLAGS) -unittest
+UDFLAGS = $(DFLAGS) -unittest -version=CoreUnittest
 
 .PHONY: all clean
 all: $(addprefix $(ROOT)/,$(addsuffix .done,$(TESTS)))
diff --git a/test/gc/win64.mak b/test/gc/win64.mak
index e831b1f2ed..bdc7ffeb79 100644
--- a/test/gc/win64.mak
+++ b/test/gc/win64.mak
@@ -6,7 +6,7 @@ DRUNTIMELIB=druntime64.lib
 
 SRC_GC = src/gc/impl/conservative/gc.d
 SRC = $(SRC_GC) src/rt/lifetime.d src/object.d
-UDFLAGS = -m$(MODEL) -g -unittest -conf= -Isrc -defaultlib=$(DRUNTIMELIB)
+UDFLAGS = -m$(MODEL) -g -unittest -version=CoreUnittest -conf= -Isrc -defaultlib=$(DRUNTIMELIB)
 
 test: sentinel printf memstomp invariant logging precise precisegc recoverfree
 
diff --git a/test/stdcpp/Makefile b/test/stdcpp/Makefile
index 8e3bf346c0..4ade1458cb 100644
--- a/test/stdcpp/Makefile
+++ b/test/stdcpp/Makefile
@@ -63,22 +63,22 @@ $(ROOT)/%_old.done : $(ROOT)/%_old
 # build C++98 tests
 $(ROOT)/%: $(SRC)/%.cpp $(SRC)/%_test.d
 	mkdir -p $(dir $@)
-	$(QUIET)$(DMD) $(DFLAGS) -extern-std=c++98 -main -unittest -c -of=$(ROOT)/$*_d.o $(SRC)/$*_test.d
+	$(QUIET)$(DMD) $(DFLAGS) -extern-std=c++98 -main -unittest -version=CoreUnittest -c -of=$(ROOT)/$*_d.o $(SRC)/$*_test.d
 	$(QUIET)$(CXX) $(CXXFLAGS_BASE) -std=c++98 -o $@ $< $(ROOT)/$*_d.o $(DRUNTIME) -lpthread
 # build C++11 tests
 $(ROOT)/%_11: $(SRC)/%.cpp $(SRC)/%_test.d
 	mkdir -p $(dir $@)
-	$(QUIET)$(DMD) $(DFLAGS) -extern-std=c++11 -main -unittest -c -of=$(ROOT)/$*_11_d.o $(SRC)/$*_test.d
+	$(QUIET)$(DMD) $(DFLAGS) -extern-std=c++11 -main -unittest -version=CoreUnittest -c -of=$(ROOT)/$*_11_d.o $(SRC)/$*_test.d
 	$(QUIET)$(CXX) $(CXXFLAGS_BASE) -std=c++11 -o $@ $< $(ROOT)/$*_11_d.o $(DRUNTIME) -lpthread
 # build C++17 tests
 $(ROOT)/%_17: $(SRC)/%.cpp $(SRC)/%_test.d
 	mkdir -p $(dir $@)
-	$(QUIET)$(DMD) $(DFLAGS) -extern-std=c++17 -main -unittest -c -of=$(ROOT)/$*_17_d.o $(SRC)/$*_test.d
+	$(QUIET)$(DMD) $(DFLAGS) -extern-std=c++17 -main -unittest -version=CoreUnittest -c -of=$(ROOT)/$*_17_d.o $(SRC)/$*_test.d
 	$(QUIET)$(CXX) $(CXXFLAGS_BASE) -std=c++17 -o $@ $< $(ROOT)/$*_17_d.o $(DRUNTIME) -lpthread
 # build libstdc++ _GLIBCXX_USE_CXX11_ABI=0 tests
 $(ROOT)/%_old: $(SRC)/%.cpp $(SRC)/%_test.d
 	mkdir -p $(dir $@)
-	$(QUIET)$(DMD) $(DFLAGS) -version=_GLIBCXX_USE_CXX98_ABI -main -unittest -c -of=$(ROOT)/$*_old_d.o $(SRC)/$*_test.d
+	$(QUIET)$(DMD) $(DFLAGS) -version=_GLIBCXX_USE_CXX98_ABI -main -unittest -version=CoreUnittest -c -of=$(ROOT)/$*_old_d.o $(SRC)/$*_test.d
 	$(QUIET)$(CXX) $(CXXFLAGS_BASE) -D_GLIBCXX_USE_CXX11_ABI=0 -o $@ $< $(ROOT)/$*_old_d.o $(DRUNTIME) -lpthread
 
 clean:
diff --git a/test/stdcpp/win64.mak b/test/stdcpp/win64.mak
index 8d15b20a93..2bf2c6168f 100644
--- a/test/stdcpp/win64.mak
+++ b/test/stdcpp/win64.mak
@@ -18,21 +18,21 @@ test: $(TESTS)
 
 $(TESTS):
 	"$(CC)" -c /Fo$@_cpp.obj test\stdcpp\src\$@.cpp /EHsc /MT $(ADD_CFLAGS)
-	"$(DMD)" -of=$@.exe -m$(MODEL) -conf= -Isrc -defaultlib=$(DRUNTIMELIB) -main -unittest -version=_MSC_VER_$(_MSC_VER) -mscrtlib=libcmt $(ADD_DFLAGS) test\stdcpp\src\$@_test.d $@_cpp.obj
+	"$(DMD)" -of=$@.exe -m$(MODEL) -conf= -Isrc -defaultlib=$(DRUNTIMELIB) -main -unittest -version=CoreUnittest -version=_MSC_VER_$(_MSC_VER) -mscrtlib=libcmt $(ADD_DFLAGS) test\stdcpp\src\$@_test.d $@_cpp.obj
 	$@.exe
 	del $@.exe $@.obj $@_cpp.obj
 
 	"$(CC)" -c /Fo$@_cpp.obj test\stdcpp\src\$@.cpp /EHsc /MD $(ADD_CFLAGS)
-	"$(DMD)" -of=$@.exe -m$(MODEL) -conf= -Isrc -defaultlib=$(DRUNTIMELIB) -main -unittest -version=_MSC_VER_$(_MSC_VER) -mscrtlib=msvcrt $(ADD_DFLAGS) test\stdcpp\src\$@_test.d $@_cpp.obj
+	"$(DMD)" -of=$@.exe -m$(MODEL) -conf= -Isrc -defaultlib=$(DRUNTIMELIB) -main -unittest -version=CoreUnittest -version=_MSC_VER_$(_MSC_VER) -mscrtlib=msvcrt $(ADD_DFLAGS) test\stdcpp\src\$@_test.d $@_cpp.obj
 	$@.exe
 	del $@.exe $@.obj $@_cpp.obj
 
 	"$(CC)" -c /Fo$@_cpp.obj test\stdcpp\src\$@.cpp /EHsc /MTd $(ADD_CFLAGS)
-	"$(DMD)" -of=$@.exe -m$(MODEL) -conf= -Isrc -defaultlib=$(DRUNTIMELIB) -main -unittest -version=_MSC_VER_$(_MSC_VER) -mscrtlib=libcmtd $(ADD_DFLAGS) test\stdcpp\src\$@_test.d $@_cpp.obj
+	"$(DMD)" -of=$@.exe -m$(MODEL) -conf= -Isrc -defaultlib=$(DRUNTIMELIB) -main -unittest -version=CoreUnittest -version=_MSC_VER_$(_MSC_VER) -mscrtlib=libcmtd $(ADD_DFLAGS) test\stdcpp\src\$@_test.d $@_cpp.obj
 	$@.exe
 	del $@.exe $@.obj $@_cpp.obj
 
 	"$(CC)" -c /Fo$@_cpp.obj test\stdcpp\src\$@.cpp /EHsc /MDd $(ADD_CFLAGS)
-	"$(DMD)" -of=$@.exe -m$(MODEL) -conf= -Isrc -defaultlib=$(DRUNTIMELIB) -main -unittest -version=_MSC_VER_$(_MSC_VER) -mscrtlib=msvcrtd $(ADD_DFLAGS) test\stdcpp\src\$@_test.d $@_cpp.obj
+	"$(DMD)" -of=$@.exe -m$(MODEL) -conf= -Isrc -defaultlib=$(DRUNTIMELIB) -main -unittest -version=CoreUnittest -version=_MSC_VER_$(_MSC_VER) -mscrtlib=msvcrtd $(ADD_DFLAGS) test\stdcpp\src\$@_test.d $@_cpp.obj
 	$@.exe
 	del $@.exe $@.obj $@_cpp.obj