first commit

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 936bea4b2545c4a4fad2e623b0f6371f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/Canvas.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: b86b117346968ac4d9cc63e4385becb7
+folderAsset: yes
+timeCreated: 1459501450
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/Canvas/AssertionFailureOnOutputVertexCount.cs

@@ -0,0 +1,40 @@
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityEngine.TestTools;
+using UnityEditor.SceneManagement;
+using UnityEditor;
+
+public class AssertionFailureOnOutputVertexCount
+{
+    const string scenePath = "Assets/AssertionFailureOnOutputVertexCountTestScene.unity";
+    [Test]
+    public void AssertionFailureOnOutputVertexCountTest()
+    {
+        var newScene = EditorSceneManager.NewScene(UnityEditor.SceneManagement.NewSceneSetup.DefaultGameObjects, UnityEditor.SceneManagement.NewSceneMode.Single);
+
+        var canvasMaster = new GameObject("Canvas", typeof(Canvas), typeof(CanvasScaler), typeof(GraphicRaycaster));
+        var canvasChild = new GameObject("Canvas Child", typeof(Canvas), typeof(CanvasScaler), typeof(GraphicRaycaster));
+        canvasChild.transform.SetParent(canvasMaster.transform);
+
+        var panel1 = new GameObject("Panel", typeof(CanvasRenderer), typeof(UnityEngine.UI.Image));
+        panel1.transform.SetParent(canvasMaster.transform);
+
+        var panel2 = new GameObject("Panel", typeof(CanvasRenderer), typeof(UnityEngine.UI.Image));
+        panel2.transform.SetParent(canvasChild.transform);
+
+        // Saving a scene would trigger the error case 893551
+        EditorSceneManager.SaveScene(newScene, scenePath);
+        Debug.Log("Success");
+
+        LogAssert.Expect(LogType.Log, "Success");
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+#if UNITY_EDITOR
+        AssetDatabase.DeleteAsset(scenePath);
+#endif
+    }
+}

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/Canvas/AssertionFailureOnOutputVertexCount.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bede4033d9f359b41878c4cda6a910b3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/Canvas/CanvasElementsMaintainValidPositionsWhenCameraOrthoSizeIsZero.cs

@@ -0,0 +1,57 @@
+using NUnit.Framework;
+using System.Collections;
+using UnityEngine;
+using UnityEngine.TestTools;
+using UnityEngine.UI;
+
+
+public class CanvasElementsMaintainValidPositionsWhenCameraOrthoSizeIsZero
+{
+    GameObject image;
+    GameObject canvas;
+    GameObject camera;
+
+    [SetUp]
+    public void TestSetup()
+    {
+        canvas = new GameObject("Canvas", typeof(Canvas));
+
+        image = new GameObject("Image", typeof(Image));
+        image.transform.SetParent(canvas.transform);
+
+        camera = new GameObject("Camera", typeof(Camera));
+        var cameraComponent = camera.GetComponent<Camera>();
+        cameraComponent.orthographic = true;
+
+        var canvasComponent = canvas.GetComponent<Canvas>();
+        canvasComponent.worldCamera = camera.GetComponent<Camera>();
+        canvasComponent.renderMode = RenderMode.ScreenSpaceCamera;
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        GameObject.DestroyImmediate(canvas);
+        GameObject.DestroyImmediate(camera);
+    }
+
+    [UnityTest]
+    public IEnumerator TestCanvasElementsMaintainValidPositionsWhenCameraOrthoSizeIsZero()
+    {
+        var cameraComponent = camera.GetComponent<Camera>();
+        cameraComponent.orthographicSize = 0;
+        yield return null;
+
+        Assert.AreNotEqual(image.transform.position.x, float.NaN);
+        Assert.AreNotEqual(image.transform.position.y, float.NaN);
+
+
+        cameraComponent.orthographicSize = 2;
+        yield return null;
+
+        Assert.AreEqual(image.transform.position.x, 0.0f);
+        Assert.AreEqual(image.transform.position.y, 0.0f);
+
+        Assert.Pass();
+    }
+}

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/Canvas/CanvasElementsMaintainValidPositionsWhenCameraOrthoSizeIsZero.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 35a0d10199de49f4db0128003bfd3bda
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/Canvas/CanvasWidthAssertionErrorWithRectTransform.cs

@@ -0,0 +1,47 @@
+using UnityEngine;
+using NUnit.Framework;
+using UnityEngine.UI;
+
+[TestFixture]
+[Category("RegressionTest")]
+[Description("CoveredBugID = 913932")]
+public class CanvasWidthAssertionErrorWithRectTransform
+{
+    GameObject m_CanvasMaster;
+    GameObject m_CanvasChild;
+
+    [SetUp]
+    public void TestSetup()
+    {
+        m_CanvasMaster = new GameObject("Canvas", typeof(Canvas), typeof(CanvasScaler), typeof(GraphicRaycaster));
+        m_CanvasChild = new GameObject("Canvas", typeof(Canvas), typeof(CanvasScaler), typeof(GraphicRaycaster));
+    }
+
+    [Test]
+    public void CanvasWidthAssertionErrorCheckOnModifyingRectTransform()
+    {
+        // Creating canvas and child canvas
+        m_CanvasChild.transform.SetParent(m_CanvasMaster.transform);
+
+        // Getting the rect Transform and modifying it
+        RectTransform rt = m_CanvasChild.GetComponent<RectTransform>();
+
+        rt.anchorMin = new Vector2(0, 0);
+        rt.anchorMax = new Vector2(1, 1);
+
+        rt.offsetMin = new Vector2(rt.offsetMin.x, 1000);
+        rt.offsetMax = new Vector2(rt.offsetMax.x, 200);
+
+        rt.offsetMin = new Vector2(rt.offsetMin.y, 1);
+        rt.offsetMax = new Vector2(rt.offsetMax.y, 0);
+
+        //Assertion failed: Assertion failed on expression: 'width >= 0 should not happen
+        Assert.Pass();
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        GameObject.DestroyImmediate(m_CanvasMaster);
+    }
+}

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/Canvas/CanvasWidthAssertionErrorWithRectTransform.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4585b5feb801bdb44b0e5eafdd95a3be
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/Canvas/RootCanvasTests.cs

@@ -0,0 +1,81 @@
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.UI;
+
+[Category("Canvas")]
+public class RootCanvasTests : TestBehaviourBase<UnityEngine.Canvas>
+{
+    // A simple nested canvas hierarchy
+    // m_TestObject
+    //     └ rootCanvasChild
+    //              └ emptyChildGameObject
+    //                          └ baseCanvas
+    private UnityEngine.Canvas rootCanvasChild;
+    private GameObject emptyChildGameObject;
+    private UnityEngine.Canvas baseCanvas;
+
+    [SetUp]
+    public override void TestSetup()
+    {
+        base.TestSetup();
+
+        var rootChildGO = new GameObject("root child");
+        rootCanvasChild = rootChildGO.AddComponent<Canvas>();
+
+        emptyChildGameObject = new GameObject("empty");
+
+        var baseGO = new GameObject("base");
+        baseCanvas = baseGO.AddComponent<Canvas>();
+
+        baseCanvas.transform.SetParent(emptyChildGameObject.transform);
+        emptyChildGameObject.transform.SetParent(rootChildGO.transform);
+        rootChildGO.transform.SetParent(m_TestObject.transform);
+    }
+
+    [Test]
+    public void IsRootCanvasTest()
+    {
+        Assert.IsFalse(baseCanvas.isRootCanvas);
+        Assert.IsFalse(rootCanvasChild.isRootCanvas);
+        Assert.IsTrue(m_TestObject.isRootCanvas);
+    }
+
+    [Test]
+    public void CorrectRootCanvasReturned()
+    {
+        Assert.AreEqual(m_TestObject, m_TestObject.rootCanvas);
+        Assert.AreEqual(m_TestObject, rootCanvasChild.rootCanvas);
+        Assert.AreEqual(m_TestObject, baseCanvas.rootCanvas);
+    }
+
+    [Test]
+    public void NotRootCanvasAnchorsDontGetReset()
+    {
+        var rect = rootCanvasChild.GetComponent<RectTransform>();
+
+        rect.anchorMin = Vector2.zero;
+        rect.anchorMax = Vector2.one;
+
+        Assert.IsTrue(rect.anchorMin == Vector2.zero);
+        Assert.IsTrue(rect.anchorMax == Vector2.one);
+
+        m_TestObject.gameObject.SetActive(false);
+
+        Assert.IsTrue(rect.anchorMin == Vector2.zero);
+        Assert.IsTrue(rect.anchorMax == Vector2.one);
+    }
+
+    [Test]
+    public void ChildOfDisabledCanvasCantReceiveClicks()
+    {
+        rootCanvasChild.gameObject.AddComponent<Image>();
+        var raycasts = GraphicRegistry.GetRaycastableGraphicsForCanvas(rootCanvasChild);
+
+        Assert.IsTrue(raycasts.Count == 1);
+
+        m_TestObject.gameObject.SetActive(false);
+        raycasts = GraphicRegistry.GetRaycastableGraphicsForCanvas(rootCanvasChild);
+
+        Assert.IsTrue(raycasts.Count == 0);
+    }
+}

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/Canvas/RootCanvasTests.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 798968d841703b54bb9d08b1da6bc52f
+timeCreated: 1459501500
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/Canvas/UISystemProfilerAddMarkerWithNullObjectDoesNotCrash.cs

@@ -0,0 +1,14 @@
+using UnityEngine;
+using NUnit.Framework;
+
+namespace Tests
+{
+    public class UISystemProfilerAddMarkerWithNullObjectDoesNotCrash
+    {
+        [Test]
+        public void AddMarkerShouldNotCrashWithNullObject()
+        {
+            UISystemProfilerApi.AddMarker("Test", null);
+        }
+    }
+}

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/Canvas/UISystemProfilerAddMarkerWithNullObjectDoesNotCrash.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0ca81982e37e893498abf804c12a22c7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/CanvasRenderer.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: ae242449e9279d44789513b922d3178a
+folderAsset: yes
+timeCreated: 1493922593
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/CanvasRenderer/ChangingHierarchyOfCanvasRenderer.cs

@@ -0,0 +1,41 @@
+using UnityEngine;
+using UnityEngine.TestTools;
+using NUnit.Framework;
+using System.Collections;
+using UnityEditor.SceneManagement;
+
+public class ChangingHierarchyOfCanvasRenderer
+{
+    [Test]
+    public void ChangingHierarchyOfCanvasRenderer_DoesntCrash()
+    {
+        // Canvas
+        //  - Middle
+        //      - Renderer
+        // OtherCanvas
+        var canvasObject = new GameObject("Canvas");
+        canvasObject.AddComponent<Canvas>();
+
+        var otherCanvasObject = new GameObject("OtherCanvas");
+        otherCanvasObject.AddComponent<Canvas>();
+
+        var middleObject = new GameObject("Middle");
+        middleObject.transform.parent = canvasObject.transform;
+
+        var renderObject = new GameObject("Render");
+        renderObject.AddComponent<CanvasRenderer>();
+        renderObject.transform.parent = middleObject.transform;
+        renderObject.SetActive(false);
+
+        // Translation causes IgnoreNextTransformChanged to be set on Renderer
+        canvasObject.transform.Translate(1, 1, 1);
+        // Reparenting after ignore
+        middleObject.transform.parent = otherCanvasObject.transform;
+
+        // Destroy the original canvas, and create a new scene to force destruction of everything else
+        GameObject.DestroyImmediate(canvasObject);
+        EditorSceneManager.NewScene(NewSceneSetup.EmptyScene);
+
+        Assert.Pass();
+    }
+}

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/CanvasRenderer/ChangingHierarchyOfCanvasRenderer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c825bad77a42dd341a8f0a5ef9cd5f4c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/CanvasRenderer/ParentCanvasIsSane.cs

@@ -0,0 +1,58 @@
+using UnityEngine;
+using UnityEngine.TestTools;
+using NUnit.Framework;
+using System.Collections;
+using UnityEngine.UI;
+
+public class ParentCanvasIsSane
+{
+    GameObject rootCanvas;
+    GameObject rootObject;
+    GameObject child1;
+    CanvasGroup c1CanvasGroup;
+    GameObject child2;
+    GameObject child3;
+
+    [SetUp]
+    public void TestSetup()
+    {
+        // root GO
+        // root Canvas
+        //  L child1 GO (RectTransform, CanvasGroup)
+        //     L child2 GO (RectTransform)
+        //        L child3 GO (Image)
+
+        rootCanvas = new GameObject("root Canvas");
+        rootCanvas.AddComponent<Canvas>();
+        rootCanvas.AddComponent<CanvasScaler>();
+
+        rootObject = new GameObject("root GO");
+
+        child1 = new GameObject("child1 GO");
+        child1.AddComponent<RectTransform>();
+        c1CanvasGroup = child1.AddComponent<CanvasGroup>();
+
+        child2 = new GameObject("child2 GO");
+        child2.AddComponent<RectTransform>();
+
+        child3 = new GameObject("child3 GO");
+        child3.AddComponent<Image>();
+
+        child3.transform.SetParent(child2.transform);
+        child2.transform.SetParent(child1.transform);
+        child1.transform.SetParent(rootCanvas.transform);
+    }
+
+    [UnityTest]
+    public IEnumerator RecalculatingAlphaOnReparentedInactiveObjectsDoesNotCrash()
+    {
+        Assert.IsNotNull(child3.GetComponent<CanvasRenderer>());
+
+        c1CanvasGroup.alpha = 0.5f;
+        child1.SetActive(false);
+        child1.transform.SetParent(rootObject.transform, true);
+
+        // This will crash if child3.GetComponent<CanvasRenderer>().m_ParentCanvas is not null.
+        yield return null;
+    }
+}

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/CanvasRenderer/ParentCanvasIsSane.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: dcb49b07db5e5f64e876b498105314f1
+timeCreated: 1493922633
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/Dropdown.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 1f71aeacc4a9f1a40b22a1a590331f6b
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/Dropdown/DropdownOptionsListDrawer.cs

@@ -0,0 +1,34 @@
+using System.Collections;
+using UnityEngine;
+using UnityEngine.TestTools;
+using UnityEngine.UI;
+using UnityEditor;
+using NUnit.Framework;
+
+public class DropdownOptionsListDrawer : WrapperWindowFixture
+{
+    public class Fixture : MonoBehaviour
+    {
+        public Dropdown.OptionDataList options = new Dropdown.OptionDataList();
+    }
+
+    [UnityTest]
+    public IEnumerator PropertyDrawerDoesNotThrowExceptionWhenObjectIsDisposed()
+    {
+        var go = new GameObject();
+        var component = go.AddComponent<Fixture>();
+        var so = new SerializedObject(component);
+        var win = GetWindow((wnd) => {
+            Assert.DoesNotThrow(() => EditorGUILayout.PropertyField(so.FindProperty("options")));
+            so.Dispose();
+            so = new SerializedObject(component);
+            Assert.DoesNotThrow(() => EditorGUILayout.PropertyField(so.FindProperty("options")));
+            return true;
+        });
+
+        while (win.TestCompleted == false)
+        {
+            yield return null;
+        }
+    }
+}

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/Dropdown/DropdownOptionsListDrawer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b180d0cec21671c45a32a9ce99bff2f5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/EventSystem.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 98d14ab1acf42df4f88a0561822ac807
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/EventSystem/EventTriggerRemoveDuringExecution.cs

@@ -0,0 +1,38 @@
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+public class EventTriggerRemoveDuringExecution
+{
+    [Test]
+    [Description("ArgumentOutOfRange Exception is thrown when removing handler in callback in EventTrigger (case 1401557)")]
+    public void EventTrigger_DoesNotThrowExceptionWhenRemovingEventDuringExecution()
+    {
+        var go = new GameObject();
+        var eventTrigger = go.AddComponent<EventTrigger>();
+        var eventSystem = go.AddComponent<EventSystem>();
+
+        var entry1 = new EventTrigger.Entry { eventID = EventTriggerType.PointerDown };
+        var entry2 = new EventTrigger.Entry { eventID = EventTriggerType.PointerDown };
+
+        bool executed1 = false;
+        bool executed2 = false;
+        entry1.callback.AddListener(e =>
+        {
+            executed1 = true;
+            eventTrigger.triggers.Remove(entry2);
+        });
+        entry2.callback.AddListener(e => executed2 = true);
+
+        eventTrigger.triggers.Add(entry1);
+        eventTrigger.triggers.Add(entry2);
+
+        Assert.DoesNotThrow(() => eventTrigger.OnPointerDown(new PointerEventData(eventSystem)));
+        Assert.True(executed1, "Expected Event 1 to be called but it was not.");
+        Assert.False(executed2, "Expected Event 2 to not be called as it was removed by event 1.");
+        Assert.That(eventTrigger.triggers, Does.Not.Contains(entry2));
+        Assert.That(eventTrigger.triggers, Does.Contain(entry1));
+
+        Object.DestroyImmediate(go);
+    }
+}

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/EventSystem/EventTriggerRemoveDuringExecution.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4adb1f65bbae8004a88d8f5bc3523298
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/EventSystem/InterceptedEventsPreviewTests.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Reflection;
+using System.Collections.Generic;
+using UnityEngine.EventSystems;
+using UnityEditor;
+using NUnit.Framework;
+
+public class InterceptedEventsPreviewTests
+{
+    [Test]
+    public void InterceptedEventsPreviewCacheUsingTypeCacheReturnsSameTypes()
+    {
+        var typeCacheEventInterfaces = new List<Type>();
+        TypeCache.TypeCollection types = TypeCache.GetTypesDerivedFrom<IEventSystemHandler>();
+        foreach (var type in types)
+        {
+            if (!type.IsInterface)
+                continue;
+
+            typeCacheEventInterfaces.Add(type);
+        }
+
+        var appDomainEventInterfaces = new List<Type>();
+        foreach (var type in GetAccessibleTypesInLoadedAssemblies())
+        {
+            if (!type.IsInterface)
+                continue;
+
+            appDomainEventInterfaces.Add(type);
+        }
+
+        Assert.AreNotEqual(typeCacheEventInterfaces.Count, appDomainEventInterfaces.Count, "Did not find the same number of EventInterface types");
+
+        for (int i = 0; i < typeCacheEventInterfaces.Count; ++i)
+        {
+            Assert.Contains(typeCacheEventInterfaces[i], appDomainEventInterfaces);
+        }
+    }
+
+    private static IEnumerable<Type> GetAccessibleTypesInLoadedAssemblies()
+    {
+        var assemblies = AppDomain.CurrentDomain.GetAssemblies();
+        for (var i = 0; i < assemblies.Length; ++i)
+        {
+            Type[] types;
+            var assembly = assemblies[i];
+
+            if (assembly == null)
+                continue;
+
+            try
+            {
+                types = assembly.GetTypes();
+            }
+            catch (ReflectionTypeLoadException e)
+            {
+                // assembly.GetTypes() might fail in case the Assembly cannot resolve all its references,
+                // or in case it was built targetting a newer version of .NET.
+                // In case the resolution fails for some types, we can still access the ones that have been
+                // properly loaded.
+                types = e.Types;
+            }
+
+            for (var j = 0; j < types.Length; ++j)
+            {
+                var type = types[j];
+                if (type == null)
+                    continue;
+
+                yield return type;
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/EventSystem/InterceptedEventsPreviewTests.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2aff4fada0516c64a8537a20bfe1b699
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/InputField.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c16c54fe03afb5740bcc0a2a295cb79d
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/InputField/CharacterLimitValidation.cs

@@ -0,0 +1,45 @@
+using NUnit.Framework;
+
+namespace Core.InputField
+{
+    public class CharacterLimitValidation : TestBehaviourBase<UnityEngine.UI.InputField>
+    {
+        [Test]
+        public void LimitCanNotBeNegative()
+        {
+            const int testValue = -1;
+            m_TestObject.characterLimit = testValue;
+            Assert.AreNotEqual(testValue, m_TestObject.characterLimit);
+        }
+
+        [Test]
+        public void TextLengthShorterThanLimit()
+        {
+            const string testValue = "Test";
+            m_TestObject.characterLimit = 10;
+            m_TestObject.text = testValue;
+
+            Assert.AreEqual(testValue, m_TestObject.text);
+        }
+
+        [Test]
+        public void TextLengthEqualToLimit()
+        {
+            const string testValue = "0123456789";
+            m_TestObject.characterLimit = 10;
+            m_TestObject.text = testValue;
+
+            Assert.AreEqual(testValue, m_TestObject.text);
+        }
+
+        [Test]
+        public void TextLengthGreaterThanLimit()
+        {
+            m_TestObject.characterLimit = 10;
+            m_TestObject.text = "01234567891234567890";
+
+            Assert.AreEqual(10, m_TestObject.text.Length);
+            Assert.AreEqual("0123456789", m_TestObject.text);
+        }
+    }
+}

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/InputField/CharacterLimitValidation.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 4b8be68229770db4ea3c78ab0d854325
+timeCreated: 1456921340
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/InputField/ContentValidation.cs

@@ -0,0 +1,94 @@
+using NUnit.Framework;
+using ContentType = UnityEngine.UI.InputField.ContentType;
+
+namespace Core.InputField
+{
+    public class ContentValidation : TestBehaviourBase<UnityEngine.UI.InputField>
+    {
+        [Test]
+        [TestCase(ContentType.Alphanumeric, "0", "0")]
+        [TestCase(ContentType.Alphanumeric, "1", "1")]
+        [TestCase(ContentType.Alphanumeric, "123456", "123456")]
+        [TestCase(ContentType.Alphanumeric, "0123456", "0123456")]
+        [TestCase(ContentType.Alphanumeric, "111110123456", "111110123456")]
+        [TestCase(ContentType.Alphanumeric, "123456", "123456")]
+        [TestCase(ContentType.Alphanumeric, "-1.0", "10")]
+        [TestCase(ContentType.Alphanumeric, "-00.45", "0045")]
+        [TestCase(ContentType.Alphanumeric, "-1111101.23456", "111110123456")]
+        [TestCase(ContentType.Alphanumeric, "Test", "Test")]
+        [TestCase(ContentType.Alphanumeric, "-1-", "1")]
+        [TestCase(ContentType.Alphanumeric, "--1", "1")]
+        [TestCase(ContentType.Alphanumeric, "123456abc", "123456abc")]
+        [TestCase(ContentType.Alphanumeric, "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM0123456789", "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM0123456789")]
+
+        [TestCase(ContentType.DecimalNumber, "0", "0")]
+        [TestCase(ContentType.DecimalNumber, "1", "1")]
+        [TestCase(ContentType.DecimalNumber, "123456", "123456")]
+        [TestCase(ContentType.DecimalNumber, "0123456", "0123456")]
+        [TestCase(ContentType.DecimalNumber, "111110123456", "111110123456")]
+        //[TestCase(ContentType.DecimalNumber, "3.14", "3.14")]
+        //[TestCase(ContentType.DecimalNumber, "1.23", "1.23")]
+        //[TestCase(ContentType.DecimalNumber, "1.0", "1.0")]
+        //[TestCase(ContentType.DecimalNumber, "00.45", "00.45")]
+        //[TestCase(ContentType.DecimalNumber, "1111101.23456", "1111101.23456")]
+        //[TestCase(ContentType.DecimalNumber, "-1", "-1")]
+        [TestCase(ContentType.DecimalNumber, "-123456", "-123456")]
+        [TestCase(ContentType.DecimalNumber, "-0123456", "-0123456")]
+        [TestCase(ContentType.DecimalNumber, "-111110123456", "-111110123456")]
+        //[TestCase(ContentType.DecimalNumber, "-3.14", "-3.14")]
+        //[TestCase(ContentType.DecimalNumber, "-1.23", "-1.23")]
+        //[TestCase(ContentType.DecimalNumber, "-1.0", "-1.0")]
+        //[TestCase(ContentType.DecimalNumber, "-00.45", "-00.45")]
+        //[TestCase(ContentType.DecimalNumber, "-1111101.23456", "-1111101.23456")]
+        [TestCase(ContentType.DecimalNumber, "Test", "")]
+        [TestCase(ContentType.DecimalNumber, "-1-", "-1")]
+        //[TestCase(ContentType.DecimalNumber, "-0", "0")]
+        [TestCase(ContentType.DecimalNumber, "--1", "-1")]
+        [TestCase(ContentType.DecimalNumber, "123456abc", "123456")]
+        //[TestCase(ContentType.DecimalNumber, "12.34.5#6abc", "12.3456")]
+
+        [TestCase(ContentType.EmailAddress, "name@domain.com", "name@domain.com")]
+        [TestCase(ContentType.EmailAddress, "name@@@domain.com", "name@domain.com")]
+        [TestCase(ContentType.EmailAddress, "name@domain.co.uk", "name@domain.co.uk")]
+        [TestCase(ContentType.EmailAddress, "name.other@domain-site.co.uk", "name.other@domain-site.co.uk")]
+        [TestCase(ContentType.EmailAddress, "name!#$%&'*+-/=?^_`{|}~@domain.com", "name!#$%&'*+-/=?^_`{|}~@domain.com")]
+
+        [TestCase(ContentType.IntegerNumber, "0", "0")]
+        [TestCase(ContentType.IntegerNumber, "1", "1")]
+        [TestCase(ContentType.IntegerNumber, "123456", "123456")]
+        [TestCase(ContentType.IntegerNumber, "0123456", "0123456")]
+        [TestCase(ContentType.IntegerNumber, "111110123456", "111110123456")]
+        [TestCase(ContentType.IntegerNumber, "-1", "-1")]
+        [TestCase(ContentType.IntegerNumber, "-123456", "-123456")]
+        [TestCase(ContentType.IntegerNumber, "-0123456", "-0123456")]
+        [TestCase(ContentType.IntegerNumber, "-111110123456", "-111110123456")]
+        [TestCase(ContentType.IntegerNumber, "3.14", "314")]
+        [TestCase(ContentType.IntegerNumber, "Test", "")]
+        [TestCase(ContentType.IntegerNumber, "-1-", "-1")]
+        //[TestCase(ContentType.IntegerNumber, "-0", "0")]
+        //[TestCase(ContentType.IntegerNumber, "-0", "")]
+        [TestCase(ContentType.IntegerNumber, "--1", "-1")]
+        [TestCase(ContentType.IntegerNumber, "123456abc", "123456")]
+        [TestCase(ContentType.IntegerNumber, "12.34.5#6abc", "123456")]
+
+        [TestCase(ContentType.Name, "john smith", "John Smith")]
+        [TestCase(ContentType.Name, "mary jane", "Mary Jane")]
+        [TestCase(ContentType.Name, "jOHn smIth", "John Smith")]
+        [TestCase(ContentType.Name, "john123 smith123", "John Smith")]
+        [TestCase(ContentType.Name, "Bucky O'Hare", "Bucky O'Hare")]
+        [TestCase(ContentType.Name, "bucky o'Har'e", "Bucky O'Hare")]
+        [TestCase(ContentType.Name, "first second third", "First Second Third")]
+
+        [TestCase(ContentType.Pin, "012345", "012345")]
+        [TestCase(ContentType.Pin, "012345abc", "012345")]
+        [TestCase(ContentType.Pin, "0a1b2c3#45", "012345")]
+        [TestCase(ContentType.Pin, "-012345", "-012345")]
+        [TestCase(ContentType.Pin, " 012345", "012345")]
+        public void ValueIsValidatedCorrectly(ContentType type, string testValue, string expected)
+        {
+            m_TestObject.contentType = type;
+            m_TestObject.text = testValue;
+            Assert.AreEqual(expected, m_TestObject.text);
+        }
+    }
+}

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/InputField/ContentValidation.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 5a2e98b03511c6f43bc645238cd40857
+timeCreated: 1457018121
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/RectMask2D.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 305ca32be1aa5504aa182f583895dfe4
+folderAsset: yes
+timeCreated: 1458135852
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/RectMask2D/RectMask2DCulling.cs

@@ -0,0 +1,42 @@
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.UI;
+
+public class RectMask2DCulling : TestBehaviourBase<UnityEngine.Canvas>
+{
+    [Test]
+    public void CullFlagNotResetWhenReparented740604()
+    {
+        var noMaskGameObject = new GameObject("noMaskGO");
+        noMaskGameObject.AddComponent<RectTransform>();
+
+        var maskGameObject = new GameObject("MaskGO");
+        var rectMask2D = maskGameObject.AddComponent<RectMask2D>();
+
+        noMaskGameObject.transform.SetParent(m_TestObject.transform);
+        maskGameObject.transform.SetParent(m_TestObject.transform);
+
+        noMaskGameObject.GetComponent<RectTransform>().sizeDelta = new Vector2(800, 800);
+        maskGameObject.GetComponent<RectTransform>().sizeDelta = new Vector2(400, 400);
+
+        var imageGameObject = new GameObject("ImageGO");
+        var image = imageGameObject.AddComponent<Image>();
+        imageGameObject.transform.SetParent(maskGameObject.transform);
+
+        imageGameObject.GetComponent<RectTransform>().sizeDelta = new Vector2(100, 100);
+
+        // Start with image inside RectMask2D area so that it's no culled
+        rectMask2D.PerformClipping();
+        Assert.IsFalse(image.canvasRenderer.cull);
+
+        // Move image outside of RectMask2D so that it is culled
+        imageGameObject.GetComponent<RectTransform>().position = new Vector2(275, 275);
+        rectMask2D.PerformClipping();
+        Assert.IsTrue(image.canvasRenderer.cull);
+
+        // Change parent to noMask so that it's unaffected by RectMask2D and isn't culled
+        imageGameObject.transform.SetParent(noMaskGameObject.transform);
+        rectMask2D.PerformClipping();
+        Assert.IsFalse(image.canvasRenderer.cull);
+    }
+}

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/RectMask2D/RectMask2DCulling.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 4402dcee6e9969549bf5b33f11533208
+timeCreated: 1458135886
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/RectMask2D/RectTransformPosition.cs

@@ -0,0 +1,18 @@
+using UnityEngine;
+using NUnit.Framework;
+
+public class RectTransformPosition
+{
+    [Test]
+    public void SettingPositionBeforeGameObjectIsActivatedWorks_953409()
+    {
+        var positionToSet = new Vector3(1, 2, 3);
+        var go = new GameObject("RectTransform", typeof(RectTransform));
+
+        go.SetActive(false);
+        go.transform.position = positionToSet;
+        go.SetActive(true);
+
+        Assert.AreEqual(positionToSet, go.transform.position, "Expected RectTransform position to be set but it was not.");
+    }
+}

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/RectMask2D/RectTransformPosition.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: fb660d86885d89a499a31c6ab6f26269
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/Slider.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4cfe5ade9a1375e40aed87618b92bd12
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/Slider/SliderRectReferences.cs

@@ -0,0 +1,54 @@
+using NUnit.Framework;
+using UnityEngine.UI;
+using UnityEngine;
+
+[Category("Slider")]
+public class SliderRectRefernces : Behaviour
+{
+    private Slider slider;
+    private GameObject emptyGO;
+    private GameObject rootGO;
+
+    [SetUp]
+    public void TestSetup()
+    {
+        rootGO = new GameObject("root child");
+        rootGO.AddComponent<Canvas>();
+
+        var sliderGameObject = new GameObject("Slider");
+        slider = sliderGameObject.AddComponent<Slider>();
+
+        emptyGO = new GameObject("base", typeof(RectTransform));
+
+        sliderGameObject.transform.SetParent(rootGO.transform);
+        emptyGO.transform.SetParent(sliderGameObject.transform);
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        GameObject.DestroyImmediate(rootGO);
+    }
+
+    [Test]
+    public void AssigningSelfResultsInNullReferenceField()
+    {
+        slider.fillRect = (RectTransform)slider.transform;
+        Assert.IsNull(slider.fillRect);
+
+        slider.handleRect = (RectTransform)slider.transform;
+        Assert.IsNull(slider.handleRect);
+    }
+
+    [Test]
+    public void AssigningOtherObjectResultsInCorrectReferenceField()
+    {
+        slider.fillRect = (RectTransform)emptyGO.transform;
+        Assert.IsNotNull(slider.fillRect);
+        Assert.AreEqual(slider.fillRect, (RectTransform)emptyGO.transform);
+
+        slider.handleRect = (RectTransform)emptyGO.transform;
+        Assert.IsNotNull(slider.handleRect);
+        Assert.AreEqual(slider.handleRect, (RectTransform)emptyGO.transform);
+    }
+}

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/Slider/SliderRectReferences.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 373b4c78c0396334288fa5ff8e7b7350
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/TestBehaviourBase.cs

@@ -0,0 +1,20 @@
+using NUnit.Framework;
+using UnityEngine;
+
+public class TestBehaviourBase<T> where T : Behaviour
+{
+    protected T m_TestObject;
+
+    [SetUp]
+    public virtual void TestSetup()
+    {
+        var gameObject = new GameObject();
+        m_TestObject = gameObject.AddComponent<T>();
+    }
+
+    [TearDown]
+    public virtual void Teardown()
+    {
+        GameObject.DestroyImmediate(m_TestObject.gameObject);
+    }
+}

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/TestBehaviourBase.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 393b15da08c88194dbbcacd6ee15a89c
+timeCreated: 1456926887
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/Text.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 4f9ac6e545d53f94b9f09c85b9576f36
+folderAsset: yes
+timeCreated: 1485515713
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/Text/FontCreatedByScript.cs

@@ -0,0 +1,60 @@
+using System;
+using NUnit.Framework;
+using UnityEngine;
+
+[Category("Text")]
+public class FontCreatedByScript
+{
+    static Font CreateDefaultFontWithOneCharacter(int character)
+    {
+        var font = new Font();
+        CharacterInfo[] characterInfo = new CharacterInfo[1];
+        characterInfo[0].index = character;
+        font.characterInfo = characterInfo;
+        return font;
+    }
+
+    [Test]
+    public static void GetCharacterInfo_FindsCharacterInfoThatIsInSet()
+    {
+        char character = 'A';
+        int charIndex = Convert.ToInt32(character);
+
+        var font = CreateDefaultFontWithOneCharacter(charIndex);
+        CharacterInfo result = new CharacterInfo();
+        Assert.IsTrue(font.GetCharacterInfo(character, out result), "Could not find character info for '" + character + "' even though the Font contains it.");
+        Assert.AreEqual(charIndex, result.index, "Incorrect character info was returned for " + character);
+    }
+
+    [Test]
+    public static void GetCharacterInfo_DoesNotFindCharacterInfoThatIsNotInSet()
+    {
+        char character = 'A';
+        char characterNotInSet = 'X';
+        int charIndex = Convert.ToInt32(character);
+
+        var font = CreateDefaultFontWithOneCharacter(charIndex);
+        CharacterInfo result;
+        Assert.IsFalse(font.GetCharacterInfo(characterNotInSet, out result), "Found character info for '" + characterNotInSet + "' even though the Font does not contain it.");
+    }
+
+    [Test]
+    public static void HasCharacterReturns8BitChars()
+    {
+        char character = 'A';
+        int charIndex = Convert.ToInt32(character);
+
+        var font = CreateDefaultFontWithOneCharacter(charIndex);
+        Assert.IsTrue(font.HasCharacter(character), "HasCharacter returned false even though it should have " + character);
+    }
+
+    [Test]
+    public static void HasCharacterReturns16BitChars()
+    {
+        char character = '\u03A9';
+        int charIndex = Convert.ToInt32(character);
+
+        var font = CreateDefaultFontWithOneCharacter(charIndex);
+        Assert.IsTrue(font.HasCharacter(character), "HasCharacter returned false even though it should have " + character);
+    }
+}

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/Text/FontCreatedByScript.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 812aaaefaab404448a3e4db49dfa5206
+timeCreated: 1485515717
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/UI.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e7689eda3a8b1a847a8b197dbe90d9a6
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/UI/PropertyDrawers.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 24333a116497b144f9782b1160984b57
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/UI/PropertyDrawers/PropertyDrawerTests.cs

@@ -0,0 +1,116 @@
+using NUnit.Framework;
+using System.Collections;
+using System.Linq;
+using UnityEditor;
+using UnityEditor.UIElements;
+using UnityEngine;
+using UnityEngine.TestTools;
+using UnityEngine.UI;
+using UnityEngine.UIElements;
+using UnityEngine.Search;
+using UnityEngine;
+
+public class PropertyDrawerTests
+{
+    class PropertyDrawerTestsWindow : EditorWindow
+    {
+        public Navigation navigation;
+        public SpriteState spriteState;
+        public Dropdown.OptionDataList optionDataList;
+        [SearchContext("t:gameObject is:gameObject", "gameObject")]
+        public GameObject searchContext;
+        public ExposedReference<GameObject> exposedReference;
+
+        SerializedObject serializedObject;
+
+        void CreateGUI()
+        {
+            serializedObject = new SerializedObject(this);
+
+            Add(nameof(navigation));
+            Add(nameof(spriteState));
+            Add(nameof(optionDataList));
+            Add(nameof(searchContext));
+            Add(nameof(exposedReference));
+
+            rootVisualElement.Bind(serializedObject);
+
+            // Forces visual tree update
+            Rebuild();
+        }
+
+        void Add(string propertyName)
+        {
+            rootVisualElement.Add(new PropertyField() { bindingPath = propertyName });
+        }
+
+        public SerializedProperty Property(string propertyName) => serializedObject.FindProperty(propertyName);
+
+        public void Rebuild() => rootVisualElement.Bind(serializedObject);
+    }
+
+    static PropertyDrawerTestsWindow window;
+
+    [OneTimeSetUp]
+    [MenuItem("Tests/Open Property Drawer Test Window")]
+    public static void OneTimeSetUp() => window = EditorWindow.GetWindow<PropertyDrawerTestsWindow>();
+
+    [OneTimeTearDown]
+    public void OneTimeTearDown() => window.Close();
+
+    [UnityTest]
+    public IEnumerator NavigationDrawer_IsVisible()
+    {
+        yield return null;
+        Assert.IsNotNull(window.rootVisualElement.Query<VisualElement>("Navigation").Build().First());
+    }
+
+    [UnityTest]
+    public IEnumerator SpriteStateDrawer_IsVisible()
+    {
+        yield return null;
+        Assert.IsNotNull(window.rootVisualElement.Q("SpriteState"));
+    }
+
+    [UnityTest, Ignore("Disabled for Instability https://jira.unity3d.com/browse/UUM-11060")]
+    public IEnumerator DropdownOptionDataListDrawer_IsVisible()
+    {
+        yield return null;
+        Assert.IsNotNull(window.rootVisualElement.Q("DropdownOptionDataList"), $"Item is null. Root object count: {window.rootVisualElement.childCount}");
+    }
+
+    [UnityTest]
+    public IEnumerator SearchContextDrawer_IsVisible()
+    {
+        yield return null;
+        Assert.IsNotNull(window.rootVisualElement.Q("SearchContext"));
+    }
+
+    [UnityTest, Ignore("Disabled for Instability https://jira.unity3d.com/browse/UUM-11060")]
+    public IEnumerator ExposedReferenceDrawer_IsVisible()
+    {
+        yield return null;
+        Assert.IsNotNull(window.rootVisualElement.Q("ExposedReference"), $"Item is null. Root object count: {window.rootVisualElement.childCount}");
+    }
+
+    // Fake expected result in order to make TestCaseAttribute to work with UnityTest
+    [UnityTest]
+    [TestCase(new object[] { (int)Navigation.Mode.None, 0}, ExpectedResult = null)]
+    [TestCase(new object[] { (int)Navigation.Mode.Horizontal, 1 }, ExpectedResult = null)]
+    [TestCase(new object[] { (int)Navigation.Mode.Vertical, 1 }, ExpectedResult = null)]
+    [TestCase(new object[] { (int)Navigation.Mode.Automatic, 0 }, ExpectedResult = null)]
+    [TestCase(new object[] { (int)Navigation.Mode.Explicit, 4 }, ExpectedResult = null)]
+    [TestCase(new object[] { (int)(Navigation.Mode.Explicit | Navigation.Mode.Horizontal), 0 }, ExpectedResult = null)]
+    [TestCase(new object[] { (int)(Navigation.Mode.Automatic | Navigation.Mode.Explicit), 0 }, ExpectedResult = null)]
+    public static IEnumerator NavigationDrawer_ShowsCorrectAdditionalControlCount(int mode, int expectedCount)
+    {
+        window.Property("navigation.m_Mode").enumValueFlag = mode;
+        window.Rebuild();
+        yield return null;
+
+        var indent = window.rootVisualElement.Query<VisualElement>("Navigation").Build().First().Query<VisualElement>("Indent").Build().First();
+        var visibleChildren = indent.Children().Count(child => child.resolvedStyle.display != DisplayStyle.None);
+        Assert.AreEqual(expectedCount, visibleChildren, $"{expectedCount} additional Navigation object properties should be " +
+            $"visible when 'Mode' is set to '{(Navigation.Mode)window.Property("navigation.m_Mode").enumValueFlag}'");
+    }
+}

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/UI/PropertyDrawers/PropertyDrawerTests.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 433d3b96b2a40a5479d3d7d8495882ed
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/UnityEditor.UI.EditorTests.asmdef

@@ -0,0 +1,14 @@
+{
+    "name": "UnityEditor.UI.EditorTests",
+    "references": [
+        "UnityEditor.UI",
+        "UnityEngine.UI"
+    ],
+    "optionalUnityReferences": [
+        "TestAssemblies"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": []
+}

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/UnityEditor.UI.EditorTests.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 7c04f0dfa9243c04681a55d90d3ff3fc
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.ugui@1.0.0/Tests/Editor/UnityEvent.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e90cc37a5ccf4a44dbecc5b7172ec512
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: