Upgrade SRPTests projects to GTF 9.0.0-exp.43, update test resolution to 1080p accordingly

Author: guillaumelevass

Tests/SRPTests/Packages/com.unity.testing.hdrp/TestRunner/Editor/HDRP_TestSettings_Editor.cs

@@ -81,18 +81,23 @@ override public void OnInspectorGUI()
         EditorGUILayout.PropertyField(containsVFX);
         EditorGUILayout.PropertyField(doBeforeTest);
 
-        if(typedTarget.ImageComparisonSettings.UseBackBuffer)
+     string resolutionSource = "";
+
+        if (typedTarget.ImageComparisonSettings.UseBackBuffer)
         {
-            targetResolution = GetResolutionFromBackBufferResolutionEnum(typedTarget.ImageComparisonSettings.ImageResolution.ToString());
+            // Default to 1080p when using backbuffer
+            targetResolution = new Vector2(1920, 1080);
+            resolutionSource = "Backbuffer Default (1920x1080)";
         }
         else
         {
             targetResolution = new Vector2(typedTarget.ImageComparisonSettings.TargetWidth, typedTarget.ImageComparisonSettings.TargetHeight);
+            resolutionSource = $"Target {targetResolution.x}x{targetResolution.y}";
         }
 
         liveViewSize = GUILayout.Toggle(liveViewSize, "When enabled, Game View resolution is updated live.");
 
-        if (GUILayout.Button("Set Game View Size") || liveViewSize && (prevWidth != targetResolution.x || prevHeight != targetResolution.y))
+       if (GUILayout.Button($"Set Game View Size to {resolutionSource}") || liveViewSize && (prevWidth != targetResolution.x || prevHeight != targetResolution.y))
         {
             prevWidth = (int)targetResolution.x;
             prevHeight = (int)targetResolution.y;

Tests/SRPTests/Packages/com.unity.testing.urp/Scripts/Runtime/UniversalGraphicsTestSettings.cs

@@ -1,3 +1,4 @@
+using UnityEngine;
 using UnityEngine.TestTools.Graphics;
 
 public class UniversalGraphicsTestSettings : GraphicsTestSettings
@@ -16,7 +17,7 @@ public enum RenderBackendCompatibility
     }
     public RenderBackendCompatibility renderBackendCompatibility = RenderBackendCompatibility.RenderGraphAndNonRenderGraph;
 
-    [UnityEngine.Tooltip("If enabled, the back buffer resolution will be set to the value specified by Image Comparison Settings -> Image Resolution, before doing the back buffer capture.")]
+    [HideInInspector]
     public bool SetBackBufferResolution = false;
 
     public UniversalGraphicsTestSettings()

Tests/SRPTests/Packages/com.unity.testing.urp/Scripts/Runtime/UniversalGraphicsTests.cs

@@ -53,8 +53,6 @@ public static IEnumerator RunGraphicsTest(SceneGraphicsTestCase testCase)
             Watermark.showDeveloperWatermark = false;
             GraphicsTestLogger.Log(
                 $"Running test case '{testCase}' with scene '{testCase.ScenePath}'.");
-            GlobalResolutionSetter.SetResolution(RuntimePlatform.Android, width: 1920, height: 1080);
-            GlobalResolutionSetter.SetResolution(RuntimePlatform.EmbeddedLinuxArm64, width: 1920, height: 1080);
 
             SceneManager.LoadScene(testCase.ScenePath);
 
@@ -113,22 +111,20 @@ public static IEnumerator RunGraphicsTest(SceneGraphicsTestCase testCase)
 
             if (settings.SetBackBufferResolution)
             {
-                // Set screen/backbuffer resolution before doing the capture in ImageAssert.AreEqual. This will avoid doing
-                // any resizing/scaling of the rendered image when comparing with the reference image in ImageAssert.AreEqual.
-                // This has to be done before WaitForEndOfFrame, as the request will only be applied after the frame ends.
-                int targetWidth = settings.ImageComparisonSettings.TargetWidth;
-                int targetHeight = settings.ImageComparisonSettings.TargetHeight;
-                Screen.SetResolution(targetWidth, targetHeight, settings.ImageComparisonSettings.UseBackBuffer ? FullScreenMode.FullScreenWindow : Screen.fullScreenMode);
-
-                // Yield once to finish the current frame (this code runs before the rendering in a frame) with the former
-                // resolution.
-                // Yield twice to finish the next frame with the new resolution taking effect.
-                // Note that once the yields finish and the test resumes after the next for loop, the rendering will be
-                // in the same frame where the new resolution first took place. For effects such as motion vector
-                // rendering it means if the aspect ratio changes after setting the resolution, the previous camera matrix
-                // will be reset, cancelling out all the camera-based motions.
-                // In this case (e.g. UniversalGraphicsTest_Terrain, test scene 300 and 301) increase the wait frame to 3
-                // on the UniversalGraphicsTestSettings component.
+                //This option is disabled and we keep it only to keep the extra wait frames and preserve the existing
+                // reference image.
+
+                // Changing resolution during a test run introduce instabilities.
+                // Decides of a resolution for a test run and leave it to that. The resolution for most
+                // test projects is set to a constant 1080p,except when running in XR compatibility mode.
+
+                // XR compatibility mode changes resolution depending on the target size, because the image is
+                // always captured from the backbuffer.
+
+                GraphicsTestLogger.Log(LogType.Log, "Set back buffer resolution is being deprecated and does not change the resolution anymore, it only introduces extra wait frames to the test.");
+
+                // Removing this line causes a subset of tests to fail. Removing it would require to update images
+                // and revisit some tests.
                 waitFrames = Mathf.Max(waitFrames, 2);
             }
 

Tests/SRPTests/Packages/com.unity.testing.xr/Runtime/ConfigureMockHMD.cs

@@ -33,7 +33,15 @@ static public int SetupTest(bool xrCompatible, int waitFrames, UnityEngine.TestT
                     Unity.XR.MockHMD.MockHMD.SetRenderMode(Unity.XR.MockHMD.MockHMDBuildSettings.RenderMode.SinglePassInstanced);
 
                     // Configure MockHMD to match the original settings from the test scene
-                    UnityEngine.TestTools.Graphics.ImageAssert.GetImageResolution(settings, out int w, out int h);
+                    int w = 1920;
+                    int h = 1080;
+
+                    if(!settings.UseBackBuffer)
+                    {
+                        w = settings.TargetWidth;
+                        h = settings.TargetHeight;
+                    }
+
                     Unity.XR.MockHMD.MockHMD.SetEyeResolution(w, h);
                     Unity.XR.MockHMD.MockHMD.SetMirrorViewCrop(0.0f);
 

Tests/SRPTests/Packages/local.gtf.references/package.json

@@ -14,6 +14,6 @@
   ],
   "category": "Libraries",
   "dependencies": {
-    "com.unity.testframework.graphics": "9.0.0-exp.33"
+    "com.unity.testframework.graphics": "9.0.0-exp.43"
   }
 }

Tests/SRPTests/Projects/HDRP_DXR_Tests/Assets/Tests/HDRP_DXR_Graphics_Tests.cs

@@ -92,6 +92,13 @@ public IEnumerator Run(SceneGraphicsTestCase testCase)
             yield return HDRP_GraphicTestRunner.Run(testCase);
         }
 
+        [OneTimeSetUp]
+        public void OneTimeSetUp()
+        {
+            // Standard resolution for backbuffer capture is 1080p
+            Screen.SetResolution(1920, 1080, true);
+        }
+
 #if UNITY_EDITOR
 
         public void Setup()
@@ -143,6 +150,8 @@ public HDRP_GRD_DXR_Graphics_Tests(GpuResidentDrawerContext grdContext)
         [OneTimeSetUp]
         public void OneTimeSetUp()
         {
+            // Standard resolution for backbuffer capture is 1080p
+            Screen.SetResolution(1920, 1080, true);
             SceneManager.LoadScene("GraphicsTestTransitionScene", LoadSceneMode.Single);
         }
 

Tests/SRPTests/Projects/HDRP_RuntimeTests/Assets/Tests/HDRP_Runtime_Graphics_Tests.cs

@@ -13,6 +13,13 @@ public class HDRP_Runtime_Graphics_Tests
     : IPrebuildSetup
 #endif
 {
+    [OneTimeSetUp]
+    public void SetDefaultResolution()
+    {
+        // Standard resolution for backbuffer capture is 1080p
+        Screen.SetResolution(1920, 1080, true);
+    }
+
     [UnityTest]
     [SceneGraphicsTest(@"Assets/Scenes/^[0-9]+")]
     [Timeout(450 * 1000)] // Set timeout to 450 sec. to handle complex scenes with many shaders (previous timeout was 300s)
@@ -44,6 +51,11 @@ public class HDRP_Runtime_Graphics_Tests
         "",
         graphicsDeviceTypes: new GraphicsDeviceType[] { GraphicsDeviceType.Metal }
     )]
+    [IgnoreGraphicsTest(
+        "011-HighQualityLines",
+        "https://jira.unity3d.com/browse/UUM-132442",
+        runtimePlatforms: new RuntimePlatform[] { RuntimePlatform.Switch }
+    )]
     [IgnoreGraphicsTest(
         "004-CloudsFlaresDecals$",
         "Area with cloud-coverage is blue on Intel-based MacOS (CI).",

Tests/SRPTests/Projects/HDRP_Tests/Assets/GraphicTests/Tests/HDRP_Graphics_Tests.cs

@@ -54,6 +54,8 @@ public HDRP_Graphics_Tests(GpuResidentDrawerContext grdContext)
         [OneTimeSetUp]
         public void OneTimeSetUp()
         {
+            // Standard resolution for backbuffer capture is 1080p
+            Screen.SetResolution(1920, 1080, true);
             SceneManager.LoadScene("GraphicsTestTransitionScene", LoadSceneMode.Single);
         }
 

Tests/SRPTests/Projects/HDRP_Tests/Assets/Tests/LightBaker/InputExtractionMaterials.cs

@@ -163,7 +163,7 @@ Vector4[] textureData
             }
         };
 
-        [Test, Category("Graphics"), GraphicsTest(TextureFormat = TextureFormat .RGBAHalf, Extension = "exr")]
+        [Test, Category("Graphics"), GraphicsTest(TextureFormat = TextureFormat .RGBAHalf, ImageExtension = ImageExtension.EXR)]
         public void MetaPassTemplateTests(
             GraphicsTestCase testCase,
             [ValueSource(nameof(metaPassTests))] MetaPassSceneTest metaPassTest