@@ -85,13 +85,14 @@ TEST(MyUnitTest, ConfigureAndGet) {
 | Property | Required | Description |
 |----------|----------|-------------|
 | `lobster-tracing` | yes | One or more requirement IDs (`Package.RecordId`), linking the test to `CompReq` records. Multiple IDs are separated by whitespace (the docs also describe comma-separated). |
-| `given` | no | Initial state / precondition |
+| `given` | with coverage lock | Initial state / precondition |
 | `when` | no | Action or event under test |
-| `then` | no | Expected outcome |
+| `then` | with coverage lock | Expected outcome |
 
 - A test **without** `lobster-tracing` has no traceability and is excluded from coverage tracking.
 - The referenced IDs must resolve to `CompReq` records exposed through the component's
   `requirements` targets.
+- A test case in a coverage lock needs a Given and a Then; When is always optional.
 
 ```starlark
 cc_test(
@@ -108,6 +109,29 @@ unit(
 )
 ```
 
+### Given/When/Then from the test name
+
+A test named `[<Prefix>_]Given<X>[_When<Y>]_(Expect|Then)<Z>` needs no `given`/`when`/`then`
+properties; its name provides them. `<Prefix>` is alphanumeric; `<X>`, `<Y>`, `<Z>` are CamelCase and
+become lowercase words separated by spaces:
+
+```cpp
+// Given "empty stack", When "pop called", Then "error"
+TEST(Stack, GivenEmptyStack_WhenPopCalled_ExpectError) {
+  ::testing::Test::RecordProperty("lobster-tracing", "MinimalExample.FEAT_001");
+  ...
+}
+```
+
+- `_When<Y>` is optional; `GivenEmptyStack_ExpectError` has no When.
+- A test that sets any of the three properties to a non-blank value ignores its name completely, so
+  missing parts are not filled in from the name. If the name also matches, lobster prints a warning.
+  Set all needed parts, or none.
+- Needs a `lobster` version that provides `--derive-gwt-from-test-name`. It is not available in
+  lobster 1.0.6 and earlier, where only the properties are used.
+- After a `lobster` upgrade that provides the option, the lock entries of pattern-named tests without
+  properties become stale; run `bazel run //<pkg>:<component>.update` and review the diff.
+
 ---
 
 ## Test-Case Coverage (`test_case_coverage.lock.yaml`)
@@ -140,7 +164,8 @@ requirements:
 
 - `requirements[].id` — matches the `lobster-tracing` value; extracted from the requirements targets.
 - `test_cases[].uid` — `//bazel_package/SuiteName:TestName`, a package-scoped gtest tag.
-- `given` / `when` / `then` — the GWT fields from `RecordProperty`; **any** change makes the lock stale.
+- `given` / `when` / `then` — the GWT fields from `RecordProperty` or the test name; **any** change
+  makes the lock stale. `given` and `then` must be non-blank; `when` may be empty and is stored as `''`.
 
 ### Two workflows keep the lock in sync
 
@@ -159,8 +184,8 @@ controls how strict it is:
 
 | `maturity` | Behavior |
 |------------|----------|
-| `"development"` | `--allow-check-failures`: lock-drift **and** missing-GWT-annotation errors are downgraded to warnings; the `.lobster` artifact is always produced. |
-| `"release"` | A drift or a missing GWT annotation fails the Bazel build action directly. |
+| `"development"` | `--allow-check-failures`: lock-drift **and** missing-Given/Then errors are downgraded to warnings; the `.lobster` artifact is always produced. |
+| `"release"` | A drift or a missing Given/Then fails the Bazel build action directly. |
 
 Switch back to `"release"` before certification.
 
 
@@ -38,6 +38,15 @@ bazel_dep(name = "flatbuffers", version = "25.9.23")
 bazel_dep(name = "download_utils", version = "1.2.2")
 bazel_dep(name = "trlc", version = "3.0.1")
 bazel_dep(name = "lobster", version = "1.0.6")
+
+# Probes which optional features the resolved lobster module provides, so that
+# the rules can keep working with versions that predate them.
+lobster_capabilities = use_extension(
+    "//bazel/rules/rules_score/private:lobster_capabilities.bzl",
+    "lobster_capabilities",
+)
+use_repo(lobster_capabilities, "lobster_capabilities")
+
 bazel_dep(name = "rules_distroless", version = "0.8.0")
 bazel_dep(name = "googletest", version = "1.17.0.bcr.2")
 
 
@@ -277,16 +277,58 @@ section "Tool Requirements" {
 
         ToolQualification.ToolRequirement Parse_GWT_Annotations {
             description = '''
-                The tool shall parse GTest XML result files, extracting
-                RecordProperty values for the keys lobster-tracing, given, when,
-                and then on a per-TEST, per-TEST_F, and per-TEST_P basis. A test case
-                without a given, when, or then property shall be included with an
-                empty string for each missing field.
+                The tool shall read the requirement references and the given,
+                when, and then parts of every test case from the gtest.lobster
+                file that lobster-gtest produces from the GTest XML result
+                files. A test case without a given, when, or then part shall be
+                included with an empty string for each missing part.
             '''
             derived_from = [Detect_Specification_Drift, Detect_Coverage_Set_Changes]
             satisfied_by = Tools.TestCaseCoverage
         }
 
+        ToolQualification.ToolRequirement Enable_GWT_Derivation {
+            description = '''
+                The component rule shall pass the option
+                --derive-gwt-from-test-name to lobster-gtest when the resolved
+                lobster version provides that option, and shall omit it
+                otherwise.
+            '''
+            derived_from = [Detect_Specification_Drift]
+            satisfied_by = Tools.Bazel
+        }
+
+        ToolQualification.ToolRequirement Derive_GWT_From_Test_Name {
+            description = '''
+                With the option --derive-gwt-from-test-name, lobster-gtest
+                shall derive the given, when, and then parts of a test case
+                from its test name, if the name matches
+                [<Prefix>_]Given<X>[_When<Y>]_(Expect|Then)<Z>. <Prefix> is
+                alphanumeric, and <X>, <Y>, and <Z> are in CamelCase. Each
+                derived part is its CamelCase text converted to lowercase
+                words separated by spaces. A test case whose name has no When
+                part shall have an empty when field. A test case that sets a
+                non-blank given, when, or then RecordProperty shall take all
+                three parts from its RecordProperty values only, and its
+                name shall be ignored.
+            '''
+            derived_from = [Detect_Specification_Drift]
+            satisfied_by = Tools.Lobster
+        }
+
+        ToolQualification.ToolRequirement Require_Given_And_Then {
+            description = '''
+                The tool shall report every linked test case whose given or
+                then field is empty or blank as an error naming the requirement
+                identifier, the test uid, and the missing fields. An empty
+                when field shall not be reported. The error shall fail the
+                test action, and shall prevent the .update command from
+                writing the lock file, unless check failures are allowed.
+            '''
+            derived_from = [Declare_Complete_Coverage, Detect_Specification_Drift]
+            satisfied_by = Tools.TestCaseCoverage
+        }
+
         ToolQualification.ToolRequirement Multi_Requirement_Linking {
             description = '''
                 A test case that carries lobster-tracing values matching more than
 
@@ -57,10 +57,10 @@ Two phases
 
   * ``maturity = "development"`` — ``--allow-check-failures`` is passed so
     the ``.lobster`` artifact is always produced even when coverage drifts.
-    Both lock-drift failures **and** missing-GWT-annotation errors are
+    Both lock-drift failures **and** missing Given/Then errors are
     downgraded to warnings;
   * ``maturity = "release"`` — no ``--allow-check-failures``; a drift or
-    missing GWT annotation fails the Bazel build action directly.  The
+    a missing Given or Then fails the Bazel build action directly.  The
     ``.lobster`` artifact is physically written before the action exits, but
     Bazel marks the action as failed.
 
@@ -133,5 +133,10 @@ reviewing ``git diff``.
    * - ``test_cases[].uid``
      - ``//bazel_package/SuiteName:TestName`` — package-scoped gtest tag
    * - ``test_cases[].given`` / ``when`` / ``then``
-     - Individual GWT fields from ``RecordProperty`` annotations; any change
-       makes the lock stale
+     - Individual GWT fields from ``RecordProperty`` annotations or the test
+       name; any change makes the lock stale. ``given`` and ``then`` must be
+       non-blank. ``when`` may be empty and is then stored as ``''``
+
+Upgrading ``lobster`` to a version that derives the GWT fields from test names
+changes the text of tests that follow the naming pattern and set no properties.
+Run ``.update`` and review the diff, see :doc:`../user_guide/validation`.
@@ -45,6 +45,10 @@ They are picked up the same way as ``lobster-tracing`` — as plain
 traceability report. Test cases without them are still traced, but show up
 without a Given-When-Then specification.
 
+Instead of the properties, a test can be named
+``[<Prefix>_]Given<X>[_When<Y>]_(Expect|Then)<Z>`` so that its name provides the
+specification. See :doc:`../validation` for the rules.
+
 BUILD
 ------
 
 
@@ -54,15 +54,51 @@ Call ``RecordProperty`` inside the test body next to the respective code blocks:
      - yes
      - Comma-separated requirement IDs; links the test to one or more ``CompReq`` records
    * - ``given``
-     - no
+     - with coverage lock
      - Initial state / precondition
    * - ``when``
      - no
      - Action or event under test
    * - ``then``
-     - no
+     - with coverage lock
      - Expected outcome
 
+A test case that is part of a coverage lock (see `Stating Coverage for test cases`_)
+needs a ``given`` and a ``then``. The ``when`` is always optional.
+
+Deriving Given/When/Then from the Test Name
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+A test named ``[<Prefix>_]Given<X>[_When<Y>]_(Expect|Then)<Z>`` does not need the
+``given``/``when``/``then`` properties. Its name provides them. ``<Prefix>`` is
+alphanumeric, and ``<X>``, ``<Y>`` and ``<Z>`` are in CamelCase. Each of them becomes
+lowercase words separated by spaces:
+
+.. code-block:: cpp
+
+   TEST(Stack, GivenEmptyStack_WhenPopCalled_ExpectError) {
+       ::testing::Test::RecordProperty("lobster-tracing",
+                                       "SampleComponent.REQ_COMP_001");
+       ...
+   }
+
+This test has the Given ``empty stack``, the When ``pop called`` and the Then
+``error``.
+
+* The ``_When<Y>`` part is optional. ``GivenEmptyStack_ExpectError`` has no When.
+* For a value-parameterized test, the segments of the name are separated by ``/``
+  and the last segment that matches is used.
+* If a test sets any of ``given``, ``when`` or ``then`` to a non-blank value, its
+  name is ignored completely, so parts missing from the properties are not filled in
+  from the name. If the name also matches the pattern, lobster prints a warning. Set
+  all parts that the test needs, or none.
+* Deriving requires a ``lobster`` version that provides the option
+  ``--derive-gwt-from-test-name``. It is not available in lobster 1.0.6 and earlier,
+  where only the properties are used.
+* After a ``lobster`` upgrade that provides the option, the derived text of tests that
+  follow the pattern and set none of the properties changes. Their entries in the lock
+  become stale, so run ``bazel run //<pkg>:<name>.update`` and review the diff.
+
 A ``dependable_element`` report renders every annotated test on its **Unit
 Test** page at ``<dependable-element>_index/traceability_report/unit_test.html``.
 The entry shows its Given/When/Then text, links to the traced requirements, and
@@ -78,6 +114,13 @@ Coverage is declared through a committed ``test_case_coverage.lock.yaml`` file t
 per requirement, every test case (uid + given/when/then) that covers it.
 Committing the file is stating the coverage claim.
 
+Every test case in the lock needs a Given and a Then, set through properties or
+derived from the test name. The When is optional and is stored as an empty string
+when absent. A test case without a Given or a Then is reported as an error. With
+``maturity = "release"`` on the ``dependable_element`` the error fails the build, with
+``"development"`` it is downgraded to a warning (see
+:doc:`../tool_reference/test_case_coverage`).
+
 In Bazel the yaml file can be linked to the ``component`` macro via the ``test_case_coverage_lock`` attribute:
 
 .. code-block:: starlark
 
@@ -20,6 +20,7 @@ with associated requirements and tests.
 """
 
 load("@lobster//:lobster.bzl", "subrule_lobster_gtest", "subrule_lobster_html_report", "subrule_lobster_report")
+load("@lobster_capabilities//:capabilities.bzl", "SUPPORTS_DERIVE_GWT_FROM_TEST_NAME")
 load("//bazel/rules/rules_score:providers.bzl", "AssumedSystemRequirementsInfo", "CertifiedScope", "ComponentInfo", "ComponentRequirementsInfo", "ComponentTestCaseCoverageInfo", "FeatureRequirementsInfo", "SphinxSourcesInfo", "UnitInfo")
 load("//bazel/rules/rules_score/private:lobster_config.bzl", "format_lobster_sources")
 
@@ -246,7 +247,15 @@ def _component_impl(ctx):
                 collected_architecture.append(component[ComponentInfo].architecture)
 
     # Convert unit test XML files to a single gtest.lobster file
-    gtest_lobster_file, provider = subrule_lobster_gtest(depset(transitive = collected_unit_test_files).to_list())
+    # Given/When/Then is derived from conventionally named test cases, so that
+    # tests do not have to repeat the information as record properties. Older
+    # lobster versions do not offer the option and keep relying on the record
+    # properties alone.
+    derive_gwt = {"derive_gwt_from_test_name": True} if SUPPORTS_DERIVE_GWT_FROM_TEST_NAME else {}
+    gtest_lobster_file, provider = subrule_lobster_gtest(
+        depset(transitive = collected_unit_test_files).to_list(),
+        **derive_gwt
+    )
 
     # -------------------------------------------------------------------------
     # Architecture Lobster: generate architecture.lobster for this component
 
@@ -0,0 +1,67 @@
+# *******************************************************************************
+# Copyright (c) 2026 Contributors to the Eclipse Foundation
+#
+# See the NOTICE file(s) distributed with this work for additional
+# information regarding copyright ownership.
+#
+# This program and the accompanying materials are made available under the
+# terms of the Apache License Version 2.0 which is available at
+# https://www.apache.org/licenses/LICENSE-2.0
+#
+# SPDX-License-Identifier: Apache-2.0
+# *******************************************************************************
+"""Detect optional features of the resolved ``lobster`` module.
+
+``subrule_lobster_gtest`` gained the keyword argument
+``derive_gwt_from_test_name`` after the 1.0.6 release. Passing an unknown
+keyword argument to a subrule is an analysis error, and Starlark offers no way
+to introspect a subrule's signature, so the capability is probed by reading
+lobster's own rule definition.
+
+The result is exposed as a load-time constant through a generated repository,
+which lets the call sites choose the matching invocation. Pinning a lobster
+version that predates the feature therefore degrades to the previous behaviour
+instead of breaking the build, and bumping to a version that provides it
+enables the feature without any further change.
+"""
+
+_DERIVE_GWT_FROM_TEST_NAME = "derive_gwt_from_test_name"
+
+# Definition of the gtest rule inside the lobster module. A restructuring of
+# lobster makes the probe report "unsupported", which is the safe answer.
+_LOBSTER_GTEST_BZL = Label("@lobster//bazel/private:lobster_gtest.bzl")
+
+_CAPABILITIES_TEMPLATE = """\
+\"\"\"Generated by //bazel/rules/rules_score/private:lobster_capabilities.bzl.
+
+Do not edit. Describes the features of the lobster module that the current
+dependency resolution selected.
+\"\"\"
+
+# Whether subrule_lobster_gtest accepts the keyword argument
+# "derive_gwt_from_test_name".
+SUPPORTS_DERIVE_GWT_FROM_TEST_NAME = {derive_gwt_from_test_name}
+"""
+
+def _lobster_capabilities_repo_impl(repository_ctx):
+    definition = repository_ctx.read(repository_ctx.path(_LOBSTER_GTEST_BZL))
+    repository_ctx.file("BUILD.bazel", "")
+    repository_ctx.file(
+        "capabilities.bzl",
+        _CAPABILITIES_TEMPLATE.format(
+            derive_gwt_from_test_name = repr(_DERIVE_GWT_FROM_TEST_NAME in definition),
+        ),
+    )
+
+_lobster_capabilities_repo = repository_rule(
+    implementation = _lobster_capabilities_repo_impl,
+    doc = "Generates a .bzl file holding the probed lobster feature flags.",
+)
+
+def _lobster_capabilities_impl(_module_ctx):
+    _lobster_capabilities_repo(name = "lobster_capabilities")
+
+lobster_capabilities = module_extension(
+    implementation = _lobster_capabilities_impl,
+    doc = "Provides the @lobster_capabilities repository.",
+)
@@ -92,29 +92,21 @@ def compare_lock_files(
 
 
 def validate_specs(computed: LockFile) -> tuple[bool, list[str]]:
-    """Fail if any test case in *computed* is missing a GWT spec.
+    """Fail if any test case in *computed* lacks a ``given`` or ``then`` part.
 
-    A missing spec means the developer did not add ``given``/``when``/``then``
-    ``RecordProperty`` annotations to the test.  Coverage without a spec
-    cannot be meaningfully reviewed or approved.
+    ``when`` is optional, because a test name derived by lobster-gtest may omit it.
+    Coverage without ``given`` and ``then`` cannot be meaningfully reviewed or approved.
 
     Returns (ok, issue_lines).
     """
     issues: list[str] = []
     for req in computed.requirements:
         for tc in req.test_cases:
-            missing = [
-                name
-                for name, val in (
-                    ("given", tc.given),
-                    ("when", tc.when),
-                    ("then", tc.then),
-                )
-                if not val.strip()
-            ]
+            missing = [name for name, val in (("given", tc.given), ("then", tc.then)) if not val.strip()]
             if missing:
                 issues.append(
                     f"  ! [{req.id}] test missing GWT fields ({', '.join(missing)}): {tc.uid}\n"
-                    f"    Add RecordProperty('given'/'when'/'then') annotations."
+                    f"    Set RecordProperty 'given' and 'then' ('when' is optional). Alternatively, name the test "
+                    f"Given<X>[_When<Y>]_(Expect|Then)<Z> if lobster provides --derive-gwt-from-test-name."
                 )
     return len(issues) == 0, issues