diff --git a/homeassistant/components/madvr/__init__.py b/homeassistant/components/madvr/__init__.py
index b73c1f0dece..a6ad3b2d1fd 100644
--- a/homeassistant/components/madvr/__init__.py
+++ b/homeassistant/components/madvr/__init__.py
@@ -12,7 +12,7 @@ from homeassistant.core import Event, HomeAssistant, callback
 
 from .coordinator import MadVRCoordinator
 
-PLATFORMS: list[Platform] = [Platform.BINARY_SENSOR, Platform.REMOTE]
+PLATFORMS: list[Platform] = [Platform.BINARY_SENSOR, Platform.REMOTE, Platform.SENSOR]
 
 
 type MadVRConfigEntry = ConfigEntry[MadVRCoordinator]
diff --git a/homeassistant/components/madvr/const.py b/homeassistant/components/madvr/const.py
index f0adeb9b6a5..3ac80725478 100644
--- a/homeassistant/components/madvr/const.py
+++ b/homeassistant/components/madvr/const.py
@@ -4,3 +4,31 @@ DOMAIN = "madvr"
 
 DEFAULT_NAME = "envy"
 DEFAULT_PORT = 44077
+
+# Sensor keys
+TEMP_GPU = "temp_gpu"
+TEMP_HDMI = "temp_hdmi"
+TEMP_CPU = "temp_cpu"
+TEMP_MAINBOARD = "temp_mainboard"
+INCOMING_RES = "incoming_res"
+INCOMING_SIGNAL_TYPE = "incoming_signal_type"
+INCOMING_FRAME_RATE = "incoming_frame_rate"
+INCOMING_COLOR_SPACE = "incoming_color_space"
+INCOMING_BIT_DEPTH = "incoming_bit_depth"
+INCOMING_COLORIMETRY = "incoming_colorimetry"
+INCOMING_BLACK_LEVELS = "incoming_black_levels"
+INCOMING_ASPECT_RATIO = "incoming_aspect_ratio"
+OUTGOING_RES = "outgoing_res"
+OUTGOING_SIGNAL_TYPE = "outgoing_signal_type"
+OUTGOING_FRAME_RATE = "outgoing_frame_rate"
+OUTGOING_COLOR_SPACE = "outgoing_color_space"
+OUTGOING_BIT_DEPTH = "outgoing_bit_depth"
+OUTGOING_COLORIMETRY = "outgoing_colorimetry"
+OUTGOING_BLACK_LEVELS = "outgoing_black_levels"
+ASPECT_RES = "aspect_res"
+ASPECT_DEC = "aspect_dec"
+ASPECT_INT = "aspect_int"
+ASPECT_NAME = "aspect_name"
+MASKING_RES = "masking_res"
+MASKING_DEC = "masking_dec"
+MASKING_INT = "masking_int"
diff --git a/homeassistant/components/madvr/icons.json b/homeassistant/components/madvr/icons.json
index 42645787767..2f9f7217f5b 100644
--- a/homeassistant/components/madvr/icons.json
+++ b/homeassistant/components/madvr/icons.json
@@ -25,6 +25,89 @@
           "off": "mdi:signal-off"
         }
       }
+    },
+    "sensor": {
+      "mac_address": {
+        "default": "mdi:ethernet"
+      },
+      "temp_gpu": {
+        "default": "mdi:thermometer"
+      },
+      "temp_hdmi": {
+        "default": "mdi:thermometer"
+      },
+      "temp_cpu": {
+        "default": "mdi:thermometer"
+      },
+      "temp_mainboard": {
+        "default": "mdi:thermometer"
+      },
+      "incoming_res": {
+        "default": "mdi:television"
+      },
+      "incoming_frame_rate": {
+        "default": "mdi:television"
+      },
+      "incoming_color_space": {
+        "default": "mdi:television"
+      },
+      "incoming_bit_depth": {
+        "default": "mdi:television"
+      },
+      "incoming_colorimetry": {
+        "default": "mdi:television"
+      },
+      "incoming_black_levels": {
+        "default": "mdi:television"
+      },
+      "incoming_aspect_ratio": {
+        "default": "mdi:aspect-ratio"
+      },
+      "outgoing_res": {
+        "default": "mdi:television"
+      },
+      "outgoing_frame_rate": {
+        "default": "mdi:television"
+      },
+      "outgoing_color_space": {
+        "default": "mdi:television"
+      },
+      "outgoing_bit_depth": {
+        "default": "mdi:television"
+      },
+      "outgoing_colorimetry": {
+        "default": "mdi:television"
+      },
+      "outgoing_black_levels": {
+        "default": "mdi:television"
+      },
+      "aspect_res": {
+        "default": "mdi:aspect-ratio"
+      },
+      "incoming_signal_type": {
+        "default": "mdi:video-image"
+      },
+      "outgoing_signal_type": {
+        "default": "mdi:video-image"
+      },
+      "aspect_dec": {
+        "default": "mdi:aspect-ratio"
+      },
+      "aspect_int": {
+        "default": "mdi:aspect-ratio"
+      },
+      "aspect_name": {
+        "default": "mdi:aspect-ratio"
+      },
+      "masking_res": {
+        "default": "mdi:television"
+      },
+      "masking_dec": {
+        "default": "mdi:television"
+      },
+      "masking_int": {
+        "default": "mdi:television"
+      }
     }
   }
 }
diff --git a/homeassistant/components/madvr/sensor.py b/homeassistant/components/madvr/sensor.py
new file mode 100644
index 00000000000..d0f5556cc5d
--- /dev/null
+++ b/homeassistant/components/madvr/sensor.py
@@ -0,0 +1,280 @@
+"""Sensor entities for the madVR integration."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+
+from homeassistant.components.sensor import (
+    SensorDeviceClass,
+    SensorEntity,
+    SensorEntityDescription,
+    SensorStateClass,
+)
+from homeassistant.const import UnitOfTemperature
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
+from homeassistant.helpers.typing import StateType
+
+from . import MadVRConfigEntry
+from .const import (
+    ASPECT_DEC,
+    ASPECT_INT,
+    ASPECT_NAME,
+    ASPECT_RES,
+    INCOMING_ASPECT_RATIO,
+    INCOMING_BIT_DEPTH,
+    INCOMING_BLACK_LEVELS,
+    INCOMING_COLOR_SPACE,
+    INCOMING_COLORIMETRY,
+    INCOMING_FRAME_RATE,
+    INCOMING_RES,
+    INCOMING_SIGNAL_TYPE,
+    MASKING_DEC,
+    MASKING_INT,
+    MASKING_RES,
+    OUTGOING_BIT_DEPTH,
+    OUTGOING_BLACK_LEVELS,
+    OUTGOING_COLOR_SPACE,
+    OUTGOING_COLORIMETRY,
+    OUTGOING_FRAME_RATE,
+    OUTGOING_RES,
+    OUTGOING_SIGNAL_TYPE,
+    TEMP_CPU,
+    TEMP_GPU,
+    TEMP_HDMI,
+    TEMP_MAINBOARD,
+)
+from .coordinator import MadVRCoordinator
+from .entity import MadVREntity
+
+
+def is_valid_temperature(value: float | None) -> bool:
+    """Check if the temperature value is valid."""
+    return value is not None and value > 0
+
+
+def get_temperature(coordinator: MadVRCoordinator, key: str) -> float | None:
+    """Get temperature value if valid, otherwise return None."""
+    try:
+        temp = float(coordinator.data.get(key, 0))
+    except ValueError:
+        return None
+    else:
+        return temp if is_valid_temperature(temp) else None
+
+
+@dataclass(frozen=True, kw_only=True)
+class MadvrSensorEntityDescription(SensorEntityDescription):
+    """Describe madVR sensor entity."""
+
+    value_fn: Callable[[MadVRCoordinator], StateType]
+
+
+SENSORS: tuple[MadvrSensorEntityDescription, ...] = (
+    MadvrSensorEntityDescription(
+        key=TEMP_GPU,
+        device_class=SensorDeviceClass.TEMPERATURE,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        value_fn=lambda coordinator: get_temperature(coordinator, TEMP_GPU),
+        translation_key=TEMP_GPU,
+        entity_registry_enabled_default=False,
+    ),
+    MadvrSensorEntityDescription(
+        key=TEMP_HDMI,
+        device_class=SensorDeviceClass.TEMPERATURE,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        value_fn=lambda coordinator: get_temperature(coordinator, TEMP_HDMI),
+        translation_key=TEMP_HDMI,
+        entity_registry_enabled_default=False,
+    ),
+    MadvrSensorEntityDescription(
+        key=TEMP_CPU,
+        device_class=SensorDeviceClass.TEMPERATURE,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        value_fn=lambda coordinator: get_temperature(coordinator, TEMP_CPU),
+        translation_key=TEMP_CPU,
+        entity_registry_enabled_default=False,
+    ),
+    MadvrSensorEntityDescription(
+        key=TEMP_MAINBOARD,
+        device_class=SensorDeviceClass.TEMPERATURE,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        value_fn=lambda coordinator: get_temperature(coordinator, TEMP_MAINBOARD),
+        translation_key=TEMP_MAINBOARD,
+        entity_registry_enabled_default=False,
+    ),
+    MadvrSensorEntityDescription(
+        key=INCOMING_RES,
+        value_fn=lambda coordinator: coordinator.data.get(INCOMING_RES),
+        translation_key=INCOMING_RES,
+    ),
+    MadvrSensorEntityDescription(
+        key=INCOMING_SIGNAL_TYPE,
+        value_fn=lambda coordinator: coordinator.data.get(INCOMING_SIGNAL_TYPE),
+        translation_key=INCOMING_SIGNAL_TYPE,
+        device_class=SensorDeviceClass.ENUM,
+        options=["2D", "3D"],
+        entity_registry_enabled_default=False,
+    ),
+    MadvrSensorEntityDescription(
+        key=INCOMING_FRAME_RATE,
+        value_fn=lambda coordinator: coordinator.data.get(INCOMING_FRAME_RATE),
+        translation_key=INCOMING_FRAME_RATE,
+    ),
+    MadvrSensorEntityDescription(
+        key=INCOMING_COLOR_SPACE,
+        value_fn=lambda coordinator: coordinator.data.get(INCOMING_COLOR_SPACE),
+        translation_key=INCOMING_COLOR_SPACE,
+        device_class=SensorDeviceClass.ENUM,
+        options=["RGB", "444", "422", "420"],
+    ),
+    MadvrSensorEntityDescription(
+        key=INCOMING_BIT_DEPTH,
+        value_fn=lambda coordinator: coordinator.data.get(INCOMING_BIT_DEPTH),
+        translation_key=INCOMING_BIT_DEPTH,
+        device_class=SensorDeviceClass.ENUM,
+        options=["8bit", "10bit", "12bit"],
+    ),
+    MadvrSensorEntityDescription(
+        key=INCOMING_COLORIMETRY,
+        value_fn=lambda coordinator: coordinator.data.get(INCOMING_COLORIMETRY),
+        translation_key=INCOMING_COLORIMETRY,
+        device_class=SensorDeviceClass.ENUM,
+        options=["SDR", "HDR10", "HLG 601", "PAL", "709", "DCI", "2020"],
+    ),
+    MadvrSensorEntityDescription(
+        key=INCOMING_BLACK_LEVELS,
+        value_fn=lambda coordinator: coordinator.data.get(INCOMING_BLACK_LEVELS),
+        translation_key=INCOMING_BLACK_LEVELS,
+        device_class=SensorDeviceClass.ENUM,
+        options=["TV", "PC"],
+    ),
+    MadvrSensorEntityDescription(
+        key=INCOMING_ASPECT_RATIO,
+        value_fn=lambda coordinator: coordinator.data.get(INCOMING_ASPECT_RATIO),
+        translation_key=INCOMING_ASPECT_RATIO,
+        device_class=SensorDeviceClass.ENUM,
+        options=["16:9", "4:3"],
+        entity_registry_enabled_default=False,
+    ),
+    MadvrSensorEntityDescription(
+        key=OUTGOING_RES,
+        value_fn=lambda coordinator: coordinator.data.get(OUTGOING_RES),
+        translation_key=OUTGOING_RES,
+    ),
+    MadvrSensorEntityDescription(
+        key=OUTGOING_SIGNAL_TYPE,
+        value_fn=lambda coordinator: coordinator.data.get(OUTGOING_SIGNAL_TYPE),
+        translation_key=OUTGOING_SIGNAL_TYPE,
+        device_class=SensorDeviceClass.ENUM,
+        options=["2D", "3D"],
+        entity_registry_enabled_default=False,
+    ),
+    MadvrSensorEntityDescription(
+        key=OUTGOING_FRAME_RATE,
+        value_fn=lambda coordinator: coordinator.data.get(OUTGOING_FRAME_RATE),
+        translation_key=OUTGOING_FRAME_RATE,
+    ),
+    MadvrSensorEntityDescription(
+        key=OUTGOING_COLOR_SPACE,
+        value_fn=lambda coordinator: coordinator.data.get(OUTGOING_COLOR_SPACE),
+        translation_key=OUTGOING_COLOR_SPACE,
+        device_class=SensorDeviceClass.ENUM,
+        options=["RGB", "444", "422", "420"],
+    ),
+    MadvrSensorEntityDescription(
+        key=OUTGOING_BIT_DEPTH,
+        value_fn=lambda coordinator: coordinator.data.get(OUTGOING_BIT_DEPTH),
+        translation_key=OUTGOING_BIT_DEPTH,
+        device_class=SensorDeviceClass.ENUM,
+        options=["8bit", "10bit", "12bit"],
+    ),
+    MadvrSensorEntityDescription(
+        key=OUTGOING_COLORIMETRY,
+        value_fn=lambda coordinator: coordinator.data.get(OUTGOING_COLORIMETRY),
+        translation_key=OUTGOING_COLORIMETRY,
+        device_class=SensorDeviceClass.ENUM,
+        options=["SDR", "HDR10", "HLG 601", "PAL", "709", "DCI", "2020"],
+    ),
+    MadvrSensorEntityDescription(
+        key=OUTGOING_BLACK_LEVELS,
+        value_fn=lambda coordinator: coordinator.data.get(OUTGOING_BLACK_LEVELS),
+        translation_key=OUTGOING_BLACK_LEVELS,
+        device_class=SensorDeviceClass.ENUM,
+        options=["TV", "PC"],
+    ),
+    MadvrSensorEntityDescription(
+        key=ASPECT_RES,
+        value_fn=lambda coordinator: coordinator.data.get(ASPECT_RES),
+        translation_key=ASPECT_RES,
+        entity_registry_enabled_default=False,
+    ),
+    MadvrSensorEntityDescription(
+        key=ASPECT_DEC,
+        value_fn=lambda coordinator: coordinator.data.get(ASPECT_DEC),
+        translation_key=ASPECT_DEC,
+    ),
+    MadvrSensorEntityDescription(
+        key=ASPECT_INT,
+        value_fn=lambda coordinator: coordinator.data.get(ASPECT_INT),
+        translation_key=ASPECT_INT,
+        entity_registry_enabled_default=False,
+    ),
+    MadvrSensorEntityDescription(
+        key=ASPECT_NAME,
+        value_fn=lambda coordinator: coordinator.data.get(ASPECT_NAME),
+        translation_key=ASPECT_NAME,
+        entity_registry_enabled_default=False,
+    ),
+    MadvrSensorEntityDescription(
+        key=MASKING_RES,
+        value_fn=lambda coordinator: coordinator.data.get(MASKING_RES),
+        translation_key=MASKING_RES,
+        entity_registry_enabled_default=False,
+    ),
+    MadvrSensorEntityDescription(
+        key=MASKING_DEC,
+        value_fn=lambda coordinator: coordinator.data.get(MASKING_DEC),
+        translation_key=MASKING_DEC,
+    ),
+    MadvrSensorEntityDescription(
+        key=MASKING_INT,
+        value_fn=lambda coordinator: coordinator.data.get(MASKING_INT),
+        translation_key=MASKING_INT,
+        entity_registry_enabled_default=False,
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: MadVRConfigEntry,
+    async_add_entities: AddEntitiesCallback,
+) -> None:
+    """Set up the sensor entities."""
+    coordinator = entry.runtime_data
+    async_add_entities(MadvrSensor(coordinator, description) for description in SENSORS)
+
+
+class MadvrSensor(MadVREntity, SensorEntity):
+    """Base class for madVR sensors."""
+
+    def __init__(
+        self,
+        coordinator: MadVRCoordinator,
+        description: MadvrSensorEntityDescription,
+    ) -> None:
+        """Initialize the sensor."""
+        super().__init__(coordinator)
+        self.entity_description: MadvrSensorEntityDescription = description
+        self._attr_unique_id = f"{coordinator.mac}_{description.key}"
+
+    @property
+    def native_value(self) -> float | str | None:
+        """Return the state of the sensor."""
+        return self.entity_description.value_fn(self.coordinator)
diff --git a/homeassistant/components/madvr/strings.json b/homeassistant/components/madvr/strings.json
index c8b9851e780..3e8e786f775 100644
--- a/homeassistant/components/madvr/strings.json
+++ b/homeassistant/components/madvr/strings.json
@@ -36,6 +36,86 @@
       "signal_state": {
         "name": "Signal state"
       }
+    },
+    "sensor": {
+      "temp_gpu": {
+        "name": "GPU temperature"
+      },
+      "temp_hdmi": {
+        "name": "HDMI temperature"
+      },
+      "temp_cpu": {
+        "name": "CPU temperature"
+      },
+      "temp_mainboard": {
+        "name": "Mainboard temperature"
+      },
+      "incoming_res": {
+        "name": "Incoming resolution"
+      },
+      "incoming_signal_type": {
+        "name": "Incoming signal type"
+      },
+      "incoming_frame_rate": {
+        "name": "Incoming frame rate"
+      },
+      "incoming_color_space": {
+        "name": "Incoming color space"
+      },
+      "incoming_bit_depth": {
+        "name": "Incoming bit depth"
+      },
+      "incoming_colorimetry": {
+        "name": "Incoming colorimetry"
+      },
+      "incoming_black_levels": {
+        "name": "Incoming black levels"
+      },
+      "incoming_aspect_ratio": {
+        "name": "Incoming aspect ratio"
+      },
+      "outgoing_res": {
+        "name": "Outgoing resolution"
+      },
+      "outgoing_signal_type": {
+        "name": "Outgoing signal type"
+      },
+      "outgoing_frame_rate": {
+        "name": "Outgoing frame rate"
+      },
+      "outgoing_color_space": {
+        "name": "Outgoing color space"
+      },
+      "outgoing_bit_depth": {
+        "name": "Outgoing bit depth"
+      },
+      "outgoing_colorimetry": {
+        "name": "Outgoing colorimetry"
+      },
+      "outgoing_black_levels": {
+        "name": "Outgoing black levels"
+      },
+      "aspect_res": {
+        "name": "Aspect resolution"
+      },
+      "aspect_dec": {
+        "name": "Aspect decimal"
+      },
+      "aspect_int": {
+        "name": "Aspect integer"
+      },
+      "aspect_name": {
+        "name": "Aspect name"
+      },
+      "masking_res": {
+        "name": "Masking resolution"
+      },
+      "masking_dec": {
+        "name": "Masking decimal"
+      },
+      "masking_int": {
+        "name": "Masking integer"
+      }
     }
   }
 }
diff --git a/tests/components/madvr/snapshots/test_binary_sensors.ambr b/tests/components/madvr/snapshots/test_binary_sensors.ambr
index 87069542eb1..7fd54a7c240 100644
--- a/tests/components/madvr/snapshots/test_binary_sensors.ambr
+++ b/tests/components/madvr/snapshots/test_binary_sensors.ambr
@@ -45,194 +45,6 @@
     'state': 'off',
   })
 # ---
-# name: test_binary_sensor_setup[binary_sensor.madvr_envy_madvr_hdr_flag-entry]
-  EntityRegistryEntrySnapshot({
-    'aliases': set({
-    }),
-    'area_id': None,
-    'capabilities': None,
-    'config_entry_id': <ANY>,
-    'device_class': None,
-    'device_id': <ANY>,
-    'disabled_by': None,
-    'domain': 'binary_sensor',
-    'entity_category': None,
-    'entity_id': 'binary_sensor.madvr_envy_madvr_hdr_flag',
-    'has_entity_name': True,
-    'hidden_by': None,
-    'icon': None,
-    'id': <ANY>,
-    'labels': set({
-    }),
-    'name': None,
-    'options': dict({
-    }),
-    'original_device_class': None,
-    'original_icon': 'mdi:hdr-off',
-    'original_name': 'madvr HDR Flag',
-    'platform': 'madvr',
-    'previous_unique_id': None,
-    'supported_features': 0,
-    'translation_key': None,
-    'unique_id': '00:11:22:33:44:55_hdr_flag',
-    'unit_of_measurement': None,
-  })
-# ---
-# name: test_binary_sensor_setup[binary_sensor.madvr_envy_madvr_hdr_flag-state]
-  StateSnapshot({
-    'attributes': ReadOnlyDict({
-      'friendly_name': 'madVR Envy madvr HDR Flag',
-      'icon': 'mdi:hdr-off',
-    }),
-    'context': <ANY>,
-    'entity_id': 'binary_sensor.madvr_envy_madvr_hdr_flag',
-    'last_changed': <ANY>,
-    'last_reported': <ANY>,
-    'last_updated': <ANY>,
-    'state': 'off',
-  })
-# ---
-# name: test_binary_sensor_setup[binary_sensor.madvr_envy_madvr_outgoing_hdr_flag-entry]
-  EntityRegistryEntrySnapshot({
-    'aliases': set({
-    }),
-    'area_id': None,
-    'capabilities': None,
-    'config_entry_id': <ANY>,
-    'device_class': None,
-    'device_id': <ANY>,
-    'disabled_by': None,
-    'domain': 'binary_sensor',
-    'entity_category': None,
-    'entity_id': 'binary_sensor.madvr_envy_madvr_outgoing_hdr_flag',
-    'has_entity_name': True,
-    'hidden_by': None,
-    'icon': None,
-    'id': <ANY>,
-    'labels': set({
-    }),
-    'name': None,
-    'options': dict({
-    }),
-    'original_device_class': None,
-    'original_icon': 'mdi:hdr-off',
-    'original_name': 'madvr Outgoing HDR Flag',
-    'platform': 'madvr',
-    'previous_unique_id': None,
-    'supported_features': 0,
-    'translation_key': None,
-    'unique_id': '00:11:22:33:44:55_outgoing_hdr_flag',
-    'unit_of_measurement': None,
-  })
-# ---
-# name: test_binary_sensor_setup[binary_sensor.madvr_envy_madvr_outgoing_hdr_flag-state]
-  StateSnapshot({
-    'attributes': ReadOnlyDict({
-      'friendly_name': 'madVR Envy madvr Outgoing HDR Flag',
-      'icon': 'mdi:hdr-off',
-    }),
-    'context': <ANY>,
-    'entity_id': 'binary_sensor.madvr_envy_madvr_outgoing_hdr_flag',
-    'last_changed': <ANY>,
-    'last_reported': <ANY>,
-    'last_updated': <ANY>,
-    'state': 'off',
-  })
-# ---
-# name: test_binary_sensor_setup[binary_sensor.madvr_envy_madvr_power_state-entry]
-  EntityRegistryEntrySnapshot({
-    'aliases': set({
-    }),
-    'area_id': None,
-    'capabilities': None,
-    'config_entry_id': <ANY>,
-    'device_class': None,
-    'device_id': <ANY>,
-    'disabled_by': None,
-    'domain': 'binary_sensor',
-    'entity_category': None,
-    'entity_id': 'binary_sensor.madvr_envy_madvr_power_state',
-    'has_entity_name': True,
-    'hidden_by': None,
-    'icon': None,
-    'id': <ANY>,
-    'labels': set({
-    }),
-    'name': None,
-    'options': dict({
-    }),
-    'original_device_class': None,
-    'original_icon': 'mdi:power-off',
-    'original_name': 'madvr Power State',
-    'platform': 'madvr',
-    'previous_unique_id': None,
-    'supported_features': 0,
-    'translation_key': None,
-    'unique_id': '00:11:22:33:44:55_power_state',
-    'unit_of_measurement': None,
-  })
-# ---
-# name: test_binary_sensor_setup[binary_sensor.madvr_envy_madvr_power_state-state]
-  StateSnapshot({
-    'attributes': ReadOnlyDict({
-      'friendly_name': 'madVR Envy madvr Power State',
-      'icon': 'mdi:power-off',
-    }),
-    'context': <ANY>,
-    'entity_id': 'binary_sensor.madvr_envy_madvr_power_state',
-    'last_changed': <ANY>,
-    'last_reported': <ANY>,
-    'last_updated': <ANY>,
-    'state': 'off',
-  })
-# ---
-# name: test_binary_sensor_setup[binary_sensor.madvr_envy_madvr_signal_state-entry]
-  EntityRegistryEntrySnapshot({
-    'aliases': set({
-    }),
-    'area_id': None,
-    'capabilities': None,
-    'config_entry_id': <ANY>,
-    'device_class': None,
-    'device_id': <ANY>,
-    'disabled_by': None,
-    'domain': 'binary_sensor',
-    'entity_category': None,
-    'entity_id': 'binary_sensor.madvr_envy_madvr_signal_state',
-    'has_entity_name': True,
-    'hidden_by': None,
-    'icon': None,
-    'id': <ANY>,
-    'labels': set({
-    }),
-    'name': None,
-    'options': dict({
-    }),
-    'original_device_class': None,
-    'original_icon': 'mdi:signal-off',
-    'original_name': 'madvr Signal State',
-    'platform': 'madvr',
-    'previous_unique_id': None,
-    'supported_features': 0,
-    'translation_key': None,
-    'unique_id': '00:11:22:33:44:55_signal_state',
-    'unit_of_measurement': None,
-  })
-# ---
-# name: test_binary_sensor_setup[binary_sensor.madvr_envy_madvr_signal_state-state]
-  StateSnapshot({
-    'attributes': ReadOnlyDict({
-      'friendly_name': 'madVR Envy madvr Signal State',
-      'icon': 'mdi:signal-off',
-    }),
-    'context': <ANY>,
-    'entity_id': 'binary_sensor.madvr_envy_madvr_signal_state',
-    'last_changed': <ANY>,
-    'last_reported': <ANY>,
-    'last_updated': <ANY>,
-    'state': 'off',
-  })
-# ---
 # name: test_binary_sensor_setup[binary_sensor.madvr_envy_outgoing_hdr_flag-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({
diff --git a/tests/components/madvr/snapshots/test_sensors.ambr b/tests/components/madvr/snapshots/test_sensors.ambr
new file mode 100644
index 00000000000..7b0dd254f77
--- /dev/null
+++ b/tests/components/madvr/snapshots/test_sensors.ambr
@@ -0,0 +1,1359 @@
+# serializer version: 1
+# name: test_sensor_setup_and_states[sensor.madvr_envy_aspect_decimal-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': None,
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.madvr_envy_aspect_decimal',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': None,
+    'original_icon': None,
+    'original_name': 'Aspect decimal',
+    'platform': 'madvr',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'aspect_dec',
+    'unique_id': '00:11:22:33:44:55_aspect_dec',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_aspect_decimal-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'friendly_name': 'madVR Envy Aspect decimal',
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.madvr_envy_aspect_decimal',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '1.78',
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_aspect_integer-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': None,
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.madvr_envy_aspect_integer',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': None,
+    'original_icon': None,
+    'original_name': 'Aspect integer',
+    'platform': 'madvr',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'aspect_int',
+    'unique_id': '00:11:22:33:44:55_aspect_int',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_aspect_integer-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'friendly_name': 'madVR Envy Aspect integer',
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.madvr_envy_aspect_integer',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '178',
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_aspect_name-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': None,
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.madvr_envy_aspect_name',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': None,
+    'original_icon': None,
+    'original_name': 'Aspect name',
+    'platform': 'madvr',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'aspect_name',
+    'unique_id': '00:11:22:33:44:55_aspect_name',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_aspect_name-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'friendly_name': 'madVR Envy Aspect name',
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.madvr_envy_aspect_name',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'Widescreen',
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_aspect_resolution-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': None,
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.madvr_envy_aspect_resolution',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': None,
+    'original_icon': None,
+    'original_name': 'Aspect resolution',
+    'platform': 'madvr',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'aspect_res',
+    'unique_id': '00:11:22:33:44:55_aspect_res',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_aspect_resolution-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'friendly_name': 'madVR Envy Aspect resolution',
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.madvr_envy_aspect_resolution',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '3840:2160',
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_cpu_temperature-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': dict({
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+    }),
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.madvr_envy_cpu_temperature',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
+    'original_icon': None,
+    'original_name': 'CPU temperature',
+    'platform': 'madvr',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'temp_cpu',
+    'unique_id': '00:11:22:33:44:55_temp_cpu',
+    'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_cpu_temperature-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'temperature',
+      'friendly_name': 'madVR Envy CPU temperature',
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+      'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.madvr_envy_cpu_temperature',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '50.2',
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_gpu_temperature-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': dict({
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+    }),
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.madvr_envy_gpu_temperature',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
+    'original_icon': None,
+    'original_name': 'GPU temperature',
+    'platform': 'madvr',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'temp_gpu',
+    'unique_id': '00:11:22:33:44:55_temp_gpu',
+    'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_gpu_temperature-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'temperature',
+      'friendly_name': 'madVR Envy GPU temperature',
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+      'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.madvr_envy_gpu_temperature',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '45.5',
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_hdmi_temperature-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': dict({
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+    }),
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.madvr_envy_hdmi_temperature',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
+    'original_icon': None,
+    'original_name': 'HDMI temperature',
+    'platform': 'madvr',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'temp_hdmi',
+    'unique_id': '00:11:22:33:44:55_temp_hdmi',
+    'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_hdmi_temperature-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'temperature',
+      'friendly_name': 'madVR Envy HDMI temperature',
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+      'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.madvr_envy_hdmi_temperature',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '40.0',
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_incoming_aspect_ratio-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': dict({
+      'options': list([
+        '16:9',
+        '4:3',
+      ]),
+    }),
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.madvr_envy_incoming_aspect_ratio',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': <SensorDeviceClass.ENUM: 'enum'>,
+    'original_icon': None,
+    'original_name': 'Incoming aspect ratio',
+    'platform': 'madvr',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'incoming_aspect_ratio',
+    'unique_id': '00:11:22:33:44:55_incoming_aspect_ratio',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_incoming_aspect_ratio-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'enum',
+      'friendly_name': 'madVR Envy Incoming aspect ratio',
+      'options': list([
+        '16:9',
+        '4:3',
+      ]),
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.madvr_envy_incoming_aspect_ratio',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '16:9',
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_incoming_bit_depth-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': dict({
+      'options': list([
+        '8bit',
+        '10bit',
+        '12bit',
+      ]),
+    }),
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.madvr_envy_incoming_bit_depth',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': <SensorDeviceClass.ENUM: 'enum'>,
+    'original_icon': None,
+    'original_name': 'Incoming bit depth',
+    'platform': 'madvr',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'incoming_bit_depth',
+    'unique_id': '00:11:22:33:44:55_incoming_bit_depth',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_incoming_bit_depth-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'enum',
+      'friendly_name': 'madVR Envy Incoming bit depth',
+      'options': list([
+        '8bit',
+        '10bit',
+        '12bit',
+      ]),
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.madvr_envy_incoming_bit_depth',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '10bit',
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_incoming_black_levels-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': dict({
+      'options': list([
+        'TV',
+        'PC',
+      ]),
+    }),
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.madvr_envy_incoming_black_levels',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': <SensorDeviceClass.ENUM: 'enum'>,
+    'original_icon': None,
+    'original_name': 'Incoming black levels',
+    'platform': 'madvr',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'incoming_black_levels',
+    'unique_id': '00:11:22:33:44:55_incoming_black_levels',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_incoming_black_levels-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'enum',
+      'friendly_name': 'madVR Envy Incoming black levels',
+      'options': list([
+        'TV',
+        'PC',
+      ]),
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.madvr_envy_incoming_black_levels',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'PC',
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_incoming_color_space-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': dict({
+      'options': list([
+        'RGB',
+        '444',
+        '422',
+        '420',
+      ]),
+    }),
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.madvr_envy_incoming_color_space',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': <SensorDeviceClass.ENUM: 'enum'>,
+    'original_icon': None,
+    'original_name': 'Incoming color space',
+    'platform': 'madvr',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'incoming_color_space',
+    'unique_id': '00:11:22:33:44:55_incoming_color_space',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_incoming_color_space-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'enum',
+      'friendly_name': 'madVR Envy Incoming color space',
+      'options': list([
+        'RGB',
+        '444',
+        '422',
+        '420',
+      ]),
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.madvr_envy_incoming_color_space',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'RGB',
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_incoming_colorimetry-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': dict({
+      'options': list([
+        'SDR',
+        'HDR10',
+        'HLG 601',
+        'PAL',
+        '709',
+        'DCI',
+        '2020',
+      ]),
+    }),
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.madvr_envy_incoming_colorimetry',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': <SensorDeviceClass.ENUM: 'enum'>,
+    'original_icon': None,
+    'original_name': 'Incoming colorimetry',
+    'platform': 'madvr',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'incoming_colorimetry',
+    'unique_id': '00:11:22:33:44:55_incoming_colorimetry',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_incoming_colorimetry-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'enum',
+      'friendly_name': 'madVR Envy Incoming colorimetry',
+      'options': list([
+        'SDR',
+        'HDR10',
+        'HLG 601',
+        'PAL',
+        '709',
+        'DCI',
+        '2020',
+      ]),
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.madvr_envy_incoming_colorimetry',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '2020',
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_incoming_frame_rate-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': None,
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.madvr_envy_incoming_frame_rate',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': None,
+    'original_icon': None,
+    'original_name': 'Incoming frame rate',
+    'platform': 'madvr',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'incoming_frame_rate',
+    'unique_id': '00:11:22:33:44:55_incoming_frame_rate',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_incoming_frame_rate-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'friendly_name': 'madVR Envy Incoming frame rate',
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.madvr_envy_incoming_frame_rate',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '60p',
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_incoming_resolution-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': None,
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.madvr_envy_incoming_resolution',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': None,
+    'original_icon': None,
+    'original_name': 'Incoming resolution',
+    'platform': 'madvr',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'incoming_res',
+    'unique_id': '00:11:22:33:44:55_incoming_res',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_incoming_resolution-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'friendly_name': 'madVR Envy Incoming resolution',
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.madvr_envy_incoming_resolution',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '3840x2160',
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_incoming_signal_type-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': dict({
+      'options': list([
+        '2D',
+        '3D',
+      ]),
+    }),
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.madvr_envy_incoming_signal_type',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': <SensorDeviceClass.ENUM: 'enum'>,
+    'original_icon': None,
+    'original_name': 'Incoming signal type',
+    'platform': 'madvr',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'incoming_signal_type',
+    'unique_id': '00:11:22:33:44:55_incoming_signal_type',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_incoming_signal_type-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'enum',
+      'friendly_name': 'madVR Envy Incoming signal type',
+      'options': list([
+        '2D',
+        '3D',
+      ]),
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.madvr_envy_incoming_signal_type',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '3D',
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_mainboard_temperature-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': dict({
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+    }),
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.madvr_envy_mainboard_temperature',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
+    'original_icon': None,
+    'original_name': 'Mainboard temperature',
+    'platform': 'madvr',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'temp_mainboard',
+    'unique_id': '00:11:22:33:44:55_temp_mainboard',
+    'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_mainboard_temperature-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'temperature',
+      'friendly_name': 'madVR Envy Mainboard temperature',
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+      'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.madvr_envy_mainboard_temperature',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '35.8',
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_masking_decimal-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': None,
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.madvr_envy_masking_decimal',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': None,
+    'original_icon': None,
+    'original_name': 'Masking decimal',
+    'platform': 'madvr',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'masking_dec',
+    'unique_id': '00:11:22:33:44:55_masking_dec',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_masking_decimal-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'friendly_name': 'madVR Envy Masking decimal',
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.madvr_envy_masking_decimal',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '1.78',
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_masking_integer-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': None,
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.madvr_envy_masking_integer',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': None,
+    'original_icon': None,
+    'original_name': 'Masking integer',
+    'platform': 'madvr',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'masking_int',
+    'unique_id': '00:11:22:33:44:55_masking_int',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_masking_integer-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'friendly_name': 'madVR Envy Masking integer',
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.madvr_envy_masking_integer',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '178',
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_masking_resolution-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': None,
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.madvr_envy_masking_resolution',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': None,
+    'original_icon': None,
+    'original_name': 'Masking resolution',
+    'platform': 'madvr',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'masking_res',
+    'unique_id': '00:11:22:33:44:55_masking_res',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_masking_resolution-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'friendly_name': 'madVR Envy Masking resolution',
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.madvr_envy_masking_resolution',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '3840:2160',
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_outgoing_bit_depth-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': dict({
+      'options': list([
+        '8bit',
+        '10bit',
+        '12bit',
+      ]),
+    }),
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.madvr_envy_outgoing_bit_depth',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': <SensorDeviceClass.ENUM: 'enum'>,
+    'original_icon': None,
+    'original_name': 'Outgoing bit depth',
+    'platform': 'madvr',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'outgoing_bit_depth',
+    'unique_id': '00:11:22:33:44:55_outgoing_bit_depth',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_outgoing_bit_depth-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'enum',
+      'friendly_name': 'madVR Envy Outgoing bit depth',
+      'options': list([
+        '8bit',
+        '10bit',
+        '12bit',
+      ]),
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.madvr_envy_outgoing_bit_depth',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '10bit',
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_outgoing_black_levels-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': dict({
+      'options': list([
+        'TV',
+        'PC',
+      ]),
+    }),
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.madvr_envy_outgoing_black_levels',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': <SensorDeviceClass.ENUM: 'enum'>,
+    'original_icon': None,
+    'original_name': 'Outgoing black levels',
+    'platform': 'madvr',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'outgoing_black_levels',
+    'unique_id': '00:11:22:33:44:55_outgoing_black_levels',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_outgoing_black_levels-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'enum',
+      'friendly_name': 'madVR Envy Outgoing black levels',
+      'options': list([
+        'TV',
+        'PC',
+      ]),
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.madvr_envy_outgoing_black_levels',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'PC',
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_outgoing_color_space-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': dict({
+      'options': list([
+        'RGB',
+        '444',
+        '422',
+        '420',
+      ]),
+    }),
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.madvr_envy_outgoing_color_space',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': <SensorDeviceClass.ENUM: 'enum'>,
+    'original_icon': None,
+    'original_name': 'Outgoing color space',
+    'platform': 'madvr',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'outgoing_color_space',
+    'unique_id': '00:11:22:33:44:55_outgoing_color_space',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_outgoing_color_space-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'enum',
+      'friendly_name': 'madVR Envy Outgoing color space',
+      'options': list([
+        'RGB',
+        '444',
+        '422',
+        '420',
+      ]),
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.madvr_envy_outgoing_color_space',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'RGB',
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_outgoing_colorimetry-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': dict({
+      'options': list([
+        'SDR',
+        'HDR10',
+        'HLG 601',
+        'PAL',
+        '709',
+        'DCI',
+        '2020',
+      ]),
+    }),
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.madvr_envy_outgoing_colorimetry',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': <SensorDeviceClass.ENUM: 'enum'>,
+    'original_icon': None,
+    'original_name': 'Outgoing colorimetry',
+    'platform': 'madvr',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'outgoing_colorimetry',
+    'unique_id': '00:11:22:33:44:55_outgoing_colorimetry',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_outgoing_colorimetry-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'enum',
+      'friendly_name': 'madVR Envy Outgoing colorimetry',
+      'options': list([
+        'SDR',
+        'HDR10',
+        'HLG 601',
+        'PAL',
+        '709',
+        'DCI',
+        '2020',
+      ]),
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.madvr_envy_outgoing_colorimetry',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '2020',
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_outgoing_frame_rate-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': None,
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.madvr_envy_outgoing_frame_rate',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': None,
+    'original_icon': None,
+    'original_name': 'Outgoing frame rate',
+    'platform': 'madvr',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'outgoing_frame_rate',
+    'unique_id': '00:11:22:33:44:55_outgoing_frame_rate',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_outgoing_frame_rate-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'friendly_name': 'madVR Envy Outgoing frame rate',
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.madvr_envy_outgoing_frame_rate',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '60p',
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_outgoing_resolution-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': None,
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.madvr_envy_outgoing_resolution',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': None,
+    'original_icon': None,
+    'original_name': 'Outgoing resolution',
+    'platform': 'madvr',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'outgoing_res',
+    'unique_id': '00:11:22:33:44:55_outgoing_res',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_outgoing_resolution-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'friendly_name': 'madVR Envy Outgoing resolution',
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.madvr_envy_outgoing_resolution',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '3840x2160',
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_outgoing_signal_type-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': dict({
+      'options': list([
+        '2D',
+        '3D',
+      ]),
+    }),
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.madvr_envy_outgoing_signal_type',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': <SensorDeviceClass.ENUM: 'enum'>,
+    'original_icon': None,
+    'original_name': 'Outgoing signal type',
+    'platform': 'madvr',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'outgoing_signal_type',
+    'unique_id': '00:11:22:33:44:55_outgoing_signal_type',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_sensor_setup_and_states[sensor.madvr_envy_outgoing_signal_type-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'enum',
+      'friendly_name': 'madVR Envy Outgoing signal type',
+      'options': list([
+        '2D',
+        '3D',
+      ]),
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.madvr_envy_outgoing_signal_type',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '2D',
+  })
+# ---
diff --git a/tests/components/madvr/test_sensors.py b/tests/components/madvr/test_sensors.py
new file mode 100644
index 00000000000..5a918dcd433
--- /dev/null
+++ b/tests/components/madvr/test_sensors.py
@@ -0,0 +1,91 @@
+"""Tests for the MadVR sensor entities."""
+
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, patch
+
+import pytest
+from syrupy import SnapshotAssertion
+
+from homeassistant.const import STATE_UNKNOWN, Platform
+from homeassistant.core import HomeAssistant
+import homeassistant.helpers.entity_registry as er
+
+from . import setup_integration
+from .conftest import get_update_callback
+
+from tests.common import MockConfigEntry, snapshot_platform
+
+
+@pytest.mark.usefixtures("entity_registry_enabled_by_default")
+async def test_sensor_setup_and_states(
+    hass: HomeAssistant,
+    snapshot: SnapshotAssertion,
+    mock_config_entry: MockConfigEntry,
+    entity_registry: er.EntityRegistry,
+    mock_madvr_client: AsyncMock,
+) -> None:
+    """Test setup of the sensor entities and their states."""
+    with patch("homeassistant.components.madvr.PLATFORMS", [Platform.SENSOR]):
+        await setup_integration(hass, mock_config_entry)
+
+    update_callback = get_update_callback(mock_madvr_client)
+
+    # Create a big data update with all sensor values
+    update_data = {
+        "temp_gpu": 45.5,
+        "temp_hdmi": 40.0,
+        "temp_cpu": 50.2,
+        "temp_mainboard": 35.8,
+        "incoming_res": "3840x2160",
+        "incoming_frame_rate": "60p",
+        "outgoing_signal_type": "2D",
+        "incoming_signal_type": "3D",
+        "incoming_color_space": "RGB",
+        "incoming_bit_depth": "10bit",
+        "incoming_colorimetry": "2020",
+        "incoming_black_levels": "PC",
+        "incoming_aspect_ratio": "16:9",
+        "outgoing_res": "3840x2160",
+        "outgoing_frame_rate": "60p",
+        "outgoing_color_space": "RGB",
+        "outgoing_bit_depth": "10bit",
+        "outgoing_colorimetry": "2020",
+        "outgoing_black_levels": "PC",
+        "aspect_res": "3840:2160",
+        "aspect_dec": "1.78",
+        "aspect_int": "178",
+        "aspect_name": "Widescreen",
+        "masking_res": "3840:2160",
+        "masking_dec": "1.78",
+        "masking_int": "178",
+    }
+
+    # Update all sensors at once
+    update_callback(update_data)
+    await hass.async_block_till_done()
+
+    # Snapshot all entity states
+    await snapshot_platform(hass, entity_registry, snapshot, mock_config_entry.entry_id)
+
+    # Test invalid temperature value
+    update_callback({"temp_gpu": -1})
+    await hass.async_block_till_done()
+    assert hass.states.get("sensor.madvr_envy_gpu_temperature").state == STATE_UNKNOWN
+
+    # Test sensor unknown
+    update_callback({"incoming_res": None})
+    await hass.async_block_till_done()
+    assert (
+        hass.states.get("sensor.madvr_envy_incoming_resolution").state == STATE_UNKNOWN
+    )
+
+    # Test sensor becomes known again
+    update_callback({"incoming_res": "1920x1080"})
+    await hass.async_block_till_done()
+    assert hass.states.get("sensor.madvr_envy_incoming_resolution").state == "1920x1080"
+
+    # Test temperature sensor
+    update_callback({"temp_gpu": 41.2})
+    await hass.async_block_till_done()
+    assert hass.states.get("sensor.madvr_envy_gpu_temperature").state == "41.2"