Initial Commit

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,49 @@
+using NUnit.Framework;
+using UnityEngine;
+
+[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);
+    }
+}

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/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/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/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: 

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

@@ -0,0 +1,63 @@
+using UnityEngine;
+using UnityEngine.Events;
+using UnityEditor;
+using UnityEditor.Events;
+using UnityEngine.TestTools;
+using NUnit.Framework;
+using System.Collections;
+
+public class UnityEventInvoke
+{
+    class SimpleCounter : MonoBehaviour
+    {
+        public int m_Count = 0;
+
+        public void Add()
+        {
+            ++m_Count;
+        }
+
+        public void NoOp(int i)
+        {
+        }
+    }
+
+    GameObject m_CounterObject;
+    SimpleCounter Counter { get; set; }
+
+    [SetUp]
+    public void TestSetup()
+    {
+        m_CounterObject = new GameObject("Counter");
+        Counter = m_CounterObject.AddComponent<SimpleCounter>();
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        GameObject.DestroyImmediate(m_CounterObject);
+    }
+
+    [Test]
+    [Description("Using a CachedInvokableCall in a UnityEvent should not go re-trigger all the calls stored in the UnityEvent. Case-950588")]
+    public void UnityEvent_InvokeCallsListenerOnce()
+    {
+        var _event = new UnityEvent();
+        UnityEventTools.AddPersistentListener(_event, new UnityAction(Counter.Add));
+        _event.SetPersistentListenerState(0, UnityEventCallState.EditorAndRuntime);
+
+        _event.Invoke();
+
+        Assert.AreEqual(1, Counter.m_Count);
+
+        for (int i = 1; i < 5; ++i)
+        {
+            UnityEventTools.AddIntPersistentListener(_event, new UnityAction<int>(Counter.NoOp), i);
+            _event.SetPersistentListenerState(i, UnityEventCallState.EditorAndRuntime);
+        }
+
+        _event.Invoke();
+
+        Assert.AreEqual(2, Counter.m_Count);
+    }
+}

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

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