From 0a3348d5fadc50e309f796676d8648f2d684b56d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Edouard=20Choini=C3=A8re?=
 <27212526+echoix@users.noreply.github.com>
Date: Wed, 28 Oct 2026 18:32:04 +0000
Subject: [PATCH 1/2] grass.gunittest: Add option to run test files in random
 order

A fixed order of test files can hide a test which passes only because
of what an earlier test did. Add a --random-order option to
grass.gunittest.main to run the test files in a random order, and a
--randomly-seed option to set the seed or reuse the last one with the
special value last, following pytest-randomly used for the pytest
suite. Random order stays opt-in. The seed is printed and stored in the
reports, so that the same order can be repeated.

Reports list test files in discovery order regardless of the order
they ran in, so that reports of different runs can be compared. The
main HTML page is still written while the tests run and rewritten in
discovery order at the end.

Developed with the help of an AI coding agent (Claude Code).
---
 .../docs/src/gunittest_running_tests.rst      |  26 +++
 python/grass/gunittest/invoker.py             |  35 +++-
 python/grass/gunittest/loader.py              |  10 ++
 python/grass/gunittest/main.py                |  60 +++++++
 python/grass/gunittest/reporters.py           |  37 +++-
 .../grass_gunittest_random_order_test.py      | 168 ++++++++++++++++++
 6 files changed, 321 insertions(+), 15 deletions(-)
 create mode 100644 python/grass/gunittest/tests/grass_gunittest_random_order_test.py

diff --git a/python/grass/docs/src/gunittest_running_tests.rst b/python/grass/docs/src/gunittest_running_tests.rst
index 4ccccbcf523..8272474a67b 100644
--- a/python/grass/docs/src/gunittest_running_tests.rst
+++ b/python/grass/docs/src/gunittest_running_tests.rst
@@ -83,6 +83,32 @@ to run the test and ``grass.gunittest.main`` returning zero return code
 even if some tests fail, use ``--min-success 0``
 
 
+Running test files in random order
+----------------------------------
+
+By default, test files run in the same order every time. A fixed order can
+hide a test which passes only because of what an earlier test did,
+for example a file an earlier test left in a shared directory. To run the
+test files in a random order, use::
+
+    python -m grass.gunittest.main ... --random-order
+
+The seed of the random order is printed at the start and stored in the
+report. To run the test files again in the same order, pass this seed::
+
+    python -m grass.gunittest.main ... --randomly-seed 1234
+
+To reuse the seed of the previous run, which is read from the report in the
+output directory, use ``--randomly-seed last``.
+
+The same seed gives the same order only for the same set of test files.
+Regardless of the order the test files run in, the reports list them in the
+usual order, so that reports from different runs can be compared.
+Tests inside a test file still run in their usual order.
+The ``--randomly-seed`` option and the printed seed follow the
+*pytest-randomly* plugin, but the order is random only when requested.
+
+
 Excluding test files from testing
 ---------------------------------
 
diff --git a/python/grass/gunittest/invoker.py b/python/grass/gunittest/invoker.py
index 7805902c7bd..cbe60f0eee4 100644
--- a/python/grass/gunittest/invoker.py
+++ b/python/grass/gunittest/invoker.py
@@ -12,6 +12,7 @@
 import collections
 import os
 from pathlib import Path
+import random
 import shutil
 import subprocess
 import sys
@@ -140,7 +141,6 @@ def _run_test_module(
         self, module, results_dir: StrPath, gisdbase, location, timeout: float | None
     ) -> None:
         """Run one test file."""
-        self.testsuite_dirs[module.tested_dir].append(module.name)
         cwd: str = os.path.join(results_dir, module.tested_dir, module.name)
         data_dir: str = os.path.join(module.file_dir, "data")
         if Path(data_dir).exists():
@@ -284,7 +284,13 @@ def try_decode(data, encodings):
                 shutil.rmtree(mapset_dir, ignore_errors=True)
 
     def run_in_location(
-        self, gisdbase, location, location_type, results_dir: StrPath, exclude
+        self,
+        gisdbase,
+        location,
+        location_type,
+        results_dir: StrPath,
+        exclude,
+        seed: int | None = None,
     ) -> GrassTestFilesMultiReporter:
         """Run tests in a given location
 
@@ -292,6 +298,11 @@ def run_in_location(
         i.e., a file-oriented reporter as opposed to testsuite-oriented one.
         Use only the attributes related to the summary, such as file_pass_per,
         not to one file as these will simply contain the last executed file.
+
+        :param seed: if not None, test files run in a random order
+            generated from this seed (the same seed gives the same order
+            for the same set of test files); reports still list the test
+            files in discovery order
         """
         if os.path.abspath(results_dir) == os.path.abspath(self.start_dir):
             msg = (
@@ -299,6 +310,9 @@ def run_in_location(
                 " as discovery start directory"
             )
             raise RuntimeError(msg)
+        info = {"location": location, "location_type": location_type}
+        if seed is not None:
+            info["random_seed"] = seed
         self.reporter = GrassTestFilesMultiReporter(
             reporters=[
                 GrassTestFilesTextReporter(stream=sys.stderr),
@@ -306,9 +320,7 @@ def run_in_location(
                     file_anonymizer=self._file_anonymizer,
                     main_page_name="testfiles.html",
                 ),
-                GrassTestFilesKeyValueReporter(
-                    info={"location": location, "location_type": location_type}
-                ),
+                GrassTestFilesKeyValueReporter(info=info),
             ]
         )
         self.testsuite_dirs = collections.defaultdict(
@@ -326,6 +338,10 @@ def run_in_location(
             import_modules=False,
             exclude=exclude,
         )
+        for module in modules:
+            self.testsuite_dirs[module.tested_dir].append(module.name)
+        if seed is not None:
+            random.Random(seed).shuffle(modules)
 
         self.reporter.start(results_dir)
         for module in modules:
@@ -340,16 +356,23 @@ def run_in_location(
 
         # TODO: move this to some (new?) reporter
         # TODO: add basic summary of linked files so that the page is not empty
+        if seed is None:
+            order_text = ""
+        else:
+            order_text = f"<p>Test files ran in random order with seed {seed}.</p>"
         Path(os.path.join(results_dir, "index.html")).write_text(
             "<html><body>"
             "<h1>Tests for &lt;{location}&gt;"
             " using &lt;{type}&gt; type tests</h1>"
+            "{order_text}"
             "<ul>"
             '<li><a href="testsuites.html">Results by testsuites</a>'
             " (testsuite directories)</li>"
             '<li><a href="testfiles.html">Results by test files</a></li>'
             "<ul>"
-            "</body></html>".format(location=location, type=location_type),
+            "</body></html>".format(
+                location=location, type=location_type, order_text=order_text
+            ),
             encoding="utf-8",
         )
 
diff --git a/python/grass/gunittest/loader.py b/python/grass/gunittest/loader.py
index f536ab6a83d..f447643ca4f 100644
--- a/python/grass/gunittest/loader.py
+++ b/python/grass/gunittest/loader.py
@@ -57,6 +57,16 @@ class GrassTestPythonModule(NamedTuple):
     abs_file_path: str
 
 
+def discovery_sort_key(module: GrassTestPythonModule) -> tuple[tuple[str, ...], str]:
+    """Return a key which sorts test files in the order of discovery
+
+    Sorting by this key gives the order in which :func:`discover_modules`
+    returns the test files, so reports can keep that order even when
+    the test files run in a different one.
+    """
+    return PurePath(module.tested_dir).parts, os.path.basename(module.file_path)
+
+
 # TODO: implement loading without the import
 def discover_modules(
     start_dir,
diff --git a/python/grass/gunittest/main.py b/python/grass/gunittest/main.py
index f8458ec93d1..7e57eedf03b 100644
--- a/python/grass/gunittest/main.py
+++ b/python/grass/gunittest/main.py
@@ -8,6 +8,7 @@
 """
 
 import os
+import random
 import sys
 import argparse
 import configparser
@@ -17,6 +18,7 @@
 
 import grass.script.core as gs
 
+from .checkers import text_to_keyvalue
 from .loader import GrassTestLoader
 from .runner import (
     GrassTestRunner,
@@ -168,6 +170,28 @@ def get_config(start_directory, config_file):
     return config_parser["gunittest"]
 
 
+def seed_type(value: str) -> int | str:
+    """Convert a seed option value to int unless it is the special value last"""
+    if value == "last":
+        return value
+    try:
+        return int(value)
+    except ValueError:
+        msg = f"invalid seed value: {value!r} (use an integer or 'last')"
+        raise argparse.ArgumentTypeError(msg) from None
+
+
+def get_last_seed(results_dir) -> int | None:
+    """Return the seed of the previous run stored in its report, if any"""
+    summary_file = Path(results_dir) / "test_keyvalue_result.txt"
+    try:
+        text = summary_file.read_text(encoding="utf-8")
+    except OSError:
+        return None
+    seed = text_to_keyvalue(text, sep="=").get("random_seed")
+    return seed if isinstance(seed, int) else None
+
+
 def main():
     parser = argparse.ArgumentParser(
         description="Run test files in all testsuite directories starting"
@@ -220,6 +244,28 @@ def main():
         type=str,
         help=f"Path to a configuration file (default: {CONFIG_FILENAME})",
     )
+    parser.add_argument(
+        "--random-order",
+        dest="random_order",
+        action="store_true",
+        help=(
+            "Run test files in random order using a newly generated seed"
+            " (reports still list test files in the usual order)"
+        ),
+    )
+    parser.add_argument(
+        "--randomly-seed",
+        dest="randomly_seed",
+        action="store",
+        type=seed_type,
+        default=None,
+        help=(
+            "Run test files in random order generated from this seed,"
+            " or pass the special value 'last' to reuse the seed from the"
+            " previous run with the same output directory"
+            " (implies --random-order)"
+        ),
+    )
     args = parser.parse_args()
     gisdbase = args.gisdbase
     if gisdbase is None:
@@ -238,6 +284,16 @@ def main():
             f" does not exist in GRASS Database <{gisdbase}>\n"
         )
     results_dir = args.output
+    seed = args.randomly_seed
+    if seed == "last":
+        # The previous report is removed below, so get the seed first.
+        seed = get_last_seed(results_dir)
+        if seed is None:
+            return (
+                f"No seed of a previous run in random order found in <{results_dir}>\n"
+            )
+    elif args.random_order and seed is None:
+        seed = random.randrange(2**32)
     silent_rmtree(results_dir)  # TODO: too brute force?
 
     start_dir = "."
@@ -248,6 +304,9 @@ def main():
     except OSError as error:
         return f"Error reading configuration: {error}"
 
+    if seed is not None:
+        print(f"Using --randomly-seed={seed}", file=sys.stderr)
+
     invoker = GrassTestFilesInvoker(
         start_dir=start_dir,
         file_anonymizer=FileAnonymizer(paths_to_remove=[abs_start_dir]),
@@ -263,6 +322,7 @@ def main():
         location_type=location_type,
         results_dir=results_dir,
         exclude=config.get("exclude", "").split(),
+        seed=seed,
     )
     if not reporter.test_files:
         return "No tests found or executed"
diff --git a/python/grass/gunittest/reporters.py b/python/grass/gunittest/reporters.py
index eb57602eca6..91e21de1bb4 100644
--- a/python/grass/gunittest/reporters.py
+++ b/python/grass/gunittest/reporters.py
@@ -23,6 +23,7 @@
 
 from .utils import add_gitignore_to_dir, ensure_dir
 from .checkers import text_to_keyvalue
+from .loader import discovery_sort_key
 
 
 from io import StringIO
@@ -560,13 +561,17 @@ def __init__(self, file_anonymizer, main_page_name: str = "index.html"):
         self.main_index = None
         self._file_anonymizer = file_anonymizer
         self._main_page_name = main_page_name
+        self._main_page_path = None
+        self._main_page_header = None
+        self._main_page_rows = []
 
     def start(self, results_dir):
         super().start(results_dir)
         # having all variables public although not really part of API
-        main_page_name = os.path.join(results_dir, self._main_page_name)
+        self._main_page_path = os.path.join(results_dir, self._main_page_name)
+        self._main_page_rows = []
         # TODO: Ensure file is closed in all situations
-        self.main_index = open(main_page_name, "w", encoding="utf-8")  # noqa: SIM115
+        self.main_index = open(self._main_page_path, "w", encoding="utf-8")  # noqa: SIM115
 
         # TODO: this can be moved to the counter class
         self.failures = 0
@@ -589,7 +594,7 @@ def start(self, results_dir):
             svn_text = ('SVN revision <a href="{url}">{rev}</a>').format(
                 url=url, rev=svn_info["revision"]
             )
-        self.main_index.write(
+        self._main_page_header = (
             "<html><body>"
             "<h1>Test results</h1>"
             "{time:%Y-%m-%d %H:%M:%S}"
@@ -603,6 +608,7 @@ def start(self, results_dir):
             "<th>Failed</th><th>Percent successful</th>"
             "</tr></thead><tbody>".format(time=self.main_start_time, svn=svn_text)
         )
+        self.main_index.write(self._main_page_header)
 
     def finish(self):
         super().finish()
@@ -639,12 +645,16 @@ def finish(self):
             )
         )
 
-        self.main_index.write(
-            "<tbody>{tfoot}</table><p>{summary}</p></body></html>".format(
-                tfoot=tfoot, summary=summary_sentence
-            )
-        )
         self.main_index.close()
+        self._main_page_rows.sort()
+        with open(self._main_page_path, "w", encoding="utf-8") as main_page:
+            main_page.write(self._main_page_header)
+            main_page.writelines(row for unused_key, row in self._main_page_rows)
+            main_page.write(
+                "<tbody>{tfoot}</table><p>{summary}</p></body></html>".format(
+                    tfoot=tfoot, summary=summary_sentence
+                )
+            )
 
     def start_file_test(self, module):
         super().start_file_test(module)
@@ -694,7 +704,7 @@ def end_file_test(
         else:
             total = successes = pass_per = self.unknown_number
         bad_ones = failures + errors
-        self.main_index.write(
+        row = (
             "<tr><td>{d}</td>"
             '<td><a href="{d}/{m}/index.html">{m}</a></td>'
             "<td>{status}</td>"
@@ -710,6 +720,8 @@ def end_file_test(
                 ptests=pass_per,
             )
         )
+        self.main_index.write(row)
+        self._main_page_rows.append((discovery_sort_key(module), row))
         wrap_stdstream_to_html(
             infile=stdout,
             outfile=os.path.join(cwd, "stdout.html"),
@@ -852,6 +864,7 @@ def start(self, results_dir) -> None:
         self.names = []
         self.tested_dirs = []
         self.files_returncodes = []
+        self._sort_keys = []
 
         # sets (no size specified)
         self.modules = set()
@@ -860,6 +873,11 @@ def start(self, results_dir) -> None:
     def finish(self):
         super().finish()
 
+        order = sorted(range(len(self.names)), key=self._sort_keys.__getitem__)
+        self.names = [self.names[i] for i in order]
+        self.tested_dirs = [self.tested_dirs[i] for i in order]
+        self.files_returncodes = [self.files_returncodes[i] for i in order]
+
         # this should be moved to some additional meta passed in constructor
         svn_info = get_svn_info()
         svn_revision = "" if not svn_info else svn_info["revision"]
@@ -942,6 +960,7 @@ def end_file_test(
 
         self.tested_dirs.append(module.tested_dir)
         self.names.append(module.name)
+        self._sort_keys.append(discovery_sort_key(module))
 
         modules = test_summary.get("tested_modules", None)
         if modules:
diff --git a/python/grass/gunittest/tests/grass_gunittest_random_order_test.py b/python/grass/gunittest/tests/grass_gunittest_random_order_test.py
new file mode 100644
index 00000000000..3bad342be1e
--- /dev/null
+++ b/python/grass/gunittest/tests/grass_gunittest_random_order_test.py
@@ -0,0 +1,168 @@
+"""Tests of running test files in random order with grass.gunittest"""
+
+import argparse
+import os
+import re
+from pathlib import Path
+
+import pytest
+
+from grass.gunittest.checkers import text_to_keyvalue
+from grass.gunittest.invoker import GrassTestFilesInvoker
+from grass.gunittest.loader import discover_modules, discovery_sort_key
+from grass.gunittest.main import get_last_seed, seed_type
+from grass.gunittest.reporters import to_web_path
+
+# Directory names which sort differently as plain strings than as paths
+# ("a-b" < "a/b" as strings, but "a" and its subdirectories come first
+# in a directory walk).
+TESTED_DIRS = ["a", "a/b", "a-b", "a.b", "b"]
+TEST_FILES = ["test_a.py", "test_a_b.py", "test_b.py"]
+NUM_TEST_FILES = len(TESTED_DIRS) * len(TEST_FILES)
+
+# Each test file appends its path to a log file, so that the tests can
+# check in which order the test files ran.
+TEST_FILE_CODE = """
+import os
+
+with open(os.environ["ORDER_LOG"], "a", encoding="utf-8") as log:
+    log.write(os.path.realpath(__file__) + "\\n")
+"""
+
+
+@pytest.fixture
+def test_tree(tmp_path, monkeypatch):
+    """Create a directory tree with testsuite directories and a location"""
+    start_dir = tmp_path / "src"
+    for tested_dir in TESTED_DIRS:
+        testsuite = start_dir / tested_dir / "testsuite"
+        testsuite.mkdir(parents=True)
+        for name in TEST_FILES:
+            (testsuite / name).write_text(TEST_FILE_CODE, encoding="utf-8")
+    permanent = tmp_path / "grassdata" / "test" / "PERMANENT"
+    permanent.mkdir(parents=True)
+    (permanent / "DEFAULT_WIND").write_text("", encoding="utf-8")
+    # The invoker places results of a test file into a directory derived
+    # from the tested directory, so the start directory needs to be relative.
+    monkeypatch.chdir(start_dir)
+    monkeypatch.setenv("ORDER_LOG", str(tmp_path / "order.txt"))
+    return tmp_path
+
+
+def run_tests(tmp_path, results_name, seed=None):
+    """Run all test files and return the order they ran in and the results"""
+    log = Path(os.environ["ORDER_LOG"])
+    log.unlink(missing_ok=True)
+    results_dir = tmp_path / results_name
+    invoker = GrassTestFilesInvoker(start_dir=".")
+    reporter = invoker.run_in_location(
+        gisdbase=str(tmp_path / "grassdata"),
+        location="test",
+        location_type="nc",
+        results_dir=str(results_dir),
+        exclude=[],
+        seed=seed,
+    )
+    assert reporter.files_pass == NUM_TEST_FILES
+    return log.read_text(encoding="utf-8").splitlines(), results_dir
+
+
+def discover():
+    """Return test files in the order of discovery"""
+    modules = discover_modules(
+        start_dir=".",
+        skip_dirs=[],
+        testsuite_dir="testsuite",
+        grass_location="all",
+        all_locations_value="all",
+        universal_location_value="universal",
+        import_modules=False,
+        file_regexp=r".*\.py$",
+    )
+    assert len(modules) == NUM_TEST_FILES
+    return modules
+
+
+def real_paths(modules):
+    return [os.path.realpath(module.abs_file_path) for module in modules]
+
+
+def report_order(results_dir):
+    """Return test files as listed in the reports and the key-value summary"""
+    page = (results_dir / "testfiles.html").read_text(encoding="utf-8")
+    html_order = re.findall(r'<td><a href="([^"]*)/([^"/]*)/index.html">', page)
+    summary = text_to_keyvalue(
+        (results_dir / "test_keyvalue_result.txt").read_text(encoding="utf-8"),
+        sep="=",
+    )
+    keyvalue_order = list(zip(summary["tested_dirs"], summary["names"], strict=True))
+    return html_order, keyvalue_order, summary
+
+
+def test_discovery_sort_key_matches_discovery_order(test_tree):
+    """Sorting by discovery_sort_key gives the order of discovery"""
+    modules = discover()
+    assert sorted(reversed(modules), key=discovery_sort_key) == modules
+
+
+def test_default_order_is_discovery_order(test_tree):
+    """Without a seed, test files run in the order of discovery"""
+    order, unused_results_dir = run_tests(test_tree, "results")
+    assert order == real_paths(discover())
+
+
+def test_same_seed_gives_same_order(test_tree):
+    """The same seed reproduces the order and a different seed changes it"""
+    expected = real_paths(discover())
+    first, unused_results_dir = run_tests(test_tree, "results_1", seed=1)
+    second, unused_results_dir = run_tests(test_tree, "results_2", seed=1)
+    other, unused_results_dir = run_tests(test_tree, "results_3", seed=2)
+    assert first == second
+    assert sorted(first) == sorted(expected)
+    assert first != expected
+    assert other != first
+
+
+def test_reports_keep_discovery_order(test_tree):
+    """Reports list test files in the order of discovery regardless of run order"""
+    modules = discover()
+    order, results_dir = run_tests(test_tree, "results", seed=1)
+    assert order != real_paths(modules)
+    html_order, keyvalue_order, summary = report_order(results_dir)
+    assert html_order == [
+        (to_web_path(module.tested_dir), module.name) for module in modules
+    ]
+    assert keyvalue_order == [(module.tested_dir, module.name) for module in modules]
+    assert summary["random_seed"] == 1
+    index_page = (results_dir / "index.html").read_text(encoding="utf-8")
+    assert "random order with seed 1" in index_page
+
+
+def test_no_seed_in_report_by_default(test_tree):
+    """Reports mention a seed only when test files run in random order"""
+    unused_order, results_dir = run_tests(test_tree, "results")
+    unused_html_order, unused_keyvalue_order, summary = report_order(results_dir)
+    assert "random_seed" not in summary
+    index_page = (results_dir / "index.html").read_text(encoding="utf-8")
+    assert "seed" not in index_page
+
+
+def test_last_seed_is_read_from_report(test_tree):
+    """The seed of the previous run is available from its report"""
+    unused_order, results_dir = run_tests(test_tree, "results", seed=1234)
+    assert get_last_seed(results_dir) == 1234
+
+
+def test_no_last_seed_without_random_order(test_tree):
+    """There is no last seed after a run in the usual order or no run"""
+    unused_order, results_dir = run_tests(test_tree, "results")
+    assert get_last_seed(results_dir) is None
+    assert get_last_seed(test_tree / "does_not_exist") is None
+
+
+def test_seed_type():
+    """Seed is an integer or the special value last"""
+    assert seed_type("42") == 42
+    assert seed_type("last") == "last"
+    with pytest.raises(argparse.ArgumentTypeError):
+        seed_type("first")

From c72a05b31b21f2bad634df4e0fc22085062c5909 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Edouard=20Choini=C3=A8re?=
 <27212526+echoix@users.noreply.github.com>
Date: Wed, 28 Oct 2026 18:32:04 +0000
Subject: [PATCH 2/2] CI: Run gunittest thorough tests in random order on all
 platforms

Use the new --random-order option of grass.gunittest.main in
test_thorough.sh (Ubuntu, macOS, CMake, and Docker image tests) and
test_thorough.bat (Windows). The seed is printed in the job log and
stored in the test report, so an order-dependent failure can be
reproduced locally with --randomly-seed.

Developed with the help of an AI coding agent (Claude Code).
---
 .github/workflows/test_thorough.bat | 2 +-
 .github/workflows/test_thorough.sh  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/test_thorough.bat b/.github/workflows/test_thorough.bat
index d24276b48a1..e61e58aec7a 100644
--- a/.github/workflows/test_thorough.bat
+++ b/.github/workflows/test_thorough.bat
@@ -2,4 +2,4 @@ set grass=%1
 set python=%2
 
 call %grass% --tmp-project XY --exec g.download.project url=https://grass.osgeo.org/sampledata/north_carolina/nc_spm_full_v2beta1.tar.gz path=%USERPROFILE%
-call %grass% --tmp-project XY --exec %python% -m grass.gunittest.main --grassdata %USERPROFILE% --location nc_spm_full_v2beta1 --location-type nc --min-success 97.3 --config .github\workflows\osgeo4w_gunittest.cfg
+call %grass% --tmp-project XY --exec %python% -m grass.gunittest.main --grassdata %USERPROFILE% --location nc_spm_full_v2beta1 --location-type nc --min-success 97.3 --random-order --config .github\workflows\osgeo4w_gunittest.cfg
diff --git a/.github/workflows/test_thorough.sh b/.github/workflows/test_thorough.sh
index 31b225dc26e..dfc121d3c78 100755
--- a/.github/workflows/test_thorough.sh
+++ b/.github/workflows/test_thorough.sh
@@ -11,4 +11,4 @@ grass --tmp-project XY --exec \
 grass --tmp-project XY --exec \
     python3 -m grass.gunittest.main \
     --grassdata $HOME --location nc_spm_full_v2beta1 --location-type nc \
-    --min-success 100 $@
+    --min-success 100 --random-order $@