Add Test.RunnerV2 module

elm.json

@@ -7,6 +7,7 @@
     "exposed-modules": [
         "Test",
         "Test.Runner",
+        "Test.RunnerV2",
         "Test.Runner.Failure",
         "Test.Distribution",
         "Expect",

review/suppressed/NoUnused.CustomTypeConstructors.json

@@ -0,0 +1,8 @@
+{
+  "version": 1,
+  "automatically created by": "elm-review suppress",
+  "learn more": "elm-review suppress --help",
+  "suppressions": [
+    { "count": 1, "filePath": "src/Test/Internal/DebugLogs.elm" }
+  ]
+}

src/Elm/Kernel/DebugLogs.js

@@ -0,0 +1,75 @@
+/*
+
+import Elm.Kernel.Debug exposing (toString)
+import Elm.Kernel.Json exposing (wrap)
+import Elm.Kernel.Scheduler exposing (binding, succeed)
+import Elm.Kernel.Utils exposing (Tuple0)
+
+*/
+
+var _DebugLogs_modeConsoleLog = __1_CONSOLE_LOG;
+var _DebugLogs_modeCollect = __1_COLLECT;
+var _DebugLogs_modeIgnore = __1_IGNORE;
+
+var _DebugLogs_logs = '';
+var _DebugLogs_used = false;
+var _DebugLogs_mode = globalThis.elmTestPrintDebugLogsBeforeFirstTestToConsole ? __1_CONSOLE_LOG : __1_COLLECT;
+// Note: Always reset the mode to __1_CONSOLE_LOG, so that `Debug.log` used to debug a test runner
+// has a higher chance of showing up out of the box.
+
+var _DebugLogs_logsBeforeFirstTestRun = undefined;
+
+var _DebugLogs_getDebugLogsBeforeFirstTestRun = __Scheduler_binding(function(callback)
+{
+  if (_DebugLogs_logsBeforeFirstTestRun === undefined) {
+    _DebugLogs_logsBeforeFirstTestRun = _DebugLogs_logs;
+    _DebugLogs_logs = '';
+    _DebugLogs_used = false;
+    _DebugLogs_mode = __1_CONSOLE_LOG;
+  }
+  callback(__Scheduler_succeed(_DebugLogs_logsBeforeFirstTestRun));
+});
+
+var _DebugLogs_runTestWithDurationAndCollectDebugLogs = F3(function(mode, thunk, mapper)
+{
+  return __Scheduler_binding(function(callback)
+  {
+    if (_DebugLogs_logsBeforeFirstTestRun === undefined) {
+      _DebugLogs_logsBeforeFirstTestRun = _DebugLogs_logs;
+    }
+    _DebugLogs_logs = '';
+    _DebugLogs_used = false;
+    _DebugLogs_mode = mode;
+    var start = performance.now();
+    var value = thunk(__Utils_Tuple0);
+    var duration = performance.now() - start;
+    _DebugLogs_mode = __1_CONSOLE_LOG;
+    callback(__Scheduler_succeed(A4(mapper, value, duration, _DebugLogs_logs, _DebugLogs_used)));
+  });
+});
+
+function _DebugLogs_rerunFailureToCollectDebugLogs(rerunFailure)
+{
+  _DebugLogs_logs = '';
+  _DebugLogs_used = false;
+  _DebugLogs_mode = __1_COLLECT;
+  rerunFailure(__Utils_Tuple0);
+  _DebugLogs_mode = __1_CONSOLE_LOG;
+  return _DebugLogs_logs;
+}
+
+var _Debug_log = F2(function(tag, value)
+{
+  _DebugLogs_used = true;
+  switch (_DebugLogs_mode) {
+    case __1_CONSOLE_LOG:
+      console.error(tag + ': ' + __Debug_toString(value));
+      break;
+    case __1_COLLECT:
+      _DebugLogs_logs += tag + ': ' + __Debug_toString(value) + '\n';
+      break;
+    default:
+      // __1_IGNORE: Do nothing.
+  }
+  return value;
+});

src/Elm/Kernel/RandomRun.js

@@ -2,7 +2,7 @@
 
 import Basics exposing (EQ, LT, GT)
 import Maybe exposing (Just, Nothing)
-import Elm.Kernel.List exposing (Nil, Cons)
+import Elm.Kernel.List exposing (Nil, Cons, toArray)
 
 */
 
@@ -56,6 +56,10 @@ function _RandomRun_toList(rr) {
   return out;
 }
 
+function _RandomRun_fromList(list) {
+  return new Uint32Array(__List_toArray(list));
+}
+
 var _RandomRun_get = F2(function _RandomRun_get_(index, rr) {
   var item = rr[index];
   if (item === undefined) {

src/Elm/Kernel/Test.js

@@ -1,18 +1,30 @@
 /*
 
-import Elm.Kernel.Utils exposing (Tuple0)
+import Maybe exposing (Just, Nothing)
 import Result exposing (Err, Ok)
 
 */
 
-
-function _Test_runThunk(thunk)
+var _Test_runWithTryCatch = F2(function(thunk, a)
 {
   try {
     // Attempt to run the thunk as normal.
-    return __Result_Ok(thunk(__Utils_Tuple0));
+    return __Result_Ok(thunk(a));
   } catch (err) {
     // If it throws, return an error instead of crashing.
     return __Result_Err(err.toString());
   }
+});
+
+var _Test_symbol = Symbol("_Test_symbol");
+
+function _Test_tagTest(test)
+{
+  test[_Test_symbol] = true;
+  return test;
+}
+
+function _Test_identifyTest(value)
+{
+  return value && value[_Test_symbol] ? __Maybe_Just(value) : __Maybe_Nothing;
 }

src/RandomRun.elm

@@ -6,6 +6,7 @@ module RandomRun exposing
     , deleteChunk
     , empty
     , equal
+    , fromList
     , get
     , isEmpty
     , length
@@ -121,6 +122,11 @@ toList =
     Elm.Kernel.RandomRun.toList
 
 
+fromList : List Int -> RandomRun
+fromList =
+    Elm.Kernel.RandomRun.fromList
+
+
 update : Int -> (Int -> Int) -> RandomRun -> RandomRun
 update =
     Elm.Kernel.RandomRun.update

src/Test.elm

@@ -32,8 +32,8 @@ import Test.Internal as Internal
 import Test.Runner.Failure exposing (InvalidReason(..), Reason(..))
 
 
-{-| A test which has yet to be evaluated. When evaluated, it produces one
-or more [`Expectation`](Expect#Expectation)s.
+{-| A test which has yet to be evaluated. When evaluated, it produces an
+[`Expectation`](Expect#Expectation).
 
 See [`test`](#test) and [`fuzz`](#fuzz) for some ways to create a `Test`.
 
@@ -69,6 +69,7 @@ concat tests =
 
             Ok _ ->
                 Internal.ElmTestVariant__Batch tests
+                    |> Internal.wrapTestVariant
 
 
 {-| Apply a description to a list of tests.
@@ -114,28 +115,33 @@ describe untrimmedDesc tests =
             }
 
     else
+        let
+            labeled test_ =
+                Internal.ElmTestVariant__Labeled desc test_
+                    |> Internal.wrapTestVariant
+        in
         case Internal.duplicatedName tests of
             Err dups ->
                 let
                     dupDescription duped =
                         "Contains multiple tests named '" ++ duped ++ "'. Let's rename them so we know which is which."
                 in
-                Internal.ElmTestVariant__Labeled desc <|
+                labeled <|
                     Internal.failNow
                         { description = String.join "\n" (List.map dupDescription <| Set.toList dups)
                         , reason = Invalid DuplicatedName
                         }
 
             Ok childrenNames ->
                 if Set.member desc childrenNames then
-                    Internal.ElmTestVariant__Labeled desc <|
+                    labeled <|
                         Internal.failNow
                             { description = "The test '" ++ desc ++ "' contains a child test of the same name. Let's rename them so we know which is which."
                             , reason = Invalid DuplicatedName
                             }
 
                 else
-                    Internal.ElmTestVariant__Labeled desc (Internal.ElmTestVariant__Batch tests)
+                    labeled (Internal.wrapTestVariant (Internal.ElmTestVariant__Batch tests))
 
 
 {-| Create a group of tests from a list of input-output cases (also called "parameterized tests").
@@ -202,7 +208,8 @@ test untrimmedDesc thunk =
         Internal.blankDescriptionFailure
 
     else
-        Internal.ElmTestVariant__Labeled desc (Internal.ElmTestVariant__UnitTest (\() -> thunk ()))
+        Internal.ElmTestVariant__Labeled desc (Internal.wrapTestVariant (Internal.ElmTestVariant__UnitTest (Internal.wrapWithTryCatch thunk)))
+            |> Internal.wrapTestVariant
 
 
 {-| Returns a [`Test`](#Test) that is "TODO" (not yet implemented). These tests
@@ -270,8 +277,9 @@ an `only` inside a `skip`, it will also get skipped.
 
 -}
 only : Test -> Test
-only =
-    Internal.ElmTestVariant__Only
+only test_ =
+    Internal.ElmTestVariant__Only test_
+        |> Internal.wrapTestVariant
 
 
 {-| Returns a [`Test`](#Test) that gets skipped.
@@ -306,8 +314,9 @@ an `only` inside a `skip`, it will also get skipped.
 
 -}
 skip : Test -> Test
-skip =
-    Internal.ElmTestVariant__Skipped
+skip test_ =
+    Internal.ElmTestVariant__Skipped test_
+        |> Internal.wrapTestVariant
 
 
 {-| Options [`fuzzWith`](#fuzzWith) accepts.
@@ -392,35 +401,7 @@ fuzzWith desc options fuzzer getTest =
             }
 
     else
-        fuzzWithHelp options (Test.Fuzz.fuzzTest desc options.distribution fuzzer getTest)
-
-
-fuzzWithHelp : FuzzOptions a -> Test -> Test
-fuzzWithHelp options aTest =
-    case aTest of
-        Internal.ElmTestVariant__UnitTest _ ->
-            aTest
-
-        Internal.ElmTestVariant__FuzzTest run ->
-            Internal.ElmTestVariant__FuzzTest (\seed _ -> run seed options.runs)
-
-        Internal.ElmTestVariant__Labeled label subTest ->
-            Internal.ElmTestVariant__Labeled label (fuzzWithHelp options subTest)
-
-        Internal.ElmTestVariant__Skipped subTest ->
-            -- It's important to treat skipped tests exactly the same as normal,
-            -- until after seed distribution has completed.
-            fuzzWithHelp options subTest
-                |> Internal.ElmTestVariant__Only
-
-        Internal.ElmTestVariant__Only subTest ->
-            fuzzWithHelp options subTest
-                |> Internal.ElmTestVariant__Only
-
-        Internal.ElmTestVariant__Batch tests ->
-            tests
-                |> List.map (fuzzWithHelp options)
-                |> Internal.ElmTestVariant__Batch
+        Test.Fuzz.fuzzTest desc (Just options.runs) options.distribution fuzzer getTest
 
 
 {-| Specify hardcoded example inputs for your fuzz test. They will be run
@@ -499,7 +480,7 @@ fuzz :
     -> (a -> Expectation)
     -> Test
 fuzz desc fuzzer getExpectation =
-    Test.Fuzz.fuzzTest desc Test.Distribution.Internal.NoDistributionNeeded fuzzer getExpectation
+    Test.Fuzz.fuzzTest desc Nothing Test.Distribution.Internal.NoDistributionNeeded fuzzer getExpectation
 
 
 {-| Run a [fuzz test](#fuzz) using two random inputs.

src/Test/Distribution.elm

@@ -64,9 +64,6 @@ atLeast =
 
 
 {-| A result of a distribution check.
-
-Get it from your `Expectation` with `Test.Runner.getDistributionReport`.
-
 -}
 type DistributionReport
     = -- Adding a () so that all variants have the same number of arguments