# Copyright 2024 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Unittests for overlay_support.py"""

import json
import os
import unittest
from unittest import mock

# vpython-provided modules.
from pyfakefs import fake_filesystem_unittest  # pylint:disable=import-error

from gpu_tests import constants
from gpu_tests import overlay_support

rotation = overlay_support.VideoRotation

# pylint: disable=too-many-public-methods


class PresentationModeEventToStrUnittest(unittest.TestCase):
  def testAllEventsHaveStringEnum(self):
    """Tests that all defined enums have corresponding string values."""
    for event in overlay_support.PresentationModeEvent:
      event_str = overlay_support.PresentationModeEventToStr(event)
      self.assertNotIn('(unknown)', event_str)

  def testIntConversion(self):
    """Tests that ints are automatically converted to enum values."""
    event_str = overlay_support.PresentationModeEventToStr(0)
    self.assertNotIn('(unknown)', event_str)

  def testUnknownValue(self):
    """Tests behavior when an unknown value is provided."""
    event_str = overlay_support.PresentationModeEventToStr(999)
    self.assertEqual(event_str, '999 (unknown)')


class GpuOverlayConfigUnittest(unittest.TestCase):
  def testNoDirectCompositionSupport(self):
    """Tests behavior when no direct composition support is specified."""
    config = overlay_support.GpuOverlayConfig().OnDriverVersion('1')

    self.assertFalse(config.direct_composition)
    self.assertFalse(config.supports_overlays)

    self.assertEqual(
      config.nv12_overlay_support, overlay_support.OverlaySupport.NONE
    )
    self.assertEqual(
      config.yuy2_overlay_support, overlay_support.OverlaySupport.NONE
    )
    self.assertEqual(
      config.bgra8_overlay_support, overlay_support.OverlaySupport.NONE
    )

    self.assertFalse(config.supports_hw_nv12_overlays)
    self.assertFalse(config.supports_hw_yuy2_overlays)
    self.assertFalse(config.supports_hw_bgra8_overlays)

    for pixel_format in overlay_support.PixelFormat.ALL_PIXEL_FORMATS:
      self.assertEqual(
        config.GetExpectedPixelFormat(None), overlay_support.PixelFormat.BGRA8
      )
      self.assertEqual(
        config.GetExpectedPixelFormat(pixel_format),
        overlay_support.PixelFormat.BGRA8,
      )

    self.assertEqual(
      config.GetExpectedPresentationMode(
        overlay_support.PixelFormat.BGRA8, rotation.UNROTATED
      ),
      overlay_support.PresentationMode.COMPOSED,
    )

  def testSoftwareDirectCompositionSupport(self):
    """Tests behavior when software direct composition support is specified."""
    config = (
      overlay_support.GpuOverlayConfig()
      .WithDirectComposition()
      .OnDriverVersion('1')
    )

    self.assertTrue(config.direct_composition)
    self.assertTrue(config.supports_overlays)

    self.assertEqual(
      config.nv12_overlay_support, overlay_support.OverlaySupport.SOFTWARE
    )
    self.assertEqual(
      config.yuy2_overlay_support, overlay_support.OverlaySupport.SOFTWARE
    )
    self.assertEqual(
      config.bgra8_overlay_support, overlay_support.OverlaySupport.SOFTWARE
    )

    self.assertFalse(config.supports_hw_nv12_overlays)
    self.assertFalse(config.supports_hw_yuy2_overlays)
    self.assertFalse(config.supports_hw_bgra8_overlays)

    for pixel_format in overlay_support.PixelFormat.ALL_PIXEL_FORMATS:
      self.assertEqual(
        config.GetExpectedPixelFormat(None), overlay_support.PixelFormat.BGRA8
      )
      self.assertEqual(
        config.GetExpectedPixelFormat(pixel_format),
        overlay_support.PixelFormat.BGRA8,
      )

    self.assertEqual(
      config.GetExpectedPresentationMode(
        overlay_support.PixelFormat.BGRA8, rotation.UNROTATED
      ),
      overlay_support.PresentationMode.OVERLAY,
    )

  def testNV12HardwareDirectCompositionSupport(self):
    """Tests behavior when NV12 direct composition support is specified."""
    config = (
      overlay_support.GpuOverlayConfig()
      .WithDirectComposition()
      .WithHardwareNV12Support()
      .OnDriverVersion('1')
    )

    self.assertTrue(config.direct_composition)
    self.assertTrue(config.supports_overlays)

    self.assertEqual(
      config.nv12_overlay_support, overlay_support.OverlaySupport.SCALING
    )
    self.assertEqual(
      config.yuy2_overlay_support, overlay_support.OverlaySupport.SOFTWARE
    )
    self.assertEqual(
      config.bgra8_overlay_support, overlay_support.OverlaySupport.SOFTWARE
    )

    self.assertTrue(config.supports_hw_nv12_overlays)
    self.assertFalse(config.supports_hw_yuy2_overlays)
    self.assertFalse(config.supports_hw_bgra8_overlays)

    for pixel_format in overlay_support.PixelFormat.ALL_PIXEL_FORMATS:
      self.assertEqual(
        config.GetExpectedPixelFormat(None), overlay_support.PixelFormat.NV12
      )
      if pixel_format == overlay_support.PixelFormat.NV12:
        self.assertEqual(
          config.GetExpectedPixelFormat(pixel_format),
          overlay_support.PixelFormat.NV12,
        )
      else:
        self.assertEqual(
          config.GetExpectedPixelFormat(pixel_format),
          overlay_support.PixelFormat.BGRA8,
        )

    self.assertEqual(
      config.GetExpectedPresentationMode(
        overlay_support.PixelFormat.NV12, rotation.UNROTATED
      ),
      overlay_support.PresentationMode.OVERLAY,
    )
    self.assertEqual(
      config.GetExpectedPresentationMode(
        overlay_support.PixelFormat.BGRA8, rotation.UNROTATED
      ),
      overlay_support.PresentationMode.OVERLAY,
    )

  def testYUY2HardwareDirectCompositionSupport(self):
    """Tests behavior when YUY2 direct composition support is specified."""
    config = (
      overlay_support.GpuOverlayConfig()
      .WithDirectComposition()
      .WithHardwareYUY2Support()
      .OnDriverVersion('1')
    )

    self.assertTrue(config.direct_composition)
    self.assertTrue(config.supports_overlays)

    self.assertEqual(
      config.nv12_overlay_support, overlay_support.OverlaySupport.SOFTWARE
    )
    self.assertEqual(
      config.yuy2_overlay_support, overlay_support.OverlaySupport.SCALING
    )
    self.assertEqual(
      config.bgra8_overlay_support, overlay_support.OverlaySupport.SOFTWARE
    )

    self.assertFalse(config.supports_hw_nv12_overlays)
    self.assertTrue(config.supports_hw_yuy2_overlays)
    self.assertFalse(config.supports_hw_bgra8_overlays)

    for pixel_format in overlay_support.PixelFormat.ALL_PIXEL_FORMATS:
      self.assertEqual(
        config.GetExpectedPixelFormat(None), overlay_support.PixelFormat.YUY2
      )
      if pixel_format == overlay_support.PixelFormat.YUY2:
        self.assertEqual(
          config.GetExpectedPixelFormat(pixel_format),
          overlay_support.PixelFormat.YUY2,
        )
      else:
        self.assertEqual(
          config.GetExpectedPixelFormat(pixel_format),
          overlay_support.PixelFormat.BGRA8,
        )

    self.assertEqual(
      config.GetExpectedPresentationMode(
        overlay_support.PixelFormat.YUY2, rotation.UNROTATED
      ),
      overlay_support.PresentationMode.OVERLAY,
    )
    self.assertEqual(
      config.GetExpectedPresentationMode(
        overlay_support.PixelFormat.BGRA8, rotation.UNROTATED
      ),
      overlay_support.PresentationMode.OVERLAY,
    )

  def testBGRA8HardwareDirectCompositionSupport(self):
    """Tests behavior when BGRA8 direct composition support is specified."""
    config = (
      overlay_support.GpuOverlayConfig()
      .WithDirectComposition()
      .WithHardwareBGRA8Support()
      .OnDriverVersion('1')
    )

    self.assertTrue(config.direct_composition)
    self.assertTrue(config.supports_overlays)

    self.assertEqual(
      config.nv12_overlay_support, overlay_support.OverlaySupport.SOFTWARE
    )
    self.assertEqual(
      config.yuy2_overlay_support, overlay_support.OverlaySupport.SOFTWARE
    )
    self.assertEqual(
      config.bgra8_overlay_support, overlay_support.OverlaySupport.SCALING
    )

    self.assertFalse(config.supports_hw_nv12_overlays)
    self.assertFalse(config.supports_hw_yuy2_overlays)
    self.assertTrue(config.supports_hw_bgra8_overlays)

    for pixel_format in overlay_support.PixelFormat.ALL_PIXEL_FORMATS:
      self.assertEqual(
        config.GetExpectedPixelFormat(None), overlay_support.PixelFormat.BGRA8
      )
      self.assertEqual(
        config.GetExpectedPixelFormat(pixel_format),
        overlay_support.PixelFormat.BGRA8,
      )

    self.assertEqual(
      config.GetExpectedPresentationMode(
        overlay_support.PixelFormat.BGRA8, rotation.UNROTATED
      ),
      overlay_support.PresentationMode.OVERLAY,
    )

  def testForceComposedBGRA8(self):
    """Tests behavior when software BGRA8 overlays are forcibly composed."""
    config = (
      overlay_support.GpuOverlayConfig()
      .WithDirectComposition()
      .WithForceComposedBGRA8(
        driver_conditionals=[overlay_support.DriverConditional('lt', '21.0.0')]
      )
      .OnDriverVersion('20.0.3')
    )

    self.assertTrue(config.direct_composition)
    self.assertTrue(config.supports_overlays)

    self.assertEqual(
      config.nv12_overlay_support, overlay_support.OverlaySupport.SOFTWARE
    )
    self.assertEqual(
      config.yuy2_overlay_support, overlay_support.OverlaySupport.SOFTWARE
    )
    self.assertEqual(
      config.bgra8_overlay_support, overlay_support.OverlaySupport.SOFTWARE
    )

    self.assertFalse(config.supports_hw_nv12_overlays)
    self.assertFalse(config.supports_hw_yuy2_overlays)
    self.assertFalse(config.supports_hw_bgra8_overlays)

    for pixel_format in overlay_support.PixelFormat.ALL_PIXEL_FORMATS:
      self.assertEqual(
        config.GetExpectedPixelFormat(None), overlay_support.PixelFormat.BGRA8
      )
      self.assertEqual(
        config.GetExpectedPixelFormat(pixel_format),
        overlay_support.PixelFormat.BGRA8,
      )

    self.assertEqual(
      config.GetExpectedPresentationMode(
        overlay_support.PixelFormat.BGRA8, rotation.UNROTATED
      ),
      overlay_support.PresentationMode.COMPOSED,
    )

  def testInvalidDriver(self):
    """Tests behavior when an invalid driver is used."""
    # This should end up being equivalent to only having software support.
    config = (
      overlay_support.GpuOverlayConfig()
      .WithDirectComposition()
      .WithHardwareNV12Support(
        driver_conditionals=[overlay_support.DriverConditional('ge', '21.0.0')]
      )
      .WithHardwareYUY2Support(
        driver_conditionals=[overlay_support.DriverConditional('ge', '21.0.0')]
      )
      .OnDriverVersion('20.0.3')
    )

    self.assertTrue(config.direct_composition)
    self.assertTrue(config.supports_overlays)

    self.assertEqual(
      config.nv12_overlay_support, overlay_support.OverlaySupport.SOFTWARE
    )
    self.assertEqual(
      config.yuy2_overlay_support, overlay_support.OverlaySupport.SOFTWARE
    )
    self.assertEqual(
      config.bgra8_overlay_support, overlay_support.OverlaySupport.SOFTWARE
    )

    self.assertFalse(config.supports_hw_nv12_overlays)
    self.assertFalse(config.supports_hw_yuy2_overlays)
    self.assertFalse(config.supports_hw_bgra8_overlays)

    for pixel_format in overlay_support.PixelFormat.ALL_PIXEL_FORMATS:
      self.assertEqual(
        config.GetExpectedPixelFormat(None), overlay_support.PixelFormat.BGRA8
      )
      self.assertEqual(
        config.GetExpectedPixelFormat(pixel_format),
        overlay_support.PixelFormat.BGRA8,
      )

  def testZeroCopyVideoRotation(self):
    """Tests the effect of video rotation on zero copy."""
    config = (
      overlay_support.GpuOverlayConfig()
      .WithDirectComposition()
      .WithHardwareNV12Support()
      .WithZeroCopyConfig(
        overlay_support.ZeroCopyConfig(
          supported_codecs=[overlay_support.ZeroCopyCodec.VP9]
        )
      )
      .OnDriverVersion('1')
    )

    for r in overlay_support.VideoRotation:
      zero_copy = config.GetExpectedZeroCopyUsage(
        expected_pixel_format=overlay_support.PixelFormat.NV12,
        video_rotation=r,
        fullsize=True,
        codec=overlay_support.ZeroCopyCodec.VP9,
      )
      if r == rotation.UNROTATED:
        self.assertTrue(zero_copy)
      else:
        self.assertFalse(zero_copy)

  def testZeroCopyPixelFormat(self):
    """Tests the effect of pixel format on zero copy."""
    config = (
      overlay_support.GpuOverlayConfig()
      .WithDirectComposition()
      .WithHardwareNV12Support()
      .WithZeroCopyConfig(
        overlay_support.ZeroCopyConfig(
          supported_codecs=[overlay_support.ZeroCopyCodec.VP9]
        )
      )
      .OnDriverVersion('1')
    )

    for pixel_format in overlay_support.PixelFormat.ALL_PIXEL_FORMATS:
      zero_copy = config.GetExpectedZeroCopyUsage(
        expected_pixel_format=pixel_format,
        video_rotation=rotation.UNROTATED,
        fullsize=True,
        codec=overlay_support.ZeroCopyCodec.VP9,
      )
      if pixel_format == overlay_support.PixelFormat.NV12:
        self.assertTrue(zero_copy)
      else:
        self.assertFalse(zero_copy)

  def testZeroCopyScaledVideo(self):
    """Tests the effect of scaled video support on zero copy."""
    config = (
      overlay_support.GpuOverlayConfig()
      .WithDirectComposition()
      .WithHardwareNV12Support()
      .WithZeroCopyConfig(
        overlay_support.ZeroCopyConfig(
          supported_codecs=[overlay_support.ZeroCopyCodec.VP9]
        )
      )
      .OnDriverVersion('1')
    )

    self.assertTrue(
      config.GetExpectedZeroCopyUsage(
        expected_pixel_format=overlay_support.PixelFormat.NV12,
        video_rotation=rotation.UNROTATED,
        fullsize=True,
        codec=overlay_support.ZeroCopyCodec.VP9,
      )
    )

    # Same as above but with fullsize=False.
    self.assertFalse(
      config.GetExpectedZeroCopyUsage(
        expected_pixel_format=overlay_support.PixelFormat.NV12,
        video_rotation=rotation.UNROTATED,
        fullsize=False,
        codec=overlay_support.ZeroCopyCodec.VP9,
      )
    )

    config = (
      overlay_support.GpuOverlayConfig()
      .WithDirectComposition()
      .WithHardwareNV12Support()
      .WithZeroCopyConfig(
        overlay_support.ZeroCopyConfig(
          supports_scaled_video=True,
          supported_codecs=[overlay_support.ZeroCopyCodec.VP9],
        )
      )
      .OnDriverVersion('1')
    )

    # Same as first assert.
    self.assertTrue(
      config.GetExpectedZeroCopyUsage(
        expected_pixel_format=overlay_support.PixelFormat.NV12,
        video_rotation=rotation.UNROTATED,
        fullsize=True,
        codec=overlay_support.ZeroCopyCodec.VP9,
      )
    )

    # Same as second assert, but now we expect True.
    self.assertTrue(
      config.GetExpectedZeroCopyUsage(
        expected_pixel_format=overlay_support.PixelFormat.NV12,
        video_rotation=rotation.UNROTATED,
        fullsize=False,
        codec=overlay_support.ZeroCopyCodec.VP9,
      )
    )

  def testZeroCopyCodecSupport(self):
    """Tests the effect of codec support on zero copy."""
    config = (
      overlay_support.GpuOverlayConfig()
      .WithDirectComposition()
      .WithHardwareNV12Support()
      .WithZeroCopyConfig(
        overlay_support.ZeroCopyConfig(
          supported_codecs=[overlay_support.ZeroCopyCodec.H264]
        )
      )
      .OnDriverVersion('1')
    )

    self.assertTrue(
      config.GetExpectedZeroCopyUsage(
        expected_pixel_format=overlay_support.PixelFormat.NV12,
        video_rotation=rotation.UNROTATED,
        fullsize=True,
        codec=overlay_support.ZeroCopyCodec.H264,
      )
    )

    self.assertFalse(
      config.GetExpectedZeroCopyUsage(
        expected_pixel_format=overlay_support.PixelFormat.NV12,
        video_rotation=rotation.UNROTATED,
        fullsize=True,
        codec=overlay_support.ZeroCopyCodec.VP9,
      )
    )

  def testNV12RotatedVideo(self):
    """Tests NV12 behavior with rotated video."""
    config = (
      overlay_support.GpuOverlayConfig()
      .WithDirectComposition()
      .WithHardwareNV12Support(supported_rotations=[rotation.ROT180])
      .OnDriverVersion('1')
    )

    self.assertTrue(config.direct_composition)
    self.assertTrue(config.supports_overlays)

    self.assertEqual(
      config.nv12_overlay_support, overlay_support.OverlaySupport.SCALING
    )
    self.assertEqual(
      config.yuy2_overlay_support, overlay_support.OverlaySupport.SOFTWARE
    )
    self.assertEqual(
      config.bgra8_overlay_support, overlay_support.OverlaySupport.SOFTWARE
    )

    self.assertTrue(config.supports_hw_nv12_overlays)
    self.assertFalse(config.supports_hw_yuy2_overlays)
    self.assertFalse(config.supports_hw_bgra8_overlays)

    for pixel_format in overlay_support.PixelFormat.ALL_PIXEL_FORMATS:
      self.assertEqual(
        config.GetExpectedPixelFormat(None), overlay_support.PixelFormat.NV12
      )
      if pixel_format == overlay_support.PixelFormat.NV12:
        self.assertEqual(
          config.GetExpectedPixelFormat(pixel_format),
          overlay_support.PixelFormat.NV12,
        )
      else:
        self.assertEqual(
          config.GetExpectedPixelFormat(pixel_format),
          overlay_support.PixelFormat.BGRA8,
        )

    self.assertEqual(
      config.GetExpectedPresentationMode(
        overlay_support.PixelFormat.NV12, rotation.UNROTATED
      ),
      overlay_support.PresentationMode.OVERLAY,
    )
    self.assertEqual(
      config.GetExpectedPresentationMode(
        overlay_support.PixelFormat.NV12, rotation.ROT90
      ),
      overlay_support.PresentationMode.COMPOSED,
    )
    self.assertEqual(
      config.GetExpectedPresentationMode(
        overlay_support.PixelFormat.NV12, rotation.ROT180
      ),
      overlay_support.PresentationMode.OVERLAY,
    )
    self.assertEqual(
      config.GetExpectedPresentationMode(
        overlay_support.PixelFormat.NV12, rotation.ROT270
      ),
      overlay_support.PresentationMode.COMPOSED,
    )
    self.assertEqual(
      config.GetExpectedPresentationMode(
        overlay_support.PixelFormat.BGRA8, rotation.UNROTATED
      ),
      overlay_support.PresentationMode.OVERLAY,
    )

  def testYUY2RotatedVideo(self):
    """Tests YUY2 behavior with rotated video."""
    config = (
      overlay_support.GpuOverlayConfig()
      .WithDirectComposition()
      .WithHardwareYUY2Support(supported_rotations=[rotation.ROT180])
      .OnDriverVersion('1')
    )

    self.assertTrue(config.direct_composition)
    self.assertTrue(config.supports_overlays)

    self.assertEqual(
      config.nv12_overlay_support, overlay_support.OverlaySupport.SOFTWARE
    )
    self.assertEqual(
      config.yuy2_overlay_support, overlay_support.OverlaySupport.SCALING
    )
    self.assertEqual(
      config.bgra8_overlay_support, overlay_support.OverlaySupport.SOFTWARE
    )

    self.assertFalse(config.supports_hw_nv12_overlays)
    self.assertTrue(config.supports_hw_yuy2_overlays)
    self.assertFalse(config.supports_hw_bgra8_overlays)

    for pixel_format in overlay_support.PixelFormat.ALL_PIXEL_FORMATS:
      self.assertEqual(
        config.GetExpectedPixelFormat(None), overlay_support.PixelFormat.YUY2
      )
      if pixel_format == overlay_support.PixelFormat.YUY2:
        self.assertEqual(
          config.GetExpectedPixelFormat(pixel_format),
          overlay_support.PixelFormat.YUY2,
        )
      else:
        self.assertEqual(
          config.GetExpectedPixelFormat(pixel_format),
          overlay_support.PixelFormat.BGRA8,
        )

    self.assertEqual(
      config.GetExpectedPresentationMode(
        overlay_support.PixelFormat.YUY2, rotation.UNROTATED
      ),
      overlay_support.PresentationMode.OVERLAY,
    )
    self.assertEqual(
      config.GetExpectedPresentationMode(
        overlay_support.PixelFormat.YUY2, rotation.ROT90
      ),
      overlay_support.PresentationMode.COMPOSED,
    )
    self.assertEqual(
      config.GetExpectedPresentationMode(
        overlay_support.PixelFormat.YUY2, rotation.ROT180
      ),
      overlay_support.PresentationMode.OVERLAY,
    )
    self.assertEqual(
      config.GetExpectedPresentationMode(
        overlay_support.PixelFormat.YUY2, rotation.ROT270
      ),
      overlay_support.PresentationMode.COMPOSED,
    )
    self.assertEqual(
      config.GetExpectedPresentationMode(
        overlay_support.PixelFormat.BGRA8, rotation.UNROTATED
      ),
      overlay_support.PresentationMode.OVERLAY,
    )

  def testDriverVersionRequired(self):
    """Tests that usage fails if a driver version is not added."""
    config = overlay_support.GpuOverlayConfig()

    with self.assertRaises(AssertionError):
      _ = config.nv12_overlay_support

  def testDriverCanBeSetWithSameValue(self):  # pylint: disable=no-self-use
    """Tests that the driver version can be set again with the same value."""
    config = (
      overlay_support.GpuOverlayConfig()
      .OnDriverVersion('1')
      .OnDriverVersion('1')
    )
    del config

  def testDriverCannotBeSetWithDifferentValue(self):
    """Tests that the driver version cannot be set with a different value."""
    config = overlay_support.GpuOverlayConfig().OnDriverVersion('1')
    with self.assertRaises(AssertionError):
      config.OnDriverVersion('2')

  def testUnknownPixelFormat(self):
    """Tests behavior when an unknown pixel format is specified."""
    config = overlay_support.GpuOverlayConfig().OnDriverVersion('1')
    with self.assertRaises(AssertionError):
      config.GetExpectedPixelFormat('NotReal')

    with self.assertRaises(KeyError):
      config.GetExpectedPresentationMode('NotReal', rotation.UNROTATED)

  def testEqualityDifferentClass(self):
    """Tests __eq__ behavior between GpuOverlayConfig and other types."""
    config = overlay_support.GpuOverlayConfig()

    self.assertNotEqual(config, 'NotAnOverlayConfig')

  def testEqualityBase(self):
    """Tests __eq__ behavior between GpuOverlayConfigs without arguments."""
    config = overlay_support.GpuOverlayConfig()
    other = overlay_support.GpuOverlayConfig()
    self.assertEqual(config, other)

    other.WithDirectComposition()
    self.assertNotEqual(config, other)
    config.WithDirectComposition()
    self.assertEqual(config, other)

    other.WithHardwareNV12Support()
    self.assertNotEqual(config, other)
    config.WithHardwareNV12Support()
    self.assertEqual(config, other)

    other.WithHardwareYUY2Support()
    self.assertNotEqual(config, other)
    config.WithHardwareYUY2Support()
    self.assertEqual(config, other)

    other.WithHardwareBGRA8Support()
    self.assertNotEqual(config, other)
    config.WithHardwareBGRA8Support()
    self.assertEqual(config, other)

  def testEqualityDriverConditionals(self):
    """Tests __eq__ behavior between GpuOverlayConfigs w/ DriverConditionals."""
    config = overlay_support.GpuOverlayConfig().WithDirectComposition()
    other = overlay_support.GpuOverlayConfig().WithDirectComposition()
    other.WithHardwareNV12Support(
      driver_conditionals=[overlay_support.DriverConditional('ge', '1.0.0')]
    )
    self.assertNotEqual(config, other)
    config.WithHardwareNV12Support(
      driver_conditionals=[overlay_support.DriverConditional('ge', '1.0.0')]
    )
    self.assertEqual(config, other)

    config = overlay_support.GpuOverlayConfig().WithDirectComposition()
    other = overlay_support.GpuOverlayConfig().WithDirectComposition()
    other.WithHardwareNV12Support(
      driver_conditionals=[overlay_support.DriverConditional('ge', '1.0.0')]
    )
    config.WithHardwareNV12Support(
      driver_conditionals=[overlay_support.DriverConditional('le', '1.0.0')]
    )
    self.assertNotEqual(config, other)

    config = overlay_support.GpuOverlayConfig().WithDirectComposition()
    other = overlay_support.GpuOverlayConfig().WithDirectComposition()
    other.WithHardwareNV12Support(
      driver_conditionals=[overlay_support.DriverConditional('ge', '1.0.0')]
    )
    config.WithHardwareNV12Support(
      driver_conditionals=[overlay_support.DriverConditional('ge', '2.0.0')]
    )
    self.assertNotEqual(config, other)

    config = overlay_support.GpuOverlayConfig().WithDirectComposition()
    other = overlay_support.GpuOverlayConfig().WithDirectComposition()
    other.WithForceComposedBGRA8(
      driver_conditionals=[overlay_support.DriverConditional('ge', '1.0.0')]
    )
    self.assertNotEqual(config, other)
    config.WithForceComposedBGRA8(
      driver_conditionals=[overlay_support.DriverConditional('ge', '1.0.0')]
    )
    self.assertEqual(config, other)

    config = overlay_support.GpuOverlayConfig().WithDirectComposition()
    other = overlay_support.GpuOverlayConfig().WithDirectComposition()
    other.WithForceComposedBGRA8(
      driver_conditionals=[overlay_support.DriverConditional('ge', '1.0.0')]
    )
    config.WithForceComposedBGRA8(
      driver_conditionals=[overlay_support.DriverConditional('le', '1.0.0')]
    )
    self.assertNotEqual(config, other)

  def testEqualitySupportedRotations(self):
    """Tests __eq__ behavior between GpuOverlayConfigs w/ supported rotations"""
    config = overlay_support.GpuOverlayConfig().WithDirectComposition()
    other = overlay_support.GpuOverlayConfig().WithDirectComposition()
    other.WithHardwareNV12Support(supported_rotations=[rotation.ROT180])
    self.assertNotEqual(config, other)
    config.WithHardwareNV12Support(supported_rotations=[rotation.ROT180])
    self.assertEqual(config, other)

    config = overlay_support.GpuOverlayConfig().WithDirectComposition()
    other = overlay_support.GpuOverlayConfig().WithDirectComposition()
    other.WithHardwareNV12Support(supported_rotations=[rotation.ROT180])
    config.WithHardwareNV12Support(supported_rotations=[rotation.ROT90])
    self.assertNotEqual(config, other)

  def testEqualityZeroCopy(self):
    """Tests __eq__ behavior between GpuOverlayConfigs w/ zero copy configs."""
    config = overlay_support.GpuOverlayConfig().WithDirectComposition()
    other = overlay_support.GpuOverlayConfig().WithDirectComposition()
    other.WithZeroCopyConfig(overlay_support.ZeroCopyConfig())
    config.WithZeroCopyConfig(overlay_support.ZeroCopyConfig())
    self.assertEqual(config, other)

    config = overlay_support.GpuOverlayConfig().WithDirectComposition()
    other = overlay_support.GpuOverlayConfig().WithDirectComposition()
    other.WithZeroCopyConfig(
      overlay_support.ZeroCopyConfig(supports_scaled_video=True)
    )
    self.assertNotEqual(config, other)
    config.WithZeroCopyConfig(
      overlay_support.ZeroCopyConfig(supports_scaled_video=True)
    )
    self.assertEqual(config, other)

    config = overlay_support.GpuOverlayConfig().WithDirectComposition()
    other = overlay_support.GpuOverlayConfig().WithDirectComposition()
    other.WithZeroCopyConfig(
      overlay_support.ZeroCopyConfig(
        supported_codecs=[overlay_support.ZeroCopyCodec.H264]
      )
    )
    self.assertNotEqual(config, other)
    config.WithZeroCopyConfig(
      overlay_support.ZeroCopyConfig(
        supported_codecs=[overlay_support.ZeroCopyCodec.H264]
      )
    )
    self.assertEqual(config, other)

  def testEqualityDriverVersion(self):
    """Tests __eq__ behavior between GpuOverlayConfigs w/ driver version."""
    config = overlay_support.GpuOverlayConfig().WithDirectComposition()
    other = overlay_support.GpuOverlayConfig().WithDirectComposition()
    other.OnDriverVersion('1')
    self.assertNotEqual(config, other)
    config.OnDriverVersion('1')
    self.assertEqual(config, other)

    config = overlay_support.GpuOverlayConfig().WithDirectComposition()
    other = overlay_support.GpuOverlayConfig().WithDirectComposition()
    other.OnDriverVersion('1')
    config.OnDriverVersion('2')
    self.assertNotEqual(config, other)


def _createMockGpu(vendor: constants.GpuVendor | int, device: int) -> mock.Mock:
  gpu = mock.Mock()
  gpu.vendor_id = vendor
  gpu.device_id = device
  gpu.driver_version = '1.0.0'
  return gpu


class GetOverlayConfigForGpuUnittest(unittest.TestCase):
  def testKnownGpu(self):  # pylint: disable=no-self-use
    """Tests behavior when a known GPU is provided."""
    gpu = _createMockGpu(constants.GpuVendor.INTEL, 0x3E92)

    overlay_support.GetOverlayConfigForGpu(gpu)

  def testUnknownVendor(self):
    """Tests behavior when an unknown GPU vendor is provided."""
    gpu = _createMockGpu(0x1234, 0x3E92)

    with self.assertRaisesRegex(
      RuntimeError,
      'GPU with vendor ID 0x1234 and device ID 0x3e92 does not have an '
      'overlay config specified',
    ):
      overlay_support.GetOverlayConfigForGpu(gpu)

  def testUnknownDevice(self):
    """Tests behavior when an unknown GPU devices is provided."""
    gpu = _createMockGpu(constants.GpuVendor.INTEL, 0x1234)

    with self.assertRaisesRegex(
      RuntimeError,
      'GPU with vendor ID 0x8086 and device ID 0x1234 does not have an '
      'overlay config specified',
    ):
      overlay_support.GetOverlayConfigForGpu(gpu)


# mock.patch.dict is used for all tests here to ensure that any OVERLAY_CONFIGS
# changes do not persist across tests.
class ParseOverlayJsonFileUnittest(fake_filesystem_unittest.TestCase):
  def setUp(self):
    self.setUpPyfakefs()
    os.makedirs('tmp')
    self.filepath = os.path.join('tmp', 'input.json')

  def setJson(self, json_content: dict) -> None:
    with open(self.filepath, 'w', encoding='utf-8') as outfile:
      json.dump(json_content, outfile)

  @mock.patch.dict(
    overlay_support.OVERLAY_CONFIGS, overlay_support.OVERLAY_CONFIGS, clear=True
  )
  def testDuplicateConfig(self):
    """Tests behavior when a duplicate config is provided."""
    json_content = {
      '0x8086': {
        '0x3e92': [],
      }
    }
    self.setJson(json_content)
    gpu = _createMockGpu(vendor=constants.GpuVendor.INTEL, device=0x3E92)
    original_config = overlay_support.GetOverlayConfigForGpu(gpu)
    overlay_support.ParseOverlayJsonFile(self.filepath)
    updated_config = overlay_support.GetOverlayConfigForGpu(gpu)
    self.assertEqual(updated_config, original_config)

  @mock.patch.dict(
    overlay_support.OVERLAY_CONFIGS, overlay_support.OVERLAY_CONFIGS, clear=True
  )
  def testUnknownVendor(self):
    """Tests behavior when an unknown vendor is provided."""
    json_content = {
      '0x1234': {
        '0x3e92': [],
      },
    }
    self.setJson(json_content)
    with self.assertRaises(ValueError):
      overlay_support.ParseOverlayJsonFile(self.filepath)

  @mock.patch.dict(
    overlay_support.OVERLAY_CONFIGS, overlay_support.OVERLAY_CONFIGS, clear=True
  )
  def testNonHexVendor(self):
    """Tests behavior when a non-hexadecimal vendor ID is provided."""
    json_content = {
      '8086': {
        '0x3e92': [],
      },
    }
    self.setJson(json_content)
    with self.assertRaises(AssertionError):
      overlay_support.ParseOverlayJsonFile(self.filepath)

  @mock.patch.dict(
    overlay_support.OVERLAY_CONFIGS, overlay_support.OVERLAY_CONFIGS, clear=True
  )
  def testNonHexDevice(self):
    """Tests behavior when a non-hexadecimal device ID is provided."""
    json_content = {
      '0x8086': {
        '3e92': [],
      },
    }
    self.setJson(json_content)
    with self.assertRaises(AssertionError):
      overlay_support.ParseOverlayJsonFile(self.filepath)

  def _parseTestHelper(self, json_content, expected):
    self.setJson(json_content)
    overlay_support.ParseOverlayJsonFile(self.filepath)
    actual = overlay_support.GetOverlayConfigForGpu(
      _createMockGpu(constants.GpuVendor.INTEL, 0x1234)
    )
    self.assertEqual(actual, expected)

  @mock.patch.dict(overlay_support.OVERLAY_CONFIGS, {}, clear=True)
  def testBaseConfig(self):
    """Tests behavior when no additional functions are specified."""
    json_content = {
      '0x8086': {
        '0x1234': [],
      },
    }
    expected = overlay_support.GpuOverlayConfig().OnDriverVersion('1.0.0')
    self._parseTestHelper(json_content, expected)

  @mock.patch.dict(overlay_support.OVERLAY_CONFIGS, {}, clear=True)
  def testWithDirectComposition(self):
    """Tests behavior when direct composition is specified."""
    json_content = {
      '0x8086': {
        '0x1234': [
          {
            'function': 'WithDirectComposition',
          },
        ],
      },
    }
    expected = (
      overlay_support.GpuOverlayConfig()
      .WithDirectComposition()
      .OnDriverVersion('1.0.0')
    )
    self._parseTestHelper(json_content, expected)

  @mock.patch.dict(overlay_support.OVERLAY_CONFIGS, {}, clear=True)
  def testWithHardwareNV12Support(self):
    """Tests behavior when NV12 support is specified."""
    json_content = {
      '0x8086': {
        '0x1234': [
          {
            'function': 'WithDirectComposition',
          },
          {
            'function': 'WithHardwareNV12Support',
          },
        ],
      },
    }
    expected = (
      overlay_support.GpuOverlayConfig()
      .WithDirectComposition()
      .WithHardwareNV12Support()
      .OnDriverVersion('1.0.0')
    )
    self._parseTestHelper(json_content, expected)

  @mock.patch.dict(overlay_support.OVERLAY_CONFIGS, {}, clear=True)
  def testWithHardwareYUY2Support(self):
    """Tests behavior when YUY2 support is specified."""
    json_content = {
      '0x8086': {
        '0x1234': [
          {
            'function': 'WithDirectComposition',
          },
          {
            'function': 'WithHardwareYUY2Support',
          },
        ],
      },
    }
    expected = (
      overlay_support.GpuOverlayConfig()
      .WithDirectComposition()
      .WithHardwareYUY2Support()
      .OnDriverVersion('1.0.0')
    )
    self._parseTestHelper(json_content, expected)

  @mock.patch.dict(overlay_support.OVERLAY_CONFIGS, {}, clear=True)
  def testWithHardwareBGRA8Support(self):
    """Tests behavior when BGRA8 support is specified."""
    json_content = {
      '0x8086': {
        '0x1234': [
          {
            'function': 'WithDirectComposition',
          },
          {
            'function': 'WithHardwareBGRA8Support',
          },
        ],
      },
    }
    expected = (
      overlay_support.GpuOverlayConfig()
      .WithDirectComposition()
      .WithHardwareBGRA8Support()
      .OnDriverVersion('1.0.0')
    )
    self._parseTestHelper(json_content, expected)

  @mock.patch.dict(overlay_support.OVERLAY_CONFIGS, {}, clear=True)
  def testWithHardwareSupportWithDriverConditional(self):
    """Tests behavior when support is specified with driver conditionals"""
    json_content = {
      '0x8086': {
        '0x1234': [
          {
            'function': 'WithDirectComposition',
          },
          {
            'function': 'WithHardwareNV12Support',
            'args': {
              'driver_conditionals': [
                ['ge', '2.0.0'],
              ],
            },
          },
        ],
      },
    }
    expected = (
      overlay_support.GpuOverlayConfig()
      .WithDirectComposition()
      .WithHardwareNV12Support(
        driver_conditionals=[overlay_support.DriverConditional('ge', '2.0.0')]
      )
      .OnDriverVersion('1.0.0')
    )
    self._parseTestHelper(json_content, expected)

  @mock.patch.dict(overlay_support.OVERLAY_CONFIGS, {}, clear=True)
  def testWithHardwareSupportWithSupportedRotation(self):
    """Tests behavior when support is specified with supported rotations."""
    json_content = {
      '0x8086': {
        '0x1234': [
          {
            'function': 'WithDirectComposition',
          },
          {
            'function': 'WithHardwareNV12Support',
            'args': {
              'supported_rotations': [
                180,
              ],
            },
          },
        ],
      },
    }
    expected = (
      overlay_support.GpuOverlayConfig()
      .WithDirectComposition()
      .WithHardwareNV12Support(supported_rotations=[rotation.ROT180])
      .OnDriverVersion('1.0.0')
    )
    self._parseTestHelper(json_content, expected)

  @mock.patch.dict(overlay_support.OVERLAY_CONFIGS, {}, clear=True)
  def testWithForceComposedBGRA8(self):
    """Tests behavior when composed BGRA8 is forced."""
    json_content = {
      '0x8086': {
        '0x1234': [
          {
            'function': 'WithDirectComposition',
          },
          {
            'function': 'WithForceComposedBGRA8',
            'args': {
              'driver_conditionals': [
                ['ge', '2.0.0'],
              ],
            },
          },
        ],
      },
    }
    expected = (
      overlay_support.GpuOverlayConfig()
      .WithDirectComposition()
      .WithForceComposedBGRA8(
        driver_conditionals=[overlay_support.DriverConditional('ge', '2.0.0')]
      )
      .OnDriverVersion('1.0.0')
    )
    self._parseTestHelper(json_content, expected)

  @mock.patch.dict(overlay_support.OVERLAY_CONFIGS, {}, clear=True)
  def testWithZeroCopyConfig(self):
    """Tests behavior when a zero copy config is specified."""
    json_content = {
      '0x8086': {
        '0x1234': [
          {
            'function': 'WithDirectComposition',
          },
          {
            'function': 'WithZeroCopyConfig',
            'args': {
              'supports_scaled_video': True,
              'supported_codecs': [
                'H264',
              ],
            },
          },
        ],
      },
    }
    expected = (
      overlay_support.GpuOverlayConfig()
      .WithDirectComposition()
      .WithZeroCopyConfig(
        overlay_support.ZeroCopyConfig(
          supports_scaled_video=True,
          supported_codecs=[overlay_support.ZeroCopyCodec.H264],
        )
      )
      .OnDriverVersion('1.0.0')
    )
    self._parseTestHelper(json_content, expected)


if __name__ == '__main__':
  unittest.main(verbosity=2)