Repository: aristanetworks/anta
Pull request #1073 (2025-03-10 06:35:26)

refactor(anta.tests): Input model refactoring for VerifyInterfacesSpeed test
# Description

Input model refactoring for VerifyInterfacesSpeed test

# Checklist:

- [X] My code follows the style guidelines of this project
- [X] I have performed a self-review of my code
- [X] I have run pre-commit for code linting and typing (`pre-commit run`)
- [ ] I have made corresponding changes to the documentation
- [X] I have added tests that prove my fix is effective or that my feature works
- [X] New and existing unit tests pass locally with my changes (`tox -e testenv`)


sonarqubecloud[bot]: ## [![Quality Gate Passed](https://sonarsource.github.io/sonarcloud-github-static-resources/v2/checks/QualityGateBadge/qg-passed-20px.png 'Quality Gate Passed')](https://sonarcloud.io/dashboard?id=aristanetworks_anta&pullRequest=1073) **Quality Gate passed**  
Issues  
![](https://sonarsource.github.io/sonarcloud-github-static-resources/v2/common/passed-16px.png '') [0 New issues](https://sonarcloud.io/project/issues?id=aristanetworks_anta&pullRequest=1073&issueStatuses=OPEN,CONFIRMED&sinceLeakPeriod=true)  
![](https://sonarsource.github.io/sonarcloud-github-static-resources/v2/common/accepted-16px.png '') [0 Accepted issues](https://sonarcloud.io/project/issues?id=aristanetworks_anta&pullRequest=1073&issueStatuses=ACCEPTED)

Measures  
![](https://sonarsource.github.io/sonarcloud-github-static-resources/v2/common/passed-16px.png '') [0 Security Hotspots](https://sonarcloud.io/project/security_hotspots?id=aristanetworks_anta&pullRequest=1073&issueStatuses=OPEN,CONFIRMED&sinceLeakPeriod=true)  
![](https://sonarsource.github.io/sonarcloud-github-static-resources/v2/common/passed-16px.png '') [100.0% Coverage on New Code](https://sonarcloud.io/component_measures?id=aristanetworks_anta&pullRequest=1073&metric=new_coverage&view=list)  
![](https://sonarsource.github.io/sonarcloud-github-static-resources/v2/common/passed-16px.png '') [0.0% Duplication on New Code](https://sonarcloud.io/component_measures?id=aristanetworks_anta&pullRequest=1073&metric=new_duplicated_lines_density&view=list)  
  
[See analysis details on SonarQube Cloud](https://sonarcloud.io/dashboard?id=aristanetworks_anta&pullRequest=1073)


codspeed-hq[bot]: <!-- __CODSPEED_PERFORMANCE_REPORT_COMMENT__ -->
<!-- __CODSPEED_INSTRUMENTATION_PERFORMANCE_REPORT_COMMENT__ -->

## [CodSpeed Performance Report](https://codspeed.io/aristanetworks/anta/branches/vitthalmagadum%3Ainput_model%2Finterface)

### Merging #1073 will **not alter performance**

<sub>Comparing <code>vitthalmagadum:input_model/interface</code> (7ab3246) with <code>main</code> (083d51f)</sub>



### Summary

`✅ 22` untouched benchmarks  





Patch:
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 6e9430db..5570e010 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -46,7 +46,7 @@ repos:
           - "<!--|  ~|  -->"
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.9.9
+    rev: v0.9.10
     hooks:
       - id: ruff
         name: Run Ruff linter
@@ -55,7 +55,7 @@ repos:
         name: Run Ruff formatter
 
   - repo: https://github.com/pycqa/pylint
-    rev: "v3.3.4"
+    rev: "v3.3.5"
     hooks:
       - id: pylint
         name: Check code style with pylint
@@ -98,7 +98,7 @@ repos:
           - types-requests
           - types-pyOpenSSL
           - pytest
-        files: ^(anta|tests)/
+        files: ^(anta|tests|asynceapi)/
 
   - repo: https://github.com/igorshubovych/markdownlint-cli
     rev: v0.44.0
diff --git a/anta/cli/exec/utils.py b/anta/cli/exec/utils.py
index 3df4b7a5..3258d0be 100644
--- a/anta/cli/exec/utils.py
+++ b/anta/cli/exec/utils.py
@@ -13,6 +13,7 @@ import logging
 from pathlib import Path
 from typing import TYPE_CHECKING, Literal
 
+from asyncssh.misc import HostKeyNotVerifiable
 from click.exceptions import UsageError
 from httpx import ConnectError, HTTPError
 
@@ -97,7 +98,7 @@ async def collect_commands(
             logger.error("Error when collecting commands: %s", str(r))
 
 
-async def collect_show_tech(inv: AntaInventory, root_dir: Path, *, configure: bool, tags: set[str] | None = None, latest: int | None = None) -> None:
+async def collect_show_tech(inv: AntaInventory, root_dir: Path, *, configure: bool, tags: set[str] | None = None, latest: int | None = None) -> None:  # noqa: C901
     """Collect scheduled show-tech on devices."""
 
     async def collect(device: AntaDevice) -> None:
@@ -163,6 +164,11 @@ async def collect_show_tech(inv: AntaInventory, root_dir: Path, *, configure: bo
             await device.copy(sources=filenames, destination=outdir, direction="from")
             logger.info("Collected %s scheduled tech-support from %s", len(filenames), device.name)
 
+        except HostKeyNotVerifiable:
+            logger.error(
+                "Unable to collect tech-support on %s. The host SSH key could not be verified. Make sure it is part of the `known_hosts` file on your machine.",
+                device.name,
+            )
         except (EapiCommandError, HTTPError, ConnectError) as e:
             logger.error("Unable to collect tech-support on %s: %s", device.name, str(e))
 
diff --git a/anta/cli/utils.py b/anta/cli/utils.py
index 508424dd..34b96b3f 100644
--- a/anta/cli/utils.py
+++ b/anta/cli/utils.py
@@ -9,7 +9,7 @@ import enum
 import functools
 import logging
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING, Any, Callable, Literal
 
 import click
 from yaml import YAMLError
@@ -191,6 +191,14 @@ def core_options(f: Callable[..., Any]) -> Callable[..., Any]:
         required=True,
         type=click.Path(file_okay=True, dir_okay=False, exists=True, readable=True, path_type=Path),
     )
+    @click.option(
+        "--inventory-format",
+        envvar="ANTA_INVENTORY_FORMAT",
+        show_envvar=True,
+        help="Format of the inventory file, either 'yaml' or 'json'",
+        default="yaml",
+        type=click.Choice(["yaml", "json"], case_sensitive=False),
+    )
     @click.pass_context
     @functools.wraps(f)
     def wrapper(
@@ -205,6 +213,7 @@ def core_options(f: Callable[..., Any]) -> Callable[..., Any]:
         timeout: float,
         insecure: bool,
         disable_cache: bool,
+        inventory_format: Literal["json", "yaml"],
         **kwargs: dict[str, Any],
     ) -> Any:
         # If help is invoke somewhere, do not parse inventory
@@ -242,6 +251,7 @@ def core_options(f: Callable[..., Any]) -> Callable[..., Any]:
                 timeout=timeout,
                 insecure=insecure,
                 disable_cache=disable_cache,
+                file_format=inventory_format,
             )
         except (TypeError, ValueError, YAMLError, OSError, InventoryIncorrectSchemaError, InventoryRootKeyError) as e:
             anta_log_exception(e, f"Failed to parse the inventory: {inventory}", logger)
diff --git a/anta/constants.py b/anta/constants.py
index ed0ca224..2a4c0c9d 100644
--- a/anta/constants.py
+++ b/anta/constants.py
@@ -43,6 +43,7 @@ KNOWN_EOS_ERRORS = [
     r".* does not support IP",
     r"IS-IS (.*) is disabled because: .*",
     r"No source interface .*",
+    r".*controller\snot\sready.*",
 ]
 """List of known EOS errors.
 
diff --git a/anta/input_models/flow_tracking.py b/anta/input_models/flow_tracking.py
index 79676d93..5f4c25bd 100644
--- a/anta/input_models/flow_tracking.py
+++ b/anta/input_models/flow_tracking.py
@@ -47,7 +47,7 @@ class RecordExport(BaseModel):
         Inactive Timeout: 60000, Active Interval: 300000
 
         """
-        return f"Inactive Timeout: {self.on_inactive_timeout}, Active Interval: {self.on_interval}"
+        return f"Inactive Timeout: {self.on_inactive_timeout} Active Interval: {self.on_interval}"
 
 
 class Exporter(BaseModel):
diff --git a/anta/input_models/interfaces.py b/anta/input_models/interfaces.py
index 04cd4b22..c9ecedb7 100644
--- a/anta/input_models/interfaces.py
+++ b/anta/input_models/interfaces.py
@@ -9,7 +9,7 @@ from ipaddress import IPv4Interface
 from typing import Any, Literal
 from warnings import warn
 
-from pydantic import BaseModel, ConfigDict
+from pydantic import BaseModel, ConfigDict, Field
 
 from anta.custom_types import Interface, PortChannelInterface
 
@@ -42,6 +42,12 @@ class InterfaceState(BaseModel):
     """Primary IPv4 address in CIDR notation. Required field in the `VerifyInterfaceIPv4` test."""
     secondary_ips: list[IPv4Interface] | None = None
     """List of secondary IPv4 addresses in CIDR notation. Can be provided in the `VerifyInterfaceIPv4` test."""
+    auto: bool = False
+    """The auto-negotiation status of the interface. Can be provided in the `VerifyInterfacesSpeed` test."""
+    speed: float | None = Field(None, ge=1, le=1000)
+    """The speed of the interface in Gigabits per second. Valid range is 1 to 1000. Required field in the `VerifyInterfacesSpeed` test."""
+    lanes: int | None = Field(None, ge=1, le=8)
+    """The number of lanes in the interface. Valid range is 1 to 8. Can be provided in the `VerifyInterfacesSpeed` test."""
 
     def __str__(self) -> str:
         """Return a human-readable string representation of the InterfaceState for reporting.
diff --git a/anta/input_models/path_selection.py b/anta/input_models/path_selection.py
index 1c8e977c..cf06c900 100644
--- a/anta/input_models/path_selection.py
+++ b/anta/input_models/path_selection.py
@@ -25,4 +25,4 @@ class DpsPath(BaseModel):
 
     def __str__(self) -> str:
         """Return a human-readable string representation of the DpsPath for reporting."""
-        return f"Peer: {self.peer}, PathGroup: {self.path_group}, Source: {self.source_address}, Destination: {self.destination_address}"
+        return f"Peer: {self.peer} PathGroup: {self.path_group} Source: {self.source_address} Destination: {self.destination_address}"
diff --git a/anta/input_models/routing/bgp.py b/anta/input_models/routing/bgp.py
index 5c9226ec..1c9483b3 100644
--- a/anta/input_models/routing/bgp.py
+++ b/anta/input_models/routing/bgp.py
@@ -175,6 +175,10 @@ class BgpPeer(BaseModel):
     """The warning limit for the maximum routes. `0` means no warning.
 
     Optional field in the `VerifyBGPPeerRouteLimit` test. If not provided, the test will not verify the warning limit."""
+    ttl: int | None = Field(default=None, ge=1, le=255)
+    """The Time-To-Live (TTL). Required field in the `VerifyBGPPeerTtlMultiHops` test."""
+    max_ttl_hops: int | None = Field(default=None, ge=1, le=255)
+    """The Max TTL hops. Required field in the `VerifyBGPPeerTtlMultiHops` test."""
 
     def __str__(self) -> str:
         """Return a human-readable string representation of the BgpPeer for reporting."""
diff --git a/anta/input_models/snmp.py b/anta/input_models/snmp.py
index 9475d9cb..d5f14083 100644
--- a/anta/input_models/snmp.py
+++ b/anta/input_models/snmp.py
@@ -124,4 +124,4 @@ class SnmpGroup(BaseModel):
         --------
         - Group: Test_Group Version: v2c
         """
-        return f"Group: {self.group_name}, Version: {self.version}"
+        return f"Group: {self.group_name} Version: {self.version}"
diff --git a/anta/inventory/__init__.py b/anta/inventory/__init__.py
index f98c42f2..a62afacc 100644
--- a/anta/inventory/__init__.py
+++ b/anta/inventory/__init__.py
@@ -8,8 +8,9 @@ from __future__ import annotations
 import asyncio
 import logging
 from ipaddress import ip_address, ip_network
+from json import load as json_load
 from pathlib import Path
-from typing import Any, ClassVar
+from typing import Any, ClassVar, Literal
 
 from pydantic import ValidationError
 from yaml import YAMLError, safe_load
@@ -178,6 +179,7 @@ class AntaInventory(dict[str, AntaDevice]):
         password: str,
         enable_password: str | None = None,
         timeout: float | None = None,
+        file_format: Literal["yaml", "json"] = "yaml",
         *,
         enable: bool = False,
         insecure: bool = False,
@@ -199,6 +201,8 @@ class AntaInventory(dict[str, AntaDevice]):
             Enable password to use if required.
         timeout
             Timeout value in seconds for outgoing API calls.
+        file_format
+            Whether the inventory file is in JSON or YAML.
         enable
             Whether or not the commands need to be run in enable mode towards the devices.
         insecure
@@ -214,6 +218,10 @@ class AntaInventory(dict[str, AntaDevice]):
             Inventory file is not following AntaInventory Schema.
 
         """
+        if file_format not in ["yaml", "json"]:
+            message = f"'{file_format}' is not a valid format for an AntaInventory file. Only 'yaml' and 'json' are supported."
+            raise ValueError(message)
+
         inventory = AntaInventory()
         kwargs: dict[str, Any] = {
             "username": username,
@@ -224,20 +232,12 @@ class AntaInventory(dict[str, AntaDevice]):
             "insecure": insecure,
             "disable_cache": disable_cache,
         }
-        if username is None:
-            message = "'username' is required to create an AntaInventory"
-            logger.error(message)
-            raise ValueError(message)
-        if password is None:
-            message = "'password' is required to create an AntaInventory"
-            logger.error(message)
-            raise ValueError(message)
 
         try:
             filename = Path(filename)
             with filename.open(encoding="UTF-8") as file:
-                data = safe_load(file)
-        except (TypeError, YAMLError, OSError) as e:
+                data = safe_load(file) if file_format == "yaml" else json_load(file)
+        except (TypeError, YAMLError, OSError, ValueError) as e:
             message = f"Unable to parse ANTA Device Inventory file '{filename}'"
             anta_log_exception(e, message, logger)
             raise
diff --git a/anta/inventory/models.py b/anta/inventory/models.py
index 320f5276..493bad71 100644
--- a/anta/inventory/models.py
+++ b/anta/inventory/models.py
@@ -9,14 +9,26 @@ import logging
 import math
 
 import yaml
-from pydantic import BaseModel, ConfigDict, IPvAnyAddress, IPvAnyNetwork
+from pydantic import BaseModel, ConfigDict, FieldSerializationInfo, IPvAnyAddress, IPvAnyNetwork, field_serializer
 
 from anta.custom_types import Hostname, Port
 
 logger = logging.getLogger(__name__)
 
 
-class AntaInventoryHost(BaseModel):
+class AntaInventoryBaseModel(BaseModel):
+    """Pydantic BaseModel for AntaInventory objects."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    # Using check_fields as we plan to use this in the child classes
+    @field_serializer("tags", when_used="json", check_fields=False)
+    def serialize_tags(self, tags: set[str], _info: FieldSerializationInfo) -> list[str]:
+        """Make sure the tags are always dumped in the same order."""
+        return sorted(tags)
+
+
+class AntaInventoryHost(AntaInventoryBaseModel):
     """Host entry of AntaInventoryInput.
 
     Attributes
@@ -34,8 +46,6 @@ class AntaInventoryHost(BaseModel):
 
     """
 
-    model_config = ConfigDict(extra="forbid")
-
     name: str | None = None
     host: Hostname | IPvAnyAddress
     port: Port | None = None
@@ -43,7 +53,7 @@ class AntaInventoryHost(BaseModel):
     disable_cache: bool = False
 
 
-class AntaInventoryNetwork(BaseModel):
+class AntaInventoryNetwork(AntaInventoryBaseModel):
     """Network entry of AntaInventoryInput.
 
     Attributes
@@ -57,14 +67,12 @@ class AntaInventoryNetwork(BaseModel):
 
     """
 
-    model_config = ConfigDict(extra="forbid")
-
     network: IPvAnyNetwork
     tags: set[str] | None = None
     disable_cache: bool = False
 
 
-class AntaInventoryRange(BaseModel):
+class AntaInventoryRange(AntaInventoryBaseModel):
     """IP Range entry of AntaInventoryInput.
 
     Attributes
@@ -80,8 +88,6 @@ class AntaInventoryRange(BaseModel):
 
     """
 
-    model_config = ConfigDict(extra="forbid")
-
     start: IPvAnyAddress
     end: IPvAnyAddress
     tags: set[str] | None = None
@@ -109,4 +115,13 @@ class AntaInventoryInput(BaseModel):
         # This could be improved.
         # https://github.com/pydantic/pydantic/issues/1043
         # Explore if this worth using this: https://github.com/NowanIlfideme/pydantic-yaml
-        return yaml.safe_dump(yaml.safe_load(self.model_dump_json(serialize_as_any=True, exclude_unset=True)), indent=2, width=math.inf)
+        return yaml.safe_dump(yaml.safe_load(self.model_dump_json(serialize_as_any=True, exclude_unset=True)), width=math.inf)
+
+    def to_json(self) -> str:
+        """Return a JSON representation string of this model.
+
+        Returns
+        -------
+            The JSON representation string of this model.
+        """
+        return self.model_dump_json(serialize_as_any=True, exclude_unset=True, indent=2)
diff --git a/asynceapi/_constants.py b/asynceapi/_constants.py
new file mode 100644
index 00000000..2904038a
--- /dev/null
+++ b/asynceapi/_constants.py
@@ -0,0 +1,22 @@
+# Copyright (c) 2024-2025 Arista Networks, Inc.
+# Use of this source code is governed by the Apache License 2.0
+# that can be found in the LICENSE file.
+"""Constants and Enums for the asynceapi package."""
+
+from __future__ import annotations
+
+from enum import Enum
+
+
+class EapiCommandFormat(str, Enum):
+    """Enum for the eAPI command format.
+
+    NOTE: This could be updated to StrEnum when Python 3.11 is the minimum supported version in ANTA.
+    """
+
+    JSON = "json"
+    TEXT = "text"
+
+    def __str__(self) -> str:
+        """Override the __str__ method to return the value of the Enum, mimicking the behavior of StrEnum."""
+        return self.value
diff --git a/asynceapi/_errors.py b/asynceapi/_errors.py
new file mode 100644
index 00000000..321843db
--- /dev/null
+++ b/asynceapi/_errors.py
@@ -0,0 +1,36 @@
+# Copyright (c) 2024-2025 Arista Networks, Inc.
+# Use of this source code is governed by the Apache License 2.0
+# that can be found in the LICENSE file.
+"""Exceptions for the asynceapi package."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from asynceapi._models import EapiResponse
+
+
+class EapiReponseError(Exception):
+    """Exception raised when an eAPI response contains errors.
+
+    Attributes
+    ----------
+    response : EapiResponse
+        The eAPI response that contains the error.
+    """
+
+    def __init__(self, response: EapiResponse) -> None:
+        """Initialize the EapiReponseError exception."""
+        self.response = response
+
+        # Build a descriptive error message
+        message = "Error in eAPI response"
+
+        if response.error_code is not None:
+            message += f" (code: {response.error_code})"
+
+        if response.error_message is not None:
+            message += f": {response.error_message}"
+
+        super().__init__(message)
diff --git a/asynceapi/_models.py b/asynceapi/_models.py
new file mode 100644
index 00000000..0572a2f3
--- /dev/null
+++ b/asynceapi/_models.py
@@ -0,0 +1,238 @@
+# Copyright (c) 2024-2025 Arista Networks, Inc.
+# Use of this source code is governed by the Apache License 2.0
+# that can be found in the LICENSE file.
+"""Models for the asynceapi package."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from logging import getLogger
+from typing import TYPE_CHECKING, Any, Literal
+from uuid import uuid4
+
+from ._constants import EapiCommandFormat
+from ._errors import EapiReponseError
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+    from ._types import EapiComplexCommand, EapiJsonOutput, EapiSimpleCommand, EapiTextOutput, JsonRpc
+
+LOGGER = getLogger(__name__)
+
+
+# pylint: disable=too-many-instance-attributes
+@dataclass(frozen=True)
+class EapiRequest:
+    """Model for an eAPI request.
+
+    Attributes
+    ----------
+    commands : list[EapiSimpleCommand | EapiComplexCommand]
+        A list of commands to execute.
+    version : int | Literal["latest"]
+        The eAPI version to use. Defaults to "latest".
+    format : EapiCommandFormat
+        The command output format. Defaults "json".
+    timestamps : bool
+        Include timestamps in the command output. Defaults to False.
+    auto_complete : bool
+        Enable command auto-completion. Defaults to False.
+    expand_aliases : bool
+        Expand command aliases. Defaults to False.
+    stop_on_error : bool
+        Stop command execution on first error. Defaults to True.
+    id : int | str
+        The request ID. Defaults to a random hex string.
+    """
+
+    commands: list[EapiSimpleCommand | EapiComplexCommand]
+    version: int | Literal["latest"] = "latest"
+    format: EapiCommandFormat = EapiCommandFormat.JSON
+    timestamps: bool = False
+    auto_complete: bool = False
+    expand_aliases: bool = False
+    stop_on_error: bool = True
+    id: int | str = field(default_factory=lambda: uuid4().hex)
+
+    def to_jsonrpc(self) -> JsonRpc:
+        """Return the JSON-RPC dictionary payload for the request."""
+        return {
+            "jsonrpc": "2.0",
+            "method": "runCmds",
+            "params": {
+                "version": self.version,
+                "cmds": self.commands,
+                "format": self.format,
+                "timestamps": self.timestamps,
+                "autoComplete": self.auto_complete,
+                "expandAliases": self.expand_aliases,
+                "stopOnError": self.stop_on_error,
+            },
+            "id": self.id,
+        }
+
+
+@dataclass(frozen=True)
+class EapiResponse:
+    """Model for an eAPI response.
+
+    Construct an EapiResponse from a JSON-RPC response dictionary using the `from_jsonrpc` class method.
+
+    Can be iterated over to access command results in order of execution.
+
+    Attributes
+    ----------
+    request_id : str
+        The ID of the original request this response corresponds to.
+    _results : dict[int, EapiCommandResult]
+        Dictionary mapping request command indices to their respective results.
+    error_code : int | None
+        The JSON-RPC error code, if any.
+    error_message : str | None
+        The JSON-RPC error message, if any.
+    """
+
+    request_id: str
+    _results: dict[int, EapiCommandResult] = field(default_factory=dict)
+    error_code: int | None = None
+    error_message: str | None = None
+
+    @property
+    def success(self) -> bool:
+        """Return True if the response has no errors."""
+        return self.error_code is None
+
+    @property
+    def results(self) -> list[EapiCommandResult]:
+        """Get all results as a list. Results are ordered by the command indices in the request."""
+        return list(self._results.values())
+
+    def __len__(self) -> int:
+        """Return the number of results."""
+        return len(self._results)
+
+    def __iter__(self) -> Iterator[EapiCommandResult]:
+        """Enable iteration over the results. Results are yielded in the same order as provided in the request."""
+        yield from self._results.values()
+
+    @classmethod
+    def from_jsonrpc(cls, response: dict[str, Any], request: EapiRequest, *, raise_on_error: bool = False) -> EapiResponse:
+        """Build an EapiResponse from a JSON-RPC eAPI response.
+
+        Parameters
+        ----------
+        response
+            The JSON-RPC eAPI response dictionary.
+        request
+            The corresponding EapiRequest.
+        raise_on_error
+            Raise an EapiReponseError if the response contains errors, by default False.
+
+        Returns
+        -------
+        EapiResponse
+            The EapiResponse object.
+        """
+        has_error = "error" in response
+        response_data = response["error"]["data"] if has_error else response["result"]
+
+        # Handle case where we have fewer results than commands (stop_on_error=True)
+        executed_count = min(len(response_data), len(request.commands))
+
+        # Process the results we have
+        results = {}
+        for i in range(executed_count):
+            cmd = request.commands[i]
+            cmd_str = cmd["cmd"] if isinstance(cmd, dict) else cmd
+            data = response_data[i]
+
+            output = None
+            errors = []
+            success = True
+            start_time = None
+            duration = None
+
+            # Parse the output based on the data type, no output when errors are present
+            if isinstance(data, dict):
+                if "errors" in data:
+                    errors = data["errors"]
+                    success = False
+                else:
+                    output = data["output"] if request.format == EapiCommandFormat.TEXT and "output" in data else data
+
+                # Add timestamps if available
+                if request.timestamps and "_meta" in data:
+                    meta = data.pop("_meta")
+                    start_time = meta.get("execStartTime")
+                    duration = meta.get("execDuration")
+
+            elif isinstance(data, str):
+                # Handle case where eAPI returns a JSON string response (serialized JSON) for certain commands
+                try:
+                    from json import JSONDecodeError, loads
+
+                    output = loads(data)
+                except (JSONDecodeError, TypeError):
+                    # If it's not valid JSON, store as is
+                    LOGGER.warning("Invalid JSON response for command: %s. Storing as text: %s", cmd_str, data)
+                    output = data
+
+            results[i] = EapiCommandResult(
+                command=cmd_str,
+                output=output,
+                errors=errors,
+                success=success,
+                start_time=start_time,
+                duration=duration,
+            )
+
+        # If stop_on_error is True and we have an error, indicate commands not executed
+        if has_error and request.stop_on_error and executed_count < len(request.commands):
+            for i in range(executed_count, len(request.commands)):
+                cmd = request.commands[i]
+                cmd_str = cmd["cmd"] if isinstance(cmd, dict) else cmd
+                results[i] = EapiCommandResult(command=cmd_str, output=None, errors=["Command not executed due to previous error"], success=False, executed=False)
+
+        response_obj = cls(
+            request_id=response["id"],
+            _results=results,
+            error_code=response["error"]["code"] if has_error else None,
+            error_message=response["error"]["message"] if has_error else None,
+        )
+
+        if raise_on_error and has_error:
+            raise EapiReponseError(response_obj)
+
+        return response_obj
+
+
+@dataclass(frozen=True)
+class EapiCommandResult:
+    """Model for an eAPI command result.
+
+    Attributes
+    ----------
+    command : str
+        The command that was executed.
+    output : EapiJsonOutput | EapiTextOutput | None
+        The command result output. None if the command returned errors.
+    errors : list[str]
+        A list of error messages, if any.
+    success : bool
+        True if the command was successful.
+    executed : bool
+        True if the command was executed. When `stop_on_error` is True in the request, some commands may not be executed.
+    start_time : float | None
+        Command execution start time in seconds. Uses Unix epoch format. `timestamps` must be True in the request.
+    duration : float | None
+        Command execution duration in seconds. `timestamps` must be True in the request.
+    """
+
+    command: str
+    output: EapiJsonOutput | EapiTextOutput | None
+    errors: list[str] = field(default_factory=list)
+    success: bool = True
+    executed: bool = True
+    start_time: float | None = None
+    duration: float | None = None
diff --git a/asynceapi/_types.py b/asynceapi/_types.py
index 675b7715..ebebf04b 100644
--- a/asynceapi/_types.py
+++ b/asynceapi/_types.py
@@ -6,7 +6,10 @@
 from __future__ import annotations
 
 import sys
-from typing import Any, Literal
+from typing import TYPE_CHECKING, Any, Literal
+
+if TYPE_CHECKING:
+    from ._constants import EapiCommandFormat
 
 if sys.version_info >= (3, 11):
     from typing import NotRequired, TypedDict
@@ -18,11 +21,11 @@ EapiJsonOutput = dict[str, Any]
 EapiTextOutput = str
 """Type definition of an eAPI text output response."""
 EapiSimpleCommand = str
-"""Type definition of an eAPI simple command."""
+"""Type definition of an eAPI simple command. A simple command is the CLI command to run as a string."""
 
 
 class EapiComplexCommand(TypedDict):
-    """Type definition of an eAPI complex command."""
+    """Type definition of an eAPI complex command. A complex command is a dictionary with the CLI command to run with additional parameters."""
 
     cmd: str
     input: NotRequired[str]
@@ -43,7 +46,8 @@ class JsonRpcParams(TypedDict):
 
     version: NotRequired[int | Literal["latest"]]
     cmds: list[EapiSimpleCommand | EapiComplexCommand]
-    format: NotRequired[Literal["json", "text"]]
+    format: NotRequired[EapiCommandFormat]
     autoComplete: NotRequired[bool]
     expandAliases: NotRequired[bool]
     timestamps: NotRequired[bool]
+    stopOnError: NotRequired[bool]
diff --git a/asynceapi/device.py b/asynceapi/device.py
index 907ecb33..a7702daa 100644
--- a/asynceapi/device.py
+++ b/asynceapi/device.py
@@ -20,6 +20,7 @@ import httpx
 # -----------------------------------------------------------------------------
 # Private Imports
 # -----------------------------------------------------------------------------
+from ._constants import EapiCommandFormat
 from .aio_portcheck import port_check_url
 from .config_session import SessionConfig
 from .errors import EapiCommandError
@@ -133,7 +134,6 @@ class Device(httpx.AsyncClient):
         suppress_error: Literal[False] = False,
         auto_complete: bool = False,
         expand_aliases: bool = False,
-        timestamps: bool = False,
         req_id: int | str | None = None,
     ) -> EapiJsonOutput: ...
 
@@ -149,7 +149,6 @@ class Device(httpx.AsyncClient):
         suppress_error: Literal[False] = False,
         auto_complete: bool = False,
         expand_aliases: bool = False,
-        timestamps: bool = False,
         req_id: int | str | None = None,
     ) -> list[EapiJsonOutput]: ...
 
@@ -165,7 +164,6 @@ class Device(httpx.AsyncClient):
         suppress_error: Literal[False] = False,
         auto_complete: bool = False,
         expand_aliases: bool = False,
-        timestamps: bool = False,
         req_id: int | str | None = None,
     ) -> EapiTextOutput: ...
 
@@ -181,7 +179,6 @@ class Device(httpx.AsyncClient):
         suppress_error: Literal[False] = False,
         auto_complete: bool = False,
         expand_aliases: bool = False,
-        timestamps: bool = False,
         req_id: int | str | None = None,
     ) -> list[EapiTextOutput]: ...
 
@@ -197,7 +194,6 @@ class Device(httpx.AsyncClient):
         suppress_error: Literal[True],
         auto_complete: bool = False,
         expand_aliases: bool = False,
-        timestamps: bool = False,
         req_id: int | str | None = None,
     ) -> EapiJsonOutput | None: ...
 
@@ -213,7 +209,6 @@ class Device(httpx.AsyncClient):
         suppress_error: Literal[True],
         auto_complete: bool = False,
         expand_aliases: bool = False,
-        timestamps: bool = False,
         req_id: int | str | None = None,
     ) -> list[EapiJsonOutput] | None: ...
 
@@ -229,7 +224,6 @@ class Device(httpx.AsyncClient):
         suppress_error: Literal[True],
         auto_complete: bool = False,
         expand_aliases: bool = False,
-        timestamps: bool = False,
         req_id: int | str | None = None,
     ) -> EapiTextOutput | None: ...
 
@@ -245,7 +239,6 @@ class Device(httpx.AsyncClient):
         suppress_error: Literal[True],
         auto_complete: bool = False,
         expand_aliases: bool = False,
-        timestamps: bool = False,
         req_id: int | str | None = None,
     ) -> list[EapiTextOutput] | None: ...
 
@@ -260,7 +253,6 @@ class Device(httpx.AsyncClient):
         suppress_error: bool = False,
         auto_complete: bool = False,
         expand_aliases: bool = False,
-        timestamps: bool = False,
         req_id: int | str | None = None,
     ) -> EapiJsonOutput | EapiTextOutput | list[EapiJsonOutput] | list[EapiTextOutput] | None:
         """Execute one or more CLI commands.
@@ -302,8 +294,6 @@ class Device(httpx.AsyncClient):
                 For example if an alias is configured as 'sv' for 'show version'
                 then an API call with sv and the expandAliases parameter will
                 return the output of show version.
-        timestamps
-            If True, return the per-command execution time.
         req_id
             A unique identifier that will be echoed back by the switch. May be a string or number.
 
@@ -336,7 +326,6 @@ class Device(httpx.AsyncClient):
             version=version,
             auto_complete=auto_complete,
             expand_aliases=expand_aliases,
-            timestamps=timestamps,
             req_id=req_id,
         )
 
@@ -356,7 +345,6 @@ class Device(httpx.AsyncClient):
         *,
         auto_complete: bool = False,
         expand_aliases: bool = False,
-        timestamps: bool = False,
         req_id: int | str | None = None,
     ) -> JsonRpc:
         """Create the JSON-RPC command dictionary object.
@@ -387,8 +375,6 @@ class Device(httpx.AsyncClient):
                 For example if an alias is configured as 'sv' for 'show version'
                 then an API call with sv and the expandAliases parameter will
                 return the output of show version.
-        timestamps
-            If True, return the per-command execution time.
         req_id
             A unique identifier that will be echoed back by the switch. May be a string or number.
 
@@ -404,10 +390,9 @@ class Device(httpx.AsyncClient):
             "params": {
                 "version": version,
                 "cmds": commands,
-                "format": ofmt,
+                "format": EapiCommandFormat(ofmt),
                 "autoComplete": auto_complete,
                 "expandAliases": expand_aliases,
-                "timestamps": timestamps,
             },
             "id": req_id or id(self),
         }
diff --git a/docs/snippets/anta_nrfu_help.txt b/docs/snippets/anta_nrfu_help.txt
index 5801f4e3..5500389b 100644
--- a/docs/snippets/anta_nrfu_help.txt
+++ b/docs/snippets/anta_nrfu_help.txt
@@ -28,6 +28,8 @@ Options:
                                   ANTA_DISABLE_CACHE]
   -i, --inventory FILE            Path to the inventory YAML file.  [env var:
                                   ANTA_INVENTORY; required]
+  --inventory-format [yaml|json]  Format of the inventory file, either 'yaml'
+                                  or 'json'  [env var: ANTA_INVENTORY_FORMAT]
   --tags TEXT                     List of tags using comma as separator:
                                   tag1,tag2,tag3.  [env var: ANTA_TAGS]
   -c, --catalog FILE              Path to the test catalog file  [env var:
diff --git a/pyproject.toml b/pyproject.toml
index cedb9821..176ca0ff 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -271,12 +271,14 @@ commands =
   ruff format . --check
   pylint anta
   pylint tests
+  pylint asynceapi
 
 [testenv:type]
 description = Check typing
 commands =
   mypy --config-file=pyproject.toml anta
   mypy --config-file=pyproject.toml tests
+  mypy --config-file=pyproject.toml asynceapi
 
 [testenv:clean]
 description = Erase previous coverage reports


Test patch:
diff --git a/.github/workflows/code-testing.yml b/.github/workflows/code-testing.yml
index de2e6bc6..84777d68 100644
--- a/.github/workflows/code-testing.yml
+++ b/.github/workflows/code-testing.yml
@@ -43,7 +43,7 @@ jobs:
               - 'docs/**'
               - 'README.md'
   check-requirements:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     strategy:
       matrix:
         python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
@@ -62,7 +62,7 @@ jobs:
   # @gmuloc: commenting this out for now
   #missing-documentation:
   #  name: "Warning documentation is missing"
-  #  runs-on: ubuntu-20.04
+  #  runs-on: ubuntu-latest
   #  needs: [file-changes]
   #  if: needs.file-changes.outputs.cli == 'true' && needs.file-changes.outputs.docs == 'false'
   #  steps:
@@ -74,7 +74,7 @@ jobs:
   #          You should update documentation to reflect your change, or maybe not :)
   lint-python:
     name: Check the code style
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     needs: file-changes
     if: needs.file-changes.outputs.code == 'true'
     steps:
@@ -89,7 +89,7 @@ jobs:
         run: tox -e lint
   type-python:
     name: Check typing
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     needs: file-changes
     if: needs.file-changes.outputs.code == 'true'
     steps:
@@ -104,7 +104,7 @@ jobs:
         run: tox -e type
   test-python:
     name: Pytest across all supported python versions
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     needs: [lint-python, type-python]
     strategy:
       matrix:
@@ -138,7 +138,7 @@ jobs:
         run: tox
   test-documentation:
     name: Build offline documentation for testing
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     needs: [test-python]
     steps:
       - uses: actions/checkout@v4
diff --git a/anta/tests/aaa.py b/anta/tests/aaa.py
index 1dd228ea..a135fca5 100644
--- a/anta/tests/aaa.py
+++ b/anta/tests/aaa.py
@@ -51,12 +51,12 @@ class VerifyTacacsSourceIntf(AntaTest):
         """Main test function for VerifyTacacsSourceIntf."""
         command_output = self.instance_commands[0].json_output
         try:
-            if command_output["srcIntf"][self.inputs.vrf] == self.inputs.intf:
+            if (src_interface := command_output["srcIntf"][self.inputs.vrf]) == self.inputs.intf:
                 self.result.is_success()
             else:
-                self.result.is_failure(f"Wrong source-interface configured in VRF {self.inputs.vrf}")
+                self.result.is_failure(f"VRF: {self.inputs.vrf} - Source interface mismatch - Expected: {self.inputs.intf} Actual: {src_interface}")
         except KeyError:
-            self.result.is_failure(f"Source-interface {self.inputs.intf} is not configured in VRF {self.inputs.vrf}")
+            self.result.is_failure(f"VRF: {self.inputs.vrf} Source Interface: {self.inputs.intf} - Not configured")
 
 
 class VerifyTacacsServers(AntaTest):
diff --git a/anta/tests/avt.py b/anta/tests/avt.py
index 499b2505..2173510f 100644
--- a/anta/tests/avt.py
+++ b/anta/tests/avt.py
@@ -47,7 +47,7 @@ class VerifyAVTPathHealth(AntaTest):
 
         # Check if AVT is configured
         if not command_output:
-            self.result.is_failure("Adaptive virtual topology paths are not configured.")
+            self.result.is_failure("Adaptive virtual topology paths are not configured")
             return
 
         # Iterate over each VRF
@@ -61,11 +61,11 @@ class VerifyAVTPathHealth(AntaTest):
 
                     # Check the status of the AVT path
                     if not valid and not active:
-                        self.result.is_failure(f"AVT path {path} for profile {profile} in VRF {vrf} is invalid and not active.")
+                        self.result.is_failure(f"VRF: {vrf} Profile: {profile} AVT path: {path} - Invalid and not active")
                     elif not valid:
-                        self.result.is_failure(f"AVT path {path} for profile {profile} in VRF {vrf} is invalid.")
+                        self.result.is_failure(f"VRF: {vrf} Profile: {profile} AVT path: {path} - Invalid")
                     elif not active:
-                        self.result.is_failure(f"AVT path {path} for profile {profile} in VRF {vrf} is not active.")
+                        self.result.is_failure(f"VRF: {vrf} Profile: {profile} AVT path: {path} - Not active")
 
 
 class VerifyAVTSpecificPath(AntaTest):
@@ -143,7 +143,7 @@ class VerifyAVTSpecificPath(AntaTest):
                         valid = get_value(path_data, "flags.valid")
                         active = get_value(path_data, "flags.active")
                         if not all([valid, active]):
-                            self.result.is_failure(f"{avt_path} - Incorrect path {path} - Valid: {valid}, Active: {active}")
+                            self.result.is_failure(f"{avt_path} - Incorrect path {path} - Valid: {valid} Active: {active}")
 
             # If no matching path found, mark the test as failed
             if not path_found:
@@ -192,4 +192,4 @@ class VerifyAVTRole(AntaTest):
 
         # Check if the AVT role matches the expected role
         if self.inputs.role != command_output.get("role"):
-            self.result.is_failure(f"AVT role mismatch - Expected: {self.inputs.role}, Actual: {command_output.get('role')}")
+            self.result.is_failure(f"AVT role mismatch - Expected: {self.inputs.role} Actual: {command_output.get('role')}")
diff --git a/anta/tests/bfd.py b/anta/tests/bfd.py
index d33d3005..f677ae1d 100644
--- a/anta/tests/bfd.py
+++ b/anta/tests/bfd.py
@@ -159,7 +159,7 @@ class VerifyBFDPeersIntervals(AntaTest):
                 if peer.multiplier is None:
                     missing_fileds.append("multiplier")
                 if missing_fileds:
-                    msg = f"{peer} {', '.join(missing_fileds)} field(s) are missing in the input."
+                    msg = f"{peer} {', '.join(missing_fileds)} field(s) are missing in the input"
                     raise ValueError(msg)
             return bfd_peers
 
@@ -260,7 +260,7 @@ class VerifyBFDPeersHealth(AntaTest):
         # Check if any IPv4 BFD peer is configured
         ipv4_neighbors_exist = any(vrf_data["ipv4Neighbors"] for vrf_data in bfd_output["vrfs"].values())
         if not ipv4_neighbors_exist:
-            self.result.is_failure("No IPv4 BFD peers are configured for any VRF.")
+            self.result.is_failure("No IPv4 BFD peers are configured for any VRF")
             return
 
         # Iterate over IPv4 BFD peers
@@ -334,7 +334,7 @@ class VerifyBFDPeersRegProtocols(AntaTest):
             """Validate that 'protocols' field is provided in each BFD peer."""
             for peer in bfd_peers:
                 if peer.protocols is None:
-                    msg = f"{peer} 'protocols' field missing in the input."
+                    msg = f"{peer} 'protocols' field missing in the input"
                     raise ValueError(msg)
             return bfd_peers
 
diff --git a/anta/tests/configuration.py b/anta/tests/configuration.py
index 6953d476..a1c57a1b 100644
--- a/anta/tests/configuration.py
+++ b/anta/tests/configuration.py
@@ -125,4 +125,4 @@ class VerifyRunningConfigLines(AntaTest):
         if not failure_msgs:
             self.result.is_success()
         else:
-            self.result.is_failure("Following patterns were not found: " + ",".join(failure_msgs))
+            self.result.is_failure("Following patterns were not found: " + ", ".join(failure_msgs))
diff --git a/anta/tests/connectivity.py b/anta/tests/connectivity.py
index 6568d842..a5ba5fff 100644
--- a/anta/tests/connectivity.py
+++ b/anta/tests/connectivity.py
@@ -97,7 +97,7 @@ class VerifyReachability(AntaTest):
 
             # Verifies the network is unreachable.
             if not host.reachable and f"{host.repeat} received" in command.json_output["messages"][0]:
-                self.result.is_failure(f"{host} - Destination is expected to be unreachable but found reachable.")
+                self.result.is_failure(f"{host} - Destination is expected to be unreachable but found reachable")
 
 
 class VerifyLLDPNeighbors(AntaTest):
diff --git a/anta/tests/cvx.py b/anta/tests/cvx.py
index 15c8355d..25d82456 100644
--- a/anta/tests/cvx.py
+++ b/anta/tests/cvx.py
@@ -49,7 +49,7 @@ class VerifyMcsClientMounts(AntaTest):
                 continue
             mcs_mount_state_detected = True
             if (state := mount_state["state"]) != "mountStateMountComplete":
-                self.result.is_failure(f"MCS Client mount states are not valid: {state}")
+                self.result.is_failure(f"MCS Client mount states are not valid - Expected: mountStateMountComplete Actual: {state}")
 
         if not mcs_mount_state_detected:
             self.result.is_failure("MCS Client mount states are not present")
@@ -88,7 +88,12 @@ class VerifyManagementCVX(AntaTest):
         command_output = self.instance_commands[0].json_output
         self.result.is_success()
         if (cluster_state := get_value(command_output, "clusterStatus.enabled")) != self.inputs.enabled:
-            self.result.is_failure(f"Management CVX status is not valid: {cluster_state}")
+            if cluster_state is None:
+                self.result.is_failure("Management CVX status - Not configured")
+                return
+            cluster_state = "enabled" if cluster_state else "disabled"
+            self.inputs.enabled = "enabled" if self.inputs.enabled else "disabled"
+            self.result.is_failure(f"Management CVX status is not valid: Expected: {self.inputs.enabled} Actual: {cluster_state}")
 
 
 class VerifyMcsServerMounts(AntaTest):
@@ -126,13 +131,15 @@ class VerifyMcsServerMounts(AntaTest):
         mount_states = mount["mountStates"][0]
 
         if (num_path_states := len(mount_states["pathStates"])) != (expected_num := len(self.mcs_path_types)):
-            self.result.is_failure(f"Incorrect number of mount path states for {hostname} - Expected: {expected_num}, Actual: {num_path_states}")
+            self.result.is_failure(f"Host: {hostname} - Incorrect number of mount path states - Expected: {expected_num} Actual: {num_path_states}")
 
         for path in mount_states["pathStates"]:
             if (path_type := path.get("type")) not in self.mcs_path_types:
-                self.result.is_failure(f"Unexpected MCS path type for {hostname}: '{path_type}'.")
+                self.result.is_failure(f"Host: {hostname} - Unexpected MCS path type - Expected: {', '.join(self.mcs_path_types)} Actual: {path_type}")
             if (path_state := path.get("state")) != "mountStateMountComplete":
-                self.result.is_failure(f"MCS server mount state for path '{path_type}' is not valid is for {hostname}: '{path_state}'.")
+                self.result.is_failure(
+                    f"Host: {hostname} Path Type: {path_type} - MCS server mount state is not valid - Expected: mountStateMountComplete Actual:{path_state}"
+                )
 
     @AntaTest.anta_test
     def test(self) -> None:
@@ -152,18 +159,18 @@ class VerifyMcsServerMounts(AntaTest):
             mcs_mounts = [mount for mount in mounts if mount["service"] == "Mcs"]
 
             if not mounts:
-                self.result.is_failure(f"No mount status for {hostname}")
+                self.result.is_failure(f"Host: {hostname} - No mount status found")
                 continue
 
             if not mcs_mounts:
-                self.result.is_failure(f"MCS mount state not detected for {hostname}")
+                self.result.is_failure(f"Host: {hostname} - MCS mount state not detected")
             else:
                 for mount in mcs_mounts:
                     self.validate_mount_states(mount, hostname)
                     active_count += 1
 
         if active_count != self.inputs.connections_count:
-            self.result.is_failure(f"Incorrect CVX successful connections count. Expected: {self.inputs.connections_count}, Actual : {active_count}")
+            self.result.is_failure(f"Incorrect CVX successful connections count - Expected: {self.inputs.connections_count} Actual: {active_count}")
 
 
 class VerifyActiveCVXConnections(AntaTest):
@@ -200,13 +207,13 @@ class VerifyActiveCVXConnections(AntaTest):
         self.result.is_success()
 
         if not (connections := command_output.get("connections")):
-            self.result.is_failure("CVX connections are not available.")
+            self.result.is_failure("CVX connections are not available")
             return
 
         active_count = len([connection for connection in connections if connection.get("oobConnectionActive")])
 
         if self.inputs.connections_count != active_count:
-            self.result.is_failure(f"CVX active connections count. Expected: {self.inputs.connections_count}, Actual : {active_count}")
+            self.result.is_failure(f"Incorrect CVX active connections count - Expected: {self.inputs.connections_count} Actual: {active_count}")
 
 
 class VerifyCVXClusterStatus(AntaTest):
@@ -261,7 +268,7 @@ class VerifyCVXClusterStatus(AntaTest):
 
         # Check cluster role
         if (cluster_role := cluster_status.get("role")) != self.inputs.role:
-            self.result.is_failure(f"CVX Role is not valid: {cluster_role}")
+            self.result.is_failure(f"CVX Role is not valid: Expected: {self.inputs.role} Actual: {cluster_role}")
             return
 
         # Validate peer status
@@ -269,15 +276,15 @@ class VerifyCVXClusterStatus(AntaTest):
 
         # Check peer count
         if (num_of_peers := len(peer_cluster)) != (expected_num_of_peers := len(self.inputs.peer_status)):
-            self.result.is_failure(f"Unexpected number of peers {num_of_peers} vs {expected_num_of_peers}")
+            self.result.is_failure(f"Unexpected number of peers - Expected: {expected_num_of_peers} Actual: {num_of_peers}")
 
         # Check each peer
         for peer in self.inputs.peer_status:
             # Retrieve the peer status from the peer cluster
             if (eos_peer_status := get_value(peer_cluster, peer.peer_name, separator="..")) is None:
-                self.result.is_failure(f"{peer.peer_name} is not present")
+                self.result.is_failure(f"{peer.peer_name} - Not present")
                 continue
 
             # Validate the registration state of the peer
             if (peer_reg_state := eos_peer_status.get("registrationState")) != peer.registration_state:
-                self.result.is_failure(f"{peer.peer_name} registration state is not complete: {peer_reg_state}")
+                self.result.is_failure(f"{peer.peer_name} - Invalid registration state - Expected: {peer.registration_state} Actual: {peer_reg_state}")
diff --git a/anta/tests/flow_tracking.py b/anta/tests/flow_tracking.py
index 5c10b302..a115949e 100644
--- a/anta/tests/flow_tracking.py
+++ b/anta/tests/flow_tracking.py
@@ -41,10 +41,10 @@ def validate_exporters(exporters: list[dict[str, str]], tracker_info: dict[str,
         template_interval = actual_exporter_info["templateInterval"]
 
         if local_interface != exporter.local_interface:
-            failure_messages.append(f"{exporter} - Incorrect local interface - Expected: {exporter.local_interface}, Actual: {local_interface}")
+            failure_messages.append(f"{exporter} - Incorrect local interface - Expected: {exporter.local_interface} Actual: {local_interface}")
 
         if template_interval != exporter.template_interval:
-            failure_messages.append(f"{exporter} - Incorrect template interval - Expected: {exporter.template_interval}, Actual: {template_interval}")
+            failure_messages.append(f"{exporter} - Incorrect template interval - Expected: {exporter.template_interval} Actual: {template_interval}")
     return failure_messages
 
 
@@ -131,11 +131,11 @@ class VerifyHardwareFlowTrackerStatus(AntaTest):
                 act_interval = tracker_info.get("activeInterval")
                 if not all([inactive_interval == act_inactive, on_interval == act_interval]):
                     self.result.is_failure(
-                        f"{tracker}, {tracker.record_export} - Incorrect timers - Inactive Timeout: {act_inactive}, OnActive Interval: {act_interval}"
+                        f"{tracker} {tracker.record_export} - Incorrect timers - Inactive Timeout: {act_inactive} OnActive Interval: {act_interval}"
                     )
 
             # Check the input hardware tracker exporters configuration
             if tracker.exporters:
                 failure_messages = validate_exporters(tracker.exporters, tracker_info)
                 for message in failure_messages:
-                    self.result.is_failure(f"{tracker}, {message}")
+                    self.result.is_failure(f"{tracker} {message}")
diff --git a/anta/tests/hardware.py b/anta/tests/hardware.py
index f74c640b..7edd41b1 100644
--- a/anta/tests/hardware.py
+++ b/anta/tests/hardware.py
@@ -119,7 +119,7 @@ class VerifyTransceiversTemperature(AntaTest):
             if sensor["hwStatus"] != "ok":
                 self.result.is_failure(f"Sensor: {sensor['name']} - Invalid hardware state - Expected: ok Actual: {sensor['hwStatus']}")
             if sensor["alertCount"] != 0:
-                self.result.is_failure(f"Sensor: {sensor['name']} - Non-zero alert counter - Actual: {sensor['alertCount']}")
+                self.result.is_failure(f"Sensor: {sensor['name']} - Incorrect alert counter - Expected: 0 Actual: {sensor['alertCount']}")
 
 
 class VerifyEnvironmentSystemCooling(AntaTest):
@@ -267,4 +267,4 @@ class VerifyAdverseDrops(AntaTest):
         command_output = self.instance_commands[0].json_output
         total_adverse_drop = command_output.get("totalAdverseDrops", "")
         if total_adverse_drop != 0:
-            self.result.is_failure(f"Non-zero total adverse drops counter - Actual: {total_adverse_drop}")
+            self.result.is_failure(f"Incorrect total adverse drops counter - Expected: 0 Actual: {total_adverse_drop}")
diff --git a/anta/tests/interfaces.py b/anta/tests/interfaces.py
index 052bbe1c..e291bd68 100644
--- a/anta/tests/interfaces.py
+++ b/anta/tests/interfaces.py
@@ -10,14 +10,14 @@ from __future__ import annotations
 import re
 from typing import ClassVar, TypeVar
 
-from pydantic import BaseModel, Field, field_validator
+from pydantic import Field, field_validator
 from pydantic_extra_types.mac_address import MacAddress
 
-from anta.custom_types import EthernetInterface, Interface, Percent, PositiveInteger
+from anta.custom_types import Interface, Percent, PositiveInteger
 from anta.decorators import skip_on_platforms
 from anta.input_models.interfaces import InterfaceDetail, InterfaceState
 from anta.models import AntaCommand, AntaTemplate, AntaTest
-from anta.tools import custom_division, format_data, get_failed_logs, get_item, get_value
+from anta.tools import custom_division, format_data, get_item, get_value
 
 BPS_GBPS_CONVERSIONS = 1000000000
 
@@ -571,32 +571,25 @@ class VerifyL2MTU(AntaTest):
         """Default MTU we should have configured on all non-excluded interfaces. Defaults to 9214."""
         ignored_interfaces: list[str] = Field(default=["Management", "Loopback", "Vxlan", "Tunnel"])
         """A list of L2 interfaces to ignore. Defaults to ["Management", "Loopback", "Vxlan", "Tunnel"]"""
-        specific_mtu: list[dict[str, int]] = Field(default=[])
+        specific_mtu: list[dict[Interface, int]] = Field(default=[])
         """A list of dictionary of L2 interfaces with their specific MTU configured"""
 
     @AntaTest.anta_test
     def test(self) -> None:
         """Main test function for VerifyL2MTU."""
-        # Parameter to save incorrect interface settings
-        wrong_l2mtu_intf: list[dict[str, int]] = []
-        command_output = self.instance_commands[0].json_output
-        # Set list of interfaces with specific settings
-        specific_interfaces: list[str] = []
-        if self.inputs.specific_mtu:
-            for d in self.inputs.specific_mtu:
-                specific_interfaces.extend(d)
-        for interface, values in command_output["interfaces"].items():
+        self.result.is_success()
+        interface_output = self.instance_commands[0].json_output["interfaces"]
+        specific_interfaces = {key: value for details in self.inputs.specific_mtu for key, value in details.items()}
+
+        for interface, details in interface_output.items():
             catch_interface = re.findall(r"^[e,p][a-zA-Z]+[-,a-zA-Z]*\d+\/*\d*", interface, re.IGNORECASE)
-            if len(catch_interface) and catch_interface[0] not in self.inputs.ignored_interfaces and values["forwardingModel"] == "bridged":
+            if catch_interface and catch_interface not in self.inputs.ignored_interfaces and details["forwardingModel"] == "bridged":
                 if interface in specific_interfaces:
-                    wrong_l2mtu_intf.extend({interface: values["mtu"]} for custom_data in self.inputs.specific_mtu if values["mtu"] != custom_data[interface])
-                # Comparison with generic setting
-                elif values["mtu"] != self.inputs.mtu:
-                    wrong_l2mtu_intf.append({interface: values["mtu"]})
-        if wrong_l2mtu_intf:
-            self.result.is_failure(f"Some L2 interfaces do not have correct MTU configured:\n{wrong_l2mtu_intf}")
-        else:
-            self.result.is_success()
+                    if (mtu := specific_interfaces[interface]) != (act_mtu := details["mtu"]):
+                        self.result.is_failure(f"Interface: {interface} - Incorrect MTU configured - Expected: {mtu} Actual: {act_mtu}")
+
+                elif (act_mtu := details["mtu"]) != self.inputs.mtu:
+                    self.result.is_failure(f"Interface: {interface} - Incorrect MTU configured - Expected: {self.inputs.mtu} Actual: {act_mtu}")
 
 
 class VerifyInterfaceIPv4(AntaTest):
@@ -706,13 +699,10 @@ class VerifyIpVirtualRouterMac(AntaTest):
     @AntaTest.anta_test
     def test(self) -> None:
         """Main test function for VerifyIpVirtualRouterMac."""
+        self.result.is_success()
         command_output = self.instance_commands[0].json_output["virtualMacs"]
-        mac_address_found = get_item(command_output, "macAddress", self.inputs.mac_address)
-
-        if mac_address_found is None:
-            self.result.is_failure(f"IP virtual router MAC address `{self.inputs.mac_address}` is not configured.")
-        else:
-            self.result.is_success()
+        if get_item(command_output, "macAddress", self.inputs.mac_address) is None:
+            self.result.is_failure(f"IP virtual router MAC address: {self.inputs.mac_address} - Not configured")
 
 
 class VerifyInterfacesSpeed(AntaTest):
@@ -751,20 +741,19 @@ class VerifyInterfacesSpeed(AntaTest):
     class Input(AntaTest.Input):
         """Inputs for the VerifyInterfacesSpeed test."""
 
-        interfaces: list[InterfaceDetail]
-        """List of interfaces to be tested"""
-
-        class InterfaceDetail(BaseModel):
-            """Detail of an interface."""
+        interfaces: list[InterfaceState]
+        """List of interfaces with their expected state."""
+        InterfaceDetail: ClassVar[type[InterfaceDetail]] = InterfaceDetail
 
-            name: EthernetInterface
-            """The name of the interface."""
-            auto: bool
-            """The auto-negotiation status of the interface."""
-            speed: float = Field(ge=1, le=1000)
-            """The speed of the interface in Gigabits per second. Valid range is 1 to 1000."""
-            lanes: None | int = Field(None, ge=1, le=8)
-            """The number of lanes in the interface. Valid range is 1 to 8. This field is optional."""
+        @field_validator("interfaces")
+        @classmethod
+        def validate_interfaces(cls, interfaces: list[T]) -> list[T]:
+            """Validate that 'speed' field is provided in each interface."""
+            for interface in interfaces:
+                if interface.speed is None:
+                    msg = f"{interface} 'speed' field missing in the input"
+                    raise ValueError(msg)
+            return interfaces
 
     @AntaTest.anta_test
     def test(self) -> None:
@@ -774,40 +763,27 @@ class VerifyInterfacesSpeed(AntaTest):
 
         # Iterate over all the interfaces
         for interface in self.inputs.interfaces:
-            intf = interface.name
-
-            # Check if interface exists
-            if not (interface_output := get_value(command_output, f"interfaces.{intf}")):
-                self.result.is_failure(f"Interface `{intf}` is not found.")
+            if (interface_detail := get_value(command_output["interfaces"], f"{interface.name}", separator="..")) is None:
+                self.result.is_failure(f"{interface} - Not found")
                 continue
 
-            auto_negotiation = interface_output.get("autoNegotiate")
-            actual_lanes = interface_output.get("lanes")
+            # Verifies the bandwidth
+            if (speed := interface_detail.get("bandwidth")) != interface.speed * BPS_GBPS_CONVERSIONS:
+                self.result.is_failure(
+                    f"{interface} - Bandwidth mismatch - Expected: {interface.speed}Gbps Actual: {custom_division(speed, BPS_GBPS_CONVERSIONS)}Gbps"
+                )
 
-            # Collecting actual interface details
-            actual_interface_output = {
-                "auto negotiation": auto_negotiation if interface.auto is True else None,
-                "duplex mode": interface_output.get("duplex"),
-                "speed": interface_output.get("bandwidth"),
-                "lanes": actual_lanes if interface.lanes is not None else None,
-            }
+            # Verifies the duplex mode
+            if (duplex := interface_detail.get("duplex")) != "duplexFull":
+                self.result.is_failure(f"{interface} - Duplex mode mismatch - Expected: duplexFull Actual: {duplex}")
 
-            # Forming expected interface details
-            expected_interface_output = {
-                "auto negotiation": "success" if interface.auto is True else None,
-                "duplex mode": "duplexFull",
-                "speed": interface.speed * BPS_GBPS_CONVERSIONS,
-                "lanes": interface.lanes,
-            }
+            # Verifies the auto-negotiation as success if specified
+            if interface.auto and (auto_negotiation := interface_detail.get("autoNegotiate")) != "success":
+                self.result.is_failure(f"{interface} - Auto-negotiation mismatch - Expected: success Actual: {auto_negotiation}")
 
-            # Forming failure message
-            if actual_interface_output != expected_interface_output:
-                for output in [actual_interface_output, expected_interface_output]:
-                    # Convert speed to Gbps for readability
-                    if output["speed"] is not None:
-                        output["speed"] = f"{custom_division(output['speed'], BPS_GBPS_CONVERSIONS)}Gbps"
-                failed_log = get_failed_logs(expected_interface_output, actual_interface_output)
-                self.result.is_failure(f"For interface {intf}:{failed_log}\n")
+            # Verifies the communication lanes if specified
+            if interface.lanes and (lanes := interface_detail.get("lanes")) != interface.lanes:
+                self.result.is_failure(f"{interface} - Data lanes count mismatch - Expected: {interface.lanes} Actual: {lanes}")
 
 
 class VerifyLACPInterfacesStatus(AntaTest):
diff --git a/anta/tests/logging.py b/anta/tests/logging.py
index 8c234fc0..51b83aa6 100644
--- a/anta/tests/logging.py
+++ b/anta/tests/logging.py
@@ -68,7 +68,7 @@ class VerifySyslogLogging(AntaTest):
         log_output = self.instance_commands[0].text_output
 
         if "Syslog logging: enabled" not in _get_logging_states(self.logger, log_output):
-            self.result.is_failure("Syslog logging is disabled.")
+            self.result.is_failure("Syslog logging is disabled")
 
 
 class VerifyLoggingPersistent(AntaTest):
@@ -145,7 +145,7 @@ class VerifyLoggingSourceIntf(AntaTest):
         if re.search(pattern, _get_logging_states(self.logger, output)):
             self.result.is_success()
         else:
-            self.result.is_failure(f"Source-interface '{self.inputs.interface}' is not configured in VRF {self.inputs.vrf}")
+            self.result.is_failure(f"Source-interface: {self.inputs.interface} VRF: {self.inputs.vrf} - Not configured")
 
 
 class VerifyLoggingHosts(AntaTest):
diff --git a/anta/tests/mlag.py b/anta/tests/mlag.py
index 708271ca..7217d574 100644
--- a/anta/tests/mlag.py
+++ b/anta/tests/mlag.py
@@ -306,7 +306,7 @@ class VerifyMlagPrimaryPriority(AntaTest):
 
         # Check MLAG state
         if mlag_state != "primary":
-            self.result.is_failure("The device is not set as MLAG primary.")
+            self.result.is_failure("The device is not set as MLAG primary")
 
         # Check primary priority
         if primary_priority != self.inputs.primary_priority:
diff --git a/anta/tests/multicast.py b/anta/tests/multicast.py
index 64dad896..fe09c940 100644
--- a/anta/tests/multicast.py
+++ b/anta/tests/multicast.py
@@ -51,12 +51,12 @@ class VerifyIGMPSnoopingVlans(AntaTest):
         self.result.is_success()
         for vlan, enabled in self.inputs.vlans.items():
             if str(vlan) not in command_output["vlans"]:
-                self.result.is_failure(f"Supplied vlan {vlan} is not present on the device.")
+                self.result.is_failure(f"Supplied vlan {vlan} is not present on the device")
                 continue
-
+            expected_state = "enabled" if enabled else "disabled"
             igmp_state = command_output["vlans"][str(vlan)]["igmpSnoopingState"]
-            if igmp_state != "enabled" if enabled else igmp_state != "disabled":
-                self.result.is_failure(f"IGMP state for vlan {vlan} is {igmp_state}")
+            if igmp_state != expected_state:
+                self.result.is_failure(f"VLAN{vlan} - Incorrect IGMP state - Expected: {expected_state} Actual: {igmp_state}")
 
 
 class VerifyIGMPSnoopingGlobal(AntaTest):
@@ -91,5 +91,6 @@ class VerifyIGMPSnoopingGlobal(AntaTest):
         command_output = self.instance_commands[0].json_output
         self.result.is_success()
         igmp_state = command_output["igmpSnoopingState"]
-        if igmp_state != "enabled" if self.inputs.enabled else igmp_state != "disabled":
-            self.result.is_failure(f"IGMP state is not valid: {igmp_state}")
+        expected_state = "enabled" if self.inputs.enabled else "disabled"
+        if igmp_state != expected_state:
+            self.result.is_failure(f"IGMP state is not valid - Expected: {expected_state} Actual: {igmp_state}")
diff --git a/anta/tests/path_selection.py b/anta/tests/path_selection.py
index 762c9d6e..0599ecd5 100644
--- a/anta/tests/path_selection.py
+++ b/anta/tests/path_selection.py
@@ -48,7 +48,7 @@ class VerifyPathsHealth(AntaTest):
 
         # If no paths are configured for router path-selection, the test fails
         if not command_output:
-            self.result.is_failure("No path configured for router path-selection.")
+            self.result.is_failure("No path configured for router path-selection")
             return
 
         # Check the state of each path
@@ -59,12 +59,13 @@ class VerifyPathsHealth(AntaTest):
                     session = path_data["dpsSessions"]["0"]["active"]
 
                     # If the path state of any path is not 'ipsecEstablished' or 'routeResolved', the test fails
-                    if path_state not in ["ipsecEstablished", "routeResolved"]:
-                        self.result.is_failure(f"Path state for peer {peer} in path-group {group} is `{path_state}`.")
+                    expected_state = ["ipsecEstablished", "routeResolved"]
+                    if path_state not in expected_state:
+                        self.result.is_failure(f"Peer: {peer} Path Group: {group} - Invalid path state - Expected: {', '.join(expected_state)} Actual: {path_state}")
 
                     # If the telemetry state of any path is inactive, the test fails
                     elif not session:
-                        self.result.is_failure(f"Telemetry state for peer {peer} in path-group {group} is `inactive`.")
+                        self.result.is_failure(f"Peer: {peer} Path Group {group} - Telemetry state inactive")
 
 
 class VerifySpecificPath(AntaTest):
@@ -138,7 +139,7 @@ class VerifySpecificPath(AntaTest):
             path_group_details = get_value(peer_details, f"dpsGroups..{path_group}..dpsPaths", separator="..")
             # If the expected path group is not found for the peer, the test fails.
             if not path_group_details:
-                self.result.is_failure(f"{dps_path} - No DPS path found for this peer and path group.")
+                self.result.is_failure(f"{dps_path} - No DPS path found for this peer and path group")
                 continue
 
             path_data = next((path for path in path_group_details.values() if (path.get("source") == source and path.get("destination") == destination)), None)
@@ -152,6 +153,6 @@ class VerifySpecificPath(AntaTest):
 
             # If the state of the path is not 'ipsecEstablished' or 'routeResolved', or the telemetry state is 'inactive', the test fails
             if path_state not in ["ipsecEstablished", "routeResolved"]:
-                self.result.is_failure(f"{dps_path} - State is not in ipsecEstablished, routeResolved. Actual: {path_state}")
+                self.result.is_failure(f"{dps_path} - Invalid state path - Expected: ipsecEstablished, routeResolved Actual: {path_state}")
             elif not session:
                 self.result.is_failure(f"{dps_path} - Telemetry state inactive for this path")
diff --git a/anta/tests/profiles.py b/anta/tests/profiles.py
index 9f78a170..12799480 100644
--- a/anta/tests/profiles.py
+++ b/anta/tests/profiles.py
@@ -51,7 +51,7 @@ class VerifyUnifiedForwardingTableMode(AntaTest):
         if command_output["uftMode"] == str(self.inputs.mode):
             self.result.is_success()
         else:
-            self.result.is_failure(f"Not running the correct UFT mode - Expected: {self.inputs.mode}, Actual: {command_output['uftMode']}")
+            self.result.is_failure(f"Not running the correct UFT mode - Expected: {self.inputs.mode} Actual: {command_output['uftMode']}")
 
 
 class VerifyTcamProfile(AntaTest):
diff --git a/anta/tests/ptp.py b/anta/tests/ptp.py
index 5fcd8554..309871be 100644
--- a/anta/tests/ptp.py
+++ b/anta/tests/ptp.py
@@ -85,18 +85,15 @@ class VerifyPtpGMStatus(AntaTest):
     @AntaTest.anta_test
     def test(self) -> None:
         """Main test function for VerifyPtpGMStatus."""
+        self.result.is_success()
         command_output = self.instance_commands[0].json_output
 
         if (ptp_clock_summary := command_output.get("ptpClockSummary")) is None:
             self.result.is_skipped("PTP is not configured")
             return
 
-        if ptp_clock_summary["gmClockIdentity"] != self.inputs.gmid:
-            self.result.is_failure(
-                f"The device is locked to the following Grandmaster: '{ptp_clock_summary['gmClockIdentity']}', which differ from the expected one.",
-            )
-        else:
-            self.result.is_success()
+        if (act_gmid := ptp_clock_summary["gmClockIdentity"]) != self.inputs.gmid:
+            self.result.is_failure(f"The device is locked to the incorrect Grandmaster - Expected: {self.inputs.gmid} Actual: {act_gmid}")
 
 
 class VerifyPtpLockStatus(AntaTest):
diff --git a/anta/tests/routing/bgp.py b/anta/tests/routing/bgp.py
index 7522c254..c93fdea7 100644
--- a/anta/tests/routing/bgp.py
+++ b/anta/tests/routing/bgp.py
@@ -131,7 +131,7 @@ class VerifyBGPPeerCount(AntaTest):
 
             # Check if the count matches the expected count
             if address_family.num_peers != peer_count:
-                self.result.is_failure(f"{address_family} - Expected: {address_family.num_peers}, Actual: {peer_count}")
+                self.result.is_failure(f"{address_family} - Peer count mismatch - Expected: {address_family.num_peers} Actual: {peer_count}")
 
 
 class VerifyBGPPeersHealth(AntaTest):
@@ -210,7 +210,7 @@ class VerifyBGPPeersHealth(AntaTest):
             for peer in relevant_peers:
                 # Check if the BGP session is established
                 if peer["state"] != "Established":
-                    self.result.is_failure(f"{address_family} Peer: {peer['peerAddress']} - Session state is not established - State: {peer['state']}")
+                    self.result.is_failure(f"{address_family} Peer: {peer['peerAddress']} - Incorrect session state - Expected: Established Actual: {peer['state']}")
                     continue
 
                 # Check if the AFI/SAFI state is negotiated
@@ -223,7 +223,7 @@ class VerifyBGPPeersHealth(AntaTest):
                     inq = peer["peerTcpInfo"]["inputQueueLength"]
                     outq = peer["peerTcpInfo"]["outputQueueLength"]
                     if inq != 0 or outq != 0:
-                        self.result.is_failure(f"{address_family} Peer: {peer['peerAddress']} - Session has non-empty message queues - InQ: {inq}, OutQ: {outq}")
+                        self.result.is_failure(f"{address_family} Peer: {peer['peerAddress']} - Session has non-empty message queues - InQ: {inq} OutQ: {outq}")
 
 
 class VerifyBGPSpecificPeers(AntaTest):
@@ -313,7 +313,7 @@ class VerifyBGPSpecificPeers(AntaTest):
 
                 # Check if the BGP session is established
                 if peer_data["state"] != "Established":
-                    self.result.is_failure(f"{address_family} Peer: {peer_ip} - Session state is not established - State: {peer_data['state']}")
+                    self.result.is_failure(f"{address_family} Peer: {peer_ip} - Incorrect session state - Expected: Established Actual: {peer_data['state']}")
                     continue
 
                 # Check if the AFI/SAFI state is negotiated
@@ -329,7 +329,7 @@ class VerifyBGPSpecificPeers(AntaTest):
                     inq = peer_data["peerTcpInfo"]["inputQueueLength"]
                     outq = peer_data["peerTcpInfo"]["outputQueueLength"]
                     if inq != 0 or outq != 0:
-                        self.result.is_failure(f"{address_family} Peer: {peer_ip} - Session has non-empty message queues - InQ: {inq}, OutQ: {outq}")
+                        self.result.is_failure(f"{address_family} Peer: {peer_ip} - Session has non-empty message queues - InQ: {inq} OutQ: {outq}")
 
 
 class VerifyBGPPeerSession(AntaTest):
@@ -401,7 +401,7 @@ class VerifyBGPPeerSession(AntaTest):
 
             # Check if the BGP session is established
             if peer_data["state"] != "Established":
-                self.result.is_failure(f"{peer} - Session state is not established - State: {peer_data['state']}")
+                self.result.is_failure(f"{peer} - Incorrect session state - Expected: Established Actual: {peer_data['state']}")
                 continue
 
             # Check the TCP session message queues
@@ -409,7 +409,7 @@ class VerifyBGPPeerSession(AntaTest):
                 inq = peer_data["peerTcpInfo"]["inputQueueLength"]
                 outq = peer_data["peerTcpInfo"]["outputQueueLength"]
                 if inq != 0 or outq != 0:
-                    self.result.is_failure(f"{peer} - Session has non-empty message queues - InQ: {inq}, OutQ: {outq}")
+                    self.result.is_failure(f"{peer} - Session has non-empty message queues - InQ: {inq} OutQ: {outq}")
 
 
 class VerifyBGPExchangedRoutes(AntaTest):
@@ -487,7 +487,7 @@ class VerifyBGPExchangedRoutes(AntaTest):
             is_active = route_paths["active"]
             is_valid = route_paths["valid"]
             if not is_active or not is_valid:
-                return f"{peer} {route_type} route: {route} - Valid: {is_valid}, Active: {is_active}"
+                return f"{peer} {route_type} route: {route} - Valid: {is_valid} Active: {is_active}"
             return None
 
         return f"{peer} {route_type} route: {route} - Not found"
@@ -821,7 +821,7 @@ class VerifyBGPPeerMD5Auth(AntaTest):
             state = peer_data.get("state")
             md5_auth_enabled = peer_data.get("md5AuthEnabled")
             if state != "Established":
-                self.result.is_failure(f"{peer} - Session state is not established - State: {state}")
+                self.result.is_failure(f"{peer} - Incorrect session state - Expected: Established Actual: {state}")
             if not md5_auth_enabled:
                 self.result.is_failure(f"{peer} - Session does not have MD5 authentication enabled")
 
@@ -1033,9 +1033,9 @@ class VerifyBGPTimers(AntaTest):
 
             # Check BGP peer timers
             if peer_data["holdTime"] != peer.hold_time:
-                self.result.is_failure(f"{peer} - Hold time mismatch - Expected: {peer.hold_time}, Actual: {peer_data['holdTime']}")
+                self.result.is_failure(f"{peer} - Hold time mismatch - Expected: {peer.hold_time} Actual: {peer_data['holdTime']}")
             if peer_data["keepaliveTime"] != peer.keep_alive_time:
-                self.result.is_failure(f"{peer} - Keepalive time mismatch - Expected: {peer.keep_alive_time}, Actual: {peer_data['keepaliveTime']}")
+                self.result.is_failure(f"{peer} - Keepalive time mismatch - Expected: {peer.keep_alive_time} Actual: {peer_data['keepaliveTime']}")
 
 
 class VerifyBGPPeerDropStats(AntaTest):
@@ -1262,11 +1262,11 @@ class VerifyBgpRouteMaps(AntaTest):
 
             # Verify Inbound route-map
             if inbound_route_map and (inbound_map := peer_data.get("routeMapInbound", "Not Configured")) != inbound_route_map:
-                self.result.is_failure(f"{peer} - Inbound route-map mismatch - Expected: {inbound_route_map}, Actual: {inbound_map}")
+                self.result.is_failure(f"{peer} - Inbound route-map mismatch - Expected: {inbound_route_map} Actual: {inbound_map}")
 
             # Verify Outbound route-map
             if outbound_route_map and (outbound_map := peer_data.get("routeMapOutbound", "Not Configured")) != outbound_route_map:
-                self.result.is_failure(f"{peer} - Outbound route-map mismatch - Expected: {outbound_route_map}, Actual: {outbound_map}")
+                self.result.is_failure(f"{peer} - Outbound route-map mismatch - Expected: {outbound_route_map} Actual: {outbound_map}")
 
 
 class VerifyBGPPeerRouteLimit(AntaTest):
@@ -1340,11 +1340,11 @@ class VerifyBGPPeerRouteLimit(AntaTest):
 
             # Verify maximum routes
             if (actual_maximum_routes := peer_data.get("maxTotalRoutes", "Not Found")) != maximum_routes:
-                self.result.is_failure(f"{peer} - Maximum routes mismatch - Expected: {maximum_routes}, Actual: {actual_maximum_routes}")
+                self.result.is_failure(f"{peer} - Maximum routes mismatch - Expected: {maximum_routes} Actual: {actual_maximum_routes}")
 
             # Verify warning limit if provided. By default, EOS does not have a warning limit and `totalRoutesWarnLimit` is not present in the output.
             if warning_limit is not None and (actual_warning_limit := peer_data.get("totalRoutesWarnLimit", 0)) != warning_limit:
-                self.result.is_failure(f"{peer} - Maximum routes warning limit mismatch - Expected: {warning_limit}, Actual: {actual_warning_limit}")
+                self.result.is_failure(f"{peer} - Maximum routes warning limit mismatch - Expected: {warning_limit} Actual: {actual_warning_limit}")
 
 
 class VerifyBGPPeerGroup(AntaTest):
@@ -1487,7 +1487,7 @@ class VerifyBGPPeerSessionRibd(AntaTest):
 
             # Check if the BGP session is established
             if peer_data["state"] != "Established":
-                self.result.is_failure(f"{peer} - Session state is not established - State: {peer_data['state']}")
+                self.result.is_failure(f"{peer} - Incorrect session state - Expected: Established Actual: {peer_data['state']}")
                 continue
 
             # Check the TCP session message queues
@@ -1495,7 +1495,7 @@ class VerifyBGPPeerSessionRibd(AntaTest):
                 inq_stat = peer_data["peerTcpInfo"]["inputQueueLength"]
                 outq_stat = peer_data["peerTcpInfo"]["outputQueueLength"]
                 if inq_stat != 0 or outq_stat != 0:
-                    self.result.is_failure(f"{peer} - Session has non-empty message queues - InQ: {inq_stat}, OutQ: {outq_stat}")
+                    self.result.is_failure(f"{peer} - Session has non-empty message queues - InQ: {inq_stat} OutQ: {outq_stat}")
 
 
 class VerifyBGPPeersHealthRibd(AntaTest):
@@ -1548,14 +1548,14 @@ class VerifyBGPPeersHealthRibd(AntaTest):
             for peer in peer_list:
                 # Check if the BGP session is established
                 if peer["state"] != "Established":
-                    self.result.is_failure(f"Peer: {peer['peerAddress']} VRF: {vrf} - Session state is not established - State: {peer['state']}")
+                    self.result.is_failure(f"Peer: {peer['peerAddress']} VRF: {vrf} - Incorrect session state - Expected: Established Actual: {peer['state']}")
                     continue
 
                 # Check the TCP session message queues
                 inq = peer["peerTcpInfo"]["inputQueueLength"]
                 outq = peer["peerTcpInfo"]["outputQueueLength"]
                 if self.inputs.check_tcp_queues and (inq != 0 or outq != 0):
-                    self.result.is_failure(f"Peer: {peer['peerAddress']} VRF: {vrf} - Session has non-empty message queues - InQ: {inq}, OutQ: {outq}")
+                    self.result.is_failure(f"Peer: {peer['peerAddress']} VRF: {vrf} - Session has non-empty message queues - InQ: {inq} OutQ: {outq}")
 
 
 class VerifyBGPNlriAcceptance(AntaTest):
@@ -1630,7 +1630,7 @@ class VerifyBGPNlriAcceptance(AntaTest):
                     self.result.is_failure(f"{peer} - {capability} not negotiated")
 
                 if (received := capability_status.get("nlrisReceived")) != (accepted := capability_status.get("nlrisAccepted")):
-                    self.result.is_failure(f"{peer} AFI/SAFI: {capability} - some NLRI were filtered or rejected - Accepted: {accepted} Received: {received}")
+                    self.result.is_failure(f"{peer} AFI/SAFI: {capability} - Some NLRI were filtered or rejected - Accepted: {accepted} Received: {received}")
 
 
 class VerifyBGPRoutePaths(AntaTest):
@@ -1695,7 +1695,7 @@ class VerifyBGPRoutePaths(AntaTest):
         for route in self.inputs.route_entries:
             # Verify if the prefix exists in BGP table
             if not (bgp_routes := get_value(self.instance_commands[0].json_output, f"vrfs..{route.vrf}..bgpRouteEntries..{route.prefix}", separator="..")):
-                self.result.is_failure(f"{route} - prefix not found")
+                self.result.is_failure(f"{route} - Prefix not found")
                 continue
 
             # Iterating over each path.
@@ -1703,7 +1703,7 @@ class VerifyBGPRoutePaths(AntaTest):
                 nexthop = str(path.nexthop)
                 origin = path.origin
                 if not (route_path := get_item(bgp_routes["bgpRoutePaths"], "nextHop", nexthop)):
-                    self.result.is_failure(f"{route} {path} - path not found")
+                    self.result.is_failure(f"{route} {path} - Path not found")
                     continue
 
                 if (actual_origin := get_value(route_path, "routeType.origin")) != origin:
@@ -1773,14 +1773,14 @@ class VerifyBGPRouteECMP(AntaTest):
         for route in self.inputs.route_entries:
             # Verify if the prefix exists in BGP table.
             if not (bgp_route_entry := get_value(self.instance_commands[0].json_output, f"vrfs..{route.vrf}..bgpRouteEntries..{route.prefix}", separator="..")):
-                self.result.is_failure(f"{route} - prefix not found in BGP table")
+                self.result.is_failure(f"{route} - Prefix not found in BGP table")
                 continue
 
             route_paths = iter(bgp_route_entry["bgpRoutePaths"])
             head = next(route_paths, None)
             # Verify if the active ECMP head exists.
             if head is None or not all(head["routeType"][key] for key in ["valid", "active", "ecmpHead"]):
-                self.result.is_failure(f"{route} - valid and active ECMP head not found")
+                self.result.is_failure(f"{route} - Valid and active ECMP head not found")
                 continue
 
             bgp_nexthops = {head["nextHop"]}
@@ -1788,17 +1788,17 @@ class VerifyBGPRouteECMP(AntaTest):
 
             # Verify ECMP count is correct.
             if len(bgp_nexthops) != route.ecmp_count:
-                self.result.is_failure(f"{route} - ECMP count mismatch - Expected: {route.ecmp_count}, Actual: {len(bgp_nexthops)}")
+                self.result.is_failure(f"{route} - ECMP count mismatch - Expected: {route.ecmp_count} Actual: {len(bgp_nexthops)}")
                 continue
 
             # Verify if the prefix exists in routing table.
             if not (route_entry := get_value(self.instance_commands[1].json_output, f"vrfs..{route.vrf}..routes..{route.prefix}", separator="..")):
-                self.result.is_failure(f"{route} - prefix not found in routing table")
+                self.result.is_failure(f"{route} - Prefix not found in routing table")
                 continue
 
             # Verify BGP and RIB nexthops are same.
             if len(bgp_nexthops) != len(route_entry["vias"]):
-                self.result.is_failure(f"{route} - Nexthops count mismatch - BGP: {len(bgp_nexthops)}, RIB: {len(route_entry['vias'])}")
+                self.result.is_failure(f"{route} - Nexthops count mismatch - BGP: {len(bgp_nexthops)} RIB: {len(route_entry['vias'])}")
 
 
 class VerifyBGPRedistribution(AntaTest):
@@ -1893,3 +1893,83 @@ class VerifyBGPRedistribution(AntaTest):
                     failure_msg = self._validate_redistribute_route(str(vrf_data), str(address_family), afi_safi_configs, route_info)
                     for msg in failure_msg:
                         self.result.is_failure(msg)
+
+
+class VerifyBGPPeerTtlMultiHops(AntaTest):
+    """Verifies BGP TTL and max-ttl-hops count for BGP IPv4 peer(s).
+
+    This test performs the following checks for each specified BGP peer:
+
+      1. Verifies the specified BGP peer exists in the BGP configuration.
+      2. Verifies the TTL and max-ttl-hops attribute matches the expected value.
+
+    Expected Results
+    ----------------
+    * Success: The test will pass if all specified peers exist with TTL and max-ttl-hops attributes matching the expected values.
+    * Failure: If any of the following occur:
+        - A specified BGP peer is not found.
+        - A TTL or max-ttl-hops attribute doesn't match the expected value for any peer.
+
+    Examples
+    --------
+    ```yaml
+    anta.tests.routing:
+      bgp:
+        - VerifyBGPPeerTtlMultiHops:
+            bgp_peers:
+                - peer_address: 172.30.11.1
+                  vrf: default
+                  ttl: 3
+                  max_ttl_hops: 3
+                - peer_address: 172.30.11.2
+                  vrf: test
+                  ttl: 30
+                  max_ttl_hops: 30
+    ```
+    """
+
+    categories: ClassVar[list[str]] = ["bgp"]
+    commands: ClassVar[list[AntaCommand | AntaTemplate]] = [AntaCommand(command="show ip bgp neighbors vrf all", revision=2)]
+
+    class Input(AntaTest.Input):
+        """Input model for the VerifyBGPPeerTtlMultiHops test."""
+
+        bgp_peers: list[BgpPeer]
+        """List of IPv4 peer(s)."""
+
+        @field_validator("bgp_peers")
+        @classmethod
+        def validate_bgp_peers(cls, bgp_peers: list[BgpPeer]) -> list[BgpPeer]:
+            """Validate that 'ttl' and 'max_ttl_hops' field is provided in each BGP peer."""
+            for peer in bgp_peers:
+                if peer.ttl is None:
+                    msg = f"{peer} 'ttl' field missing in the input"
+                    raise ValueError(msg)
+                if peer.max_ttl_hops is None:
+                    msg = f"{peer} 'max_ttl_hops' field missing in the input"
+                    raise ValueError(msg)
+
+            return bgp_peers
+
+    @AntaTest.anta_test
+    def test(self) -> None:
+        """Main test function for VerifyBGPPeerTtlMultiHops."""
+        self.result.is_success()
+        command_output = self.instance_commands[0].json_output
+
+        for peer in self.inputs.bgp_peers:
+            peer_ip = str(peer.peer_address)
+            peer_list = get_value(command_output, f"vrfs.{peer.vrf}.peerList", default=[])
+
+            # Check if the peer is found
+            if (peer_details := get_item(peer_list, "peerAddress", peer_ip)) is None:
+                self.result.is_failure(f"{peer} - Not found")
+                continue
+
+            # Verify if the TTL duration matches the expected value.
+            if peer_details.get("ttl") != peer.ttl:
+                self.result.is_failure(f"{peer} - TTL mismatch - Expected: {peer.ttl} Actual: {peer_details.get('ttl')}")
+
+            # Verify if the max-ttl-hops time matches the expected value.
+            if peer_details.get("maxTtlHops") != peer.max_ttl_hops:
+                self.result.is_failure(f"{peer} - Max TTL Hops mismatch - Expected: {peer.max_ttl_hops} Actual: {peer_details.get('maxTtlHops')}")
diff --git a/anta/tests/routing/generic.py b/anta/tests/routing/generic.py
index 338aa615..066d39ce 100644
--- a/anta/tests/routing/generic.py
+++ b/anta/tests/routing/generic.py
@@ -63,7 +63,7 @@ class VerifyRoutingProtocolModel(AntaTest):
         if configured_model == operating_model == self.inputs.model:
             self.result.is_success()
         else:
-            self.result.is_failure(f"routing model is misconfigured: configured: {configured_model} - operating: {operating_model} - expected: {self.inputs.model}")
+            self.result.is_failure(f"Routing model is misconfigured - Expected: {self.inputs.model} Actual: {operating_model}")
 
 
 class VerifyRoutingTableSize(AntaTest):
@@ -112,7 +112,9 @@ class VerifyRoutingTableSize(AntaTest):
         if self.inputs.minimum <= total_routes <= self.inputs.maximum:
             self.result.is_success()
         else:
-            self.result.is_failure(f"Routing table has {total_routes} routes, outside the range of {self.inputs.minimum} to {self.inputs.maximum}")
+            self.result.is_failure(
+                f"Routing table routes are outside the routes range - Expected: {self.inputs.minimum} <= to >= {self.inputs.maximum} Actual: {total_routes}"
+            )
 
 
 class VerifyRoutingTableEntry(AntaTest):
@@ -341,7 +343,7 @@ class VerifyIPv4RouteNextHops(AntaTest):
 
             if entry.strict and expected_nexthops != actual_nexthops:
                 exp_nexthops = ", ".join(expected_nexthops)
-                self.result.is_failure(f"{entry} - List of next-hops not matching - Expected: {exp_nexthops} - Actual: {', '.join(actual_nexthops)}")
+                self.result.is_failure(f"{entry} - List of next-hops not matching - Expected: {exp_nexthops} Actual: {', '.join(actual_nexthops)}")
                 continue
 
             for nexthop in entry.nexthops:
diff --git a/anta/tests/routing/isis.py b/anta/tests/routing/isis.py
index 70574e51..6a73e40a 100644
--- a/anta/tests/routing/isis.py
+++ b/anta/tests/routing/isis.py
@@ -65,9 +65,11 @@ class VerifyISISNeighborState(AntaTest):
                 if not neighbors:
                     continue
                 no_neighbor = False
-                interfaces = [adj["interfaceName"] for neighbor in neighbors.values() for adj in neighbor["adjacencies"] if adj["state"] != "up"]
+                interfaces = [(adj["interfaceName"], adj["state"]) for neighbor in neighbors.values() for adj in neighbor["adjacencies"] if adj["state"] != "up"]
                 for interface in interfaces:
-                    self.result.is_failure(f"Instance: {isis_instance} VRF: {vrf} Interface: {interface} - Adjacency down")
+                    self.result.is_failure(
+                        f"Instance: {isis_instance} VRF: {vrf} Interface: {interface[0]} - Incorrect adjacency state - Expected: up Actual: {interface[1]}"
+                    )
 
         if no_neighbor:
             self.result.is_skipped("No IS-IS neighbor detected")
diff --git a/anta/tests/security.py b/anta/tests/security.py
index 12a3faee..ba8f2cb5 100644
--- a/anta/tests/security.py
+++ b/anta/tests/security.py
@@ -43,7 +43,7 @@ class VerifySSHStatus(AntaTest):
         try:
             line = next(line for line in command_output.split("\n") if line.startswith("SSHD status"))
         except StopIteration:
-            self.result.is_failure("Could not find SSH status in returned output.")
+            self.result.is_failure("Could not find SSH status in returned output")
             return
         status = line.split()[-1]
 
@@ -86,19 +86,18 @@ class VerifySSHIPv4Acl(AntaTest):
     @AntaTest.anta_test
     def test(self) -> None:
         """Main test function for VerifySSHIPv4Acl."""
+        self.result.is_success()
         command_output = self.instance_commands[0].json_output
         ipv4_acl_list = command_output["ipAclList"]["aclList"]
         ipv4_acl_number = len(ipv4_acl_list)
         if ipv4_acl_number != self.inputs.number:
-            self.result.is_failure(f"Expected {self.inputs.number} SSH IPv4 ACL(s) in vrf {self.inputs.vrf} but got {ipv4_acl_number}")
+            self.result.is_failure(f"VRF: {self.inputs.vrf} - SSH IPv4 ACL(s) count mismatch - Expected: {self.inputs.number} Actual: {ipv4_acl_number}")
             return
 
         not_configured_acl = [acl["name"] for acl in ipv4_acl_list if self.inputs.vrf not in acl["configuredVrfs"] or self.inputs.vrf not in acl["activeVrfs"]]
 
         if not_configured_acl:
-            self.result.is_failure(f"SSH IPv4 ACL(s) not configured or active in vrf {self.inputs.vrf}: {', '.join(not_configured_acl)}")
-        else:
-            self.result.is_success()
+            self.result.is_failure(f"VRF: {self.inputs.vrf} - Following SSH IPv4 ACL(s) not configured or active: {', '.join(not_configured_acl)}")
 
 
 class VerifySSHIPv6Acl(AntaTest):
@@ -134,19 +133,18 @@ class VerifySSHIPv6Acl(AntaTest):
     @AntaTest.anta_test
     def test(self) -> None:
         """Main test function for VerifySSHIPv6Acl."""
+        self.result.is_success()
         command_output = self.instance_commands[0].json_output
         ipv6_acl_list = command_output["ipv6AclList"]["aclList"]
         ipv6_acl_number = len(ipv6_acl_list)
         if ipv6_acl_number != self.inputs.number:
-            self.result.is_failure(f"Expected {self.inputs.number} SSH IPv6 ACL(s) in vrf {self.inputs.vrf} but got {ipv6_acl_number}")
+            self.result.is_failure(f"VRF: {self.inputs.vrf} - SSH IPv6 ACL(s) count mismatch - Expected: {self.inputs.number} Actual: {ipv6_acl_number}")
             return
 
         not_configured_acl = [acl["name"] for acl in ipv6_acl_list if self.inputs.vrf not in acl["configuredVrfs"] or self.inputs.vrf not in acl["activeVrfs"]]
 
         if not_configured_acl:
-            self.result.is_failure(f"SSH IPv6 ACL(s) not configured or active in vrf {self.inputs.vrf}: {', '.join(not_configured_acl)}")
-        else:
-            self.result.is_success()
+            self.result.is_failure(f"VRF: {self.inputs.vrf} - Following SSH IPv6 ACL(s) not configured or active: {', '.join(not_configured_acl)}")
 
 
 class VerifyTelnetStatus(AntaTest):
@@ -283,13 +281,13 @@ class VerifyAPIIPv4Acl(AntaTest):
         ipv4_acl_list = command_output["ipAclList"]["aclList"]
         ipv4_acl_number = len(ipv4_acl_list)
         if ipv4_acl_number != self.inputs.number:
-            self.result.is_failure(f"Expected {self.inputs.number} eAPI IPv4 ACL(s) in vrf {self.inputs.vrf} but got {ipv4_acl_number}")
+            self.result.is_failure(f"VRF: {self.inputs.vrf} - eAPI IPv4 ACL(s) count mismatch - Expected: {self.inputs.number} Actual: {ipv4_acl_number}")
             return
 
         not_configured_acl = [acl["name"] for acl in ipv4_acl_list if self.inputs.vrf not in acl["configuredVrfs"] or self.inputs.vrf not in acl["activeVrfs"]]
 
         if not_configured_acl:
-            self.result.is_failure(f"eAPI IPv4 ACL(s) not configured or active in vrf {self.inputs.vrf}: {', '.join(not_configured_acl)}")
+            self.result.is_failure(f"VRF: {self.inputs.vrf} - Following eAPI IPv4 ACL(s) not configured or active: {', '.join(not_configured_acl)}")
         else:
             self.result.is_success()
 
@@ -331,13 +329,13 @@ class VerifyAPIIPv6Acl(AntaTest):
         ipv6_acl_list = command_output["ipv6AclList"]["aclList"]
         ipv6_acl_number = len(ipv6_acl_list)
         if ipv6_acl_number != self.inputs.number:
-            self.result.is_failure(f"Expected {self.inputs.number} eAPI IPv6 ACL(s) in vrf {self.inputs.vrf} but got {ipv6_acl_number}")
+            self.result.is_failure(f"VRF: {self.inputs.vrf} - eAPI IPv6 ACL(s) count mismatch - Expected: {self.inputs.number} Actual: {ipv6_acl_number}")
             return
 
         not_configured_acl = [acl["name"] for acl in ipv6_acl_list if self.inputs.vrf not in acl["configuredVrfs"] or self.inputs.vrf not in acl["activeVrfs"]]
 
         if not_configured_acl:
-            self.result.is_failure(f"eAPI IPv6 ACL(s) not configured or active in vrf {self.inputs.vrf}: {', '.join(not_configured_acl)}")
+            self.result.is_failure(f"VRF: {self.inputs.vrf} - Following eAPI IPv6 ACL(s) not configured or active: {', '.join(not_configured_acl)}")
         else:
             self.result.is_success()
 
@@ -474,14 +472,15 @@ class VerifyBannerLogin(AntaTest):
     @AntaTest.anta_test
     def test(self) -> None:
         """Main test function for VerifyBannerLogin."""
-        login_banner = self.instance_commands[0].json_output["loginBanner"]
+        self.result.is_success()
+        if not (login_banner := self.instance_commands[0].json_output["loginBanner"]):
+            self.result.is_failure("Login banner is not configured")
+            return
 
         # Remove leading and trailing whitespaces from each line
         cleaned_banner = "\n".join(line.strip() for line in self.inputs.login_banner.split("\n"))
         if login_banner != cleaned_banner:
-            self.result.is_failure(f"Expected `{cleaned_banner}` as the login banner, but found `{login_banner}` instead.")
-        else:
-            self.result.is_success()
+            self.result.is_failure(f"Incorrect login banner configured - Expected: {cleaned_banner} Actual: {login_banner}")
 
 
 class VerifyBannerMotd(AntaTest):
@@ -516,14 +515,15 @@ class VerifyBannerMotd(AntaTest):
     @AntaTest.anta_test
     def test(self) -> None:
         """Main test function for VerifyBannerMotd."""
-        motd_banner = self.instance_commands[0].json_output["motd"]
+        self.result.is_success()
+        if not (motd_banner := self.instance_commands[0].json_output["motd"]):
+            self.result.is_failure("MOTD banner is not configured")
+            return
 
         # Remove leading and trailing whitespaces from each line
         cleaned_banner = "\n".join(line.strip() for line in self.inputs.motd_banner.split("\n"))
         if motd_banner != cleaned_banner:
-            self.result.is_failure(f"Expected `{cleaned_banner}` as the motd banner, but found `{motd_banner}` instead.")
-        else:
-            self.result.is_success()
+            self.result.is_failure(f"Incorrect MOTD banner configured - Expected: {cleaned_banner} Actual: {motd_banner}")
 
 
 class VerifyIPv4ACL(AntaTest):
@@ -624,12 +624,11 @@ class VerifyIPSecConnHealth(AntaTest):
     def test(self) -> None:
         """Main test function for VerifyIPSecConnHealth."""
         self.result.is_success()
-        failure_conn = []
         command_output = self.instance_commands[0].json_output["connections"]
 
         # Check if IP security connection is configured
         if not command_output:
-            self.result.is_failure("No IPv4 security connection configured.")
+            self.result.is_failure("No IPv4 security connection configured")
             return
 
         # Iterate over all ipsec connections
@@ -639,10 +638,7 @@ class VerifyIPSecConnHealth(AntaTest):
                 source = conn_data.get("saddr")
                 destination = conn_data.get("daddr")
                 vrf = conn_data.get("tunnelNs")
-                failure_conn.append(f"source:{source} destination:{destination} vrf:{vrf}")
-        if failure_conn:
-            failure_msg = "\n".join(failure_conn)
-            self.result.is_failure(f"The following IPv4 security connections are not established:\n{failure_msg}.")
+                self.result.is_failure(f"Source: {source} Destination: {destination} VRF: {vrf} - IPv4 security connection not established")
 
 
 class VerifySpecificIPSecConn(AntaTest):
@@ -717,9 +713,7 @@ class VerifySpecificIPSecConn(AntaTest):
                     if state != "Established":
                         source = conn_data.get("saddr")
                         destination = conn_data.get("daddr")
-                        self.result.is_failure(
-                            f"{input_peer} Source: {source} Destination: {destination} - Connection down - Expected: Established, Actual: {state}"
-                        )
+                        self.result.is_failure(f"{input_peer} Source: {source} Destination: {destination} - Connection down - Expected: Established Actual: {state}")
                 continue
 
             # Create a dictionary of existing connections for faster lookup
@@ -734,7 +728,7 @@ class VerifySpecificIPSecConn(AntaTest):
                 if (source_input, destination_input, vrf) in existing_connections:
                     existing_state = existing_connections[(source_input, destination_input, vrf)]
                     if existing_state != "Established":
-                        failure = f"Expected: Established, Actual: {existing_state}"
+                        failure = f"Expected: Established Actual: {existing_state}"
                         self.result.is_failure(f"{input_peer} Source: {source_input} Destination: {destination_input} - Connection down - {failure}")
                 else:
                     self.result.is_failure(f"{input_peer} Source: {source_input} Destination: {destination_input} - Connection not found.")
@@ -766,6 +760,6 @@ class VerifyHardwareEntropy(AntaTest):
 
         # Check if hardware entropy generation is enabled.
         if not command_output.get("hardwareEntropyEnabled"):
-            self.result.is_failure("Hardware entropy generation is disabled.")
+            self.result.is_failure("Hardware entropy generation is disabled")
         else:
             self.result.is_success()
diff --git a/anta/tests/snmp.py b/anta/tests/snmp.py
index 09bdd768..1d022522 100644
--- a/anta/tests/snmp.py
+++ b/anta/tests/snmp.py
@@ -179,7 +179,7 @@ class VerifySnmpLocation(AntaTest):
         self.result.is_success()
         # Verifies the SNMP location is configured.
         if not (location := get_value(self.instance_commands[0].json_output, "location.location")):
-            self.result.is_failure("SNMP location is not configured.")
+            self.result.is_failure("SNMP location is not configured")
             return
 
         # Verifies the expected SNMP location.
@@ -219,7 +219,7 @@ class VerifySnmpContact(AntaTest):
         self.result.is_success()
         # Verifies the SNMP contact is configured.
         if not (contact := get_value(self.instance_commands[0].json_output, "contact.contact")):
-            self.result.is_failure("SNMP contact is not configured.")
+            self.result.is_failure("SNMP contact is not configured")
             return
 
         # Verifies the expected SNMP contact.
@@ -267,7 +267,7 @@ class VerifySnmpPDUCounters(AntaTest):
 
         # Verify SNMP PDU counters.
         if not (pdu_counters := get_value(command_output, "counters")):
-            self.result.is_failure("SNMP counters not found.")
+            self.result.is_failure("SNMP counters not found")
             return
 
         # In case SNMP PDUs not provided, It will check all the update error counters.
@@ -561,7 +561,7 @@ class VerifySnmpNotificationHost(AntaTest):
 
         # If SNMP is not configured, test fails.
         if not (snmp_hosts := get_value(self.instance_commands[0].json_output, "hosts")):
-            self.result.is_failure("No SNMP host is configured.")
+            self.result.is_failure("No SNMP host is configured")
             return
 
         for host in self.inputs.notification_hosts:
@@ -584,22 +584,22 @@ class VerifySnmpNotificationHost(AntaTest):
 
             # If actual notification type does not match the expected value, test fails.
             if notification_type != (actual_notification_type := get_value(host_details, "notificationType", default_value)):
-                self.result.is_failure(f"{host} - Incorrect notification type - Expected: {notification_type}, Actual: {actual_notification_type}")
+                self.result.is_failure(f"{host} - Incorrect notification type - Expected: {notification_type} Actual: {actual_notification_type}")
 
             # If actual UDP port does not match the expected value, test fails.
             if udp_port != (actual_udp_port := get_value(host_details, "port", default_value)):
-                self.result.is_failure(f"{host} - Incorrect UDP port - Expected: {udp_port}, Actual: {actual_udp_port}")
+                self.result.is_failure(f"{host} - Incorrect UDP port - Expected: {udp_port} Actual: {actual_udp_port}")
 
             user_found = user != (actual_user := get_value(host_details, "v3Params.user", default_value))
             version_user_check = (version == "v3", user_found)
 
             # If SNMP protocol version is v1 or v2c and actual community string does not match the expected value, test fails.
             if version in ["v1", "v2c"] and community_string != (actual_community_string := get_value(host_details, "v1v2cParams.communityString", default_value)):
-                self.result.is_failure(f"{host} Version: {version} - Incorrect community string - Expected: {community_string}, Actual: {actual_community_string}")
+                self.result.is_failure(f"{host} Version: {version} - Incorrect community string - Expected: {community_string} Actual: {actual_community_string}")
 
             # If SNMP protocol version is v3 and actual user does not match the expected value, test fails.
             elif all(version_user_check):
-                self.result.is_failure(f"{host} Version: {version} - Incorrect user - Expected: {user}, Actual: {actual_user}")
+                self.result.is_failure(f"{host} Version: {version} - Incorrect user - Expected: {user} Actual: {actual_user}")
 
 
 class VerifySnmpSourceInterface(AntaTest):
@@ -717,10 +717,10 @@ class VerifySnmpGroup(AntaTest):
                 if group_details.get(f"{view_type}View") == "":
                     self.result.is_failure(f"{group} View: {view_type} - Not configured")
                 elif (act_view := group_details.get(f"{view_type}View")) != expected_view:
-                    self.result.is_failure(f"{group} - Incorrect {view_type.title()} view - Expected: {expected_view}, Actual: {act_view}")
+                    self.result.is_failure(f"{group} - Incorrect {view_type.title()} view - Expected: {expected_view} Actual: {act_view}")
                 elif not group_details.get(f"{view_type}ViewConfig"):
-                    self.result.is_failure(f"{group}, {view_type.title()} View: {expected_view} - Not configured")
+                    self.result.is_failure(f"{group} {view_type.title()} View: {expected_view} - Not configured")
 
             # For version v3, verify that the security model aligns with the expected value.
             if group.version == "v3" and (actual_auth := group_details.get("secModel")) != group.authentication:
-                self.result.is_failure(f"{group} - Incorrect security model - Expected: {group.authentication}, Actual: {actual_auth}")
+                self.result.is_failure(f"{group} - Incorrect security model - Expected: {group.authentication} Actual: {actual_auth}")
diff --git a/anta/tests/software.py b/anta/tests/software.py
index 84228ca3..82517604 100644
--- a/anta/tests/software.py
+++ b/anta/tests/software.py
@@ -131,4 +131,4 @@ class VerifyEOSExtensions(AntaTest):
         if installed_extensions != boot_extensions:
             str_installed_extensions = ", ".join(installed_extensions) if installed_extensions else "Not found"
             str_boot_extensions = ", ".join(boot_extensions) if boot_extensions else "Not found"
-            self.result.is_failure(f"EOS extensions mismatch - Installed: {str_installed_extensions}, Configured: {str_boot_extensions}")
+            self.result.is_failure(f"EOS extensions mismatch - Installed: {str_installed_extensions} Configured: {str_boot_extensions}")
diff --git a/anta/tests/stp.py b/anta/tests/stp.py
index 40f72c18..47dfb9f4 100644
--- a/anta/tests/stp.py
+++ b/anta/tests/stp.py
@@ -281,7 +281,7 @@ class VerifyStpTopologyChanges(AntaTest):
 
         # Verify the STP topology(s).
         if not stp_topologies:
-            self.result.is_failure("STP is not configured.")
+            self.result.is_failure("STP is not configured")
             return
 
         # Verifies the number of changes across all interfaces
diff --git a/anta/tests/stun.py b/anta/tests/stun.py
index ac4f0ea8..da8c2819 100644
--- a/anta/tests/stun.py
+++ b/anta/tests/stun.py
@@ -76,7 +76,7 @@ class VerifyStunClientTranslation(AntaTest):
 
             # If no bindings are found for the STUN client, mark the test as a failure and continue with the next client
             if not bindings:
-                self.result.is_failure(f"{client_input} - STUN client translation not found.")
+                self.result.is_failure(f"{client_input} - STUN client translation not found")
                 continue
 
             # Extract the transaction ID from the bindings
@@ -145,10 +145,10 @@ class VerifyStunServer(AntaTest):
         not_running = command_output.get("pid") == 0
 
         if status_disabled and not_running:
-            self.result.is_failure("STUN server status is disabled and not running.")
+            self.result.is_failure("STUN server status is disabled and not running")
         elif status_disabled:
-            self.result.is_failure("STUN server status is disabled.")
+            self.result.is_failure("STUN server status is disabled")
         elif not_running:
-            self.result.is_failure("STUN server is not running.")
+            self.result.is_failure("STUN server is not running")
         else:
             self.result.is_success()
diff --git a/anta/tests/system.py b/anta/tests/system.py
index 9ec71918..5da3688c 100644
--- a/anta/tests/system.py
+++ b/anta/tests/system.py
@@ -55,7 +55,7 @@ class VerifyUptime(AntaTest):
         self.result.is_success()
         command_output = self.instance_commands[0].json_output
         if command_output["upTime"] < self.inputs.minimum:
-            self.result.is_failure(f"Device uptime is incorrect - Expected: {self.inputs.minimum} Actual: {command_output['upTime']} seconds")
+            self.result.is_failure(f"Device uptime is incorrect - Expected: {self.inputs.minimum}s Actual: {command_output['upTime']}s")
 
 
 class VerifyReloadCause(AntaTest):
@@ -345,3 +345,51 @@ class VerifyNTPAssociations(AntaTest):
 
             if act_condition != exp_condition or act_stratum != exp_stratum:
                 self.result.is_failure(f"{ntp_server} - Bad association - Condition: {act_condition}, Stratum: {act_stratum}")
+
+
+class VerifyMaintenance(AntaTest):
+    """Verifies that the device is not currently under or entering maintenance.
+
+    Expected Results
+    ----------------
+    * Success: The test will pass if the device is not under or entering maintenance.
+    * Failure: The test will fail if the device is under or entering maintenance.
+
+    Examples
+    --------
+    ```yaml
+    anta.tests.system:
+      - VerifyMaintenance:
+    ```
+    """
+
+    categories: ClassVar[list[str]] = ["Maintenance"]
+    commands: ClassVar[list[AntaCommand | AntaTemplate]] = [AntaCommand(command="show maintenance", revision=1)]
+
+    @AntaTest.anta_test
+    def test(self) -> None:
+        """Main test function for VerifyMaintenance."""
+        self.result.is_success()
+
+        # If units is not empty we have to examine the output for details.
+        if not (units := get_value(self.instance_commands[0].json_output, "units")):
+            return
+        units_under_maintenance = [unit for unit, info in units.items() if info["state"] == "underMaintenance"]
+        units_entering_maintenance = [unit for unit, info in units.items() if info["state"] == "maintenanceModeEnter"]
+        causes = set()
+        # Iterate over units, check for units under or entering maintenance, and examine the causes.
+        for info in units.values():
+            if info["adminState"] == "underMaintenance":
+                causes.add("Quiesce is configured")
+            if info["onBootMaintenance"]:
+                causes.add("On-boot maintenance is configured")
+            if info["intfsViolatingTrafficThreshold"]:
+                causes.add("Interface traffic threshold violation")
+
+        # Building the error message.
+        if units_under_maintenance:
+            self.result.is_failure(f"Units under maintenance: '{', '.join(units_under_maintenance)}'.")
+        if units_entering_maintenance:
+            self.result.is_failure(f"Units entering maintenance: '{', '.join(units_entering_maintenance)}'.")
+        if causes:
+            self.result.is_failure(f"Possible causes: '{', '.join(sorted(causes))}'.")
diff --git a/anta/tests/vlan.py b/anta/tests/vlan.py
index 09b450ae..25fc9d52 100644
--- a/anta/tests/vlan.py
+++ b/anta/tests/vlan.py
@@ -11,7 +11,7 @@ from typing import TYPE_CHECKING, ClassVar, Literal
 
 from anta.custom_types import DynamicVlanSource, Vlan
 from anta.models import AntaCommand, AntaTest
-from anta.tools import get_failed_logs, get_value
+from anta.tools import get_value
 
 if TYPE_CHECKING:
     from anta.models import AntaTemplate
@@ -55,19 +55,22 @@ class VerifyVlanInternalPolicy(AntaTest):
     @AntaTest.anta_test
     def test(self) -> None:
         """Main test function for VerifyVlanInternalPolicy."""
+        self.result.is_success()
         command_output = self.instance_commands[0].json_output
 
-        keys_to_verify = ["policy", "startVlanId", "endVlanId"]
-        actual_policy_output = {key: get_value(command_output, key) for key in keys_to_verify}
-        expected_policy_output = {"policy": self.inputs.policy, "startVlanId": self.inputs.start_vlan_id, "endVlanId": self.inputs.end_vlan_id}
-
-        # Check if the actual output matches the expected output
-        if actual_policy_output != expected_policy_output:
-            failed_log = "The VLAN internal allocation policy is not configured properly:"
-            failed_log += get_failed_logs(expected_policy_output, actual_policy_output)
-            self.result.is_failure(failed_log)
-        else:
-            self.result.is_success()
+        if (policy := self.inputs.policy) != (act_policy := get_value(command_output, "policy")):
+            self.result.is_failure(f"Incorrect VLAN internal allocation policy configured - Expected: {policy} Actual: {act_policy}")
+            return
+
+        if (start_vlan_id := self.inputs.start_vlan_id) != (act_vlan_id := get_value(command_output, "startVlanId")):
+            self.result.is_failure(
+                f"VLAN internal allocation policy: {self.inputs.policy} - Incorrect start VLAN id configured - Expected: {start_vlan_id} Actual: {act_vlan_id}"
+            )
+
+        if (end_vlan_id := self.inputs.end_vlan_id) != (act_vlan_id := get_value(command_output, "endVlanId")):
+            self.result.is_failure(
+                f"VLAN internal allocation policy: {self.inputs.policy} - Incorrect end VLAN id configured - Expected: {end_vlan_id} Actual: {act_vlan_id}"
+            )
 
 
 class VerifyDynamicVlanSource(AntaTest):
diff --git a/examples/tests.yaml b/examples/tests.yaml
index 6e5d88c6..fd1d3e7c 100644
--- a/examples/tests.yaml
+++ b/examples/tests.yaml
@@ -494,6 +494,17 @@ anta.tests.routing.bgp:
           vrf: DEV
         - peer_address: 10.1.255.4
           vrf: DEV
+  - VerifyBGPPeerTtlMultiHops:
+      # Verifies BGP TTL and max-ttl-hops count for BGP IPv4 peer(s).
+      bgp_peers:
+          - peer_address: 172.30.11.1
+            vrf: default
+            ttl: 3
+            max_ttl_hops: 3
+          - peer_address: 172.30.11.2
+            vrf: test
+            ttl: 30
+            max_ttl_hops: 30
   - VerifyBGPPeerUpdateErrors:
       # Verifies BGP update error counters for the provided BGP IPv4 peer(s).
       bgp_peers:
@@ -951,6 +962,8 @@ anta.tests.system:
       # Verifies there are no core dump files.
   - VerifyFileSystemUtilization:
       # Verifies that no partition is utilizing more than 75% of its disk space.
+  - VerifyMaintenance:
+      # Verifies that the device is not currently under or entering maintenance.
   - VerifyMemoryUtilization:
       # Verifies whether the memory utilization is below 75%.
   - VerifyNTP:
diff --git a/tests/data/test_inventory_large.json b/tests/data/test_inventory_large.json
new file mode 100644
index 00000000..876d9409
--- /dev/null
+++ b/tests/data/test_inventory_large.json
@@ -0,0 +1,207 @@
+{
+  "anta_inventory": {
+    {
+      "hosts": [
+        {
+          "name": "super-spine1",
+          "host": "localhost"
+        },
+        {
+          "name": "super-spine2",
+          "host": "localhost"
+        },
+        {
+          "name": "pod1-spine1",
+          "host": "localhost"
+        },
+        {
+          "name": "pod1-spine2",
+          "host": "localhost"
+        },
+        {
+          "name": "pod1-spine3",
+          "host": "localhost"
+        },
+        {
+          "name": "pod1-spine4",
+          "host": "localhost"
+        },
+        {
+          "name": "pod1-leaf1a",
+          "host": "localhost"
+        },
+        {
+          "name": "pod1-leaf1b",
+          "host": "localhost"
+        },
+        {
+          "name": "pod1-leaf2a",
+          "host": "localhost"
+        },
+        {
+          "name": "pod1-leaf2b",
+          "host": "localhost"
+        },
+        {
+          "name": "pod1-leaf3a",
+          "host": "localhost"
+        },
+        {
+          "name": "pod1-leaf3b",
+          "host": "localhost"
+        },
+        {
+          "name": "pod1-leaf4a",
+          "host": "localhost"
+        },
+        {
+          "name": "pod1-leaf4b",
+          "host": "localhost"
+        },
+        {
+          "name": "pod1-leaf5a",
+          "host": "localhost"
+        },
+        {
+          "name": "pod1-leaf5b",
+          "host": "localhost"
+        },
+        {
+          "name": "pod1-leaf6a",
+          "host": "localhost"
+        },
+        {
+          "name": "pod1-leaf6b",
+          "host": "localhost"
+        },
+        {
+          "name": "pod1-leaf7a",
+          "host": "localhost"
+        },
+        {
+          "name": "pod1-leaf7b",
+          "host": "localhost"
+        },
+        {
+          "name": "pod1-leaf8a",
+          "host": "localhost"
+        },
+        {
+          "name": "pod1-leaf8b",
+          "host": "localhost"
+        },
+        {
+          "name": "pod1-leaf9a",
+          "host": "localhost"
+        },
+        {
+          "name": "pod1-leaf9b",
+          "host": "localhost"
+        },
+        {
+          "name": "pod1-leaf10a",
+          "host": "localhost"
+        },
+        {
+          "name": "pod1-leaf10b",
+          "host": "localhost"
+        },
+        {
+          "name": "pod2-spine1",
+          "host": "localhost"
+        },
+        {
+          "name": "pod2-spine2",
+          "host": "localhost"
+        },
+        {
+          "name": "pod2-spine3",
+          "host": "localhost"
+        },
+        {
+          "name": "pod2-spine4",
+          "host": "localhost"
+        },
+        {
+          "name": "pod2-leaf1a",
+          "host": "localhost"
+        },
+        {
+          "name": "pod2-leaf1b",
+          "host": "localhost"
+        },
+        {
+          "name": "pod2-leaf2a",
+          "host": "localhost"
+        },
+        {
+          "name": "pod2-leaf2b",
+          "host": "localhost"
+        },
+        {
+          "name": "pod2-leaf3a",
+          "host": "localhost"
+        },
+        {
+          "name": "pod2-leaf3b",
+          "host": "localhost"
+        },
+        {
+          "name": "pod2-leaf4a",
+          "host": "localhost"
+        },
+        {
+          "name": "pod2-leaf4b",
+          "host": "localhost"
+        },
+        {
+          "name": "pod2-leaf5a",
+          "host": "localhost"
+        },
+        {
+          "name": "pod2-leaf5b",
+          "host": "localhost"
+        },
+        {
+          "name": "pod2-leaf6a",
+          "host": "localhost"
+        },
+        {
+          "name": "pod2-leaf6b",
+          "host": "localhost"
+        },
+        {
+          "name": "pod2-leaf7a",
+          "host": "localhost"
+        },
+        {
+          "name": "pod2-leaf7b",
+          "host": "localhost"
+        },
+        {
+          "name": "pod2-leaf8a",
+          "host": "localhost"
+        },
+        {
+          "name": "pod2-leaf8b",
+          "host": "localhost"
+        },
+        {
+          "name": "pod2-leaf9a",
+          "host": "localhost"
+        },
+        {
+          "name": "pod2-leaf9b",
+          "host": "localhost"
+        },
+        {
+          "name": "pod2-leaf10a",
+          "host": "localhost"
+        },
+        {
+          "name": "pod2-leaf10b",
+          "host": "localhost"
+        }
+      ]
+    }
+}
diff --git a/tests/data/test_inventory_medium.json b/tests/data/test_inventory_medium.json
new file mode 100644
index 00000000..5c4f1473
--- /dev/null
+++ b/tests/data/test_inventory_medium.json
@@ -0,0 +1,30 @@
+{
+  "anta_inventory": {
+    "hosts": [
+      {
+        "name": "spine1",
+        "host": "localhost"
+      },
+      {
+        "name": "spine2",
+        "host": "localhost"
+      },
+      {
+        "name": "leaf1a",
+        "host": "localhost"
+      },
+      {
+        "name": "leaf1b",
+        "host": "localhost"
+      },
+      {
+        "name": "leaf2a",
+        "host": "localhost"
+      },
+      {
+        "name": "leaf2b",
+        "host": "localhost"
+      }
+    ]
+  }
+}
diff --git a/tests/data/test_inventory_with_tags.json b/tests/data/test_inventory_with_tags.json
new file mode 100644
index 00000000..0f0aa7ce
--- /dev/null
+++ b/tests/data/test_inventory_with_tags.json
@@ -0,0 +1,22 @@
+{
+  "anta_inventory": {
+    "hosts": [
+      {
+        "name": "leaf1",
+        "host": "leaf1.anta.arista.com",
+        "tags": ["dc1", "leaf"]
+      },
+      {
+        "name": "leaf2",
+        "host": "leaf2.anta.arista.com",
+        "tags": ["leaf"]
+      },
+      {
+        "name": "spine1",
+        "host": "spine1.anta.arista.com",
+        "tags": ["spine"],
+        "disable_cache": true
+      }
+    ]
+  }
+}
diff --git a/tests/data/test_inventory_with_tags.yml b/tests/data/test_inventory_with_tags.yml
index 16a9df4c..a3eb0c00 100644
--- a/tests/data/test_inventory_with_tags.yml
+++ b/tests/data/test_inventory_with_tags.yml
@@ -3,10 +3,11 @@ anta_inventory:
   hosts:
     - name: leaf1
       host: leaf1.anta.arista.com
-      tags: ["leaf", "dc1"]
+      tags: ["dc1", "leaf"]
     - name: leaf2
       host: leaf2.anta.arista.com
       tags: ["leaf"]
     - name: spine1
       host: spine1.anta.arista.com
       tags: ["spine"]
+      disable_cache: true
diff --git a/tests/units/anta_tests/routing/test_bgp.py b/tests/units/anta_tests/routing/test_bgp.py
index ee26155f..08266b67 100644
--- a/tests/units/anta_tests/routing/test_bgp.py
+++ b/tests/units/anta_tests/routing/test_bgp.py
@@ -27,6 +27,7 @@ from anta.tests.routing.bgp import (
     VerifyBGPPeerSessionRibd,
     VerifyBGPPeersHealth,
     VerifyBGPPeersHealthRibd,
+    VerifyBGPPeerTtlMultiHops,
     VerifyBGPPeerUpdateErrors,
     VerifyBGPRedistribution,
     VerifyBGPRouteECMP,
@@ -305,7 +306,7 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "AFI: vpn-ipv4 - Expected: 2, Actual: 0",
+                "AFI: vpn-ipv4 - Peer count mismatch - Expected: 2 Actual: 0",
             ],
         },
     },
@@ -374,8 +375,8 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "AFI: evpn - Expected: 3, Actual: 2",
-                "AFI: ipv4 SAFI: unicast VRF: DEV - Expected: 2, Actual: 1",
+                "AFI: evpn - Peer count mismatch - Expected: 3 Actual: 2",
+                "AFI: ipv4 SAFI: unicast VRF: DEV - Peer count mismatch - Expected: 2 Actual: 1",
             ],
         },
     },
@@ -423,9 +424,9 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "AFI: evpn - Expected: 2, Actual: 1",
-                "AFI: ipv4 SAFI: unicast VRF: default - Expected: 2, Actual: 1",
-                "AFI: ipv4 SAFI: unicast VRF: DEV - Expected: 2, Actual: 1",
+                "AFI: evpn - Peer count mismatch - Expected: 2 Actual: 1",
+                "AFI: ipv4 SAFI: unicast VRF: default - Peer count mismatch - Expected: 2 Actual: 1",
+                "AFI: ipv4 SAFI: unicast VRF: DEV - Peer count mismatch - Expected: 2 Actual: 1",
             ],
         },
     },
@@ -569,10 +570,10 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "AFI: ipv4 SAFI: unicast VRF: default Peer: 10.100.0.12 - Session state is not established - State: Idle",
-                "AFI: ipv4 SAFI: sr-te VRF: MGMT Peer: 10.100.0.12 - Session state is not established - State: Active",
-                "AFI: path-selection Peer: 10.100.0.13 - Session state is not established - State: Idle",
-                "AFI: link-state Peer: 10.100.0.14 - Session state is not established - State: Active",
+                "AFI: ipv4 SAFI: unicast VRF: default Peer: 10.100.0.12 - Incorrect session state - Expected: Established Actual: Idle",
+                "AFI: ipv4 SAFI: sr-te VRF: MGMT Peer: 10.100.0.12 - Incorrect session state - Expected: Established Actual: Active",
+                "AFI: path-selection Peer: 10.100.0.13 - Incorrect session state - Expected: Established Actual: Idle",
+                "AFI: link-state Peer: 10.100.0.14 - Incorrect session state - Expected: Established Actual: Active",
             ],
         },
     },
@@ -687,10 +688,10 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "AFI: ipv4 SAFI: unicast VRF: default Peer: 10.100.0.12 - Session has non-empty message queues - InQ: 2, OutQ: 4",
-                "AFI: ipv4 SAFI: sr-te VRF: MGMT Peer: 10.100.0.12 - Session has non-empty message queues - InQ: 5, OutQ: 1",
-                "AFI: path-selection Peer: 10.100.0.13 - Session has non-empty message queues - InQ: 1, OutQ: 1",
-                "AFI: link-state Peer: 10.100.0.14 - Session has non-empty message queues - InQ: 3, OutQ: 2",
+                "AFI: ipv4 SAFI: unicast VRF: default Peer: 10.100.0.12 - Session has non-empty message queues - InQ: 2 OutQ: 4",
+                "AFI: ipv4 SAFI: sr-te VRF: MGMT Peer: 10.100.0.12 - Session has non-empty message queues - InQ: 5 OutQ: 1",
+                "AFI: path-selection Peer: 10.100.0.13 - Session has non-empty message queues - InQ: 1 OutQ: 1",
+                "AFI: link-state Peer: 10.100.0.14 - Session has non-empty message queues - InQ: 3 OutQ: 2",
             ],
         },
     },
@@ -843,8 +844,8 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "AFI: ipv4 SAFI: unicast VRF: default Peer: 10.100.0.12 - Session state is not established - State: Idle",
-                "AFI: ipv4 SAFI: unicast VRF: MGMT Peer: 10.100.0.14 - Session state is not established - State: Idle",
+                "AFI: ipv4 SAFI: unicast VRF: default Peer: 10.100.0.12 - Incorrect session state - Expected: Established Actual: Idle",
+                "AFI: ipv4 SAFI: unicast VRF: MGMT Peer: 10.100.0.14 - Incorrect session state - Expected: Established Actual: Idle",
             ],
         },
     },
@@ -972,8 +973,8 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "AFI: ipv4 SAFI: unicast VRF: default Peer: 10.100.0.12 - Session has non-empty message queues - InQ: 3, OutQ: 3",
-                "AFI: ipv4 SAFI: unicast VRF: MGMT Peer: 10.100.0.14 - Session has non-empty message queues - InQ: 2, OutQ: 2",
+                "AFI: ipv4 SAFI: unicast VRF: default Peer: 10.100.0.12 - Session has non-empty message queues - InQ: 3 OutQ: 3",
+                "AFI: ipv4 SAFI: unicast VRF: MGMT Peer: 10.100.0.14 - Session has non-empty message queues - InQ: 2 OutQ: 2",
             ],
         },
     },
@@ -1452,13 +1453,13 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Peer: 172.30.11.1 VRF: default Advertised route: 192.0.254.3/32 - Valid: False, Active: True",
+                "Peer: 172.30.11.1 VRF: default Advertised route: 192.0.254.3/32 - Valid: False Active: True",
                 "Peer: 172.30.11.1 VRF: default Advertised route: 192.0.254.51/32 - Not found",
                 "Peer: 172.30.11.1 VRF: default Received route: 192.0.254.31/32 - Not found",
-                "Peer: 172.30.11.1 VRF: default Received route: 192.0.255.4/32 - Valid: False, Active: False",
+                "Peer: 172.30.11.1 VRF: default Received route: 192.0.255.4/32 - Valid: False Active: False",
                 "Peer: 172.30.11.5 VRF: default Advertised route: 192.0.254.31/32 - Not found",
-                "Peer: 172.30.11.5 VRF: default Advertised route: 192.0.254.5/32 - Valid: False, Active: True",
-                "Peer: 172.30.11.5 VRF: default Received route: 192.0.254.3/32 - Valid: True, Active: False",
+                "Peer: 172.30.11.5 VRF: default Advertised route: 192.0.254.5/32 - Valid: False Active: True",
+                "Peer: 172.30.11.5 VRF: default Received route: 192.0.254.3/32 - Valid: True Active: False",
                 "Peer: 172.30.11.5 VRF: default Received route: 192.0.255.41/32 - Not found",
             ],
         },
@@ -1597,9 +1598,9 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Peer: 172.30.11.1 VRF: default Advertised route: 192.0.254.3/32 - Valid: False, Active: True",
+                "Peer: 172.30.11.1 VRF: default Advertised route: 192.0.254.3/32 - Valid: False Active: True",
                 "Peer: 172.30.11.1 VRF: default Advertised route: 192.0.254.51/32 - Not found",
-                "Peer: 172.30.11.5 VRF: default Received route: 192.0.254.3/32 - Valid: True, Active: False",
+                "Peer: 172.30.11.5 VRF: default Received route: 192.0.254.3/32 - Valid: True Active: False",
                 "Peer: 172.30.11.5 VRF: default Received route: 192.0.255.41/32 - Not found",
             ],
         },
@@ -2561,8 +2562,8 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Peer: 172.30.11.1 VRF: default - Session state is not established - State: Idle",
-                "Peer: 172.30.11.10 VRF: MGMT - Session state is not established - State: Idle",
+                "Peer: 172.30.11.1 VRF: default - Incorrect session state - Expected: Established Actual: Idle",
+                "Peer: 172.30.11.10 VRF: MGMT - Incorrect session state - Expected: Established Actual: Idle",
             ],
         },
     },
@@ -3219,9 +3220,9 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Peer: 172.30.11.1 VRF: default - Hold time mismatch - Expected: 180, Actual: 160",
-                "Peer: 172.30.11.11 VRF: MGMT - Hold time mismatch - Expected: 180, Actual: 120",
-                "Peer: 172.30.11.11 VRF: MGMT - Keepalive time mismatch - Expected: 60, Actual: 40",
+                "Peer: 172.30.11.1 VRF: default - Hold time mismatch - Expected: 180 Actual: 160",
+                "Peer: 172.30.11.11 VRF: MGMT - Hold time mismatch - Expected: 180 Actual: 120",
+                "Peer: 172.30.11.11 VRF: MGMT - Keepalive time mismatch - Expected: 60 Actual: 40",
             ],
         },
     },
@@ -3831,10 +3832,10 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Peer: 10.100.0.8 VRF: default - Inbound route-map mismatch - Expected: RM-MLAG-PEER-IN, Actual: RM-MLAG-PEER",
-                "Peer: 10.100.0.8 VRF: default - Outbound route-map mismatch - Expected: RM-MLAG-PEER-OUT, Actual: RM-MLAG-PEER",
-                "Peer: 10.100.0.10 VRF: MGMT - Inbound route-map mismatch - Expected: RM-MLAG-PEER-IN, Actual: RM-MLAG-PEER",
-                "Peer: 10.100.0.10 VRF: MGMT - Outbound route-map mismatch - Expected: RM-MLAG-PEER-OUT, Actual: RM-MLAG-PEER",
+                "Peer: 10.100.0.8 VRF: default - Inbound route-map mismatch - Expected: RM-MLAG-PEER-IN Actual: RM-MLAG-PEER",
+                "Peer: 10.100.0.8 VRF: default - Outbound route-map mismatch - Expected: RM-MLAG-PEER-OUT Actual: RM-MLAG-PEER",
+                "Peer: 10.100.0.10 VRF: MGMT - Inbound route-map mismatch - Expected: RM-MLAG-PEER-IN Actual: RM-MLAG-PEER",
+                "Peer: 10.100.0.10 VRF: MGMT - Outbound route-map mismatch - Expected: RM-MLAG-PEER-OUT Actual: RM-MLAG-PEER",
             ],
         },
     },
@@ -3874,8 +3875,8 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Peer: 10.100.0.8 VRF: default - Inbound route-map mismatch - Expected: RM-MLAG-PEER-IN, Actual: RM-MLAG-PEER",
-                "Peer: 10.100.0.10 VRF: MGMT - Inbound route-map mismatch - Expected: RM-MLAG-PEER-IN, Actual: RM-MLAG-PEER",
+                "Peer: 10.100.0.8 VRF: default - Inbound route-map mismatch - Expected: RM-MLAG-PEER-IN Actual: RM-MLAG-PEER",
+                "Peer: 10.100.0.10 VRF: MGMT - Inbound route-map mismatch - Expected: RM-MLAG-PEER-IN Actual: RM-MLAG-PEER",
             ],
         },
     },
@@ -3911,10 +3912,10 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Peer: 10.100.0.8 VRF: default - Inbound route-map mismatch - Expected: RM-MLAG-PEER-IN, Actual: Not Configured",
-                "Peer: 10.100.0.8 VRF: default - Outbound route-map mismatch - Expected: RM-MLAG-PEER-OUT, Actual: Not Configured",
-                "Peer: 10.100.0.10 VRF: MGMT - Inbound route-map mismatch - Expected: RM-MLAG-PEER-IN, Actual: Not Configured",
-                "Peer: 10.100.0.10 VRF: MGMT - Outbound route-map mismatch - Expected: RM-MLAG-PEER-OUT, Actual: Not Configured",
+                "Peer: 10.100.0.8 VRF: default - Inbound route-map mismatch - Expected: RM-MLAG-PEER-IN Actual: Not Configured",
+                "Peer: 10.100.0.8 VRF: default - Outbound route-map mismatch - Expected: RM-MLAG-PEER-OUT Actual: Not Configured",
+                "Peer: 10.100.0.10 VRF: MGMT - Inbound route-map mismatch - Expected: RM-MLAG-PEER-IN Actual: Not Configured",
+                "Peer: 10.100.0.10 VRF: MGMT - Outbound route-map mismatch - Expected: RM-MLAG-PEER-OUT Actual: Not Configured",
             ],
         },
     },
@@ -4072,10 +4073,10 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Peer: 10.100.0.8 VRF: default - Maximum routes mismatch - Expected: 12000, Actual: 13000",
-                "Peer: 10.100.0.8 VRF: default - Maximum routes warning limit mismatch - Expected: 10000, Actual: 11000",
-                "Peer: 10.100.0.9 VRF: MGMT - Maximum routes mismatch - Expected: 10000, Actual: 11000",
-                "Peer: 10.100.0.9 VRF: MGMT - Maximum routes warning limit mismatch - Expected: 9000, Actual: 10000",
+                "Peer: 10.100.0.8 VRF: default - Maximum routes mismatch - Expected: 12000 Actual: 13000",
+                "Peer: 10.100.0.8 VRF: default - Maximum routes warning limit mismatch - Expected: 10000 Actual: 11000",
+                "Peer: 10.100.0.9 VRF: MGMT - Maximum routes mismatch - Expected: 10000 Actual: 11000",
+                "Peer: 10.100.0.9 VRF: MGMT - Maximum routes warning limit mismatch - Expected: 9000 Actual: 10000",
             ],
         },
     },
@@ -4113,8 +4114,8 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Peer: 10.100.0.8 VRF: default - Maximum routes warning limit mismatch - Expected: 10000, Actual: 0",
-                "Peer: 10.100.0.9 VRF: MGMT - Maximum routes warning limit mismatch - Expected: 9000, Actual: 0",
+                "Peer: 10.100.0.8 VRF: default - Maximum routes warning limit mismatch - Expected: 10000 Actual: 0",
+                "Peer: 10.100.0.9 VRF: MGMT - Maximum routes warning limit mismatch - Expected: 9000 Actual: 0",
             ],
         },
     },
@@ -4278,8 +4279,8 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Peer: 10.100.0.8 VRF: default - Session state is not established - State: Active",
-                "Peer: 10.100.0.9 VRF: MGMT - Session state is not established - State: Active",
+                "Peer: 10.100.0.8 VRF: default - Incorrect session state - Expected: Established Actual: Active",
+                "Peer: 10.100.0.9 VRF: MGMT - Incorrect session state - Expected: Established Actual: Active",
             ],
         },
     },
@@ -4325,7 +4326,7 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Peer: 10.100.0.8 VRF: default - Session has non-empty message queues - InQ: 5, OutQ: 10",
+                "Peer: 10.100.0.8 VRF: default - Session has non-empty message queues - InQ: 5 OutQ: 10",
             ],
         },
     },
@@ -4677,8 +4678,8 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Peer: 10.100.0.8 VRF: default - Session state is not established - State: Active",
-                "Peer: 10.100.0.9 VRF: MGMT - Session state is not established - State: Active",
+                "Peer: 10.100.0.8 VRF: default - Incorrect session state - Expected: Established Actual: Active",
+                "Peer: 10.100.0.9 VRF: MGMT - Incorrect session state - Expected: Established Actual: Active",
             ],
         },
     },
@@ -4724,7 +4725,7 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Peer: 10.100.0.8 VRF: default - Session has non-empty message queues - InQ: 5, OutQ: 10",
+                "Peer: 10.100.0.8 VRF: default - Session has non-empty message queues - InQ: 5 OutQ: 10",
             ],
         },
     },
@@ -4841,8 +4842,8 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Peer: 10.100.0.8 VRF: default - Session state is not established - State: Active",
-                "Peer: 10.100.0.9 VRF: MGMT - Session state is not established - State: Active",
+                "Peer: 10.100.0.8 VRF: default - Incorrect session state - Expected: Established Actual: Active",
+                "Peer: 10.100.0.9 VRF: MGMT - Incorrect session state - Expected: Established Actual: Active",
             ],
         },
     },
@@ -4883,7 +4884,7 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Peer: 10.100.0.8 VRF: default - Session has non-empty message queues - InQ: 5, OutQ: 10",
+                "Peer: 10.100.0.8 VRF: default - Session has non-empty message queues - InQ: 5 OutQ: 10",
             ],
         },
     },
@@ -5145,10 +5146,10 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Peer: 10.100.0.8 VRF: default AFI/SAFI: ipv4Unicast - some NLRI were filtered or rejected - Accepted: 16 Received: 17",
-                "Peer: 10.100.0.8 VRF: default AFI/SAFI: l2VpnEvpn - some NLRI were filtered or rejected - Accepted: 56 Received: 58",
-                "Peer: 10.100.4.5 VRF: MGMT AFI/SAFI: ipv4Unicast - some NLRI were filtered or rejected - Accepted: 14 Received: 15",
-                "Peer: 10.100.4.5 VRF: MGMT AFI/SAFI: l2VpnEvpn - some NLRI were filtered or rejected - Accepted: 56 Received: 59",
+                "Peer: 10.100.0.8 VRF: default AFI/SAFI: ipv4Unicast - Some NLRI were filtered or rejected - Accepted: 16 Received: 17",
+                "Peer: 10.100.0.8 VRF: default AFI/SAFI: l2VpnEvpn - Some NLRI were filtered or rejected - Accepted: 56 Received: 58",
+                "Peer: 10.100.4.5 VRF: MGMT AFI/SAFI: ipv4Unicast - Some NLRI were filtered or rejected - Accepted: 14 Received: 15",
+                "Peer: 10.100.4.5 VRF: MGMT AFI/SAFI: l2VpnEvpn - Some NLRI were filtered or rejected - Accepted: 56 Received: 59",
             ],
         },
     },
@@ -5344,10 +5345,10 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Prefix: 10.100.0.128/31 VRF: default Next-hop: 10.100.0.10 Origin: Incomplete - path not found",
-                "Prefix: 10.100.0.128/31 VRF: default Next-hop: 10.100.4.5 Origin: Igp - path not found",
-                "Prefix: 10.100.0.130/31 VRF: MGMT Next-hop: 10.100.0.8 Origin: Incomplete - path not found",
-                "Prefix: 10.100.0.130/31 VRF: MGMT Next-hop: 10.100.0.10 Origin: Incomplete - path not found",
+                "Prefix: 10.100.0.128/31 VRF: default Next-hop: 10.100.0.10 Origin: Incomplete - Path not found",
+                "Prefix: 10.100.0.128/31 VRF: default Next-hop: 10.100.4.5 Origin: Igp - Path not found",
+                "Prefix: 10.100.0.130/31 VRF: MGMT Next-hop: 10.100.0.8 Origin: Incomplete - Path not found",
+                "Prefix: 10.100.0.130/31 VRF: MGMT Next-hop: 10.100.0.10 Origin: Incomplete - Path not found",
             ],
         },
     },
@@ -5373,7 +5374,7 @@ DATA: list[dict[str, Any]] = [
         },
         "expected": {
             "result": "failure",
-            "messages": ["Prefix: 10.100.0.128/31 VRF: default - prefix not found", "Prefix: 10.100.0.130/31 VRF: MGMT - prefix not found"],
+            "messages": ["Prefix: 10.100.0.128/31 VRF: default - Prefix not found", "Prefix: 10.100.0.130/31 VRF: MGMT - Prefix not found"],
         },
     },
     {
@@ -5507,7 +5508,7 @@ DATA: list[dict[str, Any]] = [
             },
         ],
         "inputs": {"route_entries": [{"prefix": "10.111.124.0/24", "vrf": "default", "ecmp_count": 2}]},
-        "expected": {"result": "failure", "messages": ["Prefix: 10.111.124.0/24 VRF: default - prefix not found in BGP table"]},
+        "expected": {"result": "failure", "messages": ["Prefix: 10.111.124.0/24 VRF: default - Prefix not found in BGP table"]},
     },
     {
         "name": "failure-valid-active-ecmp-head-not-found",
@@ -5577,7 +5578,7 @@ DATA: list[dict[str, Any]] = [
             },
         ],
         "inputs": {"route_entries": [{"prefix": "10.111.134.0/24", "vrf": "default", "ecmp_count": 2}]},
-        "expected": {"result": "failure", "messages": ["Prefix: 10.111.134.0/24 VRF: default - valid and active ECMP head not found"]},
+        "expected": {"result": "failure", "messages": ["Prefix: 10.111.134.0/24 VRF: default - Valid and active ECMP head not found"]},
     },
     {
         "name": "failure-ecmp-count-mismatch",
@@ -5647,7 +5648,7 @@ DATA: list[dict[str, Any]] = [
             },
         ],
         "inputs": {"route_entries": [{"prefix": "10.111.134.0/24", "vrf": "default", "ecmp_count": 2}]},
-        "expected": {"result": "failure", "messages": ["Prefix: 10.111.134.0/24 VRF: default - ECMP count mismatch - Expected: 2, Actual: 1"]},
+        "expected": {"result": "failure", "messages": ["Prefix: 10.111.134.0/24 VRF: default - ECMP count mismatch - Expected: 2 Actual: 1"]},
     },
     {
         "name": "failure-prefix-not-found-routing-table",
@@ -5717,7 +5718,7 @@ DATA: list[dict[str, Any]] = [
             },
         ],
         "inputs": {"route_entries": [{"prefix": "10.111.134.0/24", "vrf": "default", "ecmp_count": 2}]},
-        "expected": {"result": "failure", "messages": ["Prefix: 10.111.134.0/24 VRF: default - prefix not found in routing table"]},
+        "expected": {"result": "failure", "messages": ["Prefix: 10.111.134.0/24 VRF: default - Prefix not found in routing table"]},
     },
     {
         "name": "failure-nexthops-mismatch",
@@ -5787,7 +5788,7 @@ DATA: list[dict[str, Any]] = [
             },
         ],
         "inputs": {"route_entries": [{"prefix": "10.111.134.0/24", "vrf": "default", "ecmp_count": 2}]},
-        "expected": {"result": "failure", "messages": ["Prefix: 10.111.134.0/24 VRF: default - Nexthops count mismatch - BGP: 2, RIB: 1"]},
+        "expected": {"result": "failure", "messages": ["Prefix: 10.111.134.0/24 VRF: default - Nexthops count mismatch - BGP: 2 RIB: 1"]},
     },
     {
         "name": "success",
@@ -6118,4 +6119,204 @@ DATA: list[dict[str, Any]] = [
             ],
         },
     },
+    {
+        "name": "success",
+        "test": VerifyBGPPeerTtlMultiHops,
+        "eos_data": [
+            {
+                "vrfs": {
+                    "default": {
+                        "peerList": [
+                            {
+                                "peerAddress": "10.111.0.1",
+                                "ttl": 2,
+                                "maxTtlHops": 2,
+                            },
+                            {
+                                "peerAddress": "10.111.0.2",
+                                "ttl": 1,
+                                "maxTtlHops": 1,
+                            },
+                        ]
+                    },
+                    "Test": {"peerList": [{"peerAddress": "10.111.0.3", "ttl": 255, "maxTtlHops": 255}]},
+                }
+            }
+        ],
+        "inputs": {
+            "bgp_peers": [
+                {
+                    "peer_address": "10.111.0.1",
+                    "vrf": "default",
+                    "ttl": 2,
+                    "max_ttl_hops": 2,
+                },
+                {
+                    "peer_address": "10.111.0.2",
+                    "vrf": "default",
+                    "ttl": 1,
+                    "max_ttl_hops": 1,
+                },
+                {
+                    "peer_address": "10.111.0.3",
+                    "vrf": "Test",
+                    "ttl": 255,
+                    "max_ttl_hops": 255,
+                },
+            ]
+        },
+        "expected": {"result": "success"},
+    },
+    {
+        "name": "failure-peer-not-found",
+        "test": VerifyBGPPeerTtlMultiHops,
+        "eos_data": [
+            {
+                "vrfs": {
+                    "default": {
+                        "peerList": [
+                            {
+                                "peerAddress": "10.111.0.4",
+                                "ttl": 2,
+                                "maxTtlHops": 2,
+                            },
+                            {
+                                "peerAddress": "10.111.0.5",
+                                "ttl": 1,
+                                "maxTtlHops": 1,
+                            },
+                        ]
+                    },
+                    "Test": {"peerList": [{"peerAddress": "10.111.0.6", "ttl": 255, "maxTtlHops": 255}]},
+                }
+            }
+        ],
+        "inputs": {
+            "bgp_peers": [
+                {
+                    "peer_address": "10.111.0.1",
+                    "vrf": "default",
+                    "ttl": 2,
+                    "max_ttl_hops": 2,
+                },
+                {
+                    "peer_address": "10.111.0.2",
+                    "vrf": "Test",
+                    "ttl": 255,
+                    "max_ttl_hops": 255,
+                },
+            ]
+        },
+        "expected": {"result": "failure", "messages": ["Peer: 10.111.0.1 VRF: default - Not found", "Peer: 10.111.0.2 VRF: Test - Not found"]},
+    },
+    {
+        "name": "failure-ttl-time-mismatch",
+        "test": VerifyBGPPeerTtlMultiHops,
+        "eos_data": [
+            {
+                "vrfs": {
+                    "default": {
+                        "peerList": [
+                            {
+                                "peerAddress": "10.111.0.1",
+                                "ttl": 12,
+                                "maxTtlHops": 2,
+                            },
+                            {
+                                "peerAddress": "10.111.0.2",
+                                "ttl": 120,
+                                "maxTtlHops": 1,
+                            },
+                        ]
+                    },
+                    "Test": {"peerList": [{"peerAddress": "10.111.0.3", "ttl": 205, "maxTtlHops": 255}]},
+                }
+            }
+        ],
+        "inputs": {
+            "bgp_peers": [
+                {
+                    "peer_address": "10.111.0.1",
+                    "vrf": "default",
+                    "ttl": 2,
+                    "max_ttl_hops": 2,
+                },
+                {
+                    "peer_address": "10.111.0.2",
+                    "vrf": "default",
+                    "ttl": 1,
+                    "max_ttl_hops": 1,
+                },
+                {
+                    "peer_address": "10.111.0.3",
+                    "vrf": "Test",
+                    "ttl": 255,
+                    "max_ttl_hops": 255,
+                },
+            ]
+        },
+        "expected": {
+            "result": "failure",
+            "messages": [
+                "Peer: 10.111.0.1 VRF: default - TTL mismatch - Expected: 2 Actual: 12",
+                "Peer: 10.111.0.2 VRF: default - TTL mismatch - Expected: 1 Actual: 120",
+                "Peer: 10.111.0.3 VRF: Test - TTL mismatch - Expected: 255 Actual: 205",
+            ],
+        },
+    },
+    {
+        "name": "failure-max-ttl-hops-mismatch",
+        "test": VerifyBGPPeerTtlMultiHops,
+        "eos_data": [
+            {
+                "vrfs": {
+                    "default": {
+                        "peerList": [
+                            {
+                                "peerAddress": "10.111.0.1",
+                                "ttl": 2,
+                                "maxTtlHops": 12,
+                            },
+                            {
+                                "peerAddress": "10.111.0.2",
+                                "ttl": 1,
+                                "maxTtlHops": 100,
+                            },
+                        ]
+                    },
+                    "Test": {"peerList": [{"peerAddress": "10.111.0.3", "ttl": 255, "maxTtlHops": 205}]},
+                }
+            }
+        ],
+        "inputs": {
+            "bgp_peers": [
+                {
+                    "peer_address": "10.111.0.1",
+                    "vrf": "default",
+                    "ttl": 2,
+                    "max_ttl_hops": 2,
+                },
+                {
+                    "peer_address": "10.111.0.2",
+                    "vrf": "default",
+                    "ttl": 1,
+                    "max_ttl_hops": 1,
+                },
+                {
+                    "peer_address": "10.111.0.3",
+                    "vrf": "Test",
+                    "ttl": 255,
+                    "max_ttl_hops": 255,
+                },
+            ]
+        },
+        "expected": {
+            "result": "failure",
+            "messages": [
+                "Peer: 10.111.0.1 VRF: default - Max TTL Hops mismatch - Expected: 2 Actual: 12",
+                "Peer: 10.111.0.2 VRF: default - Max TTL Hops mismatch - Expected: 1 Actual: 100",
+                "Peer: 10.111.0.3 VRF: Test - Max TTL Hops mismatch - Expected: 255 Actual: 205",
+            ],
+        },
+    },
 ]
diff --git a/tests/units/anta_tests/routing/test_generic.py b/tests/units/anta_tests/routing/test_generic.py
index 57ad584a..2e67f91d 100644
--- a/tests/units/anta_tests/routing/test_generic.py
+++ b/tests/units/anta_tests/routing/test_generic.py
@@ -27,14 +27,14 @@ DATA: list[dict[str, Any]] = [
         "test": VerifyRoutingProtocolModel,
         "eos_data": [{"vrfs": {"default": {}}, "protoModelStatus": {"configuredProtoModel": "ribd", "operatingProtoModel": "ribd"}}],
         "inputs": {"model": "multi-agent"},
-        "expected": {"result": "failure", "messages": ["routing model is misconfigured: configured: ribd - operating: ribd - expected: multi-agent"]},
+        "expected": {"result": "failure", "messages": ["Routing model is misconfigured - Expected: multi-agent Actual: ribd"]},
     },
     {
         "name": "failure-mismatch-operating-model",
         "test": VerifyRoutingProtocolModel,
         "eos_data": [{"vrfs": {"default": {}}, "protoModelStatus": {"configuredProtoModel": "multi-agent", "operatingProtoModel": "ribd"}}],
         "inputs": {"model": "multi-agent"},
-        "expected": {"result": "failure", "messages": ["routing model is misconfigured: configured: multi-agent - operating: ribd - expected: multi-agent"]},
+        "expected": {"result": "failure", "messages": ["Routing model is misconfigured - Expected: multi-agent Actual: ribd"]},
     },
     {
         "name": "success",
@@ -68,7 +68,7 @@ DATA: list[dict[str, Any]] = [
             },
         ],
         "inputs": {"minimum": 42, "maximum": 666},
-        "expected": {"result": "failure", "messages": ["Routing table has 1000 routes, outside the range of 42 to 666"]},
+        "expected": {"result": "failure", "messages": ["Routing table routes are outside the routes range - Expected: 42 <= to >= 666 Actual: 1000"]},
     },
     {
         "name": "success",
@@ -474,9 +474,9 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Prefix: 10.10.0.1/32 VRF: default - List of next-hops not matching - Expected: 10.100.0.10, 10.100.0.11, 10.100.0.8 - "
+                "Prefix: 10.10.0.1/32 VRF: default - List of next-hops not matching - Expected: 10.100.0.10, 10.100.0.11, 10.100.0.8 "
                 "Actual: 10.100.0.10, 10.100.0.8",
-                "Prefix: 10.100.0.128/31 VRF: MGMT - List of next-hops not matching - Expected: 10.100.0.10, 10.100.0.8 - Actual: 10.100.0.11, 10.100.0.8",
+                "Prefix: 10.100.0.128/31 VRF: MGMT - List of next-hops not matching - Expected: 10.100.0.10, 10.100.0.8 Actual: 10.100.0.11, 10.100.0.8",
             ],
         },
     },
diff --git a/tests/units/anta_tests/routing/test_isis.py b/tests/units/anta_tests/routing/test_isis.py
index aaa77b24..8a36d824 100644
--- a/tests/units/anta_tests/routing/test_isis.py
+++ b/tests/units/anta_tests/routing/test_isis.py
@@ -182,7 +182,7 @@ DATA: list[dict[str, Any]] = [
         "inputs": None,
         "expected": {
             "result": "failure",
-            "messages": ["Instance: CORE-ISIS VRF: default Interface: Ethernet1 - Adjacency down"],
+            "messages": ["Instance: CORE-ISIS VRF: default Interface: Ethernet1 - Incorrect adjacency state - Expected: up Actual: down"],
         },
     },
     {
@@ -249,7 +249,7 @@ DATA: list[dict[str, Any]] = [
         "inputs": {"check_all_vrfs": True},
         "expected": {
             "result": "failure",
-            "messages": ["Instance: CORE-ISIS VRF: customer Interface: Ethernet2 - Adjacency down"],
+            "messages": ["Instance: CORE-ISIS VRF: customer Interface: Ethernet2 - Incorrect adjacency state - Expected: up Actual: down"],
         },
     },
     {
diff --git a/tests/units/anta_tests/test_aaa.py b/tests/units/anta_tests/test_aaa.py
index e88c4e02..c91f0511 100644
--- a/tests/units/anta_tests/test_aaa.py
+++ b/tests/units/anta_tests/test_aaa.py
@@ -47,7 +47,7 @@ DATA: list[dict[str, Any]] = [
             },
         ],
         "inputs": {"intf": "Management0", "vrf": "MGMT"},
-        "expected": {"result": "failure", "messages": ["Source-interface Management0 is not configured in VRF MGMT"]},
+        "expected": {"result": "failure", "messages": ["VRF: MGMT Source Interface: Management0 - Not configured"]},
     },
     {
         "name": "failure-wrong-intf",
@@ -64,7 +64,7 @@ DATA: list[dict[str, Any]] = [
             },
         ],
         "inputs": {"intf": "Management0", "vrf": "MGMT"},
-        "expected": {"result": "failure", "messages": ["Wrong source-interface configured in VRF MGMT"]},
+        "expected": {"result": "failure", "messages": ["VRF: MGMT - Source interface mismatch - Expected: Management0 Actual: Management1"]},
     },
     {
         "name": "failure-wrong-vrf",
@@ -81,7 +81,7 @@ DATA: list[dict[str, Any]] = [
             },
         ],
         "inputs": {"intf": "Management0", "vrf": "MGMT"},
-        "expected": {"result": "failure", "messages": ["Source-interface Management0 is not configured in VRF MGMT"]},
+        "expected": {"result": "failure", "messages": ["VRF: MGMT Source Interface: Management0 - Not configured"]},
     },
     {
         "name": "success",
diff --git a/tests/units/anta_tests/test_avt.py b/tests/units/anta_tests/test_avt.py
index 60adbec2..39c5e1e3 100644
--- a/tests/units/anta_tests/test_avt.py
+++ b/tests/units/anta_tests/test_avt.py
@@ -94,7 +94,7 @@ DATA: list[dict[str, Any]] = [
         "inputs": {},
         "expected": {
             "result": "failure",
-            "messages": ["Adaptive virtual topology paths are not configured."],
+            "messages": ["Adaptive virtual topology paths are not configured"],
         },
     },
     {
@@ -174,9 +174,9 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "AVT path direct:10 for profile GUEST-AVT-POLICY-DEFAULT in VRF guest is not active.",
-                "AVT path direct:1 for profile CONTROL-PLANE-PROFILE in VRF default is not active.",
-                "AVT path direct:10 for profile DEFAULT-AVT-POLICY-DEFAULT in VRF default is not active.",
+                "VRF: guest Profile: GUEST-AVT-POLICY-DEFAULT AVT path: direct:10 - Not active",
+                "VRF: default Profile: CONTROL-PLANE-PROFILE AVT path: direct:1 - Not active",
+                "VRF: default Profile: DEFAULT-AVT-POLICY-DEFAULT AVT path: direct:10 - Not active",
             ],
         },
     },
@@ -257,10 +257,10 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "AVT path direct:10 for profile DATA-AVT-POLICY-DEFAULT in VRF data is invalid.",
-                "AVT path direct:8 for profile GUEST-AVT-POLICY-DEFAULT in VRF guest is invalid.",
-                "AVT path direct:10 for profile CONTROL-PLANE-PROFILE in VRF default is invalid.",
-                "AVT path direct:8 for profile DEFAULT-AVT-POLICY-DEFAULT in VRF default is invalid.",
+                "VRF: data Profile: DATA-AVT-POLICY-DEFAULT AVT path: direct:10 - Invalid",
+                "VRF: guest Profile: GUEST-AVT-POLICY-DEFAULT AVT path: direct:8 - Invalid",
+                "VRF: default Profile: CONTROL-PLANE-PROFILE AVT path: direct:10 - Invalid",
+                "VRF: default Profile: DEFAULT-AVT-POLICY-DEFAULT AVT path: direct:8 - Invalid",
             ],
         },
     },
@@ -341,13 +341,13 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "AVT path direct:10 for profile DATA-AVT-POLICY-DEFAULT in VRF data is invalid and not active.",
-                "AVT path direct:1 for profile DATA-AVT-POLICY-DEFAULT in VRF data is not active.",
-                "AVT path direct:10 for profile GUEST-AVT-POLICY-DEFAULT in VRF guest is invalid.",
-                "AVT path direct:8 for profile GUEST-AVT-POLICY-DEFAULT in VRF guest is invalid and not active.",
-                "AVT path direct:10 for profile CONTROL-PLANE-PROFILE in VRF default is invalid and not active.",
-                "AVT path direct:10 for profile DEFAULT-AVT-POLICY-DEFAULT in VRF default is not active.",
-                "AVT path direct:8 for profile DEFAULT-AVT-POLICY-DEFAULT in VRF default is invalid and not active.",
+                "VRF: data Profile: DATA-AVT-POLICY-DEFAULT AVT path: direct:10 - Invalid and not active",
+                "VRF: data Profile: DATA-AVT-POLICY-DEFAULT AVT path: direct:1 - Not active",
+                "VRF: guest Profile: GUEST-AVT-POLICY-DEFAULT AVT path: direct:10 - Invalid",
+                "VRF: guest Profile: GUEST-AVT-POLICY-DEFAULT AVT path: direct:8 - Invalid and not active",
+                "VRF: default Profile: CONTROL-PLANE-PROFILE AVT path: direct:10 - Invalid and not active",
+                "VRF: default Profile: DEFAULT-AVT-POLICY-DEFAULT AVT path: direct:10 - Not active",
+                "VRF: default Profile: DEFAULT-AVT-POLICY-DEFAULT AVT path: direct:8 - Invalid and not active",
             ],
         },
     },
@@ -647,11 +647,11 @@ DATA: list[dict[str, Any]] = [
             "result": "failure",
             "messages": [
                 "AVT: DEFAULT-AVT-POLICY-CONTROL-PLANE VRF: default Destination: 10.101.255.2 Next-hop: 10.101.255.1 - "
-                "Incorrect path multihop:3 - Valid: False, Active: True",
+                "Incorrect path multihop:3 - Valid: False Active: True",
                 "AVT: DATA-AVT-POLICY-CONTROL-PLANE VRF: data Destination: 10.101.255.1 Next-hop: 10.101.255.1 - "
-                "Incorrect path direct:10 - Valid: False, Active: True",
+                "Incorrect path direct:10 - Valid: False Active: True",
                 "AVT: DATA-AVT-POLICY-CONTROL-PLANE VRF: data Destination: 10.101.255.1 Next-hop: 10.101.255.1 - "
-                "Incorrect path direct:9 - Valid: True, Active: False",
+                "Incorrect path direct:9 - Valid: True Active: False",
             ],
         },
     },
@@ -667,6 +667,6 @@ DATA: list[dict[str, Any]] = [
         "test": VerifyAVTRole,
         "eos_data": [{"role": "transit"}],
         "inputs": {"role": "edge"},
-        "expected": {"result": "failure", "messages": ["AVT role mismatch - Expected: edge, Actual: transit"]},
+        "expected": {"result": "failure", "messages": ["AVT role mismatch - Expected: edge Actual: transit"]},
     },
 ]
diff --git a/tests/units/anta_tests/test_bfd.py b/tests/units/anta_tests/test_bfd.py
index d809b4ac..dd67397b 100644
--- a/tests/units/anta_tests/test_bfd.py
+++ b/tests/units/anta_tests/test_bfd.py
@@ -471,7 +471,7 @@ DATA: list[dict[str, Any]] = [
         "inputs": None,
         "expected": {
             "result": "failure",
-            "messages": ["No IPv4 BFD peers are configured for any VRF."],
+            "messages": ["No IPv4 BFD peers are configured for any VRF"],
         },
     },
     {
diff --git a/tests/units/anta_tests/test_configuration.py b/tests/units/anta_tests/test_configuration.py
index 9e676a93..fd483378 100644
--- a/tests/units/anta_tests/test_configuration.py
+++ b/tests/units/anta_tests/test_configuration.py
@@ -58,6 +58,6 @@ DATA: list[dict[str, Any]] = [
         "test": VerifyRunningConfigLines,
         "eos_data": ["enable password something\nsome other line"],
         "inputs": {"regex_patterns": ["bla", "bleh"]},
-        "expected": {"result": "failure", "messages": ["Following patterns were not found: 'bla','bleh'"]},
+        "expected": {"result": "failure", "messages": ["Following patterns were not found: 'bla', 'bleh'"]},
     },
 ]
diff --git a/tests/units/anta_tests/test_connectivity.py b/tests/units/anta_tests/test_connectivity.py
index 1f5044b0..7fb9a114 100644
--- a/tests/units/anta_tests/test_connectivity.py
+++ b/tests/units/anta_tests/test_connectivity.py
@@ -306,7 +306,7 @@ DATA: list[dict[str, Any]] = [
         "inputs": {"hosts": [{"destination": "10.0.0.1", "source": "10.0.0.5", "reachable": False}]},
         "expected": {
             "result": "failure",
-            "messages": ["Host: 10.0.0.1 Source: 10.0.0.5 VRF: default - Destination is expected to be unreachable but found reachable."],
+            "messages": ["Host: 10.0.0.1 Source: 10.0.0.5 VRF: default - Destination is expected to be unreachable but found reachable"],
         },
     },
     {
diff --git a/tests/units/anta_tests/test_cvx.py b/tests/units/anta_tests/test_cvx.py
index 6d0d2421..be622938 100644
--- a/tests/units/anta_tests/test_cvx.py
+++ b/tests/units/anta_tests/test_cvx.py
@@ -60,7 +60,10 @@ DATA: list[dict[str, Any]] = [
         "test": VerifyMcsClientMounts,
         "eos_data": [{"mountStates": [{"path": "mcs/v1/toSwitch/28-99-3a-8f-93-7b", "type": "Mcs::DeviceConfigV1", "state": "mountStatePreservedUnmounted"}]}],
         "inputs": None,
-        "expected": {"result": "failure", "messages": ["MCS Client mount states are not valid: mountStatePreservedUnmounted"]},
+        "expected": {
+            "result": "failure",
+            "messages": ["MCS Client mount states are not valid - Expected: mountStateMountComplete Actual: mountStatePreservedUnmounted"],
+        },
     },
     {
         "name": "failure-partial-haclient",
@@ -74,7 +77,10 @@ DATA: list[dict[str, Any]] = [
             },
         ],
         "inputs": None,
-        "expected": {"result": "failure", "messages": ["MCS Client mount states are not valid: mountStatePreservedUnmounted"]},
+        "expected": {
+            "result": "failure",
+            "messages": ["MCS Client mount states are not valid - Expected: mountStateMountComplete Actual: mountStatePreservedUnmounted"],
+        },
     },
     {
         "name": "failure-full-haclient",
@@ -88,7 +94,10 @@ DATA: list[dict[str, Any]] = [
             },
         ],
         "inputs": None,
-        "expected": {"result": "failure", "messages": ["MCS Client mount states are not valid: mountStatePreservedUnmounted"]},
+        "expected": {
+            "result": "failure",
+            "messages": ["MCS Client mount states are not valid - Expected: mountStateMountComplete Actual: mountStatePreservedUnmounted"],
+        },
     },
     {
         "name": "failure-non-mcs-client",
@@ -111,7 +120,10 @@ DATA: list[dict[str, Any]] = [
             },
         ],
         "inputs": None,
-        "expected": {"result": "failure", "messages": ["MCS Client mount states are not valid: mountStatePreservedUnmounted"]},
+        "expected": {
+            "result": "failure",
+            "messages": ["MCS Client mount states are not valid - Expected: mountStateMountComplete Actual: mountStatePreservedUnmounted"],
+        },
     },
     {
         "name": "success-enabled",
@@ -140,18 +152,31 @@ DATA: list[dict[str, Any]] = [
         "expected": {"result": "success"},
     },
     {
-        "name": "failure - no enabled state",
+        "name": "failure-invalid-state",
+        "test": VerifyManagementCVX,
+        "eos_data": [
+            {
+                "clusterStatus": {
+                    "enabled": False,
+                }
+            }
+        ],
+        "inputs": {"enabled": True},
+        "expected": {"result": "failure", "messages": ["Management CVX status is not valid: Expected: enabled Actual: disabled"]},
+    },
+    {
+        "name": "failure-no-enabled state",
         "test": VerifyManagementCVX,
         "eos_data": [{"clusterStatus": {}}],
         "inputs": {"enabled": False},
-        "expected": {"result": "failure", "messages": ["Management CVX status is not valid: None"]},
+        "expected": {"result": "failure", "messages": ["Management CVX status - Not configured"]},
     },
     {
         "name": "failure - no clusterStatus",
         "test": VerifyManagementCVX,
         "eos_data": [{}],
         "inputs": {"enabled": False},
-        "expected": {"result": "failure", "messages": ["Management CVX status is not valid: None"]},
+        "expected": {"result": "failure", "messages": ["Management CVX status - Not configured"]},
     },
     {
         "name": "success",
@@ -189,7 +214,7 @@ DATA: list[dict[str, Any]] = [
         "inputs": {"connections_count": 1},
         "expected": {
             "result": "failure",
-            "messages": ["No mount status for media-leaf-1", "Incorrect CVX successful connections count. Expected: 1, Actual : 0"],
+            "messages": ["Host: media-leaf-1 - No mount status found", "Incorrect CVX successful connections count - Expected: 1 Actual: 0"],
         },
     },
     {
@@ -221,8 +246,9 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Incorrect number of mount path states for media-leaf-1 - Expected: 3, Actual: 2",
-                "Unexpected MCS path type for media-leaf-1: 'Mcs::ApiStatus'.",
+                "Host: media-leaf-1 - Incorrect number of mount path states - Expected: 3 Actual: 2",
+                "Host: media-leaf-1 - Unexpected MCS path type - Expected: Mcs::ApiConfigRedundancyStatus, Mcs::ActiveFlows, "
+                "Mcs::Client::Status Actual: Mcs::ApiStatus",
             ],
         },
     },
@@ -253,7 +279,13 @@ DATA: list[dict[str, Any]] = [
             }
         ],
         "inputs": {"connections_count": 1},
-        "expected": {"result": "failure", "messages": ["Unexpected MCS path type for media-leaf-1: 'Mcs::ApiStatus'"]},
+        "expected": {
+            "result": "failure",
+            "messages": [
+                "Host: media-leaf-1 - Unexpected MCS path type - Expected: Mcs::ApiConfigRedundancyStatus, Mcs::ActiveFlows, Mcs::Client::Status"
+                " Actual: Mcs::ApiStatus"
+            ],
+        },
     },
     {
         "name": "failure-invalid-mount-state",
@@ -284,7 +316,10 @@ DATA: list[dict[str, Any]] = [
         "inputs": {"connections_count": 1},
         "expected": {
             "result": "failure",
-            "messages": ["MCS server mount state for path 'Mcs::ApiConfigRedundancyStatus' is not valid is for media-leaf-1: 'mountStateMountFailed'"],
+            "messages": [
+                "Host: media-leaf-1 Path Type: Mcs::ApiConfigRedundancyStatus - MCS server mount state is not valid - Expected: mountStateMountComplete"
+                " Actual:mountStateMountFailed"
+            ],
         },
     },
     {
@@ -306,14 +341,14 @@ DATA: list[dict[str, Any]] = [
             }
         ],
         "inputs": {"connections_count": 1},
-        "expected": {"result": "failure", "messages": ["MCS mount state not detected", "Incorrect CVX successful connections count. Expected: 1, Actual : 0"]},
+        "expected": {"result": "failure", "messages": ["MCS mount state not detected", "Incorrect CVX successful connections count - Expected: 1 Actual: 0"]},
     },
     {
         "name": "failure-connections",
         "test": VerifyMcsServerMounts,
         "eos_data": [{}],
         "inputs": {"connections_count": 1},
-        "expected": {"result": "failure", "messages": ["CVX connections are not available."]},
+        "expected": {"result": "failure", "messages": ["CVX connections are not available"]},
     },
     {
         "name": "success",
@@ -357,7 +392,7 @@ DATA: list[dict[str, Any]] = [
             }
         ],
         "inputs": {"connections_count": 2},
-        "expected": {"result": "failure", "messages": ["CVX active connections count. Expected: 2, Actual : 1"]},
+        "expected": {"result": "failure", "messages": ["CVX active connections count - Expected: 2 Actual: 1"]},
     },
     {
         "name": "failure-no-connections",
@@ -414,7 +449,7 @@ DATA: list[dict[str, Any]] = [
                 {"peer_name": "cvx-red-3", "registrationState": "Registration complete"},
             ],
         },
-        "expected": {"result": "failure", "messages": ["CVX Role is not valid: Standby"]},
+        "expected": {"result": "failure", "messages": ["CVX Role is not valid: Expected: Master Actual: Standby"]},
     },
     {
         "name": "failure-cvx-enabled",
@@ -473,7 +508,7 @@ DATA: list[dict[str, Any]] = [
                 {"peer_name": "cvx-red-3", "registrationState": "Registration complete"},
             ],
         },
-        "expected": {"result": "failure", "messages": ["Unexpected number of peers 1 vs 2", "cvx-red-3 is not present"]},
+        "expected": {"result": "failure", "messages": ["Unexpected number of peers - Expected: 2 Actual: 1", "cvx-red-3 - Not present"]},
     },
     {
         "name": "failure-invalid-peers",
@@ -495,7 +530,7 @@ DATA: list[dict[str, Any]] = [
                 {"peer_name": "cvx-red-3", "registrationState": "Registration complete"},
             ],
         },
-        "expected": {"result": "failure", "messages": ["Unexpected number of peers 0 vs 2", "cvx-red-2 is not present", "cvx-red-3 is not present"]},
+        "expected": {"result": "failure", "messages": ["Unexpected number of peers - Expected: 2 Actual: 0", "cvx-red-2 - Not present", "cvx-red-3 - Not present"]},
     },
     {
         "name": "failure-registration-error",
@@ -520,6 +555,6 @@ DATA: list[dict[str, Any]] = [
                 {"peer_name": "cvx-red-3", "registrationState": "Registration complete"},
             ],
         },
-        "expected": {"result": "failure", "messages": ["cvx-red-2 registration state is not complete: Registration error"]},
+        "expected": {"result": "failure", "messages": ["cvx-red-2 - Invalid registration state - Expected: Registration complete Actual: Registration error"]},
     },
 ]
diff --git a/tests/units/anta_tests/test_flow_tracking.py b/tests/units/anta_tests/test_flow_tracking.py
index 6934c021..cdd27460 100644
--- a/tests/units/anta_tests/test_flow_tracking.py
+++ b/tests/units/anta_tests/test_flow_tracking.py
@@ -184,9 +184,9 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Flow Tracker: FLOW-TRACKER, Inactive Timeout: 6000, Active Interval: 30000 - Incorrect timers - Inactive Timeout: 60000, OnActive Interval: 300000",
-                "Flow Tracker: HARDWARE-TRACKER, Inactive Timeout: 60000, Active Interval: 300000 - Incorrect timers - "
-                "Inactive Timeout: 6000, OnActive Interval: 30000",
+                "Flow Tracker: FLOW-TRACKER Inactive Timeout: 6000 Active Interval: 30000 - Incorrect timers - Inactive Timeout: 60000 OnActive Interval: 300000",
+                "Flow Tracker: HARDWARE-TRACKER Inactive Timeout: 60000 Active Interval: 300000 - Incorrect timers - "
+                "Inactive Timeout: 6000 OnActive Interval: 30000",
             ],
         },
     },
@@ -239,11 +239,11 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Flow Tracker: FLOW-TRACKER, Exporter: CVP-FLOW - Incorrect local interface - Expected: Loopback10, Actual: Loopback0",
-                "Flow Tracker: FLOW-TRACKER, Exporter: CVP-FLOW - Incorrect template interval - Expected: 3500000, Actual: 3600000",
-                "Flow Tracker: HARDWARE-TRACKER, Exporter: Hardware-flow - Incorrect local interface - Expected: Loopback99, Actual: Loopback10",
-                "Flow Tracker: HARDWARE-TRACKER, Exporter: Hardware-flow - Incorrect template interval - Expected: 3000000, Actual: 3600000",
-                "Flow Tracker: HARDWARE-TRACKER, Exporter: Reverse-flow - Not configured",
+                "Flow Tracker: FLOW-TRACKER Exporter: CVP-FLOW - Incorrect local interface - Expected: Loopback10 Actual: Loopback0",
+                "Flow Tracker: FLOW-TRACKER Exporter: CVP-FLOW - Incorrect template interval - Expected: 3500000 Actual: 3600000",
+                "Flow Tracker: HARDWARE-TRACKER Exporter: Hardware-flow - Incorrect local interface - Expected: Loopback99 Actual: Loopback10",
+                "Flow Tracker: HARDWARE-TRACKER Exporter: Hardware-flow - Incorrect template interval - Expected: 3000000 Actual: 3600000",
+                "Flow Tracker: HARDWARE-TRACKER Exporter: Reverse-flow - Not configured",
             ],
         },
     },
@@ -326,13 +326,12 @@ DATA: list[dict[str, Any]] = [
             "messages": [
                 "Flow Tracker: FLOW-Sample - Not found",
                 "Flow Tracker: FLOW-TRIGGER - Disabled",
-                "Flow Tracker: HARDWARE-FLOW, Inactive Timeout: 60000, Active Interval: 300000 - Incorrect timers - "
-                "Inactive Timeout: 6000, OnActive Interval: 30000",
-                "Flow Tracker: FLOW-TRACKER2, Exporter: CVP-FLOW - Incorrect local interface - Expected: Loopback10, Actual: Loopback0",
-                "Flow Tracker: FLOW-TRACKER2, Exporter: CVP-FLOW - Incorrect template interval - Expected: 3500000, Actual: 3600000",
-                "Flow Tracker: HARDWARE-TRACKER2, Exporter: Hardware-flow - Incorrect local interface - Expected: Loopback99, Actual: Loopback10",
-                "Flow Tracker: HARDWARE-TRACKER2, Exporter: Hardware-flow - Incorrect template interval - Expected: 3000000, Actual: 3600000",
-                "Flow Tracker: HARDWARE-TRACKER2, Exporter: Reverse-flow - Not configured",
+                "Flow Tracker: HARDWARE-FLOW Inactive Timeout: 60000 Active Interval: 300000 - Incorrect timers - Inactive Timeout: 6000 OnActive Interval: 30000",
+                "Flow Tracker: FLOW-TRACKER2 Exporter: CVP-FLOW - Incorrect local interface - Expected: Loopback10 Actual: Loopback0",
+                "Flow Tracker: FLOW-TRACKER2 Exporter: CVP-FLOW - Incorrect template interval - Expected: 3500000 Actual: 3600000",
+                "Flow Tracker: HARDWARE-TRACKER2 Exporter: Hardware-flow - Incorrect local interface - Expected: Loopback99 Actual: Loopback10",
+                "Flow Tracker: HARDWARE-TRACKER2 Exporter: Hardware-flow - Incorrect template interval - Expected: 3000000 Actual: 3600000",
+                "Flow Tracker: HARDWARE-TRACKER2 Exporter: Reverse-flow - Not configured",
             ],
         },
     },
diff --git a/tests/units/anta_tests/test_hardware.py b/tests/units/anta_tests/test_hardware.py
index 0dffe692..972b07f0 100644
--- a/tests/units/anta_tests/test_hardware.py
+++ b/tests/units/anta_tests/test_hardware.py
@@ -178,7 +178,7 @@ DATA: list[dict[str, Any]] = [
         "inputs": None,
         "expected": {
             "result": "failure",
-            "messages": ["Sensor: DomTemperatureSensor54 - Non-zero alert counter - Actual: 1"],
+            "messages": ["Sensor: DomTemperatureSensor54 - Incorrect alert counter - Expected: 0 Actual: 1"],
         },
     },
     {
@@ -917,6 +917,6 @@ DATA: list[dict[str, Any]] = [
         "test": VerifyAdverseDrops,
         "eos_data": [{"totalAdverseDrops": 10}],
         "inputs": None,
-        "expected": {"result": "failure", "messages": ["Non-zero total adverse drops counter - Actual: 10"]},
+        "expected": {"result": "failure", "messages": ["Incorrect total adverse drops counter - Expected: 0 Actual: 10"]},
     },
 ]
diff --git a/tests/units/anta_tests/test_interfaces.py b/tests/units/anta_tests/test_interfaces.py
index 65f60006..9f4ab116 100644
--- a/tests/units/anta_tests/test_interfaces.py
+++ b/tests/units/anta_tests/test_interfaces.py
@@ -1929,7 +1929,85 @@ DATA: list[dict[str, Any]] = [
             },
         ],
         "inputs": {"mtu": 1500},
-        "expected": {"result": "failure", "messages": ["Some L2 interfaces do not have correct MTU configured:\n[{'Ethernet10': 9214}, {'Port-Channel2': 9214}]"]},
+        "expected": {
+            "result": "failure",
+            "messages": [
+                "Interface: Ethernet10 - Incorrect MTU configured - Expected: 1500 Actual: 9214",
+                "Interface: Port-Channel2 - Incorrect MTU configured - Expected: 1500 Actual: 9214",
+            ],
+        },
+    },
+    {
+        "name": "failure-specific-interface",
+        "test": VerifyL2MTU,
+        "eos_data": [
+            {
+                "interfaces": {
+                    "Ethernet2": {
+                        "name": "Ethernet2",
+                        "forwardingModel": "routed",
+                        "lineProtocolStatus": "up",
+                        "interfaceStatus": "connected",
+                        "hardware": "ethernet",
+                        "mtu": 1600,
+                        "l3MtuConfigured": True,
+                        "l2Mru": 0,
+                    },
+                    "Ethernet10": {
+                        "name": "Ethernet10",
+                        "forwardingModel": "bridged",
+                        "lineProtocolStatus": "up",
+                        "interfaceStatus": "connected",
+                        "hardware": "ethernet",
+                        "mtu": 9214,
+                        "l3MtuConfigured": False,
+                        "l2Mru": 0,
+                    },
+                    "Management0": {
+                        "name": "Management0",
+                        "forwardingModel": "routed",
+                        "lineProtocolStatus": "up",
+                        "interfaceStatus": "connected",
+                        "hardware": "ethernet",
+                        "mtu": 1500,
+                        "l3MtuConfigured": False,
+                        "l2Mru": 0,
+                    },
+                    "Port-Channel2": {
+                        "name": "Port-Channel2",
+                        "forwardingModel": "bridged",
+                        "lineProtocolStatus": "lowerLayerDown",
+                        "interfaceStatus": "notconnect",
+                        "hardware": "portChannel",
+                        "mtu": 9214,
+                        "l3MtuConfigured": False,
+                        "l2Mru": 0,
+                    },
+                    "Loopback0": {
+                        "name": "Loopback0",
+                        "forwardingModel": "routed",
+                        "lineProtocolStatus": "up",
+                        "interfaceStatus": "connected",
+                        "hardware": "loopback",
+                        "mtu": 65535,
+                        "l3MtuConfigured": False,
+                        "l2Mru": 0,
+                    },
+                    "Vxlan1": {
+                        "name": "Vxlan1",
+                        "forwardingModel": "bridged",
+                        "lineProtocolStatus": "down",
+                        "interfaceStatus": "notconnect",
+                        "hardware": "vxlan",
+                        "mtu": 0,
+                        "l3MtuConfigured": False,
+                        "l2Mru": 0,
+                    },
+                },
+            },
+        ],
+        "inputs": {"specific_mtu": [{"Et10": 9214}, {"Port-Channel2": 10000}]},
+        "expected": {"result": "failure", "messages": ["Interface: Port-Channel2 - Incorrect MTU configured - Expected: 10000 Actual: 9214"]},
     },
     {
         "name": "success",
@@ -2235,7 +2313,7 @@ DATA: list[dict[str, Any]] = [
             }
         ],
         "inputs": {"mac_address": "00:1c:73:00:dc:01"},
-        "expected": {"result": "failure", "messages": ["IP virtual router MAC address `00:1c:73:00:dc:01` is not configured."]},
+        "expected": {"result": "failure", "messages": ["IP virtual router MAC address: 00:1c:73:00:dc:01 - Not configured"]},
     },
     {
         "name": "success",
@@ -2327,10 +2405,10 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "For interface Ethernet1:\nExpected `1Gbps` as the speed, but found `100Gbps` instead.",
-                "For interface Ethernet1/1/1:\nExpected `1Gbps` as the speed, but found `100Gbps` instead.",
-                "For interface Ethernet3:\nExpected `100Gbps` as the speed, but found `10Gbps` instead.",
-                "For interface Ethernet4:\nExpected `2.5Gbps` as the speed, but found `25Gbps` instead.",
+                "Interface: Ethernet1 - Bandwidth mismatch - Expected: 1.0Gbps Actual: 100Gbps",
+                "Interface: Ethernet1/1/1 - Bandwidth mismatch - Expected: 1.0Gbps Actual: 100Gbps",
+                "Interface: Ethernet3 - Bandwidth mismatch - Expected: 100.0Gbps Actual: 10Gbps",
+                "Interface: Ethernet4 - Bandwidth mismatch - Expected: 2.5Gbps Actual: 25Gbps",
             ],
         },
     },
@@ -2379,11 +2457,11 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "For interface Ethernet1:\nExpected `duplexFull` as the duplex mode, but found `duplexHalf` instead.",
-                "For interface Ethernet1/2/2:\nExpected `duplexFull` as the duplex mode, but found `duplexHalf` instead.",
-                "For interface Ethernet3:\nExpected `duplexFull` as the duplex mode, but found `duplexHalf` instead.",
-                "For interface Ethernet3:\nExpected `duplexFull` as the duplex mode, but found `duplexHalf` instead.",
-                "For interface Ethernet4:\nExpected `duplexFull` as the duplex mode, but found `duplexHalf` instead.",
+                "Interface: Ethernet1 - Duplex mode mismatch - Expected: duplexFull Actual: duplexHalf",
+                "Interface: Ethernet1/2/2 - Duplex mode mismatch - Expected: duplexFull Actual: duplexHalf",
+                "Interface: Ethernet3 - Duplex mode mismatch - Expected: duplexFull Actual: duplexHalf",
+                "Interface: Ethernet3 - Duplex mode mismatch - Expected: duplexFull Actual: duplexHalf",
+                "Interface: Ethernet4 - Duplex mode mismatch - Expected: duplexFull Actual: duplexHalf",
             ],
         },
     },
@@ -2437,10 +2515,10 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "For interface Ethernet1:\nExpected `2` as the lanes, but found `4` instead.",
-                "For interface Ethernet3:\nExpected `8` as the lanes, but found `4` instead.",
-                "For interface Ethernet4:\nExpected `4` as the lanes, but found `6` instead.",
-                "For interface Ethernet4/1/1:\nExpected `4` as the lanes, but found `6` instead.",
+                "Interface: Ethernet1 - Data lanes count mismatch - Expected: 2 Actual: 4",
+                "Interface: Ethernet3 - Data lanes count mismatch - Expected: 8 Actual: 4",
+                "Interface: Ethernet4 - Data lanes count mismatch - Expected: 4 Actual: 6",
+                "Interface: Ethernet4/1/1 - Data lanes count mismatch - Expected: 4 Actual: 6",
             ],
         },
     },
@@ -2479,36 +2557,26 @@ DATA: list[dict[str, Any]] = [
         ],
         "inputs": {
             "interfaces": [
-                {"name": "Ethernet1", "auto": False, "speed": 1},
                 {"name": "Ethernet1", "auto": False, "speed": 1, "lanes": 2},
                 {"name": "Ethernet2/1/2", "auto": False, "speed": 10},
-                {"name": "Ethernet3", "auto": True, "speed": 1},
                 {"name": "Ethernet3", "auto": True, "speed": 100, "lanes": 8},
-                {"name": "Ethernet3", "auto": True, "speed": 100},
                 {"name": "Ethernet4", "auto": False, "speed": 2.5},
             ]
         },
         "expected": {
             "result": "failure",
             "messages": [
-                "For interface Ethernet1:\nExpected `duplexFull` as the duplex mode, but found `duplexHalf` instead.\n"
-                "Expected `1Gbps` as the speed, but found `10Gbps` instead.",
-                "For interface Ethernet1:\nExpected `duplexFull` as the duplex mode, but found `duplexHalf` instead.\n"
-                "Expected `1Gbps` as the speed, but found `10Gbps` instead.\n"
-                "Expected `2` as the lanes, but found `4` instead.",
-                "For interface Ethernet2/1/2:\nExpected `duplexFull` as the duplex mode, but found `duplexHalf` instead.\n"
-                "Expected `10Gbps` as the speed, but found `1Gbps` instead.",
-                "For interface Ethernet3:\nExpected `success` as the auto negotiation, but found `unknown` instead.\n"
-                "Expected `duplexFull` as the duplex mode, but found `duplexHalf` instead.",
-                "For interface Ethernet3:\nExpected `success` as the auto negotiation, but found `unknown` instead.\n"
-                "Expected `duplexFull` as the duplex mode, but found `duplexHalf` instead.\n"
-                "Expected `100Gbps` as the speed, but found `10Gbps` instead.\n"
-                "Expected `8` as the lanes, but found `6` instead.",
-                "For interface Ethernet3:\nExpected `success` as the auto negotiation, but found `unknown` instead.\n"
-                "Expected `duplexFull` as the duplex mode, but found `duplexHalf` instead.\n"
-                "Expected `100Gbps` as the speed, but found `10Gbps` instead.",
-                "For interface Ethernet4:\nExpected `duplexFull` as the duplex mode, but found `duplexHalf` instead.\n"
-                "Expected `2.5Gbps` as the speed, but found `25Gbps` instead.",
+                "Interface: Ethernet1 - Bandwidth mismatch - Expected: 1.0Gbps Actual: 10Gbps",
+                "Interface: Ethernet1 - Duplex mode mismatch - Expected: duplexFull Actual: duplexHalf",
+                "Interface: Ethernet1 - Data lanes count mismatch - Expected: 2 Actual: 4",
+                "Interface: Ethernet2/1/2 - Bandwidth mismatch - Expected: 10.0Gbps Actual: 1Gbps",
+                "Interface: Ethernet2/1/2 - Duplex mode mismatch - Expected: duplexFull Actual: duplexHalf",
+                "Interface: Ethernet3 - Bandwidth mismatch - Expected: 100.0Gbps Actual: 10Gbps",
+                "Interface: Ethernet3 - Duplex mode mismatch - Expected: duplexFull Actual: duplexHalf",
+                "Interface: Ethernet3 - Auto-negotiation mismatch - Expected: success Actual: unknown",
+                "Interface: Ethernet3 - Data lanes count mismatch - Expected: 8 Actual: 6",
+                "Interface: Ethernet4 - Bandwidth mismatch - Expected: 2.5Gbps Actual: 25Gbps",
+                "Interface: Ethernet4 - Duplex mode mismatch - Expected: duplexFull Actual: duplexHalf",
             ],
         },
     },
diff --git a/tests/units/anta_tests/test_logging.py b/tests/units/anta_tests/test_logging.py
index a4b93e72..9ad03630 100644
--- a/tests/units/anta_tests/test_logging.py
+++ b/tests/units/anta_tests/test_logging.py
@@ -97,7 +97,7 @@ DATA: list[dict[str, Any]] = [
                 """,
         ],
         "inputs": {"interface": "Management0", "vrf": "MGMT"},
-        "expected": {"result": "failure", "messages": ["Source-interface 'Management0' is not configured in VRF MGMT"]},
+        "expected": {"result": "failure", "messages": ["Source-interface: Management0 VRF: MGMT - Not configured"]},
     },
     {
         "name": "failure-vrf",
@@ -112,7 +112,7 @@ DATA: list[dict[str, Any]] = [
                 """,
         ],
         "inputs": {"interface": "Management0", "vrf": "MGMT"},
-        "expected": {"result": "failure", "messages": ["Source-interface 'Management0' is not configured in VRF MGMT"]},
+        "expected": {"result": "failure", "messages": ["Source-interface: Management0 VRF: MGMT - Not configured"]},
     },
     {
         "name": "success",
@@ -317,6 +317,6 @@ DATA: list[dict[str, Any]] = [
             accounting                 debugging           debugging""",
         ],
         "inputs": None,
-        "expected": {"result": "failure", "messages": ["Syslog logging is disabled."]},
+        "expected": {"result": "failure", "messages": ["Syslog logging is disabled"]},
     },
 ]
diff --git a/tests/units/anta_tests/test_mlag.py b/tests/units/anta_tests/test_mlag.py
index 2a0cd25d..c49e0f71 100644
--- a/tests/units/anta_tests/test_mlag.py
+++ b/tests/units/anta_tests/test_mlag.py
@@ -329,7 +329,7 @@ DATA: list[dict[str, Any]] = [
         "inputs": {"primary_priority": 32767},
         "expected": {
             "result": "failure",
-            "messages": ["The device is not set as MLAG primary."],
+            "messages": ["The device is not set as MLAG primary"],
         },
     },
     {
@@ -344,7 +344,7 @@ DATA: list[dict[str, Any]] = [
         "inputs": {"primary_priority": 1},
         "expected": {
             "result": "failure",
-            "messages": ["The device is not set as MLAG primary.", "MLAG primary priority mismatch - Expected: 1 Actual: 32767"],
+            "messages": ["The device is not set as MLAG primary", "MLAG primary priority mismatch - Expected: 1 Actual: 32767"],
         },
     },
 ]
diff --git a/tests/units/anta_tests/test_multicast.py b/tests/units/anta_tests/test_multicast.py
index 753cd10a..7e33e26f 100644
--- a/tests/units/anta_tests/test_multicast.py
+++ b/tests/units/anta_tests/test_multicast.py
@@ -104,7 +104,10 @@ DATA: list[dict[str, Any]] = [
             },
         ],
         "inputs": {"vlans": {1: False, 42: False}},
-        "expected": {"result": "failure", "messages": ["IGMP state for vlan 1 is enabled", "Supplied vlan 42 is not present on the device."]},
+        "expected": {
+            "result": "failure",
+            "messages": ["VLAN1 - Incorrect IGMP state - Expected: disabled Actual: enabled", "Supplied vlan 42 is not present on the device"],
+        },
     },
     {
         "name": "failure-wrong-state",
@@ -132,7 +135,7 @@ DATA: list[dict[str, Any]] = [
             },
         ],
         "inputs": {"vlans": {1: True}},
-        "expected": {"result": "failure", "messages": ["IGMP state for vlan 1 is disabled"]},
+        "expected": {"result": "failure", "messages": ["VLAN1 - Incorrect IGMP state - Expected: enabled Actual: disabled"]},
     },
     {
         "name": "success-enabled",
@@ -171,6 +174,6 @@ DATA: list[dict[str, Any]] = [
             },
         ],
         "inputs": {"enabled": True},
-        "expected": {"result": "failure", "messages": ["IGMP state is not valid: disabled"]},
+        "expected": {"result": "failure", "messages": ["IGMP state is not valid - Expected: enabled Actual: disabled"]},
     },
 ]
diff --git a/tests/units/anta_tests/test_path_selection.py b/tests/units/anta_tests/test_path_selection.py
index f003df95..45b0e24d 100644
--- a/tests/units/anta_tests/test_path_selection.py
+++ b/tests/units/anta_tests/test_path_selection.py
@@ -58,7 +58,7 @@ DATA: list[dict[str, Any]] = [
             {"dpsPeers": {}},
         ],
         "inputs": {},
-        "expected": {"result": "failure", "messages": ["No path configured for router path-selection."]},
+        "expected": {"result": "failure", "messages": ["No path configured for router path-selection"]},
     },
     {
         "name": "failure-not-established",
@@ -101,9 +101,9 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Path state for peer 10.255.0.1 in path-group internet is `ipsecPending`.",
-                "Path state for peer 10.255.0.1 in path-group mpls is `ipsecPending`.",
-                "Path state for peer 10.255.0.2 in path-group mpls is `ipsecPending`.",
+                "Peer: 10.255.0.1 Path Group: internet - Invalid path state - Expected: ipsecEstablished, routeResolved Actual: ipsecPending",
+                "Peer: 10.255.0.1 Path Group: mpls - Invalid path state - Expected: ipsecEstablished, routeResolved Actual: ipsecPending",
+                "Peer: 10.255.0.2 Path Group: mpls - Invalid path state - Expected: ipsecEstablished, routeResolved Actual: ipsecPending",
             ],
         },
     },
@@ -148,9 +148,9 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Telemetry state for peer 10.255.0.1 in path-group internet is `inactive`.",
-                "Telemetry state for peer 10.255.0.1 in path-group mpls is `inactive`.",
-                "Telemetry state for peer 10.255.0.2 in path-group mpls is `inactive`.",
+                "Peer: 10.255.0.1 Path Group internet - Telemetry state inactive",
+                "Peer: 10.255.0.1 Path Group mpls - Telemetry state inactive",
+                "Peer: 10.255.0.2 Path Group mpls - Telemetry state inactive",
             ],
         },
     },
@@ -224,8 +224,8 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Peer: 10.255.0.1, PathGroup: internet, Source: 100.64.3.2, Destination: 100.64.1.2 - No DPS path found for this peer and path group",
-                "Peer: 10.255.0.2, PathGroup: mpls, Source: 172.18.13.2, Destination: 172.18.15.2 - No DPS path found for this peer and path group.",
+                "Peer: 10.255.0.1 PathGroup: internet Source: 100.64.3.2 Destination: 100.64.1.2 - No DPS path found for this peer and path group",
+                "Peer: 10.255.0.2 PathGroup: mpls Source: 172.18.13.2 Destination: 172.18.15.2 - No DPS path found for this peer and path group",
             ],
         },
     },
@@ -241,7 +241,7 @@ DATA: list[dict[str, Any]] = [
         "test": VerifySpecificPath,
         "eos_data": [{"dpsPeers": {"10.255.0.2": {}}}],
         "inputs": {"paths": [{"peer": "10.255.0.1", "path_group": "internet", "source_address": "172.18.3.2", "destination_address": "172.18.5.2"}]},
-        "expected": {"result": "failure", "messages": ["Peer: 10.255.0.1, PathGroup: internet, Source: 172.18.3.2, Destination: 172.18.5.2 - Peer not found"]},
+        "expected": {"result": "failure", "messages": ["Peer: 10.255.0.1 PathGroup: internet Source: 172.18.3.2 Destination: 172.18.5.2 - Peer not found"]},
     },
     {
         "name": "failure-not-established",
@@ -287,10 +287,10 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Peer: 10.255.0.1, PathGroup: internet, Source: 172.18.3.2, Destination: 172.18.5.2 - State is not in ipsecEstablished, routeResolved."
-                " Actual: ipsecPending",
-                "Peer: 10.255.0.2, PathGroup: mpls, Source: 172.18.13.2, Destination: 172.18.15.2 - State is not in ipsecEstablished, routeResolved."
-                " Actual: ipsecPending",
+                "Peer: 10.255.0.1 PathGroup: internet Source: 172.18.3.2 Destination: 172.18.5.2 - Invalid state path - Expected: ipsecEstablished, routeResolved "
+                "Actual: ipsecPending",
+                "Peer: 10.255.0.2 PathGroup: mpls Source: 172.18.13.2 Destination: 172.18.15.2 - Invalid state path - Expected: ipsecEstablished, routeResolved "
+                "Actual: ipsecPending",
             ],
         },
     },
@@ -335,8 +335,8 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Peer: 10.255.0.1, PathGroup: internet, Source: 172.18.3.2, Destination: 172.18.5.2 - Telemetry state inactive for this path",
-                "Peer: 10.255.0.2, PathGroup: mpls, Source: 172.18.13.2, Destination: 172.18.15.2 - Telemetry state inactive for this path",
+                "Peer: 10.255.0.1 PathGroup: internet Source: 172.18.3.2 Destination: 172.18.5.2 - Telemetry state inactive for this path",
+                "Peer: 10.255.0.2 PathGroup: mpls Source: 172.18.13.2 Destination: 172.18.15.2 - Telemetry state inactive for this path",
             ],
         },
     },
@@ -376,8 +376,8 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Peer: 10.255.0.1, PathGroup: internet, Source: 172.18.3.2, Destination: 172.18.5.2 - No path matching the source and destination found",
-                "Peer: 10.255.0.2, PathGroup: mpls, Source: 172.18.13.2, Destination: 172.18.15.2 - No path matching the source and destination found",
+                "Peer: 10.255.0.1 PathGroup: internet Source: 172.18.3.2 Destination: 172.18.5.2 - No path matching the source and destination found",
+                "Peer: 10.255.0.2 PathGroup: mpls Source: 172.18.13.2 Destination: 172.18.15.2 - No path matching the source and destination found",
             ],
         },
     },
diff --git a/tests/units/anta_tests/test_profiles.py b/tests/units/anta_tests/test_profiles.py
index 63c75c5d..4277a95a 100644
--- a/tests/units/anta_tests/test_profiles.py
+++ b/tests/units/anta_tests/test_profiles.py
@@ -23,7 +23,7 @@ DATA: list[dict[str, Any]] = [
         "test": VerifyUnifiedForwardingTableMode,
         "eos_data": [{"uftMode": "2", "urpfEnabled": False, "chipModel": "bcm56870", "l2TableSize": 163840, "l3TableSize": 147456, "lpmTableSize": 32768}],
         "inputs": {"mode": 3},
-        "expected": {"result": "failure", "messages": ["Not running the correct UFT mode - Expected: 3, Actual: 2"]},
+        "expected": {"result": "failure", "messages": ["Not running the correct UFT mode - Expected: 3 Actual: 2"]},
     },
     {
         "name": "success",
diff --git a/tests/units/anta_tests/test_ptp.py b/tests/units/anta_tests/test_ptp.py
index 91f7f035..8ff2d6c9 100644
--- a/tests/units/anta_tests/test_ptp.py
+++ b/tests/units/anta_tests/test_ptp.py
@@ -99,7 +99,7 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "The device is locked to the following Grandmaster: '0x00:1c:73:ff:ff:0a:00:01', which differ from the expected one.",
+                "The device is locked to the incorrect Grandmaster - Expected: 0xec:46:70:ff:fe:00:ff:a8 Actual: 0x00:1c:73:ff:ff:0a:00:01",
             ],
         },
     },
diff --git a/tests/units/anta_tests/test_security.py b/tests/units/anta_tests/test_security.py
index 5974eb92..6f4d370d 100644
--- a/tests/units/anta_tests/test_security.py
+++ b/tests/units/anta_tests/test_security.py
@@ -42,7 +42,7 @@ DATA: list[dict[str, Any]] = [
         "test": VerifySSHStatus,
         "eos_data": ["SSH per host connection limit is 20\nFIPS status: disabled\n\n"],
         "inputs": None,
-        "expected": {"result": "failure", "messages": ["Could not find SSH status in returned output."]},
+        "expected": {"result": "failure", "messages": ["Could not find SSH status in returned output"]},
     },
     {
         "name": "failure-ssh-enabled",
@@ -83,14 +83,14 @@ DATA: list[dict[str, Any]] = [
         "test": VerifySSHIPv4Acl,
         "eos_data": [{"ipAclList": {"aclList": []}}],
         "inputs": {"number": 1, "vrf": "MGMT"},
-        "expected": {"result": "failure", "messages": ["Expected 1 SSH IPv4 ACL(s) in vrf MGMT but got 0"]},
+        "expected": {"result": "failure", "messages": ["VRF: MGMT - SSH IPv4 ACL(s) count mismatch - Expected: 1 Actual: 0"]},
     },
     {
         "name": "failure-wrong-vrf",
         "test": VerifySSHIPv4Acl,
         "eos_data": [{"ipAclList": {"aclList": [{"type": "Ip4Acl", "name": "ACL_IPV4_SSH", "configuredVrfs": ["default"], "activeVrfs": ["default"]}]}}],
         "inputs": {"number": 1, "vrf": "MGMT"},
-        "expected": {"result": "failure", "messages": ["SSH IPv4 ACL(s) not configured or active in vrf MGMT: ACL_IPV4_SSH"]},
+        "expected": {"result": "failure", "messages": ["VRF: MGMT - Following SSH IPv4 ACL(s) not configured or active: ACL_IPV4_SSH"]},
     },
     {
         "name": "success",
@@ -104,14 +104,14 @@ DATA: list[dict[str, Any]] = [
         "test": VerifySSHIPv6Acl,
         "eos_data": [{"ipv6AclList": {"aclList": []}}],
         "inputs": {"number": 1, "vrf": "MGMT"},
-        "expected": {"result": "failure", "messages": ["Expected 1 SSH IPv6 ACL(s) in vrf MGMT but got 0"]},
+        "expected": {"result": "failure", "messages": ["VRF: MGMT - SSH IPv6 ACL(s) count mismatch - Expected: 1 Actual: 0"]},
     },
     {
         "name": "failure-wrong-vrf",
         "test": VerifySSHIPv6Acl,
         "eos_data": [{"ipv6AclList": {"aclList": [{"type": "Ip6Acl", "name": "ACL_IPV6_SSH", "configuredVrfs": ["default"], "activeVrfs": ["default"]}]}}],
         "inputs": {"number": 1, "vrf": "MGMT"},
-        "expected": {"result": "failure", "messages": ["SSH IPv6 ACL(s) not configured or active in vrf MGMT: ACL_IPV6_SSH"]},
+        "expected": {"result": "failure", "messages": ["VRF: MGMT - Following SSH IPv6 ACL(s) not configured or active: ACL_IPV6_SSH"]},
     },
     {
         "name": "success",
@@ -223,14 +223,14 @@ DATA: list[dict[str, Any]] = [
         "test": VerifyAPIIPv4Acl,
         "eos_data": [{"ipAclList": {"aclList": []}}],
         "inputs": {"number": 1, "vrf": "MGMT"},
-        "expected": {"result": "failure", "messages": ["Expected 1 eAPI IPv4 ACL(s) in vrf MGMT but got 0"]},
+        "expected": {"result": "failure", "messages": ["VRF: MGMT - eAPI IPv4 ACL(s) count mismatch - Expected: 1 Actual: 0"]},
     },
     {
         "name": "failure-wrong-vrf",
         "test": VerifyAPIIPv4Acl,
         "eos_data": [{"ipAclList": {"aclList": [{"type": "Ip4Acl", "name": "ACL_IPV4_API", "configuredVrfs": ["default"], "activeVrfs": ["default"]}]}}],
         "inputs": {"number": 1, "vrf": "MGMT"},
-        "expected": {"result": "failure", "messages": ["eAPI IPv4 ACL(s) not configured or active in vrf MGMT: ACL_IPV4_API"]},
+        "expected": {"result": "failure", "messages": ["VRF: MGMT - Following eAPI IPv4 ACL(s) not configured or active: ACL_IPV4_API"]},
     },
     {
         "name": "success",
@@ -244,14 +244,14 @@ DATA: list[dict[str, Any]] = [
         "test": VerifyAPIIPv6Acl,
         "eos_data": [{"ipv6AclList": {"aclList": []}}],
         "inputs": {"number": 1, "vrf": "MGMT"},
-        "expected": {"result": "failure", "messages": ["Expected 1 eAPI IPv6 ACL(s) in vrf MGMT but got 0"]},
+        "expected": {"result": "failure", "messages": ["VRF: MGMT - eAPI IPv6 ACL(s) count mismatch - Expected: 1 Actual: 0"]},
     },
     {
         "name": "failure-wrong-vrf",
         "test": VerifyAPIIPv6Acl,
         "eos_data": [{"ipv6AclList": {"aclList": [{"type": "Ip6Acl", "name": "ACL_IPV6_API", "configuredVrfs": ["default"], "activeVrfs": ["default"]}]}}],
         "inputs": {"number": 1, "vrf": "MGMT"},
-        "expected": {"result": "failure", "messages": ["eAPI IPv6 ACL(s) not configured or active in vrf MGMT: ACL_IPV6_API"]},
+        "expected": {"result": "failure", "messages": ["VRF: MGMT - Following eAPI IPv6 ACL(s) not configured or active: ACL_IPV6_API"]},
     },
     {
         "name": "success",
@@ -640,12 +640,26 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Expected `Copyright (c) 2023-2024 Arista Networks, Inc.\nUse of this source code is governed by the Apache License 2.0\n"
-                "that can be found in the LICENSE file.` as the login banner, but found `Copyright (c) 2023 Arista Networks, Inc.\nUse of this source code is "
-                "governed by the Apache License 2.0\nthat can be found in the LICENSE file.` instead."
+                "Incorrect login banner configured - Expected: Copyright (c) 2023-2024 Arista Networks, Inc.\n"
+                "Use of this source code is governed by the Apache License 2.0\nthat can be found in the LICENSE file. "
+                "Actual: Copyright (c) 2023 Arista Networks, Inc.\n"
+                "Use of this source code is governed by the Apache License 2.0\nthat can be found in the LICENSE file."
             ],
         },
     },
+    {
+        "name": "failure-login-banner-not-configured",
+        "test": VerifyBannerLogin,
+        "eos_data": [{"loginBanner": ""}],
+        "inputs": {
+            "login_banner": "Copyright (c) 2023-2024 Arista Networks, Inc.\nUse of this source code is governed by the Apache License 2.0\n"
+            "that can be found in the LICENSE file."
+        },
+        "expected": {
+            "result": "failure",
+            "messages": ["Login banner is not configured"],
+        },
+    },
     {
         "name": "success",
         "test": VerifyBannerMotd,
@@ -693,12 +707,26 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Expected `Copyright (c) 2023-2024 Arista Networks, Inc.\nUse of this source code is governed by the Apache License 2.0\n"
-                "that can be found in the LICENSE file.` as the motd banner, but found `Copyright (c) 2023 Arista Networks, Inc.\nUse of this source code is "
-                "governed by the Apache License 2.0\nthat can be found in the LICENSE file.` instead."
+                "Incorrect MOTD banner configured - Expected: Copyright (c) 2023-2024 Arista Networks, Inc.\n"
+                "Use of this source code is governed by the Apache License 2.0\nthat can be found in the LICENSE file. "
+                "Actual: Copyright (c) 2023 Arista Networks, Inc.\nUse of this source code is governed by the Apache License 2.0\n"
+                "that can be found in the LICENSE file."
             ],
         },
     },
+    {
+        "name": "failure-login-banner-not-configured",
+        "test": VerifyBannerMotd,
+        "eos_data": [{"motd": ""}],
+        "inputs": {
+            "motd_banner": "Copyright (c) 2023-2024 Arista Networks, Inc.\nUse of this source code is governed by the Apache License 2.0\n"
+            "that can be found in the LICENSE file."
+        },
+        "expected": {
+            "result": "failure",
+            "messages": ["MOTD banner is not configured"],
+        },
+    },
     {
         "name": "success",
         "test": VerifyIPv4ACL,
@@ -954,7 +982,7 @@ DATA: list[dict[str, Any]] = [
         "test": VerifyIPSecConnHealth,
         "eos_data": [{"connections": {}}],
         "inputs": {},
-        "expected": {"result": "failure", "messages": ["No IPv4 security connection configured."]},
+        "expected": {"result": "failure", "messages": ["No IPv4 security connection configured"]},
     },
     {
         "name": "failure-not-established",
@@ -976,9 +1004,8 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "The following IPv4 security connections are not established:\n"
-                "source:172.18.3.2 destination:172.18.2.2 vrf:default\n"
-                "source:100.64.3.2 destination:100.64.5.2 vrf:Guest."
+                "Source: 172.18.3.2 Destination: 172.18.2.2 VRF: default - IPv4 security connection not established",
+                "Source: 100.64.3.2 Destination: 100.64.5.2 VRF: Guest - IPv4 security connection not established",
             ],
         },
     },
@@ -1129,10 +1156,10 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Peer: 10.255.0.1 VRF: default Source: 172.18.3.2 Destination: 172.18.2.2 - Connection down - Expected: Established, Actual: Idle",
-                "Peer: 10.255.0.1 VRF: default Source: 100.64.2.2 Destination: 100.64.1.2 - Connection down - Expected: Established, Actual: Idle",
-                "Peer: 10.255.0.2 VRF: MGMT Source: 100.64.2.2 Destination: 100.64.1.2 - Connection down - Expected: Established, Actual: Idle",
-                "Peer: 10.255.0.2 VRF: MGMT Source: 172.18.2.2 Destination: 172.18.1.2 - Connection down - Expected: Established, Actual: Idle",
+                "Peer: 10.255.0.1 VRF: default Source: 172.18.3.2 Destination: 172.18.2.2 - Connection down - Expected: Established Actual: Idle",
+                "Peer: 10.255.0.1 VRF: default Source: 100.64.2.2 Destination: 100.64.1.2 - Connection down - Expected: Established Actual: Idle",
+                "Peer: 10.255.0.2 VRF: MGMT Source: 100.64.2.2 Destination: 100.64.1.2 - Connection down - Expected: Established Actual: Idle",
+                "Peer: 10.255.0.2 VRF: MGMT Source: 172.18.2.2 Destination: 172.18.1.2 - Connection down - Expected: Established Actual: Idle",
             ],
         },
     },
@@ -1192,8 +1219,8 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Peer: 10.255.0.1 VRF: default Source: 172.18.3.2 Destination: 172.18.2.2 - Connection down - Expected: Established, Actual: Idle",
-                "Peer: 10.255.0.1 VRF: default Source: 100.64.3.2 Destination: 100.64.2.2 - Connection down - Expected: Established, Actual: Idle",
+                "Peer: 10.255.0.1 VRF: default Source: 172.18.3.2 Destination: 172.18.2.2 - Connection down - Expected: Established Actual: Idle",
+                "Peer: 10.255.0.1 VRF: default Source: 100.64.3.2 Destination: 100.64.2.2 - Connection down - Expected: Established Actual: Idle",
                 "Peer: 10.255.0.2 VRF: default Source: 100.64.4.2 Destination: 100.64.1.2 - Connection not found.",
                 "Peer: 10.255.0.2 VRF: default Source: 172.18.4.2 Destination: 172.18.1.2 - Connection not found.",
             ],
@@ -1211,7 +1238,7 @@ DATA: list[dict[str, Any]] = [
         "test": VerifyHardwareEntropy,
         "eos_data": [{"cpuModel": "2.20GHz", "cryptoModule": "Crypto Module v3.0", "hardwareEntropyEnabled": False, "blockedNetworkProtocols": []}],
         "inputs": {},
-        "expected": {"result": "failure", "messages": ["Hardware entropy generation is disabled."]},
+        "expected": {"result": "failure", "messages": ["Hardware entropy generation is disabled"]},
     },
 ]
 
diff --git a/tests/units/anta_tests/test_snmp.py b/tests/units/anta_tests/test_snmp.py
index 48c6bbb1..255443d9 100644
--- a/tests/units/anta_tests/test_snmp.py
+++ b/tests/units/anta_tests/test_snmp.py
@@ -123,7 +123,7 @@ DATA: list[dict[str, Any]] = [
         "inputs": {"location": "New York"},
         "expected": {
             "result": "failure",
-            "messages": ["SNMP location is not configured."],
+            "messages": ["SNMP location is not configured"],
         },
     },
     {
@@ -162,7 +162,7 @@ DATA: list[dict[str, Any]] = [
         "inputs": {"contact": "Bob@example.com"},
         "expected": {
             "result": "failure",
-            "messages": ["SNMP contact is not configured."],
+            "messages": ["SNMP contact is not configured"],
         },
     },
     {
@@ -208,7 +208,7 @@ DATA: list[dict[str, Any]] = [
             }
         ],
         "inputs": {},
-        "expected": {"result": "failure", "messages": ["SNMP counters not found."]},
+        "expected": {"result": "failure", "messages": ["SNMP counters not found"]},
     },
     {
         "name": "failure-incorrect-counters",
@@ -297,7 +297,7 @@ DATA: list[dict[str, Any]] = [
             }
         ],
         "inputs": {},
-        "expected": {"result": "failure", "messages": ["SNMP counters not found."]},
+        "expected": {"result": "failure", "messages": ["SNMP counters not found"]},
     },
     {
         "name": "failure-incorrect-counters",
@@ -580,7 +580,7 @@ DATA: list[dict[str, Any]] = [
                 {"hostname": "192.168.1.101", "vrf": "default", "notification_type": "trap", "version": "v2c", "udp_port": 162, "community_string": "public"},
             ]
         },
-        "expected": {"result": "failure", "messages": ["No SNMP host is configured."]},
+        "expected": {"result": "failure", "messages": ["No SNMP host is configured"]},
     },
     {
         "name": "failure-details-host-not-found",
@@ -641,8 +641,8 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Host: 192.168.1.100 VRF: default - Incorrect notification type - Expected: inform, Actual: trap",
-                "Host: 192.168.1.101 VRF: default - Incorrect notification type - Expected: trap, Actual: inform",
+                "Host: 192.168.1.100 VRF: default - Incorrect notification type - Expected: inform Actual: trap",
+                "Host: 192.168.1.101 VRF: default - Incorrect notification type - Expected: trap Actual: inform",
             ],
         },
     },
@@ -680,8 +680,8 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Host: 192.168.1.100 VRF: default - Incorrect UDP port - Expected: 162, Actual: 163",
-                "Host: 192.168.1.101 VRF: default - Incorrect UDP port - Expected: 162, Actual: 164",
+                "Host: 192.168.1.100 VRF: default - Incorrect UDP port - Expected: 162 Actual: 163",
+                "Host: 192.168.1.101 VRF: default - Incorrect UDP port - Expected: 162 Actual: 164",
             ],
         },
     },
@@ -719,8 +719,8 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Host: 192.168.1.100 VRF: default Version: v1 - Incorrect community string - Expected: public, Actual: private",
-                "Host: 192.168.1.101 VRF: default Version: v2c - Incorrect community string - Expected: public, Actual: private",
+                "Host: 192.168.1.100 VRF: default Version: v1 - Incorrect community string - Expected: public Actual: private",
+                "Host: 192.168.1.101 VRF: default Version: v2c - Incorrect community string - Expected: public Actual: private",
             ],
         },
     },
@@ -746,7 +746,7 @@ DATA: list[dict[str, Any]] = [
                 {"hostname": "192.168.1.100", "vrf": "default", "notification_type": "trap", "version": "v3", "udp_port": 162, "user": "public"},
             ]
         },
-        "expected": {"result": "failure", "messages": ["Host: 192.168.1.100 VRF: default Version: v3 - Incorrect user - Expected: public, Actual: private"]},
+        "expected": {"result": "failure", "messages": ["Host: 192.168.1.100 VRF: default Version: v3 - Incorrect user - Expected: public Actual: private"]},
     },
     {
         "name": "success",
@@ -920,14 +920,14 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Group: Group1, Version: v1 - Incorrect Read view - Expected: group_read_1, Actual: group_read",
-                "Group: Group1, Version: v1 - Incorrect Write view - Expected: group_write_1, Actual: group_write",
-                "Group: Group1, Version: v1 - Incorrect Notify view - Expected: group_notify_1, Actual: group_notify",
-                "Group: Group2, Version: v2c - Incorrect Read view - Expected: group_read_2, Actual: group_read",
-                "Group: Group2, Version: v2c - Incorrect Notify view - Expected: group_notify_2, Actual: group_notify",
-                "Group: Group3, Version: v3 - Incorrect Read view - Expected: group_read_3, Actual: group_read",
-                "Group: Group3, Version: v3 - Incorrect Write view - Expected: group_write_3, Actual: group_write",
-                "Group: Group3, Version: v3 - Incorrect Notify view - Expected: group_notify_3, Actual: group_notify",
+                "Group: Group1 Version: v1 - Incorrect Read view - Expected: group_read_1 Actual: group_read",
+                "Group: Group1 Version: v1 - Incorrect Write view - Expected: group_write_1 Actual: group_write",
+                "Group: Group1 Version: v1 - Incorrect Notify view - Expected: group_notify_1 Actual: group_notify",
+                "Group: Group2 Version: v2c - Incorrect Read view - Expected: group_read_2 Actual: group_read",
+                "Group: Group2 Version: v2c - Incorrect Notify view - Expected: group_notify_2 Actual: group_notify",
+                "Group: Group3 Version: v3 - Incorrect Read view - Expected: group_read_3 Actual: group_read",
+                "Group: Group3 Version: v3 - Incorrect Write view - Expected: group_write_3 Actual: group_write",
+                "Group: Group3 Version: v3 - Incorrect Notify view - Expected: group_notify_3 Actual: group_notify",
             ],
         },
     },
@@ -995,14 +995,14 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Group: Group1, Version: v1, Read View: group_read - Not configured",
-                "Group: Group1, Version: v1, Write View: group_write - Not configured",
-                "Group: Group1, Version: v1, Notify View: group_notify - Not configured",
-                "Group: Group2, Version: v2c, Read View: group_read - Not configured",
-                "Group: Group2, Version: v2c, Write View: group_write - Not configured",
-                "Group: Group2, Version: v2c, Notify View: group_notify - Not configured",
-                "Group: Group3, Version: v3, Write View: group_write - Not configured",
-                "Group: Group3, Version: v3, Notify View: group_notify - Not configured",
+                "Group: Group1 Version: v1 Read View: group_read - Not configured",
+                "Group: Group1 Version: v1 Write View: group_write - Not configured",
+                "Group: Group1 Version: v1 Notify View: group_notify - Not configured",
+                "Group: Group2 Version: v2c Read View: group_read - Not configured",
+                "Group: Group2 Version: v2c Write View: group_write - Not configured",
+                "Group: Group2 Version: v2c Notify View: group_notify - Not configured",
+                "Group: Group3 Version: v3 Write View: group_write - Not configured",
+                "Group: Group3 Version: v3 Notify View: group_notify - Not configured",
             ],
         },
     },
@@ -1035,9 +1035,9 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Group: Group1, Version: v1 - Not configured",
-                "Group: Group2, Version: v2c - Not configured",
-                "Group: Group3, Version: v3 - Not configured",
+                "Group: Group1 Version: v1 - Not configured",
+                "Group: Group2 Version: v2c - Not configured",
+                "Group: Group3 Version: v3 - Not configured",
             ],
         },
     },
@@ -1078,7 +1078,7 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Group: Group3, Version: v3 - Incorrect security model - Expected: v3Priv, Actual: v3Auth",
+                "Group: Group3 Version: v3 - Incorrect security model - Expected: v3Priv Actual: v3Auth",
             ],
         },
     },
@@ -1106,7 +1106,7 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Group: Group3, Version: v3 View: write - Not configured",
+                "Group: Group3 Version: v3 View: write - Not configured",
             ],
         },
     },
diff --git a/tests/units/anta_tests/test_software.py b/tests/units/anta_tests/test_software.py
index 0bf88b83..217cfff8 100644
--- a/tests/units/anta_tests/test_software.py
+++ b/tests/units/anta_tests/test_software.py
@@ -145,7 +145,7 @@ DATA: list[dict[str, Any]] = [
             {"extensions": []},
         ],
         "inputs": None,
-        "expected": {"result": "failure", "messages": ["EOS extensions mismatch - Installed: AristaCloudGateway-1.0.1-1.swix, Configured: Not found"]},
+        "expected": {"result": "failure", "messages": ["EOS extensions mismatch - Installed: AristaCloudGateway-1.0.1-1.swix Configured: Not found"]},
     },
     {
         "name": "failure-multiple-extensions",
@@ -194,7 +194,7 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "EOS extensions mismatch - Installed: AristaCloudGateway-1.0.1-1.swix, Configured: AristaCloudGateway-1.0.1-1.swix, EOS-4.33.0F-NDRSensor.swix"
+                "EOS extensions mismatch - Installed: AristaCloudGateway-1.0.1-1.swix Configured: AristaCloudGateway-1.0.1-1.swix, EOS-4.33.0F-NDRSensor.swix"
             ],
         },
     },
diff --git a/tests/units/anta_tests/test_stp.py b/tests/units/anta_tests/test_stp.py
index 3dbd8c5d..539c5e92 100644
--- a/tests/units/anta_tests/test_stp.py
+++ b/tests/units/anta_tests/test_stp.py
@@ -574,7 +574,7 @@ DATA: list[dict[str, Any]] = [
             },
         ],
         "inputs": {"threshold": 10},
-        "expected": {"result": "failure", "messages": ["STP is not configured."]},
+        "expected": {"result": "failure", "messages": ["STP is not configured"]},
     },
     {
         "name": "success",
diff --git a/tests/units/anta_tests/test_stun.py b/tests/units/anta_tests/test_stun.py
index 1001af8a..0d1363c0 100644
--- a/tests/units/anta_tests/test_stun.py
+++ b/tests/units/anta_tests/test_stun.py
@@ -108,7 +108,7 @@ DATA: list[dict[str, Any]] = [
         },
         "expected": {
             "result": "failure",
-            "messages": ["Client 100.64.3.2 Port: 4500 - STUN client translation not found.", "Client 172.18.3.2 Port: 4500 - STUN client translation not found."],
+            "messages": ["Client 100.64.3.2 Port: 4500 - STUN client translation not found", "Client 172.18.3.2 Port: 4500 - STUN client translation not found"],
         },
     },
     {
@@ -134,7 +134,7 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Client 100.64.3.2 Port: 4500 - STUN client translation not found.",
+                "Client 100.64.3.2 Port: 4500 - STUN client translation not found",
                 "Client 172.18.3.2 Port: 4500 - Incorrect public-facing address - Expected: 192.118.3.2 Actual: 192.18.3.2",
                 "Client 172.18.3.2 Port: 4500 - Incorrect public-facing port - Expected: 6006 Actual: 4800",
             ],
@@ -163,7 +163,7 @@ DATA: list[dict[str, Any]] = [
         "expected": {
             "result": "failure",
             "messages": [
-                "Client 100.64.3.2 Port: 4500 - STUN client translation not found.",
+                "Client 100.64.3.2 Port: 4500 - STUN client translation not found",
                 "Client 172.18.4.2 Port: 4800 - Incorrect public-facing address - Expected: 192.118.3.2 Actual: 192.18.3.2",
                 "Client 172.18.4.2 Port: 4800 - Incorrect public-facing port - Expected: 6006 Actual: 4800",
             ],
@@ -193,7 +193,7 @@ DATA: list[dict[str, Any]] = [
         "inputs": {},
         "expected": {
             "result": "failure",
-            "messages": ["STUN server status is disabled."],
+            "messages": ["STUN server status is disabled"],
         },
     },
     {
@@ -208,7 +208,7 @@ DATA: list[dict[str, Any]] = [
         "inputs": {},
         "expected": {
             "result": "failure",
-            "messages": ["STUN server is not running."],
+            "messages": ["STUN server is not running"],
         },
     },
     {
@@ -223,7 +223,7 @@ DATA: list[dict[str, Any]] = [
         "inputs": {},
         "expected": {
             "result": "failure",
-            "messages": ["STUN server status is disabled and not running."],
+            "messages": ["STUN server status is disabled and not running"],
         },
     },
 ]
diff --git a/tests/units/anta_tests/test_system.py b/tests/units/anta_tests/test_system.py
index 5fe0fbad..eb7c584f 100644
--- a/tests/units/anta_tests/test_system.py
+++ b/tests/units/anta_tests/test_system.py
@@ -12,6 +12,7 @@ from anta.tests.system import (
     VerifyCoredump,
     VerifyCPUUtilization,
     VerifyFileSystemUtilization,
+    VerifyMaintenance,
     VerifyMemoryUtilization,
     VerifyNTP,
     VerifyNTPAssociations,
@@ -33,7 +34,7 @@ DATA: list[dict[str, Any]] = [
         "test": VerifyUptime,
         "eos_data": [{"upTime": 665.15, "loadAvg": [0.13, 0.12, 0.09], "users": 1, "currentTime": 1683186659.139859}],
         "inputs": {"minimum": 666},
-        "expected": {"result": "failure", "messages": ["Device uptime is incorrect - Expected: 666 Actual: 665.15 seconds"]},
+        "expected": {"result": "failure", "messages": ["Device uptime is incorrect - Expected: 666s Actual: 665.15s"]},
     },
     {
         "name": "success-no-reload",
@@ -496,4 +497,208 @@ poll interval unknown
             ],
         },
     },
+    {
+        "name": "success-no-maintenance-configured",
+        "test": VerifyMaintenance,
+        "eos_data": [
+            {
+                "units": {},
+                "interfaces": {},
+                "vrfs": {},
+                "warnings": ["Maintenance Mode is disabled."],
+            },
+        ],
+        "inputs": None,
+        "expected": {"result": "success"},
+    },
+    {
+        "name": "success-maintenance-configured-but-not-enabled",
+        "test": VerifyMaintenance,
+        "eos_data": [
+            {
+                "units": {
+                    "System": {
+                        "state": "active",
+                        "adminState": "active",
+                        "stateChangeTime": 0.0,
+                        "onBootMaintenance": False,
+                        "intfsViolatingTrafficThreshold": False,
+                        "aggInBpsRate": 0,
+                        "aggOutBpsRate": 0,
+                    }
+                },
+                "interfaces": {},
+                "vrfs": {},
+            },
+        ],
+        "inputs": None,
+        "expected": {"result": "success"},
+    },
+    {
+        "name": "success-multiple-units-but-not-enabled",
+        "test": VerifyMaintenance,
+        "eos_data": [
+            {
+                "units": {
+                    "mlag": {
+                        "state": "active",
+                        "adminState": "active",
+                        "stateChangeTime": 0.0,
+                        "onBootMaintenance": False,
+                        "intfsViolatingTrafficThreshold": False,
+                        "aggInBpsRate": 0,
+                        "aggOutBpsRate": 0,
+                    },
+                    "System": {
+                        "state": "active",
+                        "adminState": "active",
+                        "stateChangeTime": 0.0,
+                        "onBootMaintenance": False,
+                        "intfsViolatingTrafficThreshold": False,
+                        "aggInBpsRate": 0,
+                        "aggOutBpsRate": 0,
+                    },
+                },
+                "interfaces": {},
+                "vrfs": {},
+            },
+        ],
+        "inputs": None,
+        "expected": {"result": "success"},
+    },
+    {
+        "name": "failure-maintenance-enabled",
+        "test": VerifyMaintenance,
+        "eos_data": [
+            {
+                "units": {
+                    "mlag": {
+                        "state": "underMaintenance",
+                        "adminState": "underMaintenance",
+                        "stateChangeTime": 1741257120.9532886,
+                        "onBootMaintenance": False,
+                        "intfsViolatingTrafficThreshold": False,
+                        "aggInBpsRate": 0,
+                        "aggOutBpsRate": 0,
+                    },
+                    "System": {
+                        "state": "active",
+                        "adminState": "active",
+                        "stateChangeTime": 0.0,
+                        "onBootMaintenance": False,
+                        "intfsViolatingTrafficThreshold": False,
+                        "aggInBpsRate": 0,
+                        "aggOutBpsRate": 0,
+                    },
+                },
+                "interfaces": {},
+                "vrfs": {},
+            },
+        ],
+        "inputs": None,
+        "expected": {
+            "result": "failure",
+            "messages": [
+                "Units under maintenance: 'mlag'.",
+                "Possible causes: 'Quiesce is configured'.",
+            ],
+        },
+    },
+    {
+        "name": "failure-multiple-reasons",
+        "test": VerifyMaintenance,
+        "eos_data": [
+            {
+                "units": {
+                    "mlag": {
+                        "state": "underMaintenance",
+                        "adminState": "underMaintenance",
+                        "stateChangeTime": 1741257120.9532895,
+                        "onBootMaintenance": False,
+                        "intfsViolatingTrafficThreshold": False,
+                        "aggInBpsRate": 0,
+                        "aggOutBpsRate": 0,
+                    },
+                    "System": {
+                        "state": "maintenanceModeEnter",
+                        "adminState": "underMaintenance",
+                        "stateChangeTime": 1741257669.7231765,
+                        "onBootMaintenance": False,
+                        "intfsViolatingTrafficThreshold": False,
+                        "aggInBpsRate": 0,
+                        "aggOutBpsRate": 0,
+                    },
+                },
+                "interfaces": {},
+                "vrfs": {},
+            },
+        ],
+        "inputs": None,
+        "expected": {
+            "result": "failure",
+            "messages": [
+                "Units under maintenance: 'mlag'.",
+                "Units entering maintenance: 'System'.",
+                "Possible causes: 'Quiesce is configured'.",
+            ],
+        },
+    },
+    {
+        "name": "failure-onboot-maintenance",
+        "test": VerifyMaintenance,
+        "eos_data": [
+            {
+                "units": {
+                    "System": {
+                        "state": "underMaintenance",
+                        "adminState": "underMaintenance",
+                        "stateChangeTime": 1741258774.3756502,
+                        "onBootMaintenance": True,
+                        "intfsViolatingTrafficThreshold": False,
+                        "aggInBpsRate": 0,
+                        "aggOutBpsRate": 0,
+                    }
+                },
+                "interfaces": {},
+                "vrfs": {},
+            },
+        ],
+        "inputs": None,
+        "expected": {
+            "result": "failure",
+            "messages": [
+                "Units under maintenance: 'System'.",
+                "Possible causes: 'On-boot maintenance is configured, Quiesce is configured'.",
+            ],
+        },
+    },
+    {
+        "name": "failure-entering-maintenance-interface-violation",
+        "test": VerifyMaintenance,
+        "eos_data": [
+            {
+                "units": {
+                    "System": {
+                        "state": "maintenanceModeEnter",
+                        "adminState": "underMaintenance",
+                        "stateChangeTime": 1741257669.7231765,
+                        "onBootMaintenance": False,
+                        "intfsViolatingTrafficThreshold": True,
+                        "aggInBpsRate": 0,
+                        "aggOutBpsRate": 0,
+                    }
+                },
+                "interfaces": {},
+                "vrfs": {},
+            },
+        ],
+        "inputs": None,
+        "expected": {
+            "result": "failure",
+            "messages": [
+                "Units entering maintenance: 'System'.",
+                "Possible causes: 'Interface traffic threshold violation, Quiesce is configured'.",
+            ],
+        },
+    },
 ]
diff --git a/tests/units/anta_tests/test_vlan.py b/tests/units/anta_tests/test_vlan.py
index 7fc8b868..fd900ca4 100644
--- a/tests/units/anta_tests/test_vlan.py
+++ b/tests/units/anta_tests/test_vlan.py
@@ -23,13 +23,21 @@ DATA: list[dict[str, Any]] = [
         "test": VerifyVlanInternalPolicy,
         "eos_data": [{"policy": "descending", "startVlanId": 4094, "endVlanId": 1006}],
         "inputs": {"policy": "ascending", "start_vlan_id": 1006, "end_vlan_id": 4094},
+        "expected": {
+            "result": "failure",
+            "messages": ["Incorrect VLAN internal allocation policy configured - Expected: ascending Actual: descending"],
+        },
+    },
+    {
+        "name": "failure-incorrect-start-end-id",
+        "test": VerifyVlanInternalPolicy,
+        "eos_data": [{"policy": "ascending", "startVlanId": 4094, "endVlanId": 1006}],
+        "inputs": {"policy": "ascending", "start_vlan_id": 1006, "end_vlan_id": 4094},
         "expected": {
             "result": "failure",
             "messages": [
-                "The VLAN internal allocation policy is not configured properly:\n"
-                "Expected `ascending` as the policy, but found `descending` instead.\n"
-                "Expected `1006` as the startVlanId, but found `4094` instead.\n"
-                "Expected `4094` as the endVlanId, but found `1006` instead."
+                "VLAN internal allocation policy: ascending - Incorrect start VLAN id configured - Expected: 1006 Actual: 4094",
+                "VLAN internal allocation policy: ascending - Incorrect end VLAN id configured - Expected: 4094 Actual: 1006",
             ],
         },
     },
diff --git a/tests/units/asynceapi/test__constants.py b/tests/units/asynceapi/test__constants.py
new file mode 100644
index 00000000..aee1a484
--- /dev/null
+++ b/tests/units/asynceapi/test__constants.py
@@ -0,0 +1,42 @@
+# Copyright (c) 2023-2025 Arista Networks, Inc.
+# Use of this source code is governed by the Apache License 2.0
+# that can be found in the LICENSE file.
+"""Unit tests for the asynceapi._constants module."""
+
+import pytest
+
+from asynceapi._constants import EapiCommandFormat
+
+
+class TestEapiCommandFormat:
+    """Test cases for the EapiCommandFormat enum."""
+
+    def test_enum_values(self) -> None:
+        """Test that the enum has the expected values."""
+        assert EapiCommandFormat.JSON.value == "json"
+        assert EapiCommandFormat.TEXT.value == "text"
+
+    def test_str_method(self) -> None:
+        """Test that the __str__ method returns the string value."""
+        assert str(EapiCommandFormat.JSON) == "json"
+        assert str(EapiCommandFormat.TEXT) == "text"
+
+        # Test in string formatting
+        assert f"Format: {EapiCommandFormat.JSON}" == "Format: json"
+
+    def test_string_behavior(self) -> None:
+        """Test that the enum behaves like a string."""
+        # String methods should work
+        assert EapiCommandFormat.JSON.upper() == "JSON"
+
+        # String comparisons should work
+        assert EapiCommandFormat.JSON == "json"
+        assert EapiCommandFormat.TEXT == "text"
+
+    def test_enum_lookup(self) -> None:
+        """Test enum lookup by value."""
+        assert EapiCommandFormat("json") is EapiCommandFormat.JSON
+        assert EapiCommandFormat("text") is EapiCommandFormat.TEXT
+
+        with pytest.raises(ValueError, match="'invalid' is not a valid EapiCommandFormat"):
+            EapiCommandFormat("invalid")
diff --git a/tests/units/asynceapi/test__models.py b/tests/units/asynceapi/test__models.py
new file mode 100644
index 00000000..447c2433
--- /dev/null
+++ b/tests/units/asynceapi/test__models.py
@@ -0,0 +1,435 @@
+# Copyright (c) 2023-2025 Arista Networks, Inc.
+# Use of this source code is governed by the Apache License 2.0
+# that can be found in the LICENSE file.
+"""Unit tests for the asynceapi._models module."""
+
+import logging
+from typing import TYPE_CHECKING
+from uuid import UUID
+
+import pytest
+
+from asynceapi._constants import EapiCommandFormat
+from asynceapi._errors import EapiReponseError
+from asynceapi._models import EapiCommandResult, EapiRequest, EapiResponse
+
+if TYPE_CHECKING:
+    from asynceapi._types import EapiComplexCommand, EapiSimpleCommand
+
+
+class TestEapiRequest:
+    """Test cases for the EapiRequest class."""
+
+    def test_init_with_defaults(self) -> None:
+        """Test initialization with just required parameters."""
+        commands: list[EapiSimpleCommand | EapiComplexCommand] = ["show version", "show interfaces"]
+        req = EapiRequest(commands=commands)
+
+        # Check required attributes
+        assert req.commands == commands
+
+        # Check default values
+        assert req.version == "latest"
+        assert req.format == EapiCommandFormat.JSON
+        assert req.timestamps is False
+        assert req.auto_complete is False
+        assert req.expand_aliases is False
+        assert req.stop_on_error is True
+
+        # Check that ID is generated as a UUID hex string
+        try:
+            UUID(str(req.id))
+            is_valid_uuid = True
+        except ValueError:
+            is_valid_uuid = False
+        assert is_valid_uuid
+
+    def test_init_with_custom_values(self) -> None:
+        """Test initialization with custom parameter values."""
+        commands: list[EapiSimpleCommand | EapiComplexCommand] = [{"cmd": "enable", "input": "password"}, "show version"]
+        req = EapiRequest(
+            commands=commands,
+            version=1,
+            format=EapiCommandFormat.TEXT,
+            timestamps=True,
+            auto_complete=True,
+            expand_aliases=True,
+            stop_on_error=False,
+            id="custom-id-123",
+        )
+
+        # Check all attributes match expected values
+        assert req.commands == commands
+        assert req.version == 1
+        assert req.format == EapiCommandFormat.TEXT
+        assert req.timestamps is True
+        assert req.auto_complete is True
+        assert req.expand_aliases is True
+        assert req.stop_on_error is False
+        assert req.id == "custom-id-123"
+
+    def test_to_jsonrpc(self) -> None:
+        """Test conversion to JSON-RPC dictionary."""
+        commands: list[EapiSimpleCommand | EapiComplexCommand] = ["show version", "show interfaces"]
+        req = EapiRequest(commands=commands, version=1, format=EapiCommandFormat.TEXT, id="test-id-456")
+
+        jsonrpc = req.to_jsonrpc()
+
+        # Check that structure matches expected JSON-RPC format
+        assert jsonrpc["jsonrpc"] == "2.0"
+        assert jsonrpc["method"] == "runCmds"
+        assert jsonrpc["id"] == "test-id-456"
+
+        # Check params matches our configuration
+        params = jsonrpc["params"]
+        assert params["version"] == 1
+        assert params["cmds"] == commands
+        assert params["format"] == EapiCommandFormat.TEXT
+        assert params["timestamps"] is False
+        assert params["autoComplete"] is False
+        assert params["expandAliases"] is False
+        assert params["stopOnError"] is True
+
+    def test_to_jsonrpc_with_complex_commands(self) -> None:
+        """Test JSON-RPC conversion with complex commands."""
+        commands: list[EapiSimpleCommand | EapiComplexCommand] = [
+            {"cmd": "enable", "input": "password"},
+            {"cmd": "configure", "input": ""},
+            {"cmd": "hostname test-device"},
+        ]
+        req = EapiRequest(commands=commands)
+
+        jsonrpc = req.to_jsonrpc()
+
+        # Verify commands are passed correctly
+        assert jsonrpc["params"]["cmds"] == commands
+
+    def test_immutability(self) -> None:
+        """Test that the dataclass is truly immutable (frozen)."""
+        commands: list[EapiSimpleCommand | EapiComplexCommand] = ["show version"]
+        req = EapiRequest(commands=commands)
+
+        # Attempting to modify any attribute should raise an error
+        with pytest.raises(AttributeError):
+            req.commands = ["new command"]  # type: ignore[misc]
+
+        with pytest.raises(AttributeError):
+            req.id = "new-id"  # type: ignore[misc]
+
+
+class TestEapiResponse:
+    """Test cases for the EapiResponse class."""
+
+    def test_init_and_properties(self) -> None:
+        """Test basic initialization and properties."""
+        # Create mock command results
+        result1 = EapiCommandResult(command="show version", output={"version": "4.33.2F-40713977.4332F (engineering build)"})
+        result2 = EapiCommandResult(command="show hostname", output={"hostname": "DC1-LEAF1A"})
+
+        # Create response with results
+        results = {0: result1, 1: result2}
+        response = EapiResponse(request_id="test-123", _results=results)
+
+        # Check attributes
+        assert response.request_id == "test-123"
+        assert response.error_code is None
+        assert response.error_message is None
+
+        # Check properties
+        assert response.success is True
+        assert len(response.results) == 2
+        assert response.results[0] == result1
+        assert response.results[1] == result2
+
+    def test_error_response(self) -> None:
+        """Test initialization with error information."""
+        result = EapiCommandResult(command="show bad command", output=None, errors=["Invalid input (at token 1: 'bad')"], success=False)
+        results = {0: result}
+        response = EapiResponse(
+            request_id="test-456", _results=results, error_code=1002, error_message="CLI command 1 of 1 'show bad command' failed: invalid command"
+        )
+
+        assert response.request_id == "test-456"
+        assert response.error_code == 1002
+        assert response.error_message == "CLI command 1 of 1 'show bad command' failed: invalid command"
+        assert response.success is False
+        assert len(response.results) == 1
+        assert response.results[0].success is False
+        assert "Invalid input (at token 1: 'bad')" in response.results[0].errors
+
+    def test_len_and_iteration(self) -> None:
+        """Test __len__ and __iter__ methods."""
+        # Create 3 command results
+        results = {
+            0: EapiCommandResult(command="cmd1", output="out1"),
+            1: EapiCommandResult(command="cmd2", output="out2"),
+            2: EapiCommandResult(command="cmd3", output="out3"),
+        }
+        response = EapiResponse(request_id="test-789", _results=results)
+
+        # Test __len__
+        assert len(response) == 3
+
+        # Test __iter__
+        iterated_results = list(response)
+        assert len(iterated_results) == 3
+        assert [r.command for r in iterated_results] == ["cmd1", "cmd2", "cmd3"]
+
+    def test_from_jsonrpc_success(self) -> None:
+        """Test from_jsonrpc with successful response."""
+        # Mock request
+        request = EapiRequest(commands=["show version", "show hostname"], format=EapiCommandFormat.JSON)
+
+        # Mock response data
+        jsonrpc_response = {
+            "jsonrpc": "2.0",
+            "id": "test-id-123",
+            "result": [{"modelName": "cEOSLab", "version": "4.33.2F-40713977.4332F (engineering build)"}, {"hostname": "DC1-LEAF1A"}],
+        }
+
+        response = EapiResponse.from_jsonrpc(jsonrpc_response, request)
+
+        # Verify response object
+        assert response.request_id == "test-id-123"
+        assert response.success is True
+        assert response.error_code is None
+        assert response.error_message is None
+
+        # Verify results
+        assert len(response) == 2
+        assert response.results[0].command == "show version"
+        assert response.results[0].output == {"modelName": "cEOSLab", "version": "4.33.2F-40713977.4332F (engineering build)"}
+        assert response.results[0].success is True
+        assert response.results[1].command == "show hostname"
+        assert response.results[1].output == {"hostname": "DC1-LEAF1A"}
+        assert response.results[1].success is True
+
+    def test_from_jsonrpc_text_format(self) -> None:
+        """Test from_jsonrpc with TEXT format responses."""
+        # Mock request with TEXT format
+        request = EapiRequest(commands=["show version", "show hostname"], format=EapiCommandFormat.TEXT)
+
+        # Mock response data
+        jsonrpc_response = {
+            "jsonrpc": "2.0",
+            "id": "text-format-id",
+            "result": [{"output": "Arista cEOSLab\n\nSoftware image version: 4.33.2F-40713977.4332F"}, {"output": "Hostname: DC1-LEAF1A\nFQDN:     DC1-LEAF1A\n"}],
+        }
+
+        response = EapiResponse.from_jsonrpc(jsonrpc_response, request)
+
+        # Verify results contain the text output
+        assert len(response) == 2
+        assert response.results[0].output is not None
+        assert "Arista cEOSLab" in response.results[0].output
+        assert response.results[1].output is not None
+        assert "Hostname: DC1-LEAF1A" in response.results[1].output
+
+    def test_from_jsonrpc_with_timestamps(self) -> None:
+        """Test from_jsonrpc with timestamps enabled."""
+        # Mock request with timestamps
+        request = EapiRequest(commands=["show version"], format=EapiCommandFormat.JSON, timestamps=True)
+
+        # Mock response data with timestamps
+        jsonrpc_response = {
+            "jsonrpc": "2.0",
+            "id": "timestamp-id",
+            "result": [
+                {
+                    "modelName": "cEOSLab",
+                    "version": "4.33.2F-40713977.4332F (engineering build)",
+                    "_meta": {"execStartTime": 1741014072.2534037, "execDuration": 0.0024061203002929688},
+                }
+            ],
+        }
+
+        response = EapiResponse.from_jsonrpc(jsonrpc_response, request)
+
+        # Verify timestamp data is processed
+        assert len(response) == 1
+        assert response.results[0].start_time == 1741014072.2534037
+        assert response.results[0].duration == 0.0024061203002929688
+
+        # Verify _meta is removed from output
+        assert response.results[0].output is not None
+        assert "_meta" not in response.results[0].output
+
+    def test_from_jsonrpc_error_stop_on_error_true(self) -> None:
+        """Test from_jsonrpc with error and stop_on_error=True."""
+        # Mock request with stop_on_error=True
+        request = EapiRequest(commands=["show bad command", "show version", "show hostname"], stop_on_error=True)
+
+        # Mock error response
+        jsonrpc_response = {
+            "jsonrpc": "2.0",
+            "id": "error-id",
+            "error": {
+                "code": 1002,
+                "message": "CLI command 1 of 3 'show bad command' failed: invalid command",
+                "data": [{"errors": ["Invalid input (at token 1: 'bad')"]}],
+            },
+        }
+
+        response = EapiResponse.from_jsonrpc(jsonrpc_response, request)
+
+        # Verify error info
+        assert response.request_id == "error-id"
+        assert response.error_code == 1002
+        assert response.error_message == "CLI command 1 of 3 'show bad command' failed: invalid command"
+        assert response.success is False
+
+        # Verify results - should have entries for all commands
+        assert len(response) == 3
+
+        # First command failed
+        assert response.results[0].command == "show bad command"
+        assert response.results[0].output is None
+        assert response.results[0].success is False
+        assert response.results[0].errors == ["Invalid input (at token 1: 'bad')"]
+
+        # Remaining commands weren't executed due to stop_on_error=True
+        assert response.results[1].command == "show version"
+        assert response.results[1].output is None
+        assert response.results[1].success is False
+        assert "Command not executed due to previous error" in response.results[1].errors
+        assert response.results[1].executed is False
+
+        assert response.results[2].command == "show hostname"
+        assert response.results[2].output is None
+        assert response.results[2].success is False
+        assert "Command not executed due to previous error" in response.results[2].errors
+        assert response.results[2].executed is False
+
+    def test_from_jsonrpc_error_stop_on_error_false(self) -> None:
+        """Test from_jsonrpc with error and stop_on_error=False."""
+        # Mock request with stop_on_error=False
+        request = EapiRequest(commands=["show bad command", "show version", "show hostname"], stop_on_error=False)
+
+        # Mock response with error for first command but others succeed
+        jsonrpc_response = {
+            "jsonrpc": "2.0",
+            "id": "error-continue-id",
+            "error": {
+                "code": 1002,
+                "message": "CLI command 1 of 3 'show bad command' failed: invalid command",
+                "data": [
+                    {"errors": ["Invalid input (at token 1: 'bad')"]},
+                    {"modelName": "cEOSLab", "version": "4.33.2F-40713977.4332F (engineering build)"},
+                    {"hostname": "DC1-LEAF1A"},
+                ],
+            },
+        }
+
+        response = EapiResponse.from_jsonrpc(jsonrpc_response, request)
+
+        # Verify error info
+        assert response.request_id == "error-continue-id"
+        assert response.error_code == 1002
+        assert response.error_message == "CLI command 1 of 3 'show bad command' failed: invalid command"
+        assert response.success is False
+
+        # Verify individual command results
+        assert len(response) == 3
+
+        # First command failed
+        assert response.results[0].command == "show bad command"
+        assert response.results[0].output is None
+        assert response.results[0].success is False
+        assert response.results[0].errors == ["Invalid input (at token 1: 'bad')"]
+
+        # Remaining commands succeeded
+        assert response.results[1].command == "show version"
+        assert response.results[1].output == {"modelName": "cEOSLab", "version": "4.33.2F-40713977.4332F (engineering build)"}
+        assert response.results[1].success is True
+
+        assert response.results[2].command == "show hostname"
+        assert response.results[2].output == {"hostname": "DC1-LEAF1A"}
+        assert response.results[2].success is True
+
+    def test_from_jsonrpc_raise_on_error(self) -> None:
+        """Test from_jsonrpc with raise_on_error=True."""
+        # Mock request
+        request = EapiRequest(commands=["show bad command"])
+
+        # Mock error response
+        jsonrpc_response = {
+            "jsonrpc": "2.0",
+            "id": "raise-error-id",
+            "error": {
+                "code": 1002,
+                "message": "CLI command 1 of 1 'show bad command' failed: invalid command",
+                "data": [{"errors": ["Invalid input (at token 1: 'bad')"]}],
+            },
+        }
+
+        # Should raise EapiReponseError
+        with pytest.raises(EapiReponseError) as excinfo:
+            EapiResponse.from_jsonrpc(jsonrpc_response, request, raise_on_error=True)
+
+        # Verify the exception contains the response
+        assert excinfo.value.response.request_id == "raise-error-id"
+        assert excinfo.value.response.error_code == 1002
+        assert excinfo.value.response.error_message == "CLI command 1 of 1 'show bad command' failed: invalid command"
+
+    def test_from_jsonrpc_string_data(self, caplog: pytest.LogCaptureFixture) -> None:
+        """Test from_jsonrpc with string data response."""
+        caplog.set_level(logging.WARNING)
+
+        # Mock request
+        request = EapiRequest(commands=["show bgp ipv4 unicast summary", "show bad command"])
+
+        # Mock response with JSON string
+        jsonrpc_response = {
+            "jsonrpc": "2.0",
+            "id": "EapiExplorer-1",
+            "error": {
+                "code": 1002,
+                "message": "CLI command 2 of 2 'show bad command' failed: invalid command",
+                "data": [
+                    '{"vrfs":{"default":{"vrf":"default","routerId":"10.1.0.11","asn":"65101","peers":{}}}}\n',
+                    {"errors": ["Invalid input (at token 1: 'bad')"]},
+                ],
+            },
+        }
+
+        response = EapiResponse.from_jsonrpc(jsonrpc_response, request)
+
+        # Verify string was parsed as JSON
+        assert response.results[0].output == {"vrfs": {"default": {"vrf": "default", "routerId": "10.1.0.11", "asn": "65101", "peers": {}}}}
+
+        # Now test with a non-JSON string
+        jsonrpc_response = {
+            "jsonrpc": "2.0",
+            "id": "EapiExplorer-1",
+            "error": {
+                "code": 1002,
+                "message": "CLI command 2 of 2 'show bad command' failed: invalid command",
+                "data": ["This is not JSON", {"errors": ["Invalid input (at token 1: 'bad')"]}],
+            },
+        }
+
+        response = EapiResponse.from_jsonrpc(jsonrpc_response, request)
+
+        # Verify WARNING log message
+        assert "Invalid JSON response for command: show bgp ipv4 unicast summary. Storing as text: This is not JSON" in caplog.text
+
+        # Verify string is kept as is
+        assert response.results[0].output == "This is not JSON"
+
+    def test_from_jsonrpc_complex_commands(self) -> None:
+        """Test from_jsonrpc with complex command structures."""
+        # Mock request with complex commands
+        request = EapiRequest(commands=[{"cmd": "enable", "input": "password"}, "show version"])
+
+        # Mock response
+        jsonrpc_response = {
+            "jsonrpc": "2.0",
+            "id": "complex-cmd-id",
+            "result": [{}, {"modelName": "cEOSLab", "version": "4.33.2F-40713977.4332F (engineering build)"}],
+        }
+
+        response = EapiResponse.from_jsonrpc(jsonrpc_response, request)
+
+        # Verify command strings are extracted correctly
+        assert response.results[0].command == "enable"
+        assert response.results[1].command == "show version"
diff --git a/tests/units/asynceapi/test_data.py b/tests/units/asynceapi/test_data.py
index a1400fe8..94004c1a 100644
--- a/tests/units/asynceapi/test_data.py
+++ b/tests/units/asynceapi/test_data.py
@@ -3,6 +3,7 @@
 # that can be found in the LICENSE file.
 """Unit tests data for the asynceapi client package."""
 
+from asynceapi._constants import EapiCommandFormat
 from asynceapi._types import EapiJsonOutput, JsonRpc
 
 SUCCESS_EAPI_RESPONSE: EapiJsonOutput = {
@@ -86,5 +87,10 @@ ERROR_EAPI_RESPONSE: EapiJsonOutput = {
 }
 """Error eAPI JSON response."""
 
-JSONRPC_REQUEST_TEMPLATE: JsonRpc = {"jsonrpc": "2.0", "method": "runCmds", "params": {"version": 1, "cmds": [], "format": "json"}, "id": "EapiExplorer-1"}
+JSONRPC_REQUEST_TEMPLATE: JsonRpc = {
+    "jsonrpc": "2.0",
+    "method": "runCmds",
+    "params": {"version": 1, "cmds": [], "format": EapiCommandFormat.JSON},
+    "id": "EapiExplorer-1",
+}
 """Template for JSON-RPC eAPI request. `cmds` must be filled by the parametrize decorator."""
diff --git a/tests/units/asynceapi/test_device.py b/tests/units/asynceapi/test_device.py
index b2293d91..c15eb355 100644
--- a/tests/units/asynceapi/test_device.py
+++ b/tests/units/asynceapi/test_device.py
@@ -1,7 +1,7 @@
 # Copyright (c) 2023-2025 Arista Networks, Inc.
 # Use of this source code is governed by the Apache License 2.0
 # that can be found in the LICENSE file.
-"""Unit tests the asynceapi.device module."""
+"""Unit tests for the asynceapi.device module."""
 
 from __future__ import annotations
 
@@ -63,13 +63,12 @@ async def test_jsonrpc_exec_eapi_command_error(
     jsonrpc_request = JSONRPC_REQUEST_TEMPLATE.copy()
     jsonrpc_request["params"]["cmds"] = cmds
 
-    error_eapi_response = ERROR_EAPI_RESPONSE.copy()
-    httpx_mock.add_response(json=error_eapi_response)
+    httpx_mock.add_response(json=ERROR_EAPI_RESPONSE)
 
     with pytest.raises(EapiCommandError) as exc_info:
         await asynceapi_device.jsonrpc_exec(jsonrpc=jsonrpc_request)
 
-    assert exc_info.value.passed == [error_eapi_response["error"]["data"][0]]
+    assert exc_info.value.passed == [ERROR_EAPI_RESPONSE["error"]["data"][0]]
     assert exc_info.value.failed == "bad command"
     assert exc_info.value.errors == ["Invalid input (at token 1: 'bad')"]
     assert exc_info.value.errmsg == "CLI command 2 of 3 'bad command' failed: invalid command"
diff --git a/tests/units/cli/conftest.py b/tests/units/cli/conftest.py
index 326b2c07..37646957 100644
--- a/tests/units/cli/conftest.py
+++ b/tests/units/cli/conftest.py
@@ -39,7 +39,7 @@ MOCK_CLI_JSON: dict[str, asynceapi.EapiCommandError | dict[str, Any]] = {
         errmsg="Invalid command",
         not_exec=[],
     ),
-    "show interfaces": {},
+    "show interfaces": {"interfaces": {}},
 }
 
 MOCK_CLI_TEXT: dict[str, asynceapi.EapiCommandError | str] = {
diff --git a/tests/units/cli/nrfu/test_commands.py b/tests/units/cli/nrfu/test_commands.py
index 52caf5e1..1910636a 100644
--- a/tests/units/cli/nrfu/test_commands.py
+++ b/tests/units/cli/nrfu/test_commands.py
@@ -82,9 +82,9 @@ def test_anta_nrfu_text_multiple_failures(click_runner: CliRunner) -> None:
     assert result.exit_code == ExitCode.TESTS_FAILED
     assert (
         """spine1 :: VerifyInterfacesSpeed :: FAILURE
-    Interface `Ethernet2` is not found.
-    Interface `Ethernet3` is not found.
-    Interface `Ethernet4` is not found."""
+    Interface: Ethernet2 - Not found
+    Interface: Ethernet3 - Not found
+    Interface: Ethernet4 - Not found"""
         in result.output
     )
 
diff --git a/tests/units/input_models/routing/test_bgp.py b/tests/units/input_models/routing/test_bgp.py
index 0ff859ff..d0ad243c 100644
--- a/tests/units/input_models/routing/test_bgp.py
+++ b/tests/units/input_models/routing/test_bgp.py
@@ -19,6 +19,7 @@ from anta.tests.routing.bgp import (
     VerifyBGPPeerGroup,
     VerifyBGPPeerMPCaps,
     VerifyBGPPeerRouteLimit,
+    VerifyBGPPeerTtlMultiHops,
     VerifyBGPRouteECMP,
     VerifyBgpRouteMaps,
     VerifyBGPRoutePaths,
@@ -435,3 +436,29 @@ class TestVerifyBGPAddressFamilyConfig:
     def test_valid_str(self, afi_safi: RedistributedAfiSafi, redistributed_routes: list[Any], expected: str) -> None:
         """Test AddressFamilyConfig __str__."""
         assert str(AddressFamilyConfig(afi_safi=afi_safi, redistributed_routes=redistributed_routes)) == expected
+
+
+class TestVerifyBGPPeerTtlMultiHopsInput:
+    """Test anta.tests.routing.bgp.VerifyBGPPeerTtlMultiHops.Input."""
+
+    @pytest.mark.parametrize(
+        ("bgp_peers"),
+        [
+            pytest.param([{"peer_address": "172.30.255.5", "vrf": "default", "ttl": 3, "max_ttl_hops": 3}], id="valid"),
+        ],
+    )
+    def test_valid(self, bgp_peers: list[BgpPeer]) -> None:
+        """Test VerifyBGPPeerTtlMultiHops.Input valid inputs."""
+        VerifyBGPPeerTtlMultiHops.Input(bgp_peers=bgp_peers)
+
+    @pytest.mark.parametrize(
+        ("bgp_peers"),
+        [
+            pytest.param([{"peer_address": "172.30.255.5", "vrf": "default", "ttl": None, "max_ttl_hops": 3}], id="invalid-ttl-time"),
+            pytest.param([{"peer_address": "172.30.255.6", "vrf": "default", "ttl": 3, "max_ttl_hops": None}], id="invalid-max-ttl-hops"),
+        ],
+    )
+    def test_invalid(self, bgp_peers: list[BgpPeer]) -> None:
+        """Test VerifyBGPPeerTtlMultiHops.Input invalid inputs."""
+        with pytest.raises(ValidationError):
+            VerifyBGPPeerTtlMultiHops.Input(bgp_peers=bgp_peers)
diff --git a/tests/units/input_models/test_interfaces.py b/tests/units/input_models/test_interfaces.py
index 881e3bdb..c4bb8eff 100644
--- a/tests/units/input_models/test_interfaces.py
+++ b/tests/units/input_models/test_interfaces.py
@@ -12,7 +12,7 @@ import pytest
 from pydantic import ValidationError
 
 from anta.input_models.interfaces import InterfaceState
-from anta.tests.interfaces import VerifyInterfaceIPv4, VerifyInterfacesStatus, VerifyLACPInterfacesStatus
+from anta.tests.interfaces import VerifyInterfaceIPv4, VerifyInterfacesSpeed, VerifyInterfacesStatus, VerifyLACPInterfacesStatus
 
 if TYPE_CHECKING:
     from anta.custom_types import Interface, PortChannelInterface
@@ -108,3 +108,28 @@ class TestVerifyInterfaceIPv4Input:
         """Test VerifyInterfaceIPv4.Input invalid inputs."""
         with pytest.raises(ValidationError):
             VerifyInterfaceIPv4.Input(interfaces=interfaces)
+
+
+class TestVerifyInterfacesSpeedInput:
+    """Test anta.tests.interfaces.VerifyInterfacesSpeed.Input."""
+
+    @pytest.mark.parametrize(
+        ("interfaces"),
+        [
+            pytest.param([{"name": "Ethernet1", "speed": 10}], id="valid-speed-is-given"),
+        ],
+    )
+    def test_valid(self, interfaces: list[InterfaceState]) -> None:
+        """Test VerifyInterfacesSpeed.Input valid inputs."""
+        VerifyInterfacesSpeed.Input(interfaces=interfaces)
+
+    @pytest.mark.parametrize(
+        ("interfaces"),
+        [
+            pytest.param([{"name": "Ethernet1"}], id="invalid-speed-is-not-given"),
+        ],
+    )
+    def test_invalid(self, interfaces: list[InterfaceState]) -> None:
+        """Test VerifyInterfacesSpeed.Input invalid inputs."""
+        with pytest.raises(ValidationError):
+            VerifyInterfacesSpeed.Input(interfaces=interfaces)
diff --git a/tests/units/inventory/test__init__.py b/tests/units/inventory/test__init__.py
index 9eee8803..461f0379 100644
--- a/tests/units/inventory/test__init__.py
+++ b/tests/units/inventory/test__init__.py
@@ -5,7 +5,7 @@
 
 from __future__ import annotations
 
-from pathlib import Path
+import logging
 from typing import TYPE_CHECKING
 
 import pytest
@@ -15,10 +15,9 @@ from anta.inventory import AntaInventory
 from anta.inventory.exceptions import InventoryIncorrectSchemaError, InventoryRootKeyError
 
 if TYPE_CHECKING:
-    from _pytest.mark.structures import ParameterSet
-
-FILE_DIR: Path = Path(__file__).parent.parent.resolve() / "data" / "inventory"
+    from pathlib import Path
 
+    from _pytest.mark.structures import ParameterSet
 
 INIT_VALID_PARAMS: list[ParameterSet] = [
     pytest.param(
@@ -76,3 +75,15 @@ class TestAntaInventory:
         """Parse invalid YAML file to create ANTA inventory."""
         with pytest.raises((InventoryIncorrectSchemaError, InventoryRootKeyError, ValidationError)):
             AntaInventory.parse(filename=yaml_file, username="arista", password="arista123")
+
+    def test_parse_wrong_format(self) -> None:
+        """Use wrong file format to parse the ANTA inventory."""
+        with pytest.raises(ValueError, match=" is not a valid format for an AntaInventory file. Only 'yaml' and 'json' are supported."):
+            AntaInventory.parse(filename="dummy.yml", username="arista", password="arista123", file_format="wrong")  # type: ignore[arg-type]
+
+    def test_parse_os_error(self, caplog: pytest.LogCaptureFixture) -> None:
+        """Use wrong file name to parse the ANTA inventory."""
+        caplog.set_level(logging.INFO)
+        with pytest.raises(OSError, match="No such file or directory"):
+            _ = AntaInventory.parse(filename="dummy.yml", username="arista", password="arista123")
+        assert "Unable to parse ANTA Device Inventory file" in caplog.records[0].message
diff --git a/tests/units/inventory/test_models.py b/tests/units/inventory/test_models.py
index 63ce7a78..f6bd7d63 100644
--- a/tests/units/inventory/test_models.py
+++ b/tests/units/inventory/test_models.py
@@ -5,16 +5,21 @@
 
 from __future__ import annotations
 
+import json
+from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 import pytest
 from pydantic import ValidationError
+from yaml import safe_load
 
-from anta.inventory.models import AntaInventoryHost, AntaInventoryNetwork, AntaInventoryRange
+from anta.inventory.models import AntaInventoryHost, AntaInventoryInput, AntaInventoryNetwork, AntaInventoryRange
 
 if TYPE_CHECKING:
     from _pytest.mark.structures import ParameterSet
 
+FILE_DIR: Path = Path(__file__).parents[2] / "data"
+
 INVENTORY_HOST_VALID_PARAMS: list[ParameterSet] = [
     pytest.param(None, "1.1.1.1", None, None, None, id="IPv4"),
     pytest.param(None, "fe80::cc62:a9ff:feef:932a", None, None, None, id="IPv6"),
@@ -164,3 +169,33 @@ class TestAntaInventoryRange:
         """Invalid model parameters."""
         with pytest.raises(ValidationError):
             AntaInventoryRange.model_validate({"start": start, "end": end, "tags": tags, "disable_cache": disable_cache})
+
+
+class TestAntaInventoryInputs:
+    """Test anta.inventory.models.AntaInventoryInputs."""
+
+    def test_dump_to_json(self) -> None:
+        """Load a YAML file, dump it to JSON and verify it works."""
+        input_yml_path = FILE_DIR / "test_inventory_with_tags.yml"
+        expected_json_path = FILE_DIR / "test_inventory_with_tags.json"
+        with input_yml_path.open("r") as f:
+            data = safe_load(f)
+        anta_inventory_input = AntaInventoryInput(**data["anta_inventory"])
+
+        with expected_json_path.open("r") as f:
+            expected_data = json.load(f)
+
+        assert anta_inventory_input.to_json() == json.dumps(expected_data["anta_inventory"], indent=2)
+
+    def test_dump_to_yaml(self) -> None:
+        """Load a JSON file, dump it to YAML and verify it works."""
+        input_json_path = FILE_DIR / "test_inventory_medium.json"
+        expected_yml_path = FILE_DIR / "test_inventory_medium.yml"
+        with input_json_path.open("r") as f:
+            data = json.load(f)
+        anta_inventory_input = AntaInventoryInput(**data["anta_inventory"])
+
+        with expected_yml_path.open("r") as f:
+            expected_data = safe_load(f)
+
+        assert safe_load(anta_inventory_input.yaml()) == expected_data["anta_inventory"]