testss

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Runtime/Graphic/GraphicTests.cs

@@ -0,0 +1,264 @@
+using System.Collections.Generic;
+using System.IO;
+using NUnit.Framework;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.EventSystems;
+using UnityEngine.TestTools;
+using UnityEngine.UI;
+using UnityEngine.UI.Tests;
+
+namespace Graphics
+{
+    class GraphicTests : IPrebuildSetup
+    {
+        private GameObject m_PrefabRoot;
+        private ConcreteGraphic m_graphic;
+        private Canvas m_canvas;
+
+        const string kPrefabPath = "Assets/Resources/GraphicTestsPrefab.prefab";
+
+        bool m_dirtyVert;
+        bool m_dirtyLayout;
+        bool m_dirtyMaterial;
+
+        public void Setup()
+        {
+#if UNITY_EDITOR
+            var rootGO = new GameObject("rootGo");
+            var canvasGO = new GameObject("CanvasRoot", typeof(Canvas), typeof(GraphicRaycaster));
+            canvasGO.transform.SetParent(rootGO.transform);
+
+            var graphicGO = new GameObject("Graphic", typeof(RectTransform), typeof(ConcreteGraphic));
+            graphicGO.transform.SetParent(canvasGO.transform);
+
+            var gameObject = new GameObject("EventSystem", typeof(EventSystem));
+            gameObject.transform.SetParent(rootGO.transform);
+
+            if (!Directory.Exists("Assets/Resources/"))
+                Directory.CreateDirectory("Assets/Resources/");
+
+            PrefabUtility.SaveAsPrefabAsset(rootGO, kPrefabPath);
+
+            GameObject.DestroyImmediate(rootGO);
+#endif
+        }
+
+        [SetUp]
+        public void TestSetup()
+        {
+            m_PrefabRoot = Object.Instantiate(Resources.Load("GraphicTestsPrefab")) as GameObject;
+
+            m_canvas = m_PrefabRoot.GetComponentInChildren<Canvas>();
+            m_graphic = m_PrefabRoot.GetComponentInChildren<ConcreteGraphic>();
+
+            m_graphic.RegisterDirtyVerticesCallback(() => m_dirtyVert = true);
+            m_graphic.RegisterDirtyLayoutCallback(() => m_dirtyLayout = true);
+            m_graphic.RegisterDirtyMaterialCallback(() => m_dirtyMaterial = true);
+
+            ResetDirtyFlags();
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            m_graphic = null;
+            m_canvas = null;
+            GameObject.DestroyImmediate(m_PrefabRoot);
+        }
+
+        [OneTimeTearDown]
+        public void OneTimeTearDown()
+        {
+#if UNITY_EDITOR
+            AssetDatabase.DeleteAsset(kPrefabPath);
+#endif
+        }
+
+        private void ResetDirtyFlags()
+        {
+            m_dirtyVert = m_dirtyLayout = m_dirtyMaterial = false;
+        }
+
+        [Test]
+        public void SettingDirtyOnActiveGraphicCallsCallbacks()
+        {
+            m_graphic.enabled = false;
+            m_graphic.enabled = true;
+            m_graphic.SetAllDirty();
+
+            Assert.True(m_dirtyVert, "Vertices have not been dirtied");
+            Assert.True(m_dirtyLayout, "Layout has not been dirtied");
+            Assert.True(m_dirtyMaterial, "Material has not been dirtied");
+
+            ResetDirtyFlags();
+
+            m_graphic.SetLayoutDirty();
+            Assert.True(m_dirtyLayout, "Layout has not been dirtied");
+
+            m_graphic.SetVerticesDirty();
+            Assert.True(m_dirtyVert, "Vertices have not been dirtied");
+
+            m_graphic.SetMaterialDirty();
+            Assert.True(m_dirtyMaterial, "Material has not been dirtied");
+        }
+
+        private bool ContainsGraphic(IList<Graphic> array, int size, Graphic element)
+        {
+            for (int i = 0; i < size; ++i)
+            {
+                if (array[i] == element)
+                    return true;
+            }
+
+            return false;
+        }
+
+        private void RefreshGraphicByRaycast()
+        {
+            // force refresh by raycast
+            List<RaycastResult> raycastResultCache = new List<RaycastResult>();
+            PointerEventData data = new PointerEventData(EventSystem.current);
+            var raycaster = m_canvas.GetComponent<GraphicRaycaster>();
+            raycaster.Raycast(data, raycastResultCache);
+        }
+
+        private bool CheckGraphicAddedToGraphicRegistry()
+        {
+            var graphicList = GraphicRegistry.GetGraphicsForCanvas(m_canvas);
+            var graphicListSize = graphicList.Count;
+            return ContainsGraphic(graphicList, graphicListSize, m_graphic);
+        }
+
+        private bool CheckGraphicAddedToRaycastGraphicRegistry()
+        {
+            var graphicList = GraphicRegistry.GetRaycastableGraphicsForCanvas(m_canvas);
+            var graphicListSize = graphicList.Count;
+            return ContainsGraphic(graphicList, graphicListSize, m_graphic);
+        }
+
+        private void CheckGraphicRaycastDisableValidity()
+        {
+            RefreshGraphicByRaycast();
+            Assert.False(CheckGraphicAddedToGraphicRegistry(), "Graphic should no longer be registered in m_CanvasGraphics");
+            Assert.False(CheckGraphicAddedToRaycastGraphicRegistry(), "Graphic should no longer be registered in m_RaycastableGraphics");
+        }
+
+        [Test]
+        public void OnEnableLeavesGraphicInExpectedState()
+        {
+            m_graphic.enabled = false;
+            m_graphic.enabled = true; // on enable is called directly
+
+            Assert.True(CheckGraphicAddedToGraphicRegistry(), "Graphic should be registered in m_CanvasGraphics");
+            Assert.True(CheckGraphicAddedToRaycastGraphicRegistry(), "Graphic should be registered in m_RaycastableGraphics");
+
+            Assert.AreEqual(Texture2D.whiteTexture, m_graphic.mainTexture, "mainTexture should be Texture2D.whiteTexture");
+
+            Assert.NotNull(m_graphic.canvas);
+
+            Assert.True(m_dirtyVert, "Vertices have not been dirtied");
+            Assert.True(m_dirtyLayout, "Layout has not been dirtied");
+            Assert.True(m_dirtyMaterial, "Material has not been dirtied");
+        }
+
+        [Test]
+        public void OnEnableTwiceLeavesGraphicInExpectedState()
+        {
+            m_graphic.enabled = true;
+
+            // force onEnable by reflection to call it second time
+            m_graphic.InvokeOnEnable();
+
+            m_graphic.enabled = false;
+
+            CheckGraphicRaycastDisableValidity();
+        }
+
+        [Test]
+        public void OnDisableLeavesGraphicInExpectedState()
+        {
+            m_graphic.enabled = true;
+            m_graphic.enabled = false;
+
+            CheckGraphicRaycastDisableValidity();
+        }
+
+        [Test]
+        public void OnPopulateMeshWorksAsExpected()
+        {
+            m_graphic.rectTransform.anchoredPosition = new Vector2(100, 100);
+            m_graphic.rectTransform.sizeDelta = new Vector2(150, 742);
+            m_graphic.color = new Color(50, 100, 150, 200);
+
+            VertexHelper vh = new VertexHelper();
+            m_graphic.InvokeOnPopulateMesh(vh);
+
+            GraphicTestHelper.TestOnPopulateMeshDefaultBehavior(m_graphic, vh);
+        }
+
+        [Test]
+        public void OnDidApplyAnimationPropertiesSetsAllDirty()
+        {
+            m_graphic.enabled = true; // Usually set through SetEnabled, from Behavior
+
+            m_graphic.InvokeOnDidApplyAnimationProperties();
+            Assert.True(m_dirtyVert, "Vertices have not been dirtied");
+            Assert.True(m_dirtyLayout, "Layout has not been dirtied");
+            Assert.True(m_dirtyMaterial, "Material has not been dirtied");
+        }
+
+        [Test]
+        public void MakingGraphicNonRaycastableRemovesGraphicFromProperLists()
+        {
+            Assert.True(CheckGraphicAddedToGraphicRegistry(), "Graphic should be registered in m_CanvasGraphics");
+            Assert.True(CheckGraphicAddedToRaycastGraphicRegistry(), "Graphic should be registered in m_RaycastableGraphics");
+
+            m_graphic.raycastTarget = false;
+
+            Assert.True(CheckGraphicAddedToGraphicRegistry(), "Graphic should be registered in m_CanvasGraphics");
+            Assert.False(CheckGraphicAddedToRaycastGraphicRegistry(), "Graphic should no longer be registered in m_RaycastableGraphics");
+        }
+
+        [Test]
+        public void OnEnableLeavesNonRaycastGraphicInExpectedState()
+        {
+            m_graphic.enabled = false;
+            m_graphic.raycastTarget = false;
+            m_graphic.enabled = true; // on enable is called directly
+
+            Assert.True(CheckGraphicAddedToGraphicRegistry(), "Graphic should be registered in m_CanvasGraphics");
+            Assert.False(CheckGraphicAddedToRaycastGraphicRegistry(), "Graphic should no longer be registered in m_RaycastableGraphics");
+
+            Assert.AreEqual(Texture2D.whiteTexture, m_graphic.mainTexture, "mainTexture should be Texture2D.whiteTexture");
+
+            Assert.NotNull(m_graphic.canvas);
+
+            Assert.True(m_dirtyVert, "Vertices have not been dirtied");
+            Assert.True(m_dirtyLayout, "Layout has not been dirtied");
+            Assert.True(m_dirtyMaterial, "Material has not been dirtied");
+        }
+
+        [Test]
+        public void SettingRaycastTargetOnDisabledGraphicDoesntAddItRaycastList()
+        {
+            Assert.True(CheckGraphicAddedToGraphicRegistry(), "Graphic should be registered in m_CanvasGraphics");
+            Assert.True(CheckGraphicAddedToRaycastGraphicRegistry(), "Graphic should be registered in m_RaycastableGraphics");
+
+            m_graphic.raycastTarget = false;
+
+            Assert.True(CheckGraphicAddedToGraphicRegistry(), "Graphic should be registered in m_CanvasGraphics");
+            Assert.False(CheckGraphicAddedToRaycastGraphicRegistry(), "Graphic should no longer be registered in m_RaycastableGraphics");
+
+            m_graphic.enabled = false;
+
+            Assert.False(CheckGraphicAddedToGraphicRegistry(), "Graphic should NOT be registered in m_CanvasGraphics");
+            Assert.False(CheckGraphicAddedToRaycastGraphicRegistry(), "Graphic should no longer be registered in m_RaycastableGraphics");
+
+            m_graphic.raycastTarget = true;
+
+            Assert.False(CheckGraphicAddedToGraphicRegistry(), "Graphic should NOT be registered in m_CanvasGraphics");
+            Assert.False(CheckGraphicAddedToRaycastGraphicRegistry(), "Graphic should no longer be registered in m_RaycastableGraphics");
+        }
+    }
+}

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Runtime/Graphic/ImageTests.cs

@@ -0,0 +1,517 @@
+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+
+namespace UnityEngine.UI.Tests
+{
+    [TestFixture]
+    class ImageTests
+    {
+        Image m_Image;
+        private Sprite m_Sprite;
+        private Sprite m_OverrideSprite;
+        Texture2D texture = new Texture2D(128, 128);
+        Texture2D overrideTexture = new Texture2D(512, 512);
+
+        bool m_dirtyVert;
+        bool m_dirtyLayout;
+        bool m_dirtyMaterial;
+
+        Camera m_camera;
+        GameObject m_CanvasRoot;
+
+        [SetUp]
+        public void TestSetup()
+        {
+            m_CanvasRoot = new GameObject("Canvas", typeof(RectTransform), typeof(Canvas));
+            GameObject gameObject = new GameObject("Image", typeof(RectTransform), typeof(Image));
+            gameObject.transform.SetParent(m_CanvasRoot.transform);
+
+            m_camera = new GameObject("Camera", typeof(Camera)).GetComponent<Camera>();
+
+            m_Image = gameObject.GetComponent<Image>();
+
+            Color[] colors = new Color[128 * 128];
+            for (int y = 0; y < 128; y++)
+                for (int x = 0; x < 128; x++)
+                    colors[x + 128 * y] = new Color(0, 0, 0, 1 - x / 128f);
+            texture.SetPixels(colors);
+            texture.Apply();
+
+            Color[] overrideColors = new Color[512 * 512];
+            for (int y = 0; y < 512; y++)
+                for (int x = 0; x < 512; x++)
+                    overrideColors[x + 512 * y] = new Color(0, 0, 0, y / 512f);
+            overrideTexture.SetPixels(overrideColors);
+            overrideTexture.Apply();
+
+            m_Sprite = Sprite.Create(texture, new Rect(0, 0, 128, 128), new Vector2(0.5f, 0.5f), 100);
+            m_OverrideSprite = Sprite.Create(overrideTexture, new Rect(0, 0, 512, 512), new Vector2(0.5f, 0.5f), 200);
+
+            m_Image.rectTransform.anchoredPosition = new Vector2(0, 0);
+            m_Image.rectTransform.sizeDelta = new Vector2(100, 100);
+            m_Image.RegisterDirtyVerticesCallback(() => m_dirtyVert = true);
+            m_Image.RegisterDirtyLayoutCallback(() => m_dirtyLayout = true);
+            m_Image.RegisterDirtyMaterialCallback(() => m_dirtyMaterial = true);
+
+            ResetDirtyFlags();
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            m_Image = null;
+            m_Sprite = null;
+
+            GameObject.DestroyImmediate(m_CanvasRoot);
+            GameObject.DestroyImmediate(m_camera.gameObject);
+            m_camera = null;
+        }
+
+        private void ResetDirtyFlags()
+        {
+            m_dirtyVert = m_dirtyLayout = m_dirtyMaterial = false;
+        }
+
+        [Test]
+        public void SetTestSprite()
+        {
+            m_Image.sprite = m_Sprite;
+            m_Image.overrideSprite = m_OverrideSprite;
+            Assert.AreEqual(m_Sprite, m_Image.sprite);
+            m_Image.sprite = null;
+            Assert.AreEqual(null, m_Image.sprite);
+        }
+
+        [Test]
+        public void TestPixelsPerUnit()
+        {
+            m_Image.sprite = m_Sprite;
+            Assert.AreEqual(1.0f, m_Image.pixelsPerUnit);
+
+            m_Image.overrideSprite = m_OverrideSprite;
+            Assert.AreEqual(2.0f, m_Image.pixelsPerUnit);
+
+            m_Image.overrideSprite = null;
+            Assert.AreEqual(1.0f, m_Image.pixelsPerUnit);
+        }
+
+        [Test]
+        public void RaycastOverImageWithoutASpriteReturnTrue()
+        {
+            m_Image.sprite = null;
+            bool raycast = m_Image.Raycast(new Vector2(10, 10), m_camera);
+            Assert.AreEqual(true, raycast);
+        }
+
+        [Test]
+        [TestCase(0.0f, 1000, 1000)]
+        [TestCase(1.0f, 1000, 1000)]
+        [TestCase(0.0f, -1000, 1000)]
+        [TestCase(1.0f, -1000, 1000)]
+        [TestCase(0.0f, 1000, -1000)]
+        [TestCase(1.0f, 1000, -1000)]
+        [TestCase(0.0f, -1000, -1000)]
+        [TestCase(1.0f, -1000, -1000)]
+        public void RaycastOverImageWithoutASpriteReturnsTrueWithCoordinatesOutsideTheBoundaries(float alphaThreshold, float x, float y)
+        {
+            m_Image.alphaHitTestMinimumThreshold = 1.0f - alphaThreshold;
+            bool raycast = m_Image.Raycast(new Vector2(x, y), m_camera);
+            Assert.IsTrue(raycast);
+        }
+
+        [Test]
+        public void SettingSpriteMarksAllAsDirty()
+        {
+            m_Image.sprite = m_Sprite;
+            Assert.True(m_dirtyVert, "Vertices have not been dirtied");
+            Assert.True(m_dirtyLayout, "Layout has not been dirtied");
+            Assert.True(m_dirtyMaterial, "Material has not been dirtied");
+        }
+
+        [Test]
+        public void SettingOverrideSpriteMarksAllAsDirty()
+        {
+            m_Image.overrideSprite = m_OverrideSprite;
+            Assert.True(m_dirtyVert, "Vertices have not been dirtied");
+            Assert.True(m_dirtyLayout, "Layout has not been dirtied");
+            Assert.True(m_dirtyMaterial, "Material has not been dirtied");
+        }
+
+        [Test]
+        public void SettingTypeMarksVerticesAsDirty()
+        {
+            m_Image.type = Image.Type.Filled;
+            Assert.True(m_dirtyVert, "Vertices have not been dirtied");
+            Assert.False(m_dirtyLayout, "Layout has been dirtied");
+            Assert.False(m_dirtyMaterial, "Material has been dirtied");
+        }
+
+        [Test]
+        public void SettingPreserveAspectMarksVerticesAsDirty()
+        {
+            m_Image.preserveAspect = true;
+            Assert.True(m_dirtyVert, "Vertices have not been dirtied");
+            Assert.False(m_dirtyLayout, "Layout has been dirtied");
+            Assert.False(m_dirtyMaterial, "Material has been dirtied");
+        }
+
+        [Test]
+        public void SettingFillCenterMarksVerticesAsDirty()
+        {
+            m_Image.fillCenter = false;
+            Assert.True(m_dirtyVert, "Vertices have not been dirtied");
+            Assert.False(m_dirtyLayout, "Layout has been dirtied");
+            Assert.False(m_dirtyMaterial, "Material has been dirtied");
+        }
+
+        [Test]
+        public void SettingFillMethodMarksVerticesAsDirty()
+        {
+            m_Image.fillMethod = Image.FillMethod.Horizontal;
+            Assert.True(m_dirtyVert, "Vertices have not been dirtied");
+            Assert.False(m_dirtyLayout, "Layout has been dirtied");
+            Assert.False(m_dirtyMaterial, "Material has been dirtied");
+        }
+
+        [Test]
+        public void SettingFillAmountMarksVerticesAsDirty()
+        {
+            m_Image.fillAmount = 0.5f;
+            Assert.True(m_dirtyVert, "Vertices have not been dirtied");
+            Assert.False(m_dirtyLayout, "Layout has been dirtied");
+            Assert.False(m_dirtyMaterial, "Material has been dirtied");
+        }
+
+        [Test]
+        public void SettingFillClockwiseMarksVerticesAsDirty()
+        {
+            m_Image.fillClockwise = false;
+            Assert.True(m_dirtyVert, "Vertices have not been dirtied");
+            Assert.False(m_dirtyLayout, "Layout has been dirtied");
+            Assert.False(m_dirtyMaterial, "Material has been dirtied");
+        }
+
+        [Test]
+        public void SettingFillOriginMarksVerticesAsDirty()
+        {
+            m_Image.fillOrigin = 1;
+            Assert.True(m_dirtyVert, "Vertices have not been dirtied");
+            Assert.False(m_dirtyLayout, "Layout has been dirtied");
+            Assert.False(m_dirtyMaterial, "Material has been dirtied");
+        }
+
+        [Test]
+        public void SettingEventAlphaThresholdMarksNothingAsDirty()
+        {
+            m_Image.alphaHitTestMinimumThreshold = 0.5f;
+            Assert.False(m_dirtyVert, "Vertices have been dirtied");
+            Assert.False(m_dirtyLayout, "Layout has been dirtied");
+            Assert.False(m_dirtyMaterial, "Material has been dirtied");
+        }
+
+        [Test]
+        public void OnAfterDeserializeMakeFillOriginZeroIfNotBetweenZeroAndThree()
+        {
+            for (int i = -10; i < 0; i++)
+            {
+                m_Image.fillOrigin = i;
+                m_Image.OnAfterDeserialize();
+                Assert.AreEqual(0, m_Image.fillOrigin);
+            }
+
+            for (int i = 0; i < 4; i++)
+            {
+                m_Image.fillOrigin = i;
+                m_Image.OnAfterDeserialize();
+                Assert.AreEqual(i, m_Image.fillOrigin);
+            }
+
+            for (int i = 4; i < 10; i++)
+            {
+                m_Image.fillOrigin = i;
+                m_Image.OnAfterDeserialize();
+                Assert.AreEqual(0, m_Image.fillOrigin);
+            }
+        }
+
+        [Test]
+        public void OnAfterDeserializeMakeFillOriginZeroIfFillOriginGreaterThan1AndFillMethodHorizontalOrVertical()
+        {
+            m_Image.fillMethod = Image.FillMethod.Horizontal;
+            Image.FillMethod[] fillMethodsToTest = {Image.FillMethod.Horizontal, Image.FillMethod.Vertical};
+
+            foreach (var fillMethod in fillMethodsToTest)
+            {
+                m_Image.fillMethod = fillMethod;
+                for (int i = -10; i < 0; i++)
+                {
+                    m_Image.fillOrigin = i;
+                    m_Image.OnAfterDeserialize();
+                    Assert.AreEqual(0, m_Image.fillOrigin);
+                }
+
+                for (int i = 0; i < 2; i++)
+                {
+                    m_Image.fillOrigin = i;
+                    m_Image.OnAfterDeserialize();
+                    Assert.AreEqual(i, m_Image.fillOrigin);
+                }
+
+                for (int i = 2; i < 100; i++)
+                {
+                    m_Image.fillOrigin = i;
+                    m_Image.OnAfterDeserialize();
+                    Assert.AreEqual(0, m_Image.fillOrigin);
+                }
+            }
+        }
+
+        [Test]
+        public void OnAfterDeserializeClampsFillAmountBetweenZeroAndOne()
+        {
+            for (float f = -5; f < 0; f += 0.1f)
+            {
+                m_Image.fillAmount = f;
+                m_Image.OnAfterDeserialize();
+                Assert.AreEqual(0, m_Image.fillAmount);
+            }
+
+            for (float f = 0; f < 1; f += 0.1f)
+            {
+                m_Image.fillAmount = f;
+                m_Image.OnAfterDeserialize();
+                Assert.AreEqual(f, m_Image.fillAmount);
+            }
+
+            for (float f = 1; f < 5; f += 0.1f)
+            {
+                m_Image.fillAmount = f;
+                m_Image.OnAfterDeserialize();
+                Assert.AreEqual(1, m_Image.fillAmount);
+            }
+        }
+
+        [Test]
+        public void SetNativeSizeSetsAllAsDirtyAndSetsAnchorMaxAndSizeDeltaWhenOverrideSpriteIsNotNull()
+        {
+            m_Image.sprite = m_Sprite;
+            m_Image.overrideSprite = m_OverrideSprite;
+            m_Image.rectTransform.anchorMax = new Vector2(100, 100);
+            m_Image.rectTransform.anchorMin = new Vector2(0, 0);
+            m_Image.SetNativeSize();
+            Assert.True(m_dirtyVert, "Vertices have not been dirtied");
+            Assert.True(m_dirtyLayout, "Layout has not been dirtied");
+            Assert.True(m_dirtyMaterial, "Material has not been dirtied");
+            Assert.AreEqual(m_Image.rectTransform.anchorMin, m_Image.rectTransform.anchorMax);
+            Assert.AreEqual(m_OverrideSprite.rect.size / m_Image.pixelsPerUnit, m_Image.rectTransform.sizeDelta);
+        }
+
+        [Test]
+        public void OnPopulateMeshWhenNoOverrideSpritePresentDefersToGraphicImplementation()
+        {
+            m_OverrideSprite = null;
+            m_Image.rectTransform.anchoredPosition = new Vector2(100, 452);
+            m_Image.rectTransform.sizeDelta = new Vector2(881, 593);
+            m_Image.color = new Color(0.1f, 0.2f, 0.8f, 0);
+
+            VertexHelper vh = new VertexHelper();
+
+            m_Image.InvokeOnPopulateMesh(vh);
+            Assert.AreEqual(4, vh.currentVertCount);
+            List<UIVertex> verts = new List<UIVertex>();
+            vh.GetUIVertexStream(verts);
+
+            // The vertices for the 2 triangles of the canvas
+            UIVertex[] expectedVertices =
+            {
+                new UIVertex
+                {
+                    color = m_Image.color,
+                    position = m_Image.rectTransform.rect.min,
+                    uv0 = new Vector2(0f, 0f),
+                    normal = new Vector3(0, 0, -1),
+                    tangent = new Vector4(1, 0, 0, -1)
+                },
+                new UIVertex
+                {
+                    color = m_Image.color,
+                    position = new Vector3(m_Image.rectTransform.rect.xMin, m_Image.rectTransform.rect.yMax),
+                    uv0 = new Vector2(0f, 1f),
+                    normal = new Vector3(0, 0, -1),
+                    tangent = new Vector4(1, 0, 0, -1)
+                },
+                new UIVertex
+                {
+                    color = m_Image.color,
+                    position = m_Image.rectTransform.rect.max,
+                    uv0 = new Vector2(1f, 1f),
+                    normal = new Vector3(0, 0, -1),
+                    tangent = new Vector4(1, 0, 0, -1)
+                },
+                new UIVertex
+                {
+                    color = m_Image.color,
+                    position = m_Image.rectTransform.rect.max,
+                    uv0 = new Vector2(1f, 1f),
+                    normal = new Vector3(0, 0, -1),
+                    tangent = new Vector4(1, 0, 0, -1)
+                },
+                new UIVertex
+                {
+                    color = m_Image.color,
+                    position = new Vector3(m_Image.rectTransform.rect.xMax, m_Image.rectTransform.rect.yMin),
+                    uv0 = new Vector2(1f, 0f),
+                    normal = new Vector3(0, 0, -1),
+                    tangent = new Vector4(1, 0, 0, -1)
+                },
+                new UIVertex
+                {
+                    color = m_Image.color,
+                    position = m_Image.rectTransform.rect.min,
+                    uv0 = new Vector2(0f, 0f),
+                    normal = new Vector3(0, 0, -1),
+                    tangent = new Vector4(1, 0, 0, -1)
+                },
+            };
+
+            for (int i = 0; i < verts.Count; i++)
+            {
+                Assert.AreEqual(expectedVertices[i], verts[i]);
+            }
+        }
+
+        private void TestOnPopulateMeshTypeSimple(VertexHelper vh, Vector4 UVs)
+        {
+            List<UIVertex> verts = new List<UIVertex>();
+            vh.GetUIVertexStream(verts);
+
+            Assert.AreEqual(4, vh.currentVertCount);
+            Assert.AreEqual(6, vh.currentIndexCount);
+
+            var imgRect = m_Image.rectTransform.rect;
+            Vector3[] expectedVertices =
+            {
+                imgRect.min,
+                new Vector3(imgRect.xMin, imgRect.yMax),
+                imgRect.max,
+                imgRect.max,
+                new Vector3(imgRect.xMax, imgRect.yMin),
+                imgRect.min
+            };
+
+            Vector2[] expectedUV0s =
+            {
+                new Vector2(UVs.x, UVs.y),
+                new Vector2(UVs.x, UVs.w),
+                new Vector2(UVs.z, UVs.w),
+                new Vector2(UVs.z, UVs.w),
+                new Vector2(UVs.z, UVs.y),
+                new Vector2(UVs.x, UVs.y),
+            };
+
+            var expectedNormal = new Vector3(0, 0, -1);
+            var expectedTangent = new Vector4(1, 0, 0, -1);
+            Color32 expectedColor = m_Image.color;
+            Vector2 expectedUV1 = new Vector2(0, 0);
+
+            for (int i = 0; i < 6; i++)
+            {
+                Assert.AreEqual(expectedVertices[i], verts[i].position);
+                Assert.AreEqual(expectedUV0s[i], verts[i].uv0);
+                Assert.AreEqual(expectedUV1, verts[i].uv1);
+                Assert.AreEqual(expectedNormal, verts[i].normal);
+                Assert.AreEqual(expectedTangent, verts[i].tangent);
+                Assert.AreEqual(expectedColor, verts[i].color);
+            }
+        }
+
+        [Test]
+        public void OnPopulateMeshWithTypeTiledNoBorderGeneratesExpectedResults()
+        {
+            m_Image.sprite = m_Sprite;
+            m_Image.sprite.texture.wrapMode = TextureWrapMode.Repeat;
+
+            m_Image.type = Image.Type.Tiled;
+
+            VertexHelper vh = new VertexHelper();
+
+            m_Image.InvokeOnPopulateMesh(vh);
+
+            Assert.AreEqual(4, vh.currentVertCount);
+            Assert.AreEqual(6, vh.currentIndexCount);
+        }
+
+        [Test]
+        public void MinWidthHeightAreZeroWithNoImage()
+        {
+            Assert.AreEqual(0, m_Image.minWidth);
+            Assert.AreEqual(0, m_Image.minHeight);
+        }
+
+        [Test]
+        public void FlexibleWidthHeightAreCorrectWithNoImage()
+        {
+            Assert.AreEqual(-1, m_Image.flexibleWidth);
+            Assert.AreEqual(-1, m_Image.flexibleHeight);
+        }
+
+        [Test]
+        public void PreferredWidthHeightAreCorrectWithNoImage()
+        {
+            Assert.AreEqual(0, m_Image.preferredWidth);
+            Assert.AreEqual(0, m_Image.preferredHeight);
+        }
+
+        [Test]
+        public void MinWidthHeightAreZeroWithImage()
+        {
+            m_Image.sprite = m_Sprite;
+            Assert.AreEqual(0, m_Image.minWidth);
+            Assert.AreEqual(0, m_Image.minHeight);
+        }
+
+        [Test]
+        public void FlexibleWidthHeightAreCorrectWithImage()
+        {
+            m_Image.sprite = m_Sprite;
+            Assert.AreEqual(-1, m_Image.flexibleWidth);
+            Assert.AreEqual(-1, m_Image.flexibleHeight);
+        }
+
+        [Test]
+        public void PreferredWidthHeightAreCorrectWithImage()
+        {
+            m_Image.sprite = m_Sprite;
+            Assert.AreEqual(128, m_Image.preferredWidth);
+            Assert.AreEqual(128, m_Image.preferredHeight);
+        }
+
+        [Test]
+        public void MinWidthHeightAreZeroWithOverrideImage()
+        {
+            m_Image.sprite = m_Sprite;
+            m_Image.overrideSprite = m_OverrideSprite;
+            Assert.AreEqual(0, m_Image.minWidth);
+            Assert.AreEqual(0, m_Image.minHeight);
+        }
+
+        [Test]
+        public void FlexibleWidthHeightAreCorrectWithOverrideImage()
+        {
+            m_Image.sprite = m_Sprite;
+            m_Image.overrideSprite = m_OverrideSprite;
+            Assert.AreEqual(-1, m_Image.flexibleWidth);
+            Assert.AreEqual(-1, m_Image.flexibleHeight);
+        }
+
+        [Test]
+        public void PreferredWidthHeightAreCorrectWithOverrideImage()
+        {
+            m_Image.sprite = m_Sprite;
+            m_Image.overrideSprite = m_OverrideSprite;
+            Assert.AreEqual(256, m_Image.preferredWidth);
+            Assert.AreEqual(256, m_Image.preferredHeight);
+        }
+    }
+}

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Runtime/Graphic/MaskTests.cs

@@ -0,0 +1,163 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using NUnit.Framework;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEngine.TestTools;
+using UnityEngine.UI;
+
+namespace Graphics
+{
+    class MaskTests : IPrebuildSetup
+    {
+        GameObject m_PrefabRoot;
+        const string kPrefabPath = "Assets/Resources/MaskTestsPrefab.prefab";
+
+        Mask m_mask;
+
+        public void Setup()
+        {
+#if UNITY_EDITOR
+            var rootGO = new GameObject("rootGo");
+            GameObject canvasGO = new GameObject("Canvas", typeof(RectTransform), typeof(Canvas));
+            canvasGO.transform.SetParent(rootGO.transform);
+
+            var canvas = canvasGO.GetComponent<Canvas>();
+            canvas.referencePixelsPerUnit = 100;
+
+            var gameObject = new GameObject("Mask", typeof(RectTransform), typeof(Mask), typeof(Image));
+            gameObject.transform.SetParent(canvasGO.transform);
+
+            if (!Directory.Exists("Assets/Resources/"))
+                Directory.CreateDirectory("Assets/Resources/");
+
+            PrefabUtility.SaveAsPrefabAsset(rootGO, kPrefabPath);
+            GameObject.DestroyImmediate(rootGO);
+#endif
+        }
+
+        [SetUp]
+        public void TestSetup()
+        {
+            m_PrefabRoot = Object.Instantiate(Resources.Load("MaskTestsPrefab")) as GameObject;
+            m_mask = m_PrefabRoot.GetComponentInChildren<Mask>();
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            m_mask = null;
+            Object.DestroyImmediate(m_PrefabRoot);
+        }
+
+        [OneTimeTearDown]
+        public void OneTimeTearDown()
+        {
+#if UNITY_EDITOR
+            AssetDatabase.DeleteAsset(kPrefabPath);
+#endif
+        }
+
+        [UnityTest]
+        public IEnumerator GetModifiedMaterialReturnsOriginalMaterialWhenNoGraphicComponentIsAttached()
+        {
+            Object.DestroyImmediate(m_mask.gameObject.GetComponent<Image>());
+            yield return null;
+            Material material = new Material(Graphic.defaultGraphicMaterial);
+            Material modifiedMaterial = m_mask.GetModifiedMaterial(material);
+            Assert.AreEqual(material, modifiedMaterial);
+        }
+
+        private Dictionary<string, GameObject> CreateMaskHierarchy(string suffix, int hierarchyDepth, out GameObject root)
+        {
+            var nameToObjectMapping = new Dictionary<string, GameObject>();
+
+            root = new GameObject("root", typeof(RectTransform), typeof(Canvas));
+            nameToObjectMapping["root"] = root;
+
+            GameObject current = root;
+
+            for (int i = 0; i < hierarchyDepth; i++)
+            {
+                string name = suffix + (i + 1);
+                var gameObject = new GameObject(name, typeof(RectTransform), typeof(Mask), typeof(Image));
+                gameObject.transform.SetParent(current.transform);
+                nameToObjectMapping[name] = gameObject;
+                current = gameObject;
+            }
+
+            return nameToObjectMapping;
+        }
+
+        [Test]
+        public void GetModifiedMaterialReturnsOriginalMaterialWhenDepthIsEightOrMore()
+        {
+            GameObject root;
+            var objectsMap = CreateMaskHierarchy("subMask", 9, out root);
+            Mask mask = objectsMap["subMask" + 9].GetComponent<Mask>();
+            Material material = new Material(Graphic.defaultGraphicMaterial);
+            Material modifiedMaterial = mask.GetModifiedMaterial(material);
+            Assert.AreEqual(material, modifiedMaterial);
+            GameObject.DestroyImmediate(root);
+        }
+
+        [Test]
+        public void GetModifiedMaterialReturnsDesiredMaterialWithSingleMask()
+        {
+            Material material = new Material(Graphic.defaultGraphicMaterial);
+            Material modifiedMaterial = m_mask.GetModifiedMaterial(material);
+
+            Assert.AreNotEqual(material, modifiedMaterial);
+            Assert.AreEqual(1, modifiedMaterial.GetInt("_Stencil"));
+            Assert.AreEqual(StencilOp.Replace, (StencilOp)modifiedMaterial.GetInt("_StencilOp"));
+            Assert.AreEqual(CompareFunction.Always, (CompareFunction)modifiedMaterial.GetInt("_StencilComp"));
+            Assert.AreEqual(255, modifiedMaterial.GetInt("_StencilReadMask"));
+            Assert.AreEqual(255, modifiedMaterial.GetInt("_StencilWriteMask"));
+            Assert.AreEqual(ColorWriteMask.All, (ColorWriteMask)modifiedMaterial.GetInt("_ColorMask"));
+            Assert.AreEqual(1, modifiedMaterial.GetInt("_UseUIAlphaClip"));
+
+            Assert.IsTrue(modifiedMaterial.IsKeywordEnabled("UNITY_UI_ALPHACLIP"));
+        }
+
+        [Test]
+        public void GetModifiedMaterialReturnsDesiredMaterialWithMultipleMasks()
+        {
+            for (int i = 2; i < 8; i++)
+            {
+                GameObject root;
+                var objectsMap = CreateMaskHierarchy("subMask", i, out root);
+                Mask mask = objectsMap["subMask" + i].GetComponent<Mask>();
+
+                int stencilDepth = MaskUtilities.GetStencilDepth(mask.transform, objectsMap["root"].transform);
+
+                int desiredStencilBit = 1 << stencilDepth;
+                Material material = new Material(Graphic.defaultGraphicMaterial);
+                Material modifiedMaterial = mask.GetModifiedMaterial(material);
+                int stencil = modifiedMaterial.GetInt("_Stencil");
+
+                Assert.AreNotEqual(material, modifiedMaterial);
+                Assert.AreEqual(desiredStencilBit | (desiredStencilBit - 1), stencil);
+                Assert.AreEqual(StencilOp.Replace, (StencilOp)modifiedMaterial.GetInt("_StencilOp"));
+                Assert.AreEqual(CompareFunction.Equal, (CompareFunction)modifiedMaterial.GetInt("_StencilComp"));
+                Assert.AreEqual(desiredStencilBit - 1, modifiedMaterial.GetInt("_StencilReadMask"));
+                Assert.AreEqual(desiredStencilBit | (desiredStencilBit - 1), modifiedMaterial.GetInt("_StencilWriteMask"));
+                Assert.AreEqual(ColorWriteMask.All, (ColorWriteMask)modifiedMaterial.GetInt("_ColorMask"));
+                Assert.AreEqual(1, modifiedMaterial.GetInt("_UseUIAlphaClip"));
+                Assert.IsTrue(modifiedMaterial.IsKeywordEnabled("UNITY_UI_ALPHACLIP"));
+
+                GameObject.DestroyImmediate(root);
+            }
+        }
+
+        [Test]
+        public void GraphicComponentWithMaskIsMarkedAsIsMaskingGraphicWhenEnabled()
+        {
+            var graphic = m_PrefabRoot.GetComponentInChildren<Image>();
+            Assert.AreEqual(true, graphic.isMaskingGraphic);
+            m_mask.enabled = false;
+            Assert.AreEqual(false, graphic.isMaskingGraphic);
+        }
+    }
+}

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Runtime/Graphic/NavigationTests.cs

@@ -0,0 +1,169 @@
+using System.Reflection;
+using System.Collections;
+using NUnit.Framework;
+using UnityEngine.EventSystems;
+using UnityEngine.TestTools;
+
+namespace UnityEngine.UI.Tests
+{
+    [TestFixture]
+    class NavigationTests
+    {
+        GameObject canvasRoot;
+        Selectable topLeftSelectable;
+        Selectable bottomLeftSelectable;
+        Selectable topRightSelectable;
+        Selectable bottomRightSelectable;
+
+        [SetUp]
+        public void TestSetup()
+        {
+            canvasRoot = new GameObject("Canvas", typeof(RectTransform), typeof(Canvas));
+            GameObject topLeftGO = new GameObject("topLeftGO", typeof(RectTransform), typeof(CanvasRenderer), typeof(Selectable));
+            topLeftGO.transform.SetParent(canvasRoot.transform);
+            (topLeftGO.transform as RectTransform).anchoredPosition = new Vector2(50, 200);
+            topLeftSelectable = topLeftGO.GetComponent<Selectable>();
+
+            GameObject bottomLeftGO = new GameObject("bottomLeftGO", typeof(RectTransform), typeof(CanvasRenderer), typeof(Selectable));
+            bottomLeftGO.transform.SetParent(canvasRoot.transform);
+            (bottomLeftGO.transform as RectTransform).anchoredPosition = new Vector2(50, 50);
+            bottomLeftSelectable = bottomLeftGO.GetComponent<Selectable>();
+
+            GameObject topRightGO = new GameObject("topRightGO", typeof(RectTransform), typeof(CanvasRenderer), typeof(Selectable));
+            topRightGO.transform.SetParent(canvasRoot.transform);
+            (topRightGO.transform as RectTransform).anchoredPosition = new Vector2(200, 200);
+            topRightSelectable = topRightGO.GetComponent<Selectable>();
+
+            GameObject bottomRightGO = new GameObject("bottomRightGO", typeof(RectTransform), typeof(CanvasRenderer), typeof(Selectable));
+            bottomRightGO.transform.SetParent(canvasRoot.transform);
+            (bottomRightGO.transform as RectTransform).anchoredPosition = new Vector2(200, 50);
+            bottomRightSelectable = bottomRightGO.GetComponent<Selectable>();
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            GameObject.DestroyImmediate(canvasRoot);
+        }
+
+        [Test]
+        public void FindSelectableOnRight_ReturnsNextSelectableRightOfTarget()
+        {
+            Selectable selectableRightOfTopLeft = topLeftSelectable.FindSelectableOnRight();
+            Selectable selectableRightOfBottomLeft = bottomLeftSelectable.FindSelectableOnRight();
+
+            Assert.AreEqual(topRightSelectable, selectableRightOfTopLeft, "Wrong selectable to right of Top Left Selectable");
+            Assert.AreEqual(bottomRightSelectable, selectableRightOfBottomLeft, "Wrong selectable to right of Bottom Left Selectable");
+        }
+
+        [Test]
+        public void FindSelectableOnLeft_ReturnsNextSelectableLeftOfTarget()
+        {
+            Selectable selectableLeftOfTopRight = topRightSelectable.FindSelectableOnLeft();
+            Selectable selectableLeftOfBottomRight = bottomRightSelectable.FindSelectableOnLeft();
+
+            Assert.AreEqual(topLeftSelectable, selectableLeftOfTopRight, "Wrong selectable to left of Top Right Selectable");
+            Assert.AreEqual(bottomLeftSelectable, selectableLeftOfBottomRight, "Wrong selectable to left of Bottom Right Selectable");
+        }
+
+        [Test]
+        public void FindSelectableOnRDown_ReturnsNextSelectableBelowTarget()
+        {
+            Selectable selectableDownOfTopLeft = topLeftSelectable.FindSelectableOnDown();
+            Selectable selectableDownOfTopRight = topRightSelectable.FindSelectableOnDown();
+
+            Assert.AreEqual(bottomLeftSelectable, selectableDownOfTopLeft, "Wrong selectable to Bottom of Top Left Selectable");
+            Assert.AreEqual(bottomRightSelectable, selectableDownOfTopRight, "Wrong selectable to Bottom of top Right Selectable");
+        }
+
+        [Test]
+        public void FindSelectableOnUp_ReturnsNextSelectableAboveTarget()
+        {
+            Selectable selectableUpOfBottomLeft = bottomLeftSelectable.FindSelectableOnUp();
+            Selectable selectableUpOfBottomRight = bottomRightSelectable.FindSelectableOnUp();
+
+            Assert.AreEqual(topLeftSelectable, selectableUpOfBottomLeft, "Wrong selectable to Up of bottom Left Selectable");
+            Assert.AreEqual(topRightSelectable, selectableUpOfBottomRight, "Wrong selectable to Up of bottom Right Selectable");
+        }
+
+        [Test]
+        public void FindSelectableOnRight__WrappingEnabled_ReturnsFurthestSelectableOnLeft()
+        {
+            Navigation nav = topRightSelectable.navigation;
+            nav.wrapAround = true;
+            nav.mode = Navigation.Mode.Horizontal;
+            topRightSelectable.navigation = nav;
+
+            nav = bottomRightSelectable.navigation;
+            nav.wrapAround = true;
+            nav.mode = Navigation.Mode.Horizontal;
+            bottomRightSelectable.navigation = nav;
+
+            Selectable selectableRightOfTopRight = topRightSelectable.FindSelectableOnRight();
+            Selectable selectableRightOfBottomRight = bottomRightSelectable.FindSelectableOnRight();
+
+            Assert.AreEqual(bottomLeftSelectable, selectableRightOfTopRight, "Wrong selectable to right of Top Right Selectable");
+            Assert.AreEqual(topLeftSelectable, selectableRightOfBottomRight, "Wrong selectable to right of Bottom Right Selectable");
+        }
+
+        [Test]
+        public void FindSelectableOnLeft_WrappingEnabled_ReturnsFurthestSelectableOnRight()
+        {
+            Navigation nav = topLeftSelectable.navigation;
+            nav.wrapAround = true;
+            nav.mode = Navigation.Mode.Horizontal;
+            topLeftSelectable.navigation = nav;
+
+            nav = bottomLeftSelectable.navigation;
+            nav.wrapAround = true;
+            nav.mode = Navigation.Mode.Horizontal;
+            bottomLeftSelectable.navigation = nav;
+
+            Selectable selectableLeftOfTopLeft = topLeftSelectable.FindSelectableOnLeft();
+            Selectable selectableLeftOfBottomLeft = bottomLeftSelectable.FindSelectableOnLeft();
+
+            Assert.AreEqual(bottomRightSelectable, selectableLeftOfTopLeft, "Wrong selectable to left of Top Left Selectable");
+            Assert.AreEqual(topRightSelectable, selectableLeftOfBottomLeft, "Wrong selectable to left of Bottom Left Selectable");
+        }
+
+        [Test]
+        public void FindSelectableOnDown_WrappingEnabled_ReturnsFurthestSelectableAbove()
+        {
+            Navigation nav = bottomLeftSelectable.navigation;
+            nav.wrapAround = true;
+            nav.mode = Navigation.Mode.Vertical;
+            bottomLeftSelectable.navigation = nav;
+
+            nav = bottomRightSelectable.navigation;
+            nav.wrapAround = true;
+            nav.mode = Navigation.Mode.Vertical;
+            bottomRightSelectable.navigation = nav;
+
+            Selectable selectableDownOfBottomLeft = bottomLeftSelectable.FindSelectableOnDown();
+            Selectable selectableDownOfBottomRight = bottomRightSelectable.FindSelectableOnDown();
+
+            Assert.AreEqual(topRightSelectable, selectableDownOfBottomLeft, "Wrong selectable to Bottom of Bottom Left Selectable");
+            Assert.AreEqual(topLeftSelectable, selectableDownOfBottomRight, "Wrong selectable to Bottom of Bottom Right Selectable");
+        }
+
+        [Test]
+        public void FindSelectableOnUp_WrappingEnabled_ReturnsFurthestSelectableBelow()
+        {
+            Navigation nav = topLeftSelectable.navigation;
+            nav.wrapAround = true;
+            nav.mode = Navigation.Mode.Vertical;
+            topLeftSelectable.navigation = nav;
+
+            nav = topRightSelectable.navigation;
+            nav.wrapAround = true;
+            nav.mode = Navigation.Mode.Vertical;
+            topRightSelectable.navigation = nav;
+
+            Selectable selectableUpOfTopLeft = topLeftSelectable.FindSelectableOnUp();
+            Selectable selectableUpOfTopRight = topRightSelectable.FindSelectableOnUp();
+
+            Assert.AreEqual(bottomRightSelectable, selectableUpOfTopLeft, "Wrong selectable to Up of Top Left Selectable");
+            Assert.AreEqual(bottomLeftSelectable, selectableUpOfTopRight, "Wrong selectable to Up of Top Right Selectable");
+        }
+    }
+}

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Runtime/Graphic/RawImageTest.cs

@@ -0,0 +1,77 @@
+using System.Collections;
+using System.IO;
+using NUnit.Framework;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.TestTools;
+using UnityEngine.UI;
+
+namespace Graphics
+{
+    public class RawImageTest : IPrebuildSetup
+    {
+        private const int Width = 32;
+        private const int Height = 32;
+
+        private GameObject m_PrefabRoot;
+        private RawImageTestHook m_image;
+        private Texture2D m_defaultTexture;
+
+        const string kPrefabPath = "Assets/Resources/RawImageUpdatePrefab.prefab";
+
+        public void Setup()
+        {
+#if UNITY_EDITOR
+            var rootGO = new GameObject("Root");
+            var canvasGO = new GameObject("Canvas", typeof(Canvas));
+            var canvas = canvasGO.GetComponent<Canvas>();
+            canvas.renderMode = RenderMode.WorldSpace;
+            canvasGO.transform.SetParent(rootGO.transform);
+
+            var imageGO = new GameObject("Image", typeof(RectTransform), typeof(RawImageTestHook));
+            var imageTransform = imageGO.GetComponent<RectTransform>();
+            imageTransform.SetParent(canvas.transform);
+
+            imageTransform.anchoredPosition = Vector2.zero;
+
+            if (!Directory.Exists("Assets/Resources/"))
+                Directory.CreateDirectory("Assets/Resources/");
+
+            PrefabUtility.SaveAsPrefabAsset(rootGO, kPrefabPath);
+            GameObject.DestroyImmediate(rootGO);
+#endif
+        }
+
+        [SetUp]
+        public void TestSetup()
+        {
+            m_PrefabRoot = Object.Instantiate(Resources.Load("RawImageUpdatePrefab")) as GameObject;
+
+            m_image = m_PrefabRoot.transform.Find("Canvas/Image").GetComponent<RawImageTestHook>();
+            m_defaultTexture = new Texture2D(Width, Height);
+            m_image.texture = m_defaultTexture;
+        }
+
+        [UnityTest]
+        public IEnumerator Sprite_Material()
+        {
+            m_image.ResetTest();
+
+            // can test only on texture change, same texture is bypass by RawImage property
+            m_image.texture = new Texture2D(Width, Height);
+            yield return new WaitUntil(() => m_image.isGeometryUpdated);
+
+            // validate that layout change rebuild is called
+            Assert.IsTrue(m_image.isMaterialRebuild);
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            GameObject.DestroyImmediate(m_PrefabRoot);
+#if UNITY_EDITOR
+            AssetDatabase.DeleteAsset(kPrefabPath);
+#endif
+        }
+    }
+}

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Runtime/Graphic/RawImageTestHook.cs

@@ -0,0 +1,38 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+
+public class RawImageTestHook : RawImage
+{
+    public bool isGeometryUpdated;
+    public bool isCacheUsed;
+    public bool isLayoutRebuild;
+    public bool isMaterialRebuild;
+
+    public void ResetTest()
+    {
+        isGeometryUpdated = false;
+        isLayoutRebuild = false;
+        isMaterialRebuild = false;
+        isCacheUsed = false;
+    }
+
+    public override void SetLayoutDirty()
+    {
+        base.SetLayoutDirty();
+        isLayoutRebuild = true;
+    }
+
+    public override void SetMaterialDirty()
+    {
+        base.SetMaterialDirty();
+        isMaterialRebuild = true;
+    }
+
+    protected override void UpdateGeometry()
+    {
+        base.UpdateGeometry();
+        isGeometryUpdated = true;
+    }
+}

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Runtime/Graphic/ToggleTestImageHook.cs

@@ -0,0 +1,14 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+
+public class ToggleTestImageHook : Image
+{
+    public float durationTween;
+    public override void CrossFadeColor(Color targetColor, float duration, bool ignoreTimeScale, bool useAlpha, bool useRGB)
+    {
+        durationTween = duration;
+        base.CrossFadeColor(targetColor, duration, ignoreTimeScale, useAlpha, useRGB);
+    }
+}