testss

Library/PackageCache/com.unity.shadergraph@11.0.0/Tests/Editor/IntegrationTests/NamespaceTests.cs

@@ -0,0 +1,38 @@
+using System.Reflection;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Internal;
+
+namespace UnityEditor.ShaderGraph.UnitTests
+{
+    [TestFixture]
+    internal class NamespaceTests
+    {
+        [Test]
+        public void NoDanglingNamespaces()
+        {
+            var myAssembly = Assembly.GetAssembly(typeof(AbstractMaterialNode));
+            HashSet<string> namespaces = new HashSet<string>();
+            foreach (var theType in myAssembly.GetTypes().Where(t => !string.IsNullOrEmpty(t.Namespace)))
+            {
+                namespaces.Add(theType.Namespace);
+            }
+            var invalidNames = new List<string>();
+            foreach (var name in namespaces)
+            {
+                if (name.Contains("ShaderGraph"))
+                    continue;
+                if (name.Contains("UnityEditor"))
+                    continue;
+                if (name.Contains("UnityEngine"))
+                    continue;
+
+                invalidNames.Add(name);
+            }
+            Assert.IsEmpty(invalidNames, "The following namespaces are invalid for the Shader Graph package:\n" + string.Join("\n", invalidNames));
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@11.0.0/Tests/Editor/IntegrationTests/SerializationTests.cs

@@ -0,0 +1,261 @@
+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEditor.ShaderGraph;
+using UnityEditor.ShaderGraph.Serialization;
+
+namespace UnityEditor.Graphing.IntegrationTests
+{
+    [TestFixture]
+    public class SerializationTests
+    {
+        private class DummyJsonHolder : JsonObject
+        {
+            public List<JsonData<MaterialSlot>> testSlots = new List<JsonData<MaterialSlot>>();
+
+            public DummyJsonHolder() : base()
+            {
+            }
+
+            public DummyJsonHolder(List<MaterialSlot> materialSlots)
+            {
+                foreach (var slot in materialSlots)
+                {
+                    testSlots.Add(slot);
+                }
+            }
+        }
+        interface ITestInterface
+        {}
+
+        [Serializable]
+        class SimpleSerializeClass : ITestInterface
+        {
+            [SerializeField]
+            public string stringValue;
+
+            [SerializeField]
+            public int intValue;
+
+            [SerializeField]
+            public float floatValue;
+
+            [SerializeField]
+            public int[] arrayValue;
+
+            public static SimpleSerializeClass instance
+            {
+                get
+                {
+                    return new SimpleSerializeClass
+                    {
+                        stringValue = "ABCD",
+                        intValue = 5,
+                        floatValue = 7.7f,
+                        arrayValue = new[] {1, 2, 3, 4}
+                    };
+                }
+            }
+
+            public virtual void AssertAsReference()
+            {
+                var reference = instance;
+                Assert.AreEqual(reference.stringValue, stringValue);
+                Assert.AreEqual(reference.intValue, intValue);
+                Assert.AreEqual(reference.floatValue, floatValue);
+                Assert.AreEqual(reference.arrayValue.Length, arrayValue.Length);
+                Assert.AreEqual(reference.arrayValue, arrayValue);
+            }
+        }
+
+        [Serializable]
+        class ChildClassA : SimpleSerializeClass
+        {
+            [SerializeField]
+            public string childString;
+
+            public new static ChildClassA instance
+            {
+                get
+                {
+                    return new ChildClassA
+                    {
+                        stringValue = "qwee",
+                        intValue = 5,
+                        floatValue = 6f,
+                        arrayValue = new[] {5, 6, 7, 8},
+                        childString = "CHILD"
+                    };
+                }
+            }
+
+            public override void AssertAsReference()
+            {
+                var reference = instance;
+                Assert.AreEqual(reference.stringValue, stringValue);
+                Assert.AreEqual(reference.intValue, intValue);
+                Assert.AreEqual(reference.floatValue, floatValue);
+                Assert.AreEqual(reference.arrayValue.Length, arrayValue.Length);
+                Assert.AreEqual(reference.arrayValue, arrayValue);
+                Assert.AreEqual(reference.childString, childString);
+            }
+        }
+
+        [Serializable]
+        class ChildClassB : SimpleSerializeClass
+        {
+            [SerializeField]
+            public int childInt;
+
+            public new static ChildClassB instance
+            {
+                get
+                {
+                    return new ChildClassB
+                    {
+                        stringValue = "qwee",
+                        intValue = 5,
+                        floatValue = 6f,
+                        arrayValue = new[] {5, 6, 7, 8},
+                        childInt = 666
+                    };
+                }
+            }
+
+            public override void AssertAsReference()
+            {
+                var reference = instance;
+                Assert.AreEqual(reference.stringValue, stringValue);
+                Assert.AreEqual(reference.intValue, intValue);
+                Assert.AreEqual(reference.floatValue, floatValue);
+                Assert.AreEqual(reference.arrayValue.Length, arrayValue.Length);
+                Assert.AreEqual(reference.arrayValue, arrayValue);
+                Assert.AreEqual(reference.childInt, childInt);
+            }
+        }
+
+        [Serializable]
+        class SerializationContainer
+        {
+            public List<SerializationHelper.JSONSerializedElement> serializedElements;
+        }
+
+        [Test]
+        public void TestSerializationHelperCanSerializeThenDeserialize()
+        {
+            var toSerialize = new List<SimpleSerializeClass>()
+            {
+                SimpleSerializeClass.instance
+            };
+
+            var serialized = SerializationHelper.Serialize<SimpleSerializeClass>(toSerialize);
+            Assert.AreEqual(1, serialized.Count);
+
+            var loaded = SerializationHelper.Deserialize<SimpleSerializeClass>(serialized, GraphUtil.GetLegacyTypeRemapping());
+            Assert.AreEqual(1, loaded.Count);
+            Assert.IsInstanceOf<SimpleSerializeClass>(loaded[0]);
+            loaded[0].AssertAsReference();
+        }
+
+        [Test]
+        public void TestPolymorphicSerializationPreservesTypesViaBaseClass()
+        {
+            var toSerialize = new List<SimpleSerializeClass>()
+            {
+                SimpleSerializeClass.instance,
+                ChildClassA.instance,
+                ChildClassB.instance
+            };
+
+            var serialized = SerializationHelper.Serialize<SimpleSerializeClass>(toSerialize);
+            Assert.AreEqual(3, serialized.Count);
+
+            var loaded = SerializationHelper.Deserialize<SimpleSerializeClass>(serialized, GraphUtil.GetLegacyTypeRemapping());
+            Assert.AreEqual(3, loaded.Count);
+            Assert.IsInstanceOf<SimpleSerializeClass>(loaded[0]);
+            Assert.IsInstanceOf<ChildClassA>(loaded[1]);
+            Assert.IsInstanceOf<ChildClassB>(loaded[2]);
+            loaded[0].AssertAsReference();
+            loaded[1].AssertAsReference();
+            loaded[2].AssertAsReference();
+        }
+
+        [Test]
+        public void TestPolymorphicSerializationPreservesTypesViaInterface()
+        {
+            var toSerialize = new List<ITestInterface>()
+            {
+                SimpleSerializeClass.instance,
+                ChildClassA.instance,
+                ChildClassB.instance
+            };
+
+            var serialized = SerializationHelper.Serialize<ITestInterface>(toSerialize);
+            Assert.AreEqual(3, serialized.Count);
+
+            var loaded = SerializationHelper.Deserialize<SimpleSerializeClass>(serialized, GraphUtil.GetLegacyTypeRemapping());
+            Assert.AreEqual(3, loaded.Count);
+            Assert.IsInstanceOf<SimpleSerializeClass>(loaded[0]);
+            Assert.IsInstanceOf<ChildClassA>(loaded[1]);
+            Assert.IsInstanceOf<ChildClassB>(loaded[2]);
+            loaded[0].AssertAsReference();
+            loaded[1].AssertAsReference();
+            loaded[2].AssertAsReference();
+        }
+
+        [Test]
+        public void TestSerializationHelperElementCanSerialize()
+        {
+            var toSerialize = new List<SimpleSerializeClass>()
+            {
+                SimpleSerializeClass.instance
+            };
+
+            var serialized = SerializationHelper.Serialize<SimpleSerializeClass>(toSerialize);
+            Assert.AreEqual(1, serialized.Count);
+
+            var container = new SerializationContainer
+            {
+                serializedElements = serialized
+            };
+
+            var serializedContainer = JsonUtility.ToJson(container, true);
+
+            var deserializedContainer = JsonUtility.FromJson<SerializationContainer>(serializedContainer);
+            var loaded = SerializationHelper.Deserialize<SimpleSerializeClass>(deserializedContainer.serializedElements, GraphUtil.GetLegacyTypeRemapping());
+            Assert.AreEqual(1, loaded.Count);
+            Assert.IsInstanceOf<SimpleSerializeClass>(loaded[0]);
+            loaded[0].AssertAsReference();
+        }
+
+        [Test]
+        public void TestSerializableSlotCanSerialize()
+        {
+            var toSerialize = new List<MaterialSlot>()
+            {
+                new TestSlot(0, "InSlot", SlotType.Input),
+                new TestSlot(1, "OutSlot", SlotType.Output),
+            };
+
+            DummyJsonHolder dummyJsonHolder = new DummyJsonHolder(toSerialize);
+
+            var serialized = MultiJson.Serialize(dummyJsonHolder);
+            DummyJsonHolder dummyJsonHolder1 = new DummyJsonHolder();
+            MultiJson.Deserialize(dummyJsonHolder1, serialized);
+            Assert.AreEqual(2, dummyJsonHolder1.testSlots.Count);
+            var loaded = new List<MaterialSlot>(dummyJsonHolder1.testSlots.SelectValue());
+
+            Assert.IsInstanceOf<MaterialSlot>(loaded[0]);
+            Assert.IsInstanceOf<MaterialSlot>(loaded[1]);
+
+            Assert.AreEqual(0, loaded[0].id);
+            Assert.AreEqual("InSlot(4)", loaded[0].displayName);
+            Assert.IsTrue(loaded[0].isInputSlot);
+
+            Assert.AreEqual(1, loaded[1].id);
+            Assert.AreEqual("OutSlot(4)", loaded[1].displayName);
+            Assert.IsTrue(loaded[1].isOutputSlot);
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@11.0.0/Tests/Editor/TestNode.cs

@@ -0,0 +1,6 @@
+namespace UnityEditor.ShaderGraph
+{
+    class TestNode : AbstractMaterialNode
+    {
+    }
+}

Library/PackageCache/com.unity.shadergraph@11.0.0/Tests/Editor/TestSlot.cs

@@ -0,0 +1,36 @@
+using UnityEditor.Graphing;
+
+namespace UnityEditor.ShaderGraph
+{
+    class TestSlot : MaterialSlot
+    {
+        public TestSlot() {}
+
+        public TestSlot(int slotId, string displayName, SlotType slotType, ShaderStageCapability stageCapability = ShaderStageCapability.All, bool hidden = false)
+            : base(slotId, displayName, displayName, slotType, stageCapability, hidden) {}
+
+        public override SlotValueType valueType
+        {
+            get { return SlotValueType.Vector4; }
+        }
+
+        public override ConcreteSlotValueType concreteValueType
+        {
+            get { return ConcreteSlotValueType.Vector4; }
+        }
+
+        public override bool isDefaultValue => true;
+
+        public override void AddDefaultProperty(PropertyCollector properties, GenerationMode generationMode)
+        {
+        }
+
+        public override void CopyDefaultValue(MaterialSlot other)
+        {
+        }
+
+        public override void CopyValuesFrom(MaterialSlot foundSlot)
+        {
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@11.0.0/Tests/Editor/UnitTests/AbstractMaterialGraphTests.cs

@@ -0,0 +1,85 @@
+using System.Linq;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEditor.Graphing;
+
+namespace UnityEditor.ShaderGraph.UnitTests
+{
+    [TestFixture]
+    class AbstractMaterialGraphTests
+    {
+        private class TestableMNode : AbstractMaterialNode
+        {}
+
+        [OneTimeSetUp]
+        public void RunBeforeAnyTests()
+        {
+            Debug.unityLogger.logHandler = new ConsoleLogHandler();
+        }
+
+        [Test]
+        public void TestCanCreateMaterialGraph()
+        {
+            GraphData graph = new GraphData();
+            Assert.AreEqual(0, graph.edges.Count());
+            Assert.AreEqual(0, graph.GetNodes<AbstractMaterialNode>().Count());
+        }
+
+        [Test]
+        public void TestCanAddMaterialNodeToMaterialGraph()
+        {
+            GraphData graph = new GraphData();
+
+            var node = new TestableMNode();
+            graph.AddNode(node);
+            Assert.AreEqual(0, graph.edges.Count());
+            Assert.AreEqual(1, graph.GetNodes<AbstractMaterialNode>().Count());
+        }
+
+        [Test]
+        public void TestCanGetMaterialNodeFromMaterialGraph()
+        {
+            GraphData graph = new GraphData();
+
+            var node = new TestableMNode();
+            graph.AddNode(node);
+            Assert.AreEqual(0, graph.edges.Count());
+            Assert.AreEqual(1, graph.GetNodes<AbstractMaterialNode>().Count());
+
+            Assert.AreEqual(node, graph.GetNodeFromId(node.objectId));
+            Assert.AreEqual(node, graph.GetNodeFromId<TestableMNode>(node.objectId));
+        }
+
+        /*     [Test]
+             public void TestCreatePixelShaderGraphWorks()
+             {
+                 var graph = new UnityEngine.MaterialGraph.MaterialGraph();
+                 Assert.AreEqual(0, graph.GetNodes<AbstractMaterialNode>().Count());
+
+                 var psn = new MetallicMasterNode();
+                 graph.AddNode(psn);
+                 Assert.AreEqual(0, graph.edges.Count());
+                 Assert.AreEqual(1, graph.GetNodes<AbstractMaterialNode>().Count());
+                 Assert.IsInstanceOf(typeof(MetallicMasterNode), graph.GetNodes<AbstractMaterialNode>().FirstOrDefault());
+                 Assert.IsNotNull(graph.masterNode);
+                 Assert.AreEqual(1, graph.GetNodes<AbstractMaterialNode>().Count());
+             }
+
+             [Test]
+             public void TestCanAddMultipleMasterNode()
+             {
+                 var graph = new UnityEngine.MaterialGraph.MaterialGraph();
+                 Assert.AreEqual(0, graph.GetNodes<AbstractMaterialNode>().Count());
+
+                 var psn = new MetallicMasterNode();
+                 graph.AddNode(psn);
+                 Assert.AreEqual(0, graph.edges.Count());
+                 Assert.AreEqual(1, graph.GetNodes<AbstractMaterialNode>().Count());
+
+                 var psn2 = new SpecularMasterNode();
+                 graph.AddNode(psn2);
+                 Assert.AreEqual(0, graph.edges.Count());
+                 Assert.AreEqual(2, graph.GetNodes<AbstractMaterialNode>().Count());
+             }*/
+    }
+}

Library/PackageCache/com.unity.shadergraph@11.0.0/Tests/Editor/UnitTests/BlockNodeTests.cs

@@ -0,0 +1,119 @@
+using System.Collections.Generic;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Internal;
+
+namespace UnityEditor.ShaderGraph.UnitTests
+{
+    [TestFixture]
+    class BlockNodeTests
+    {
+        static BlockFieldDescriptor s_DescriptorA = new BlockFieldDescriptor("Test", "BlockA", string.Empty, new FloatControl(0.5f), ShaderStage.Fragment, true);
+        static BlockFieldDescriptor s_DescriptorB = new BlockFieldDescriptor("Test", "BlockB", string.Empty, new NormalControl(CoordinateSpace.World), ShaderStage.Fragment, true);
+
+        static Vector3MaterialSlot s_MaterialSlot = new Vector3MaterialSlot(0, "Test", "BlockB", SlotType.Input, Vector3.one);
+        static CustomSlotBlockFieldDescriptor s_CustomSlotDescriptor = new CustomSlotBlockFieldDescriptor("Test", "CustomBlock", string.Empty,
+            () => { return new Vector3MaterialSlot(0, "Test", "BlockB", SlotType.Input, Vector3.one); });
+
+        [OneTimeSetUp]
+        public void RunBeforeAnyTests()
+        {
+            Debug.unityLogger.logHandler = new ConsoleLogHandler();
+        }
+
+        [Test]
+        public void CanGatherBlockDescriptors()
+        {
+            GraphData graph = new GraphData();
+            graph.AddContexts();
+
+            Assert.IsNotNull(graph.blockFieldDescriptors);
+            Assert.AreNotEqual(0, graph.blockFieldDescriptors.Count);
+        }
+
+        [Test]
+        public void CanInitializeBlockNode()
+        {
+            var node = new BlockNode();
+            node.Init(s_DescriptorA);
+
+            Assert.IsNotNull(node.descriptor);
+            Assert.AreEqual(s_DescriptorA, node.descriptor);
+            Assert.AreEqual("Test.BlockA", $"{node.descriptor.tag}.{node.descriptor.name}");
+        }
+
+        [Test]
+        public void CanCreateSlotFromBlockDescriptor()
+        {
+            var node = new BlockNode();
+            node.Init(s_DescriptorA);
+            List<MaterialSlot> slots = new List<MaterialSlot>();
+            node.GetSlots(slots);
+
+            Assert.IsNotNull(slots);
+            Assert.AreEqual(1, slots.Count);
+
+            var vector3Slot = slots[0] as Vector1MaterialSlot;
+            Assert.IsNotNull(vector3Slot);
+            Assert.AreEqual(0, vector3Slot.id);
+            Assert.AreEqual(s_DescriptorA.displayName, vector3Slot.RawDisplayName());
+            Assert.AreEqual(s_DescriptorA.name, vector3Slot.shaderOutputName);
+            Assert.AreEqual(SlotType.Input, vector3Slot.slotType);
+            Assert.AreEqual(((FloatControl)s_DescriptorA.control).value, vector3Slot.value);
+            Assert.AreEqual(s_DescriptorA.shaderStage.GetShaderStageCapability(), vector3Slot.stageCapability);
+        }
+
+        [Test]
+        public void CanCreateSlotFromCustomSlotBlockDescriptor()
+        {
+            var node = new BlockNode();
+            node.Init(s_CustomSlotDescriptor);
+            List<MaterialSlot> slots = new List<MaterialSlot>();
+            node.GetSlots(slots);
+
+            Assert.IsNotNull(slots);
+            Assert.AreEqual(1, slots.Count);
+            Assert.AreNotEqual(s_MaterialSlot, slots[0]); //We actually WANT to create a new slot in this case
+            Assert.AreEqual(s_MaterialSlot.displayName, slots[0].displayName);
+            Assert.AreEqual(s_MaterialSlot.valueType, slots[0].valueType);
+            Assert.AreEqual(s_MaterialSlot.value, ((Vector3MaterialSlot)slots[0]).value);
+        }
+
+        [Test]
+        public void CanGetRequirementsFromBlockNode()
+        {
+            var node = new BlockNode();
+            node.Init(s_DescriptorB);
+
+            var iMayRequireNormals = node as IMayRequireNormal;
+            Assert.IsNotNull(iMayRequireNormals);
+
+            var neededCoordinateSpace = iMayRequireNormals.RequiresNormal(ShaderStageCapability.Fragment);
+            Assert.AreEqual(NeededCoordinateSpace.World, neededCoordinateSpace);
+        }
+
+        [Test]
+        public void CanSerializeDescriptor()
+        {
+            var node = new BlockNode();
+            node.Init(s_DescriptorA);
+            node.OnBeforeSerialize();
+
+            Assert.AreEqual("Test.BlockA", node.serializedDescriptor);
+        }
+
+        [Test]
+        public void CanGetBlockIndex()
+        {
+            GraphData graph = new GraphData();
+            graph.AddContexts();
+
+            var node = new BlockNode();
+            node.Init(s_DescriptorA);
+            graph.AddBlock(node, graph.fragmentContext, 0);
+
+            Assert.AreEqual(0, node.index);
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@11.0.0/Tests/Editor/UnitTests/DynamicSlotTests.cs

@@ -0,0 +1,236 @@
+using NUnit.Framework;
+using UnityEngine;
+using UnityEditor.Graphing;
+
+namespace UnityEditor.ShaderGraph.UnitTests
+{
+    [TestFixture]
+    class DynamicSlotTests
+    {
+        private GraphData m_Graph;
+        private DynamicNode m_DynamicNode;
+        private TestNode m_StaticNode;
+
+        class DynamicNode : AbstractMaterialNode
+        {
+            public const int DynIn1 = 0;
+            public const int DynIn2 = 1;
+            public const int DynOut = 2;
+
+            public DynamicNode()
+            {
+                AddSlot(new DynamicVectorMaterialSlot(DynIn1, "DynIn1", "DynIn1", SlotType.Input, Vector4.zero));
+                AddSlot(new DynamicVectorMaterialSlot(DynIn2, "DynIn2", "DynIn2", SlotType.Input, Vector4.zero));
+                AddSlot(new DynamicVectorMaterialSlot(DynOut, "DynOut", "DynOut", SlotType.Output, Vector4.zero));
+            }
+        }
+
+        class TestNode : AbstractMaterialNode
+        {
+            public const int V1Out = 0;
+            public const int V2Out = 1;
+            public const int V3Out = 2;
+            public const int V4Out = 3;
+
+            public TestNode()
+            {
+                AddSlot(new Vector1MaterialSlot(V1Out, "V1Out", "V1Out", SlotType.Output, 0));
+                AddSlot(new Vector2MaterialSlot(V2Out, "V2Out", "V2Out", SlotType.Output, Vector4.zero));
+                AddSlot(new Vector3MaterialSlot(V3Out, "V3Out", "V3Out", SlotType.Output, Vector4.zero));
+                AddSlot(new Vector4MaterialSlot(V4Out, "V4Out", "V4Out", SlotType.Output, Vector4.zero));
+            }
+        }
+
+        [OneTimeSetUp]
+        public void RunBeforeAnyTests()
+        {
+            Debug.unityLogger.logHandler = new ConsoleLogHandler();
+        }
+
+        [SetUp]
+        public void TestSetUp()
+        {
+            m_Graph = new GraphData();
+            m_DynamicNode = new DynamicNode();
+            m_Graph.AddNode(m_DynamicNode);
+            m_StaticNode = new TestNode();
+            m_Graph.AddNode(m_StaticNode);
+        }
+
+        [Test]
+        public void DynamicInputsV1NoneWorks()
+        {
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V1Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn1));
+            var dynOut1 = m_DynamicNode.FindOutputSlot<MaterialSlot>(DynamicNode.DynOut);
+            Assert.AreEqual(ConcreteSlotValueType.Vector1, dynOut1.concreteValueType);
+        }
+
+        [Test]
+        public void DynamicInputsV1V1Works()
+        {
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V1Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn1));
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V1Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn2));
+            var dynOut1 = m_DynamicNode.FindOutputSlot<MaterialSlot>(DynamicNode.DynOut);
+            Assert.AreEqual(ConcreteSlotValueType.Vector1, dynOut1.concreteValueType);
+        }
+
+        [Test]
+        public void DynamicInputsV1V2Works()
+        {
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V1Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn1));
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V2Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn2));
+            var dynOut1 = m_DynamicNode.FindOutputSlot<MaterialSlot>(DynamicNode.DynOut);
+            Assert.AreEqual(ConcreteSlotValueType.Vector2, dynOut1.concreteValueType);
+        }
+
+        [Test]
+        public void DynamicInputsV1V3Works()
+        {
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V1Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn1));
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V3Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn2));
+            var dynOut1 = m_DynamicNode.FindOutputSlot<MaterialSlot>(DynamicNode.DynOut);
+            Assert.AreEqual(ConcreteSlotValueType.Vector3, dynOut1.concreteValueType);
+        }
+
+        [Test]
+        public void DynamicInputsV1V4Works()
+        {
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V1Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn1));
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V4Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn2));
+            var dynOut1 = m_DynamicNode.FindOutputSlot<MaterialSlot>(DynamicNode.DynOut);
+            Assert.AreEqual(ConcreteSlotValueType.Vector4, dynOut1.concreteValueType);
+        }
+
+        [Test]
+        public void DynamicInputsV2NoneWorks()
+        {
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V2Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn1));
+            var dynOut1 = m_DynamicNode.FindOutputSlot<MaterialSlot>(DynamicNode.DynOut);
+            Assert.AreEqual(ConcreteSlotValueType.Vector2, dynOut1.concreteValueType);
+        }
+
+        [Test]
+        public void DynamicInputsV2V1Works()
+        {
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V2Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn1));
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V1Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn2));
+            var dynOut1 = m_DynamicNode.FindOutputSlot<MaterialSlot>(DynamicNode.DynOut);
+            Assert.AreEqual(ConcreteSlotValueType.Vector2, dynOut1.concreteValueType);
+        }
+
+        [Test]
+        public void DynamicInputsV2V2Works()
+        {
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V2Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn1));
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V2Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn2));
+            var dynOut1 = m_DynamicNode.FindOutputSlot<MaterialSlot>(DynamicNode.DynOut);
+            Assert.AreEqual(ConcreteSlotValueType.Vector2, dynOut1.concreteValueType);
+        }
+
+        [Test]
+        public void DynamicInputsV2V3Works()
+        {
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V2Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn1));
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V3Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn2));
+            var dynOut1 = m_DynamicNode.FindOutputSlot<MaterialSlot>(DynamicNode.DynOut);
+            Assert.AreEqual(ConcreteSlotValueType.Vector2, dynOut1.concreteValueType);
+        }
+
+        [Test]
+        public void DynamicInputsV2V4Works()
+        {
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V2Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn1));
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V4Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn2));
+            var dynOut1 = m_DynamicNode.FindOutputSlot<MaterialSlot>(DynamicNode.DynOut);
+            Assert.AreEqual(ConcreteSlotValueType.Vector2, dynOut1.concreteValueType);
+        }
+
+        [Test]
+        public void DynamicInputsV3NoneWorks()
+        {
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V3Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn1));
+            var dynOut1 = m_DynamicNode.FindOutputSlot<MaterialSlot>(DynamicNode.DynOut);
+            Assert.AreEqual(ConcreteSlotValueType.Vector3, dynOut1.concreteValueType);
+        }
+
+        [Test]
+        public void DynamicInputsV3V1Works()
+        {
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V3Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn1));
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V1Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn2));
+            var dynOut1 = m_DynamicNode.FindOutputSlot<MaterialSlot>(DynamicNode.DynOut);
+            Assert.AreEqual(ConcreteSlotValueType.Vector3, dynOut1.concreteValueType);
+        }
+
+        [Test]
+        public void DynamicInputsV3V2Works()
+        {
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V3Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn1));
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V2Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn2));
+            var dynOut1 = m_DynamicNode.FindOutputSlot<MaterialSlot>(DynamicNode.DynOut);
+            Assert.AreEqual(ConcreteSlotValueType.Vector2, dynOut1.concreteValueType);
+        }
+
+        [Test]
+        public void DynamicInputsV3V3Works()
+        {
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V3Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn1));
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V3Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn2));
+            var dynOut1 = m_DynamicNode.FindOutputSlot<MaterialSlot>(DynamicNode.DynOut);
+            Assert.AreEqual(ConcreteSlotValueType.Vector3, dynOut1.concreteValueType);
+        }
+
+        [Test]
+        public void DynamicInputsV3V4Works()
+        {
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V3Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn1));
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V4Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn2));
+            var dynOut1 = m_DynamicNode.FindOutputSlot<MaterialSlot>(DynamicNode.DynOut);
+            Assert.AreEqual(ConcreteSlotValueType.Vector3, dynOut1.concreteValueType);
+        }
+
+        [Test]
+        public void DynamicInputsV4NoneWorks()
+        {
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V4Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn1));
+            var dynOut1 = m_DynamicNode.FindOutputSlot<MaterialSlot>(DynamicNode.DynOut);
+            Assert.AreEqual(ConcreteSlotValueType.Vector4, dynOut1.concreteValueType);
+        }
+
+        [Test]
+        public void DynamicInputsV4V1Works()
+        {
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V4Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn1));
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V1Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn2));
+            var dynOut1 = m_DynamicNode.FindOutputSlot<MaterialSlot>(DynamicNode.DynOut);
+            Assert.AreEqual(ConcreteSlotValueType.Vector4, dynOut1.concreteValueType);
+        }
+
+        [Test]
+        public void DynamicInputsV4V2Works()
+        {
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V4Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn1));
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V2Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn2));
+            var dynOut1 = m_DynamicNode.FindOutputSlot<MaterialSlot>(DynamicNode.DynOut);
+            Assert.AreEqual(ConcreteSlotValueType.Vector2, dynOut1.concreteValueType);
+        }
+
+        [Test]
+        public void DynamicInputsV4V3Works()
+        {
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V4Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn1));
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V3Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn2));
+            var dynOut1 = m_DynamicNode.FindOutputSlot<MaterialSlot>(DynamicNode.DynOut);
+            Assert.AreEqual(ConcreteSlotValueType.Vector3, dynOut1.concreteValueType);
+        }
+
+        [Test]
+        public void DynamicInputsV4V4Works()
+        {
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V4Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn1));
+            m_Graph.Connect(m_StaticNode.GetSlotReference(TestNode.V4Out), m_DynamicNode.GetSlotReference(DynamicNode.DynIn2));
+            var dynOut1 = m_DynamicNode.FindOutputSlot<MaterialSlot>(DynamicNode.DynOut);
+            Assert.AreEqual(ConcreteSlotValueType.Vector4, dynOut1.concreteValueType);
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@11.0.0/Tests/Editor/UnitTests/FixedSlotTests.cs

@@ -0,0 +1,169 @@
+using NUnit.Framework;
+using UnityEngine;
+using UnityEditor.Graphing;
+
+namespace UnityEditor.ShaderGraph.UnitTests
+{
+    [TestFixture]
+    class FixedSlotTests
+    {
+        private GraphData m_Graph;
+        private TestNode m_NodeA;
+        private TestNode m_NodeB;
+
+        class TestNode : AbstractMaterialNode
+        {
+            public const int V1Out = 0;
+            public const int V2Out = 1;
+            public const int V3Out = 2;
+            public const int V4Out = 3;
+
+
+            public const int V1In = 4;
+            public const int V2In = 5;
+            public const int V3In = 6;
+            public const int V4In = 7;
+
+            public TestNode()
+            {
+                AddSlot(new Vector1MaterialSlot(V1Out, "V1Out", "V1Out", SlotType.Output, 0));
+                AddSlot(new Vector2MaterialSlot(V2Out, "V2Out", "V2Out", SlotType.Output, Vector4.zero));
+                AddSlot(new Vector3MaterialSlot(V3Out, "V3Out", "V3Out", SlotType.Output, Vector4.zero));
+                AddSlot(new Vector4MaterialSlot(V4Out, "V4Out", "V4Out", SlotType.Output, Vector4.zero));
+
+                AddSlot(new Vector1MaterialSlot(V1In, "V1In", "V1In", SlotType.Input, 0));
+                AddSlot(new Vector2MaterialSlot(V2In, "V2In", "V2In", SlotType.Input, Vector4.zero));
+                AddSlot(new Vector3MaterialSlot(V3In, "V3In", "V3In", SlotType.Input, Vector4.zero));
+                AddSlot(new Vector4MaterialSlot(V4In, "V4In", "V4In", SlotType.Input, Vector4.zero));
+            }
+        }
+
+        [OneTimeSetUp]
+        public void RunBeforeAnyTests()
+        {
+            Debug.unityLogger.logHandler = new ConsoleLogHandler();
+        }
+
+        [SetUp]
+        public void TestSetUp()
+        {
+            m_Graph = new GraphData();
+            m_NodeA = new TestNode();
+            m_NodeB = new TestNode();
+            m_Graph.AddNode(m_NodeA);
+            m_Graph.AddNode(m_NodeB);
+        }
+
+        [Test]
+        public void ConnectV1ToV1Works()
+        {
+            m_Graph.Connect(m_NodeA.GetSlotReference(TestNode.V1Out), m_NodeB.GetSlotReference(TestNode.V1In));
+            Assert.IsFalse(m_NodeB.hasError);
+        }
+
+        [Test]
+        public void ConnectV1ToV2Works()
+        {
+            m_Graph.Connect(m_NodeA.GetSlotReference(TestNode.V1Out), m_NodeB.GetSlotReference(TestNode.V2In));
+            Assert.IsFalse(m_NodeB.hasError);
+        }
+
+        [Test]
+        public void ConnectV1ToV3Works()
+        {
+            m_Graph.Connect(m_NodeA.GetSlotReference(TestNode.V1Out), m_NodeB.GetSlotReference(TestNode.V3In));
+            Assert.IsFalse(m_NodeB.hasError);
+        }
+
+        [Test]
+        public void ConnectV1ToV4Works()
+        {
+            m_Graph.Connect(m_NodeA.GetSlotReference(TestNode.V1Out), m_NodeB.GetSlotReference(TestNode.V4In));
+            Assert.IsFalse(m_NodeB.hasError);
+        }
+
+        [Test]
+        public void ConnectV2ToV1Works()
+        {
+            m_Graph.Connect(m_NodeA.GetSlotReference(TestNode.V2Out), m_NodeB.GetSlotReference(TestNode.V1In));
+            Assert.IsFalse(m_NodeB.hasError);
+        }
+
+        [Test]
+        public void ConnectV2ToV2Works()
+        {
+            m_Graph.Connect(m_NodeA.GetSlotReference(TestNode.V2Out), m_NodeB.GetSlotReference(TestNode.V2In));
+            Assert.IsFalse(m_NodeB.hasError);
+        }
+
+        [Test]
+        public void ConnectV2ToV3Works()
+        {
+            m_Graph.Connect(m_NodeA.GetSlotReference(TestNode.V2Out), m_NodeB.GetSlotReference(TestNode.V3In));
+            Assert.IsFalse(m_NodeB.hasError);
+        }
+
+        [Test]
+        public void ConnectV2ToV4Works()
+        {
+            m_Graph.Connect(m_NodeA.GetSlotReference(TestNode.V2Out), m_NodeB.GetSlotReference(TestNode.V4In));
+            Assert.IsFalse(m_NodeB.hasError);
+        }
+
+        [Test]
+        public void ConnectV3ToV1Works()
+        {
+            m_Graph.Connect(m_NodeA.GetSlotReference(TestNode.V3Out), m_NodeB.GetSlotReference(TestNode.V1In));
+            Assert.IsFalse(m_NodeB.hasError);
+        }
+
+        [Test]
+        public void ConnectV3ToV2Works()
+        {
+            m_Graph.Connect(m_NodeA.GetSlotReference(TestNode.V3Out), m_NodeB.GetSlotReference(TestNode.V2In));
+            Assert.IsFalse(m_NodeB.hasError);
+        }
+
+        [Test]
+        public void ConnectV3ToV3Works()
+        {
+            m_Graph.Connect(m_NodeA.GetSlotReference(TestNode.V3Out), m_NodeB.GetSlotReference(TestNode.V3In));
+            Assert.IsFalse(m_NodeB.hasError);
+        }
+
+        [Test]
+        public void ConnectV3ToV4Works()
+        {
+            m_Graph.Connect(m_NodeA.GetSlotReference(TestNode.V3Out), m_NodeB.GetSlotReference(TestNode.V4In));
+            Assert.IsFalse(m_NodeB.hasError);
+        }
+
+        [Test]
+        public void ConnectV4ToV1Works()
+        {
+            m_Graph.Connect(m_NodeA.GetSlotReference(TestNode.V4Out), m_NodeB.GetSlotReference(TestNode.V1In));
+            Assert.IsFalse(m_NodeB.hasError);
+        }
+
+        [Test]
+        public void ConnectV4ToV2Works()
+        {
+            m_Graph.Connect(m_NodeA.GetSlotReference(TestNode.V4Out), m_NodeB.GetSlotReference(TestNode.V2In));
+            Assert.IsFalse(m_NodeB.hasError);
+        }
+
+        [Test]
+        public void ConnectV4ToV3Works()
+        {
+            m_Graph.Connect(m_NodeA.GetSlotReference(TestNode.V4Out), m_NodeB.GetSlotReference(TestNode.V3In));
+            Assert.IsFalse(m_NodeB.hasError);
+        }
+
+        [Test]
+        public void ConnectV4ToV4Works()
+        {
+            m_Graph.Connect(m_NodeA.GetSlotReference(TestNode.V4Out), m_NodeB.GetSlotReference(TestNode.V4In));
+            Assert.IsFalse(m_NodeB.hasError);
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@11.0.0/Tests/Editor/UnitTests/ListUtilityTests.cs

@@ -0,0 +1,113 @@
+using NUnit.Framework;
+using System.Collections.Generic;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph;
+using System.Linq;
+
+
+namespace UnityEditor.ShaderGraph.UnitTests
+{
+    class ListUtilityTests
+    {
+        List<int> GetList()
+        {
+            return new List<int>()
+            {
+                0,
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                9,
+            };
+        }
+
+        List<int> GetEmptyList()
+        {
+            return new List<int>();
+        }
+
+        bool ListEquals(List<int> list, params int[] expectedValues)
+        {
+            if (list.Count != expectedValues.Length)
+                return false;
+            for (int x = 0; x < list.Count; x++)
+                if (list[x] != expectedValues[x])
+                    return false;
+            return true;
+        }
+
+        [Test]
+        public void ListSlice()
+        {
+            Assert.IsTrue(ListEquals(GetList().Slice(2, 5).ToList(), 2, 3, 4));
+            Assert.IsTrue(ListEquals(GetList().Slice(0, 1).ToList(), 0));
+            Assert.IsTrue(ListEquals(GetList().Slice(7, 10).ToList(), 7, 8, 9));
+            Assert.IsTrue(ListEquals(GetList().Slice(0, 10).ToList(), 0, 1, 2, 3, 4, 5, 6, 7, 8, 9));
+
+            Assert.IsFalse(GetList().Slice(0, 0).Any());
+            Assert.IsFalse(GetList().Slice(5, 5).Any());
+            Assert.IsFalse(GetList().Slice(10, 10).Any());
+            Assert.IsFalse(GetList().Slice(6, 4).Any());
+        }
+
+        [Test]
+        public void ListRemoveAllFromRange()
+        {
+            {
+                var list = GetList();
+                Assert.IsTrue(list.RemoveAllFromRange(x => true, 0, 10) == 10);
+                Assert.IsTrue(ListEquals(list));
+            }
+            {
+                var list = GetList();
+                Assert.IsTrue(list.RemoveAllFromRange(x => false, 0, 10) == 0);
+                Assert.IsTrue(ListEquals(list, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9));
+            }
+            {
+                var list = GetList();
+                Assert.IsTrue(list.RemoveAllFromRange(x => x == 3, 0, 6) == 1);
+                Assert.IsTrue(ListEquals(list, 0, 1, 2, 4, 5, 6, 7, 8, 9));
+            }
+            {
+                var list = GetList();
+                Assert.IsTrue(list.RemoveAllFromRange(x => true, 3, 3) == 3);
+                Assert.IsTrue(ListEquals(list, 0, 1, 2, 6, 7, 8, 9));
+            }
+            {
+                var list = GetList();
+                Assert.IsTrue(list.RemoveAllFromRange(x => x == 3, 4, 2) == 0);
+                Assert.IsTrue(ListEquals(list, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9));
+            }
+            {
+                var list = GetList();
+                Assert.IsTrue(list.RemoveAllFromRange(x => x < 5, 0, 10) == 5);
+                Assert.IsTrue(ListEquals(list, 5, 6, 7, 8, 9));
+            }
+            {
+                var list = GetList();
+                Assert.IsTrue(list.RemoveAllFromRange(x => ((x & 0x01) == 0), 2, 8) == 4);
+                Assert.IsTrue(ListEquals(list, 0, 1, 3, 5, 7, 9));
+            }
+            {
+                var list = GetList();
+                Assert.IsTrue(list.RemoveAllFromRange(x => ((x & 0x01) == 0x01), 0, 8) == 4);
+                Assert.IsTrue(ListEquals(list, 0, 2, 4, 6, 8, 9));
+            }
+            {
+                var list = GetList();
+                Assert.IsTrue(list.RemoveAllFromRange(x => ((x & 0x03) == 0x00), 0, 10) == 3);
+                Assert.IsTrue(ListEquals(list, 1, 2, 3, 5, 6, 7, 9));
+            }
+            {
+                var list = GetEmptyList();
+                Assert.IsTrue(list.RemoveAllFromRange(x => true, 0, 0) == 0);
+                Assert.IsTrue(ListEquals(list));
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@11.0.0/Tests/Editor/UnitTests/MaterialGraphTests.cs

@@ -0,0 +1,27 @@
+using System.Linq;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEditor.Graphing;
+
+namespace UnityEditor.ShaderGraph.UnitTests
+{
+    [TestFixture]
+    class MaterialGraphTests
+    {
+        [OneTimeSetUp]
+        public void RunBeforeAnyTests()
+        {
+            Debug.unityLogger.logHandler = new ConsoleLogHandler();
+        }
+
+        [Test]
+        public void TestCreateMaterialGraph()
+        {
+            var graph = new GraphData();
+
+            Assert.IsNotNull(graph);
+
+            Assert.AreEqual(0, graph.GetNodes<AbstractMaterialNode>().Count());
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@11.0.0/Tests/Editor/UnitTests/MaterialNodeTests.cs

@@ -0,0 +1,146 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Internal;
+
+namespace UnityEditor.ShaderGraph.UnitTests
+{
+    [TestFixture]
+    class MaterialNodeTests
+    {
+        private GraphData m_Graph;
+        private TestNode m_NodeA;
+
+        class TestNode : AbstractMaterialNode
+        {
+            public const int V1Out = 0;
+            public const int V1In = 1;
+
+            public TestNode()
+            {
+                AddSlot(new Vector1MaterialSlot(V1Out, "V1Out", "V1Out", SlotType.Output, 0));
+                AddSlot(new Vector1MaterialSlot(V1In, "V1In", "V1In", SlotType.Input, 0));
+            }
+        }
+
+        class NotAMaterialSlot : MaterialSlot
+        {
+            public override void AddDefaultProperty(PropertyCollector properties, GenerationMode generationMode)
+            {
+                throw new NotImplementedException();
+            }
+
+            public override void CopyValuesFrom(MaterialSlot foundSlot)
+            {
+                throw new NotImplementedException();
+            }
+
+            public override void CopyDefaultValue(MaterialSlot other)
+            {
+            }
+
+            public override SlotValueType valueType { get; }
+            public override ConcreteSlotValueType concreteValueType { get; }
+            public override bool isDefaultValue { get; }
+        }
+
+        [OneTimeSetUp]
+        public void RunBeforeAnyTests()
+        {
+            Debug.unityLogger.logHandler = new ConsoleLogHandler();
+        }
+
+        [SetUp]
+        public void TestSetUp()
+        {
+            m_Graph = new GraphData();
+            m_NodeA = new TestNode();
+            m_Graph.AddNode(m_NodeA);
+            m_NodeA.SetOverrideActiveState(AbstractMaterialNode.ActiveState.ExplicitActive);
+        }
+
+        [Test]
+        public void GetVariableNameForSlotThrowsWhenInvalid()
+        {
+            Assert.Throws<ArgumentException>(() => m_NodeA.GetVariableNameForSlot(666));
+        }
+
+        [Test]
+        public void ReplacingMaterialSlotPreservesTheOldCurrentValue()
+        {
+            m_NodeA.AddSlot(new Vector1MaterialSlot(TestNode.V1In, "V1In", "V1In", SlotType.Input, 1));
+            Assert.AreEqual(2, m_NodeA.GetSlots<MaterialSlot>().Count());
+            Assert.AreEqual(1, m_NodeA.GetInputSlots<MaterialSlot>().Count());
+
+            var slot = m_NodeA.GetInputSlots<Vector1MaterialSlot>().FirstOrDefault();
+            Assert.AreEqual(1, slot.defaultValue);
+            Assert.AreEqual(0, slot.value);
+        }
+
+        [Test]
+        public void CanConvertConcreteSlotValueTypeToOutputChunkProperly()
+        {
+            Assert.AreEqual("float", ConcreteSlotValueType.Vector1.ToShaderString(ConcretePrecision.Single));
+            Assert.AreEqual("float", ConcreteSlotValueType.Boolean.ToShaderString(ConcretePrecision.Single));
+            Assert.AreEqual("float2", ConcreteSlotValueType.Vector2.ToShaderString(ConcretePrecision.Single));
+            Assert.AreEqual("float3", ConcreteSlotValueType.Vector3.ToShaderString(ConcretePrecision.Single));
+            Assert.AreEqual("float4", ConcreteSlotValueType.Vector4.ToShaderString(ConcretePrecision.Single));
+            Assert.AreEqual("UnityTexture2D", ConcreteSlotValueType.Texture2D.ToShaderString(ConcretePrecision.Single));
+            Assert.AreEqual("float2x2", ConcreteSlotValueType.Matrix2.ToShaderString(ConcretePrecision.Single));
+            Assert.AreEqual("float3x3", ConcreteSlotValueType.Matrix3.ToShaderString(ConcretePrecision.Single));
+            Assert.AreEqual("float4x4", ConcreteSlotValueType.Matrix4.ToShaderString(ConcretePrecision.Single));
+            Assert.AreEqual("UnitySamplerState", ConcreteSlotValueType.SamplerState.ToShaderString(ConcretePrecision.Single));
+            Assert.AreEqual("UnityTextureCube", ConcreteSlotValueType.Cubemap.ToShaderString(ConcretePrecision.Single));
+        }
+
+        [Test]
+        public void CanGetDefaultInputsFromNodeAsPreviewProperties()
+        {
+            var properties = new List<PreviewProperty>();
+            m_NodeA.CollectPreviewMaterialProperties(properties);
+            var slot = m_NodeA.GetInputSlots<Vector1MaterialSlot>().FirstOrDefault();
+
+            Assert.AreEqual(1, properties.Count);
+            var pp = properties.FirstOrDefault();
+
+            Assert.AreEqual(m_NodeA.GetVariableNameForSlot(slot.id), pp.name);
+            Assert.AreEqual(PropertyType.Float, pp.propType);
+            Assert.AreEqual(slot.value, pp.floatValue);
+        }
+
+        [Test]
+        public void CanGetDefaultSlotValueWhenNoEdgesConnected()
+        {
+            string expected = string.Format("{0}", m_NodeA.GetVariableNameForSlot(TestNode.V1In));
+
+            var slot = m_NodeA.GetInputSlots<MaterialSlot>().FirstOrDefault();
+            var result = m_NodeA.GetSlotValue(slot.id, GenerationMode.Preview);
+            Assert.AreEqual(expected, result);
+        }
+
+        /*       [Test]
+               public void NodeGenerateCorrectPreviewPropertyUsages()
+               {
+                   string expected = string.Format("{0} {1};{2}", AbstractMaterialNode.OutputPrecision.@fixed, m_NodeA.GetVariableNameForSlot(TestNode.V1In), Environment.NewLine);
+                   var visitor = new ShaderGenerator();
+                   m_NodeA.precision = AbstractMaterialNode.OutputPrecision.@fixed;
+                   m_NodeA.GeneratePropertyUsages(visitor, GenerationMode.Preview);
+                   Assert.AreEqual(expected, visitor.GetShaderString(0));
+
+                   expected = string.Format("{0} {1};{2}", AbstractMaterialNode.OutputPrecision.@float, m_NodeA.GetVariableNameForSlot(TestNode.V1In), Environment.NewLine);
+                   visitor = new ShaderGenerator();
+                   m_NodeA.precision = AbstractMaterialNode.OutputPrecision.@float;
+                   m_NodeA.GeneratePropertyUsages(visitor, GenerationMode.Preview);
+                   Assert.AreEqual(expected, visitor.GetShaderString(0));
+
+                   expected = string.Format("{0} {1};{2}", AbstractMaterialNode.OutputPrecision.half, m_NodeA.GetVariableNameForSlot(TestNode.V1In), Environment.NewLine);
+                   visitor = new ShaderGenerator();
+                   m_NodeA.precision = AbstractMaterialNode.OutputPrecision.half;
+                   m_NodeA.GeneratePropertyUsages(visitor, GenerationMode.Preview);
+                   Assert.AreEqual(expected, visitor.GetShaderString(0));
+               }*/
+    }
+}

Library/PackageCache/com.unity.shadergraph@11.0.0/Tests/Editor/UnitTests/MaterialSlotTests.cs

@@ -0,0 +1,130 @@
+using NUnit.Framework;
+using UnityEngine;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Internal;
+
+namespace UnityEditor.ShaderGraph.UnitTests
+{
+    [TestFixture]
+    class MaterialSlotTests
+    {
+        private GraphData m_Graph;
+        private TestNode m_NodeA;
+
+        class TestNode : AbstractMaterialNode
+        {
+            public const int V1In = 1;
+            public const int V2In = 2;
+            public const int V3In = 3;
+            public const int V4In = 4;
+
+            public readonly Vector1MaterialSlot slot1;
+            public readonly Vector2MaterialSlot slot2;
+            public readonly Vector3MaterialSlot slot3;
+            public readonly Vector4MaterialSlot slot4;
+
+            public TestNode()
+            {
+                slot1 = new Vector1MaterialSlot(V1In, "V1In", "V1In", SlotType.Input, 1);
+                AddSlot(slot1);
+
+                slot2 = new Vector2MaterialSlot(V2In, "V2In", "V2In", SlotType.Input, Vector2.one);
+                AddSlot(slot2);
+
+                slot3 = new Vector3MaterialSlot(V3In, "V3In", "V3In", SlotType.Input, Vector3.one);
+                AddSlot(slot3);
+
+                slot4 = new Vector4MaterialSlot(V4In, "V4In", "V4In", SlotType.Input, Vector4.one);
+                AddSlot(slot4);
+            }
+        }
+
+        [OneTimeSetUp]
+        public void RunBeforeAnyTests()
+        {
+            Debug.unityLogger.logHandler = new ConsoleLogHandler();
+        }
+
+        [SetUp]
+        public void TestSetUp()
+        {
+            m_Graph = new GraphData();
+            m_NodeA = new TestNode();
+            m_NodeA.precision = Precision.Half;
+            m_Graph.AddNode(m_NodeA);
+            m_NodeA.SetOverrideActiveState(AbstractMaterialNode.ActiveState.ExplicitActive);
+        }
+
+        [Test]
+        public void SlotDisplayNameIsCorrect()
+        {
+            Assert.AreEqual("V1In(1)", m_NodeA.slot1.displayName);
+
+            Assert.AreEqual("V2In(2)", m_NodeA.slot2.displayName);
+
+            Assert.AreEqual("V3In(3)", m_NodeA.slot3.displayName);
+
+            Assert.AreEqual("V4In(4)", m_NodeA.slot4.displayName);
+        }
+
+        [Test]
+        public void CanUpdateMaterialSlotDefaultValue()
+        {
+            var slot = m_NodeA.slot1;
+            slot.value = 1;
+            Assert.AreEqual(1, slot.defaultValue);
+        }
+
+        [Test]
+        public void CanUpdateMaterialSlotCurrentValue()
+        {
+            var slot = m_NodeA.slot1;
+            slot.value = 1;
+            Assert.AreEqual(1, 1);
+        }
+
+        /*     [Test]
+             public void MaterialSlotCanGeneratePropertyUsagesForPreview()
+             {
+                 string expected = string.Format("{0} {1};{2}", m_NodeA.precision, m_NodeA.GetVariableNameForSlot(TestNode.V1In), Environment.NewLine);
+
+                 var slot = m_NodeA.slot;
+                 var visitor = new ShaderGenerator();
+                 slot.GeneratePropertyUsages(visitor, GenerationMode.Preview);
+                 Assert.AreEqual(expected, visitor.GetShaderString(0));
+             }*/
+
+        [Test]
+        public void MaterialSlotReturnsValidDefaultValue()
+        {
+            string expected = string.Format("{0}", m_NodeA.GetVariableNameForSlot(TestNode.V1In));
+
+            var result = m_NodeA.slot1.GetDefaultValue(GenerationMode.Preview);
+            Assert.AreEqual(expected, result);
+
+            m_NodeA.slot1.value = 6;
+            result = m_NodeA.slot1.GetDefaultValue(GenerationMode.ForReals);
+            Assert.AreEqual("6", result);
+
+            m_NodeA.slot2.value = new Vector4(6, 6, 6, 1);
+            result = m_NodeA.slot2.GetDefaultValue(GenerationMode.ForReals, ConcretePrecision.Half);
+            Assert.AreEqual("half2 (6, 6)", result);
+
+            m_NodeA.slot3.value = new Vector4(6, 6, 6, 1);
+            result = m_NodeA.slot3.GetDefaultValue(GenerationMode.ForReals, ConcretePrecision.Half);
+            Assert.AreEqual("half3 (6, 6, 6)", result);
+
+            m_NodeA.slot4.value = new Vector4(6, 6, 6, 1);
+            result = m_NodeA.slot4.GetDefaultValue(GenerationMode.ForReals, ConcretePrecision.Half);
+            Assert.AreEqual("half4 (6, 6, 6, 1)", result);
+        }
+
+        /* [Test]
+         public void MaterialSlotThrowsWhenNoOwner()
+         {
+             var slot = new MaterialSlot(0, string.Empty, string.Empty, SlotType.Input, SlotValueType.Vector1, Vector4.zero);
+             Assert.Throws<Exception>(() => slot.GeneratePropertyUsages(new ShaderGenerator(), GenerationMode.Preview));
+             Assert.Throws<Exception>(() => slot.GetDefaultValue(GenerationMode.Preview));
+         }*/
+    }
+}

Library/PackageCache/com.unity.shadergraph@11.0.0/Tests/Editor/UnitTests/MessageManagerTests.cs

@@ -0,0 +1,333 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Security.Cryptography.X509Certificates;
+using NUnit.Framework;
+using UnityEditor.Graphing;
+using UnityEngine;
+using UnityEditor.Graphing.Util;
+using UnityEditor.Rendering;
+
+namespace UnityEditor.ShaderGraph.UnitTests
+{
+    class TestMessageManager : MessageManager
+    {
+        public Dictionary<object, Dictionary<string, List<ShaderMessage>>> Messages
+        {
+            get { return m_Messages; }
+        }
+    }
+
+    class MessageManagerTests
+    {
+        TestMessageManager m_EmptyMgr;
+        TestMessageManager m_ComplexMgr;
+        string p0 = "Provider 0";
+        string p1 = "Provider 1";
+        AddNode node0 = new AddNode();
+        AddNode node1 = new AddNode();
+        AddNode node2 = new AddNode();
+        ShaderMessage e0 = new ShaderMessage("e0");
+        ShaderMessage e1 = new ShaderMessage("e1");
+        ShaderMessage e2 = new ShaderMessage("e2");
+        ShaderMessage e3 = new ShaderMessage("e3");
+        ShaderMessage w0 = new ShaderMessage("w0", ShaderCompilerMessageSeverity.Warning);
+        ShaderMessage w1 = new ShaderMessage("w1", ShaderCompilerMessageSeverity.Warning);
+
+        [SetUp]
+        public void Setup()
+        {
+            m_EmptyMgr = new TestMessageManager();
+
+            m_ComplexMgr = new TestMessageManager();
+            m_ComplexMgr.AddOrAppendError(p0, node0.objectId, e0);
+            m_ComplexMgr.AddOrAppendError(p0, node0.objectId, e1);
+            m_ComplexMgr.AddOrAppendError(p0, node1.objectId, e2);
+            m_ComplexMgr.AddOrAppendError(p1, node0.objectId, e1);
+            m_ComplexMgr.AddOrAppendError(p1, node1.objectId, e0);
+            m_ComplexMgr.AddOrAppendError(p1, node1.objectId, e1);
+            m_ComplexMgr.AddOrAppendError(p1, node2.objectId, e3);
+        }
+
+        // Simple helper to avoid typing that ungodly generic type
+        static List<KeyValuePair<string, List<ShaderMessage>>> GetListFrom(MessageManager mgr)
+        {
+            return new List<KeyValuePair<string, List<ShaderMessage>>>(mgr.GetNodeMessages());
+        }
+
+        [Test]
+        public void NewManager_IsEmpty()
+        {
+            var ret = GetListFrom(m_EmptyMgr);
+            Assert.IsEmpty(ret);
+        }
+
+        [Test]
+        public void AddMessage_CreatesMessage()
+        {
+            m_EmptyMgr.AddOrAppendError(p0, node0.objectId, e0);
+
+            var ret = GetListFrom(m_EmptyMgr);
+            Assert.IsNotEmpty(ret);
+            Assert.AreEqual(node0.objectId, ret[0].Key);
+            Assert.IsNotEmpty(ret[0].Value);
+            Assert.AreEqual(e0, ret[0].Value[0]);
+        }
+
+        [Test]
+        public void AddMessage_DirtiesManager()
+        {
+            m_EmptyMgr.AddOrAppendError(p0, node0.objectId, e0);
+
+            Assert.IsTrue(m_EmptyMgr.nodeMessagesChanged);
+        }
+
+        [Test]
+        public void GettingMessages_ClearsDirtyFlag()
+        {
+            m_EmptyMgr.AddOrAppendError(p0, node0.objectId, e0);
+            GetListFrom(m_EmptyMgr);
+
+            Assert.IsFalse(m_EmptyMgr.nodeMessagesChanged);
+        }
+
+        [Test]
+        public void GettingMessages_DoesNotChangeLists()
+        {
+            m_EmptyMgr.AddOrAppendError(p0, node0.objectId, e0);
+            m_EmptyMgr.AddOrAppendError(p0, node0.objectId, e1);
+            m_EmptyMgr.AddOrAppendError(p1, node0.objectId, e2);
+
+            GetListFrom(m_EmptyMgr);
+
+            Assert.AreEqual(2, m_EmptyMgr.Messages[p0][node0.objectId].Count);
+            Assert.AreEqual(e0, m_EmptyMgr.Messages[p0][node0.objectId][0]);
+            Assert.AreEqual(e1, m_EmptyMgr.Messages[p0][node0.objectId][1]);
+            Assert.AreEqual(1, m_EmptyMgr.Messages[p1][node0.objectId].Count);
+            Assert.AreEqual(e2, m_EmptyMgr.Messages[p1][node0.objectId][0]);
+        }
+
+        [Test]
+        public void RemoveNode_DoesNotDirty_IfNodeDoesNotExist()
+        {
+            m_EmptyMgr.AddOrAppendError(p0, node0.objectId, e0);
+            GetListFrom(m_EmptyMgr);
+
+            m_EmptyMgr.RemoveNode(node1.objectId);
+
+            Assert.IsFalse(m_EmptyMgr.nodeMessagesChanged);
+        }
+
+        [Test]
+        public void RemoveNode_DirtiesList_IfNodeExists()
+        {
+            m_EmptyMgr.AddOrAppendError(p0, node0.objectId, e0);
+            GetListFrom(m_EmptyMgr);
+
+            m_EmptyMgr.RemoveNode(node0.objectId);
+
+            Assert.IsTrue(m_EmptyMgr.nodeMessagesChanged);
+        }
+
+        [Test]
+        public void RemoveNode_RemovesNode()
+        {
+            m_EmptyMgr.AddOrAppendError(p0, node0.objectId, e0);
+            m_EmptyMgr.RemoveNode(node0.objectId);
+
+            var ret = GetListFrom(m_EmptyMgr);
+            Assert.IsEmpty(ret);
+        }
+
+        [Test]
+        public void RemoveNode_RemovesNode_FromAllProvides()
+        {
+            m_EmptyMgr.AddOrAppendError(p0, node0.objectId, e0);
+            m_EmptyMgr.AddOrAppendError(p1, node0.objectId, e1);
+            m_EmptyMgr.RemoveNode(node0.objectId);
+
+            var ret = GetListFrom(m_EmptyMgr);
+            Assert.IsEmpty(ret);
+        }
+
+        [Test]
+        public void AppendMessage_AppendsMessage()
+        {
+            m_EmptyMgr.AddOrAppendError(p0, node0.objectId, e0);
+            m_EmptyMgr.AddOrAppendError(p0, node0.objectId, e1);
+
+            var ret = GetListFrom(m_EmptyMgr);
+            Assert.IsNotEmpty(ret);
+            Assert.AreEqual(node0.objectId, ret[0].Key);
+            Assert.AreEqual(2, ret[0].Value.Count);
+            Assert.AreEqual(e0, ret[0].Value[0]);
+            Assert.AreEqual(e1, ret[0].Value[1]);
+        }
+
+        [Test]
+        public void Warnings_SortedAfterErrors()
+        {
+            var mixedMgr = new MessageManager();
+            mixedMgr.AddOrAppendError(p0, node0.objectId, e0);
+            mixedMgr.AddOrAppendError(p0, node0.objectId, w0);
+            mixedMgr.AddOrAppendError(p0, node0.objectId, e1);
+            mixedMgr.AddOrAppendError(p0, node0.objectId, w1);
+
+            var ret = GetListFrom(mixedMgr)[0].Value;
+            Assert.AreEqual(e0, ret[0]);
+            Assert.AreEqual(e1, ret[1]);
+            Assert.AreEqual(w0, ret[2]);
+            Assert.AreEqual(w1, ret[3]);
+        }
+
+        [Test]
+        public void Warnings_FromDifferentProviders_SortedAfterErrors()
+        {
+            var mixedMgr = new MessageManager();
+            mixedMgr.AddOrAppendError(p0, node0.objectId, e0);
+            mixedMgr.AddOrAppendError(p0, node0.objectId, w0);
+            mixedMgr.AddOrAppendError(p1, node0.objectId, e1);
+            mixedMgr.AddOrAppendError(p1, node0.objectId, w1);
+
+            var ret = GetListFrom(mixedMgr)[0].Value;
+            Assert.AreEqual(e0, ret[0]);
+            Assert.AreEqual(e1, ret[1]);
+            Assert.AreEqual(w0, ret[2]);
+            Assert.AreEqual(w1, ret[3]);
+        }
+
+        [Test]
+        public void MultipleNodes_RemainSeparate()
+        {
+            m_EmptyMgr.AddOrAppendError(p0, node0.objectId, e0);
+            m_EmptyMgr.AddOrAppendError(p0, node1.objectId, e1);
+
+            var ret = GetListFrom(m_EmptyMgr);
+            Assert.AreEqual(2, ret.Count);
+            Assert.AreEqual(node0.objectId, ret[0].Key);
+            Assert.AreEqual(e0, ret[0].Value[0]);
+            Assert.AreEqual(node1.objectId, ret[1].Key);
+            Assert.AreEqual(e1, ret[1].Value[0]);
+        }
+
+        [Test]
+        public void MultipleCreators_AggregatePerNode()
+        {
+            m_EmptyMgr.AddOrAppendError(p0, node0.objectId, e0);
+            m_EmptyMgr.AddOrAppendError(p1, node0.objectId, e1);
+
+            var ret = GetListFrom(m_EmptyMgr);
+            Assert.IsNotEmpty(ret);
+            Assert.AreEqual(node0.objectId, ret[0].Key);
+            Assert.AreEqual(2, ret[0].Value.Count);
+            Assert.AreEqual(e0, ret[0].Value[0]);
+            Assert.AreEqual(e1, ret[0].Value[1]);
+        }
+
+        [Test]
+        public void DuplicateEntries_AreNotIgnored()
+        {
+            m_EmptyMgr.AddOrAppendError(p0, node0.objectId, e0);
+            m_EmptyMgr.AddOrAppendError(p0, node0.objectId, e0);
+
+            var ret = GetListFrom(m_EmptyMgr);
+            Assert.IsNotEmpty(ret);
+            Assert.AreEqual(node0.objectId, ret[0].Key);
+            Assert.AreEqual(2, ret[0].Value.Count);
+            Assert.AreEqual(e0, ret[0].Value[0]);
+            Assert.AreEqual(e0, ret[0].Value[1]);
+        }
+
+        [Test]
+        public void ClearAllFromProvider_ZerosMessageLists()
+        {
+            m_ComplexMgr.ClearAllFromProvider(p1);
+
+            var ret = GetListFrom(m_ComplexMgr);
+            Assert.IsNotEmpty(ret);
+            Assert.AreEqual(3, ret.Count);
+            Assert.AreEqual(node0.objectId, ret[0].Key);
+            Assert.AreEqual(2, ret[0].Value.Count);
+            Assert.AreEqual(node1.objectId, ret[1].Key);
+            Assert.AreEqual(1, ret[1].Value.Count);
+            Assert.AreEqual(node2.objectId, ret[2].Key);
+            Assert.IsEmpty(ret[2].Value);
+        }
+
+        [Test]
+        public void GetList_RemovesZeroLengthLists()
+        {
+            m_ComplexMgr.ClearAllFromProvider(p1);
+            var ret = GetListFrom(m_ComplexMgr);
+            Assert.IsNotEmpty(ret.Where(kvp => kvp.Key.Equals(node2.objectId)));
+            Assert.IsEmpty(ret.First(kvp => kvp.Key.Equals(node2.objectId)).Value);
+
+            ret = GetListFrom(m_ComplexMgr);
+            Assert.IsEmpty(ret.Where(kvp => kvp.Key.Equals(node2.objectId)));
+        }
+
+        [Test]
+        public void ClearNodesFromProvider_ClearsNodes()
+        {
+            var nodesToClear = new List<AbstractMaterialNode> { node0, node2 };
+            m_ComplexMgr.ClearNodesFromProvider(p1, nodesToClear);
+
+            var ret = GetListFrom(m_ComplexMgr);
+            Assert.AreEqual(2, ret.Find(kpv => kpv.Key.Equals(node0.objectId)).Value.Count);
+            Assert.IsEmpty(ret.Find(kvp => kvp.Key.Equals(node2.objectId)).Value);
+        }
+
+        [Test]
+        public void ClearNodesFromProvider_LeavesOtherNodes()
+        {
+            var nodesToClear = new List<AbstractMaterialNode> { node0, node2 };
+            m_ComplexMgr.ClearNodesFromProvider(p1, nodesToClear);
+
+            var ret = GetListFrom(m_ComplexMgr);
+            Assert.AreEqual(3, ret.Find(kpv => kpv.Key.Equals(node1.objectId)).Value.Count);
+        }
+
+        [Test]
+        public void ReportAnyErrors_EmptyManager()
+        {
+            var ret = m_EmptyMgr.AnyError();
+            Assert.IsFalse(ret);
+        }
+
+        [Test]
+        public void ReportAnyErrors_ComplexManager()
+        {
+            var ret = m_ComplexMgr.AnyError();
+            Assert.IsTrue(ret);
+        }
+
+        [Test]
+        public void ReportAnyErrors_EmptyManager_OnlyWarnings()
+        {
+            m_EmptyMgr.AddOrAppendError(p0, node0.objectId, w0);
+            m_EmptyMgr.AddOrAppendError(p1, node1.objectId, w1);
+
+            var ret = m_EmptyMgr.AnyError();
+            Assert.IsFalse(ret);
+        }
+
+        [Test]
+        public void ReportAnyErrors_EmptyManager_ErrorOneProvider()
+        {
+            m_EmptyMgr.AddOrAppendError(p0, node0.objectId, w0);
+            m_EmptyMgr.AddOrAppendError(p1, node1.objectId, e1);
+
+            var ret = m_EmptyMgr.AnyError();
+            Assert.IsTrue(ret);
+        }
+    }
+}
+
+// m_ComplesMgr definition:
+//    m_ComplexMgr.AddOrAppendError(p0, node0, e0);
+//    m_ComplexMgr.AddOrAppendError(p0, node0, e1);
+//    m_ComplexMgr.AddOrAppendError(p0, node1, e2);
+//    m_ComplexMgr.AddOrAppendError(p1, node0, e1);
+//    m_ComplexMgr.AddOrAppendError(p1, node1, e0);
+//    m_ComplexMgr.AddOrAppendError(p1, node1, e1);
+//    m_ComplexMgr.AddOrAppendError(p1, node2, e3);

Library/PackageCache/com.unity.shadergraph@11.0.0/Tests/Editor/UnitTests/PixelShaderNodeTests.cs

@@ -0,0 +1,61 @@
+using System;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace UnityEditor.ShaderGraph.UnitTests
+{
+    [TestFixture]
+    class PixelShaderNodeTests
+    {
+        /*  private UnityEngine.MaterialGraph.MaterialGraph m_Graph;
+          private Vector1Node m_InputOne;
+          private AbsoluteNode m_Abs;
+          private MetallicMasterNode m_PixelNode;
+
+          [TestFixtureSetUp]
+          public void RunBeforeAnyTests()
+          {
+              Debug.unityLogger.logHandler = new ConsoleLogHandler();
+          }
+
+          [SetUp]
+          public void TestSetUp()
+          {
+              m_Graph = new UnityEngine.MaterialGraph.MaterialGraph();
+              m_PixelNode = new MetallicMasterNode();
+              m_InputOne = new Vector1Node();
+              m_Abs = new AbsoluteNode();
+
+              m_Graph.AddNode(m_PixelNode);
+              m_Graph.AddNode(m_InputOne);
+              m_Graph.AddNode(m_PixelNode);
+              m_Graph.AddNode(m_Abs);
+
+              m_InputOne.value = 0.2f;
+
+              m_Graph.Connect(m_InputOne.GetSlotReference(Vector1Node.OutputSlotId), m_PixelNode.GetSlotReference(AbstractSurfaceMasterNode.NormalSlotId));
+
+              // m_Graph.Connect(m_InputOne.GetSlotReference(Vector1Node.OutputSlotId), m_Abs.GetSlotReference(Function1Input.InputSlotId));
+              //m_Graph.Connect(m_Abs.GetSlotReference(Function1Input.OutputSlotId), m_PixelNode.GetSlotReference(AbstractSurfaceMasterNode.AlbedoSlotId));
+          }
+
+           [Test]
+            public void TestNodeGeneratesCorrectNodeCode()
+            {
+                string expected = string.Format("half {0} = 0.2;" + Environment.NewLine
+                        + "half {1} = abs ({0});" + Environment.NewLine
+                        + "o.Albedo = {1};" + Environment.NewLine
+                        + "o.Normal = {0};" + Environment.NewLine
+                        , m_InputOne.GetVariableNameForSlot(Vector1Node.OutputSlotId)
+                        , m_Abs.GetVariableNameForSlot(Function1Input.OutputSlotId));
+
+                var generator = new ShaderGenerator();
+                m_PixelNode.GenerateNodeCode(generator, GenerationMode.ForReals);
+
+                Console.WriteLine(generator.GetShaderString(0));
+
+                Assert.AreEqual(expected, generator.GetShaderString(0));
+                Assert.AreEqual(string.Empty, generator.GetPragmaString());
+            }*/
+    }
+}

Library/PackageCache/com.unity.shadergraph@11.0.0/Tests/Editor/UnitTests/PropertyChunkTests.cs

@@ -0,0 +1,113 @@
+using UnityEngine;
+
+namespace UnityEditor.ShaderGraph.UnitTests
+{
+    /*   [TestFixture]
+       public class PropertyChunkTests
+       {
+           class TestPropertyChunch : PropertyChunk
+           {
+               public TestPropertyChunch(string propertyName, string propertyDescription, HideState hideState)
+                   : base(propertyName, propertyDescription, hideState)
+               {}
+
+               public override string GetPropertyString()
+               {
+                   return propertyName;
+               }
+           }
+
+           [TestFixtureSetUp]
+           public void RunBeforeAnyTests()
+           {
+               Debug.unityLogger.logHandler = new ConsoleLogHandler();
+           }
+
+           [SetUp]
+           public void TestSetUp()
+           {
+           }
+
+           private const string kPropertyName = "ThePropertyName";
+           private const string kPropertyDescription = "ThePropertyDescription";
+
+           [Test]
+           public void TestSimplePropertyChunkIsConstructedProperly()
+           {
+               var chunk = new TestPropertyChunch(kPropertyName, kPropertyDescription, PropertyChunk.HideState.Visible);
+               Assert.AreEqual(kPropertyName, chunk.propertyName);
+               Assert.AreEqual(kPropertyDescription, chunk.propertyDescription);
+               Assert.AreEqual(kPropertyName, chunk.GetPropertyString());
+               Assert.AreEqual(PropertyChunk.HideState.Visible, chunk.hideState);
+           }
+
+           [Test]
+           public void TestColorChunkReturnsValidValues()
+           {
+               var expectedPropertyString = "ThePropertyName(\"ThePropertyDescription\", Color) = (1,0,0,1)";
+               var chunk = new ColorPropertyChunk(kPropertyName, kPropertyDescription, Color.red, ColorPropertyChunk.ColorType.Default, PropertyChunk.HideState.Visible);
+               Assert.AreEqual(kPropertyName, chunk.propertyName);
+               Assert.AreEqual(kPropertyDescription, chunk.propertyDescription);
+               Assert.AreEqual(expectedPropertyString, chunk.GetPropertyString());
+               Assert.AreEqual(Color.red, chunk.defaultColor);
+               Assert.AreEqual(PropertyChunk.HideState.Visible, chunk.hideState);
+           }
+
+           [Test]
+           public void TestFloatChunkReturnsValidValues()
+           {
+               var expectedPropertyString = "ThePropertyName(\"ThePropertyDescription\", Float) = 0.5";
+               var chunk = new FloatPropertyChunk(kPropertyName, kPropertyDescription, 0.5f, PropertyChunk.HideState.Visible);
+               Assert.AreEqual(kPropertyName, chunk.propertyName);
+               Assert.AreEqual(kPropertyDescription, chunk.propertyDescription);
+               Assert.AreEqual(expectedPropertyString, chunk.GetPropertyString());
+               Assert.AreEqual(0.5f, chunk.defaultValue);
+               Assert.AreEqual(PropertyChunk.HideState.Visible, chunk.hideState);
+           }
+
+           [Test]
+           public void TestVectorChunkReturnsValidValues()
+           {
+               var vector = new Vector4(0.2f, 0.4f, 0.66f, 1.0f);
+               var expectedPropertyString = "ThePropertyName(\"ThePropertyDescription\", Vector) = (0.2,0.4,0.66,1)";
+               var chunk = new VectorPropertyChunk(kPropertyName, kPropertyDescription, vector, PropertyChunk.HideState.Visible);
+               Assert.AreEqual(kPropertyName, chunk.propertyName);
+               Assert.AreEqual(kPropertyDescription, chunk.propertyDescription);
+               Assert.AreEqual(expectedPropertyString, chunk.GetPropertyString());
+               Assert.AreEqual(vector, chunk.defaultValue);
+               Assert.AreEqual(PropertyChunk.HideState.Visible, chunk.hideState);
+           }
+
+           [Test]
+           public void TestTextureChunkReturnsValidValues()
+           {
+               var expectedPropertyString = "ThePropertyName(\"ThePropertyDescription\", 2D) = \"bump\" {}";
+               var chunk = new TexturePropertyChunk(kPropertyName, kPropertyDescription, null, TextureType.Bump, PropertyChunk.HideState.Visible, TexturePropertyChunk.ModifiableState.Modifiable);
+               Assert.AreEqual(kPropertyName, chunk.propertyName);
+               Assert.AreEqual(kPropertyDescription, chunk.propertyDescription);
+               Assert.AreEqual(expectedPropertyString, chunk.GetPropertyString());
+               Assert.AreEqual(null, chunk.defaultTexture);
+               Assert.AreEqual(PropertyChunk.HideState.Visible, chunk.hideState);
+           }
+
+           [Test]
+           public void TestTexturePropertyChunkGeneratesValidPropertyStringVisibleNotModifiable()
+           {
+               var expectedPropertyString = "[NonModifiableTextureData] ThePropertyName(\"ThePropertyDescription\", 2D) = \"gray\" {}";
+               var chunk = new TexturePropertyChunk(kPropertyName, kPropertyDescription, null, TextureType.Gray, PropertyChunk.HideState.Visible, TexturePropertyChunk.ModifiableState.NonModifiable);
+               Assert.AreEqual(expectedPropertyString, chunk.GetPropertyString());
+               Assert.AreEqual(TexturePropertyChunk.ModifiableState.NonModifiable, chunk.modifiableState);
+               Assert.AreEqual(PropertyChunk.HideState.Visible, chunk.hideState);
+           }
+
+           [Test]
+           public void TestTexturePropertyChunkGeneratesValidPropertyStringHiddenNotModifiable()
+           {
+               var expectedPropertyString = "[HideInInspector] [NonModifiableTextureData] ThePropertyName(\"ThePropertyDescription\", 2D) = \"white\" {}";
+               var chunk = new TexturePropertyChunk(kPropertyName, kPropertyDescription, null, TextureType.White, PropertyChunk.HideState.Hidden, TexturePropertyChunk.ModifiableState.NonModifiable);
+               Assert.AreEqual(expectedPropertyString, chunk.GetPropertyString());
+               Assert.AreEqual(TexturePropertyChunk.ModifiableState.NonModifiable, chunk.modifiableState);
+               Assert.AreEqual(PropertyChunk.HideState.Hidden, chunk.hideState);
+           }
+       }*/
+}

Library/PackageCache/com.unity.shadergraph@11.0.0/Tests/Editor/UnitTests/PropertyGeneratorTests.cs

@@ -0,0 +1,54 @@
+using UnityEngine;
+
+namespace UnityEditor.ShaderGraph.UnitTests
+{
+    /*
+   [TestFixture]
+   public class PropertyGeneratorTests
+   {
+       [OneTimeSetUp]
+       public void RunBeforeAnyTests()
+       {
+           Debug.unityLogger.logHandler = new ConsoleLogHandler();
+       }
+
+       private const string kPropertyName = "ThePropertyName";
+       private const string kPropertyDescription = "ThePropertyDescription";
+
+     [Test]
+       public void TestCanAddPropertyChunkToPropertyGenerator()
+       {
+           var chunk = new FloatPropertyChunk(kPropertyName, kPropertyDescription, 0.5f, PropertyChunk.HideState.Visible);
+           var generator = new PropertyCollector();
+           generator.AddShaderProperty(chunk);
+
+           Assert.AreNotEqual(string.Empty, generator.GetPropertiesBlock(0));
+       }
+
+       [Test]
+       public void TestCanGetShaderStringWithIndentWorks()
+       {
+           var chunk = new FloatPropertyChunk(kPropertyName, kPropertyDescription, 0.5f, PropertyChunk.HideState.Visible);
+           var generator = new PropertyCollector();
+           generator.AddShaderProperty(chunk);
+
+           Assert.AreEqual(0, generator.GetPropertiesBlock(0).Count(x => x == '\t'));
+           Assert.AreEqual(1, generator.GetPropertiesBlock(1).Count(x => x == '\t'));
+           Assert.AreEqual(2, generator.GetPropertiesBlock(2).Count(x => x == '\t'));
+       }
+
+       [Test]
+       public void TestCanGetConfiguredTextureInfos()
+       {
+           var chunk = new TexturePropertyChunk(kPropertyName, kPropertyDescription, null, TextureType.Bump, PropertyChunk.HideState.Visible, TexturePropertyChunk.ModifiableState.Modifiable);
+           var generator = new PropertyCollector();
+           generator.AddShaderProperty(chunk);
+
+           var infos = generator.GetConfiguredTexutres();
+           Assert.AreEqual(1, infos.Count);
+           Assert.AreEqual(kPropertyName, infos[0].name);
+           Assert.AreEqual(0, infos[0].textureId);
+           Assert.AreEqual(TexturePropertyChunk.ModifiableState.Modifiable, infos[0].modifiable);
+       }
+}*/
+}

Library/PackageCache/com.unity.shadergraph@11.0.0/Tests/Editor/UnitTests/PropertyNodeTests.cs

@@ -0,0 +1,522 @@
+using System;
+using UnityEngine;
+
+namespace UnityEditor.ShaderGraph.UnitTests
+{
+    /*  [TestFixture]
+      public class PropertyNodeTests
+      {
+          private class TestPropertyNode : PropertyNode
+          {
+              public const string TestPropertyName = "TestName";
+
+              public override PropertyType propertyType
+              {
+                  get { return PropertyType.Float; }
+              }
+
+              public override PreviewProperty GetPreviewProperty()
+              {
+                  return new PreviewProperty()
+                  {
+                      m_Name = TestPropertyName
+                  };
+              }
+          }
+
+          private UnityEngine.MaterialGraph.MaterialGraph m_Graph;
+          private Vector1Node m_Vector1Node;
+          private Vector2Node m_Vector2Node;
+          private Vector3Node m_Vector3Node;
+          private Vector4Node m_Vector4Node;
+          private ColorNode m_ColorNode;
+  //        private Texture2DNode m_TextureNode;
+          private TestPropertyNode m_PropertyNode;
+
+          private const string kPropertyName = "PropertyName";
+          public const string kDescription = "NewDescription";
+
+          [TestFixtureSetUp]
+          public void RunBeforeAnyTests()
+          {
+              Debug.unityLogger.logHandler = new ConsoleLogHandler();
+          }
+
+          [SetUp]
+          public void TestSetUp()
+          {
+              m_Graph = new UnityEngine.MaterialGraph.MaterialGraph();
+              m_Vector1Node = new Vector1Node();
+              m_Vector2Node = new Vector2Node();
+              m_Vector3Node = new Vector3Node();
+              m_Vector4Node = new Vector4Node();
+              m_ColorNode = new ColorNode();
+             // m_TextureNode = new Texture2DNode();
+              m_PropertyNode = new TestPropertyNode();
+
+              m_Graph.AddNode(m_Vector1Node);
+              m_Graph.AddNode(m_Vector2Node);
+              m_Graph.AddNode(m_Vector3Node);
+              m_Graph.AddNode(m_Vector4Node);
+              m_Graph.AddNode(m_ColorNode);
+              m_Graph.AddNode(m_TextureNode);
+              m_Graph.AddNode(m_PropertyNode);
+          }
+
+          /*  [Test]
+            public void TestExposedPropertyReturnsRawName()
+            {
+                m_PropertyNode.exposedState = PropertyNode.ExposedState.Exposed;
+                m_PropertyNode.propertyName = kPropertyName;
+                Assert.AreEqual(kPropertyName + "_Uniform", m_PropertyNode.propertyName);
+            }
+
+            [Test]
+            public void TestNonExposedPropertyReturnsGeneratedName()
+            {
+                var expected = string.Format("{0}_{1}_Uniform", m_PropertyNode.name, m_PropertyNode.guid.ToString().Replace("-", "_"));
+                m_PropertyNode.exposedState = PropertyNode.ExposedState.NotExposed;
+                m_PropertyNode.propertyName = kPropertyName;
+
+                Assert.AreEqual(expected, m_PropertyNode.propertyName);
+            }
+
+            [Test]
+            public void TestPropertyNodeDescriptionWorks()
+            {
+                m_PropertyNode.propertyName = kPropertyName;
+                m_PropertyNode.description = kDescription;
+                Assert.AreEqual(kDescription, m_PropertyNode.description);
+            }
+
+            [Test]
+            public void TestPropertyNodeDescriptionReturnsPropertyNameWhenNoDescriptionSet()
+            {
+                m_PropertyNode.propertyName = kPropertyName;
+                m_PropertyNode.description = string.Empty;
+                Assert.AreEqual(kPropertyName, m_PropertyNode.description);
+            }
+
+            [Test]
+            public void TestPropertyNodeReturnsPreviewProperty()
+            {
+                var props = new List<PreviewProperty>();
+                m_PropertyNode.CollectPreviewMaterialProperties(props);
+                Assert.AreEqual(props.Count, 1);
+                Assert.AreEqual(TestPropertyNode.TestPropertyName, props[0].m_Name);
+            }
+
+            [Test]
+            public void TestDuplicatedPropertyNameGeneratesErrorWhenExposed()
+            {
+                const string failName = "SameName";
+
+                m_Vector1Node.exposedState = PropertyNode.ExposedState.Exposed;
+                m_Vector1Node.propertyName = failName;
+                m_Vector2Node.exposedState = PropertyNode.ExposedState.Exposed;
+                m_Vector2Node.propertyName = failName;
+
+                m_Vector1Node.ValidateNode();
+                m_Vector2Node.ValidateNode();
+                Assert.IsTrue(m_Vector1Node.hasError);
+                Assert.IsTrue(m_Vector2Node.hasError);
+            }
+
+            [Test]
+            public void TestDuplicatedPropertyNameGeneratesNoErrorWhenNotExposed()
+            {
+                const string failName = "SameName";
+
+                m_Vector1Node.exposedState = PropertyNode.ExposedState.NotExposed;
+                m_Vector1Node.propertyName = failName;
+                m_Vector2Node.exposedState = PropertyNode.ExposedState.Exposed;
+                m_Vector2Node.propertyName = failName;
+
+                m_Vector1Node.ValidateNode();
+                m_Vector2Node.ValidateNode();
+                Assert.IsFalse(m_Vector1Node.hasError);
+                Assert.IsFalse(m_Vector2Node.hasError);
+            }*
+
+          [Test]
+          public void TestPropertyExposedOnSubgraphReturnsFalse()
+          {
+              var subGraph = new SubGraph();
+              var subNode = new TestPropertyNode();
+              subNode.exposedState = PropertyNode.ExposedState.Exposed;
+              subGraph.AddNode(subNode);
+              Assert.AreEqual(PropertyNode.ExposedState.NotExposed, subNode.exposedState);
+
+              m_PropertyNode.exposedState = PropertyNode.ExposedState.Exposed;
+              Assert.AreEqual(PropertyNode.ExposedState.Exposed, m_PropertyNode.exposedState);
+          }
+
+          [Test]
+          public void TestVector1NodeTypeIsCorrect()
+          {
+              Assert.AreEqual(PropertyType.Float, m_Vector1Node.propertyType);
+          }
+
+          [Test]
+          public void TestVector1NodeReturnsCorrectValue()
+          {
+              m_Vector1Node.value = 0.6f;
+              Assert.AreEqual(0.6f, m_Vector1Node.value);
+          }
+
+          [Test]
+          public void TestVector1NodeReturnsPreviewProperty()
+          {
+              var props = new List<PreviewProperty>();
+              m_Vector1Node.value = 0.6f;
+              m_Vector1Node.CollectPreviewMaterialProperties(props);
+              Assert.AreEqual(props.Count, 1);
+              Assert.AreEqual(m_Vector1Node.propertyName, props[0].m_Name);
+              Assert.AreEqual(m_Vector1Node.propertyType, props[0].m_PropType);
+              Assert.AreEqual(0.6f, props[0].m_Float);
+          }
+
+          [Test]
+          public void TestVector1NodeGeneratesCorrectPropertyBlock()
+          {
+              m_Vector1Node.value = 0.6f;
+              m_Vector1Node.exposedState = PropertyNode.ExposedState.NotExposed;
+              var generator = new PropertyGenerator();
+              m_Vector1Node.GeneratePropertyBlock(generator, GenerationMode.ForReals);
+              Assert.AreEqual(string.Empty, generator.GetShaderString(0));
+
+              var expected = m_Vector1Node.propertyName
+                  + "(\""
+                  + m_Vector1Node.description
+                  + "\", Float) = "
+                  + m_Vector1Node.value
+                  + Environment.NewLine;
+
+              m_Vector1Node.exposedState = PropertyNode.ExposedState.Exposed;
+              m_Vector1Node.GeneratePropertyBlock(generator, GenerationMode.ForReals);
+              Assert.AreEqual(expected, generator.GetShaderString(0));
+          }
+
+          [Test]
+          public void TestVector1NodeGeneratesCorrectPropertyUsages()
+          {
+              m_Vector1Node.value = 0.6f;
+              m_Vector1Node.exposedState = PropertyNode.ExposedState.NotExposed;
+              var generator = new ShaderGenerator();
+              m_Vector1Node.GeneratePropertyUsages(generator, GenerationMode.ForReals);
+              Assert.AreEqual(string.Empty, generator.GetShaderString(0));
+
+              var expected = m_Vector1Node.precision
+                  + " "
+                  + m_Vector1Node.propertyName
+                  + ";"
+                  + Environment.NewLine;
+
+              m_Vector1Node.exposedState = PropertyNode.ExposedState.Exposed;
+              m_Vector1Node.GeneratePropertyUsages(generator, GenerationMode.ForReals);
+              Assert.AreEqual(expected, generator.GetShaderString(0));
+          }
+
+          [Test]
+          public void TestVector2NodeTypeIsCorrect()
+          {
+              Assert.AreEqual(PropertyType.Vector2, m_Vector2Node.propertyType);
+          }
+
+          [Test]
+          public void TestVector2NodeReturnsCorrectValue()
+          {
+              var value = new Vector2(0.6f, 0.7f);
+              m_Vector2Node.value = value;
+              Assert.AreEqual(value, m_Vector2Node.value);
+          }
+
+          [Test]
+          public void TestVector2NodeReturnsPreviewProperty()
+          {
+              var value = new Vector2(0.6f, 0.7f);
+              var props = new List<PreviewProperty>();
+              m_Vector2Node.value = value;
+              m_Vector2Node.CollectPreviewMaterialProperties(props);
+              Assert.AreEqual(props.Count, 1);
+              Assert.AreEqual(m_Vector2Node.propertyName, props[0].m_Name);
+              Assert.AreEqual(m_Vector2Node.propertyType, props[0].m_PropType);
+              Assert.AreEqual(value, m_Vector2Node.value);
+          }
+
+          [Test]
+          public void TestVector2NodeGeneratesCorrectPropertyBlock()
+          {
+              var value = new Vector2(0.6f, 0.7f);
+              m_Vector2Node.value = value;
+              m_Vector2Node.exposedState = PropertyNode.ExposedState.NotExposed;
+              var generator = new PropertyGenerator();
+              m_Vector2Node.GeneratePropertyBlock(generator, GenerationMode.ForReals);
+              Assert.AreEqual(string.Empty, generator.GetShaderString(0));
+
+              var expected = m_Vector2Node.propertyName
+                  + "(\""
+                  + m_Vector2Node.description
+                  + "\", Vector) = ("
+                  + m_Vector2Node.value.x
+                  + ","
+                  + m_Vector2Node.value.y
+                  + ",0,0)"
+                  + Environment.NewLine;
+
+              m_Vector2Node.exposedState = PropertyNode.ExposedState.Exposed;
+              m_Vector2Node.GeneratePropertyBlock(generator, GenerationMode.ForReals);
+              Assert.AreEqual(expected, generator.GetShaderString(0));
+          }
+
+          [Test]
+          public void TestVector2NodeGeneratesCorrectPropertyUsages()
+          {
+              var value = new Vector2(0.6f, 0.7f);
+              m_Vector2Node.value = value;
+              m_Vector2Node.exposedState = PropertyNode.ExposedState.NotExposed;
+              var generator = new ShaderGenerator();
+              m_Vector2Node.GeneratePropertyUsages(generator, GenerationMode.ForReals);
+              Assert.AreEqual(string.Empty, generator.GetShaderString(0));
+
+              var expected = m_Vector2Node.precision
+                  + "2 "
+                  + m_Vector2Node.propertyName
+                  + ";"
+                  + Environment.NewLine;
+
+              m_Vector2Node.exposedState = PropertyNode.ExposedState.Exposed;
+              m_Vector2Node.GeneratePropertyUsages(generator, GenerationMode.ForReals);
+              Assert.AreEqual(expected, generator.GetShaderString(0));
+          }
+
+          [Test]
+          public void TestVector3NodeTypeIsCorrect()
+          {
+              Assert.AreEqual(PropertyType.Vector3, m_Vector3Node.propertyType);
+          }
+
+          [Test]
+          public void TestVector3NodeReturnsCorrectValue()
+          {
+              var value = new Vector3(0.6f, 0.7f, 0.4f);
+              m_Vector3Node.value = value;
+              Assert.AreEqual(value, m_Vector3Node.value);
+          }
+
+          [Test]
+          public void TestVector3NodeReturnsPreviewProperty()
+          {
+              var value = new Vector3(0.6f, 0.7f, 0.4f);
+              var props = new List<PreviewProperty>();
+              m_Vector3Node.value = value;
+              m_Vector3Node.CollectPreviewMaterialProperties(props);
+              Assert.AreEqual(props.Count, 1);
+              Assert.AreEqual(m_Vector3Node.propertyName, props[0].m_Name);
+              Assert.AreEqual(m_Vector3Node.propertyType, props[0].m_PropType);
+              Assert.AreEqual(value, m_Vector3Node.value);
+          }
+
+          [Test]
+          public void TestVector3NodeGeneratesCorrectPropertyBlock()
+          {
+              var value = new Vector3(0.6f, 0.7f, 0.4f);
+              m_Vector3Node.value = value;
+              m_Vector3Node.exposedState = PropertyNode.ExposedState.NotExposed;
+              var generator = new PropertyGenerator();
+              m_Vector3Node.GeneratePropertyBlock(generator, GenerationMode.ForReals);
+              Assert.AreEqual(string.Empty, generator.GetShaderString(0));
+
+              var expected = m_Vector3Node.propertyName
+                  + "(\""
+                  + m_Vector3Node.description
+                  + "\", Vector) = ("
+                  + m_Vector3Node.value.x
+                  + ","
+                  + m_Vector3Node.value.y
+                  + ","
+                  + m_Vector3Node.value.z
+                  + ",0)"
+                  + Environment.NewLine;
+
+              m_Vector3Node.exposedState = PropertyNode.ExposedState.Exposed;
+              m_Vector3Node.GeneratePropertyBlock(generator, GenerationMode.ForReals);
+              Assert.AreEqual(expected, generator.GetShaderString(0));
+          }
+
+          [Test]
+          public void TestVector3NodeGeneratesCorrectPropertyUsages()
+          {
+              var value = new Vector3(0.6f, 0.7f, 0.4f);
+              m_Vector3Node.value = value;
+              m_Vector3Node.exposedState = PropertyNode.ExposedState.NotExposed;
+              var generator = new ShaderGenerator();
+              m_Vector3Node.GeneratePropertyUsages(generator, GenerationMode.ForReals);
+              Assert.AreEqual(string.Empty, generator.GetShaderString(0));
+
+              var expected = m_Vector3Node.precision
+                  + "3 "
+                  + m_Vector3Node.propertyName
+                  + ";"
+                  + Environment.NewLine;
+
+              m_Vector3Node.exposedState = PropertyNode.ExposedState.Exposed;
+              m_Vector3Node.GeneratePropertyUsages(generator, GenerationMode.ForReals);
+              Assert.AreEqual(expected, generator.GetShaderString(0));
+          }
+
+          [Test]
+          public void TestVector4NodeTypeIsCorrect()
+          {
+              Assert.AreEqual(PropertyType.Vector4, m_Vector4Node.propertyType);
+          }
+
+          [Test]
+          public void TestVector4NodeReturnsCorrectValue()
+          {
+              var value = new Vector4(0.6f, 0.7f, 0.4f, 0.3f);
+              m_Vector4Node.value = value;
+              Assert.AreEqual(value, m_Vector4Node.value);
+          }
+
+          [Test]
+          public void TestVector4NodeReturnsPreviewProperty()
+          {
+              var value = new Vector4(0.6f, 0.7f, 0.4f, 0.3f);
+              var props = new List<PreviewProperty>();
+              m_Vector4Node.value = value;
+              m_Vector4Node.CollectPreviewMaterialProperties(props);
+              Assert.AreEqual(props.Count, 1);
+              Assert.AreEqual(m_Vector4Node.propertyName, props[0].m_Name);
+              Assert.AreEqual(m_Vector4Node.propertyType, props[0].m_PropType);
+              Assert.AreEqual(value, m_Vector4Node.value);
+          }
+
+          [Test]
+          public void TestVector4NodeGeneratesCorrectPropertyBlock()
+          {
+              var value = new Vector4(0.6f, 0.7f, 0.4f, 0.3f);
+              m_Vector4Node.value = value;
+              m_Vector4Node.exposedState = PropertyNode.ExposedState.NotExposed;
+              var generator = new PropertyGenerator();
+              m_Vector4Node.GeneratePropertyBlock(generator, GenerationMode.ForReals);
+              Assert.AreEqual(string.Empty, generator.GetShaderString(0));
+
+              var expected = m_Vector4Node.propertyName
+                  + "(\""
+                  + m_Vector4Node.description
+                  + "\", Vector) = ("
+                  + m_Vector4Node.value.x
+                  + ","
+                  + m_Vector4Node.value.y
+                  + ","
+                  + m_Vector4Node.value.z
+                  + ","
+                  + m_Vector4Node.value.w
+                  + ")"
+                  + Environment.NewLine;
+
+              m_Vector4Node.exposedState = PropertyNode.ExposedState.Exposed;
+              m_Vector4Node.GeneratePropertyBlock(generator, GenerationMode.ForReals);
+              Assert.AreEqual(expected, generator.GetShaderString(0));
+          }
+
+          [Test]
+          public void TestVector4NodeGeneratesCorrectPropertyUsages()
+          {
+              var value = new Vector4(0.6f, 0.7f, 0.4f, 0.3f);
+              m_Vector4Node.value = value;
+              m_Vector4Node.exposedState = PropertyNode.ExposedState.NotExposed;
+              var generator = new ShaderGenerator();
+              m_Vector4Node.GeneratePropertyUsages(generator, GenerationMode.ForReals);
+              Assert.AreEqual(string.Empty, generator.GetShaderString(0));
+
+              var expected = m_Vector4Node.precision
+                  + "4 "
+                  + m_Vector4Node.propertyName
+                  + ";"
+                  + Environment.NewLine;
+
+              m_Vector4Node.exposedState = PropertyNode.ExposedState.Exposed;
+              m_Vector4Node.GeneratePropertyUsages(generator, GenerationMode.ForReals);
+              Assert.AreEqual(expected, generator.GetShaderString(0));
+          }
+
+          [Test]
+          public void TestColorNodeTypeIsCorrect()
+          {
+              Assert.AreEqual(PropertyType.Color, m_ColorNode.propertyType);
+          }
+
+          [Test]
+          public void TestColorNodeReturnsCorrectValue()
+          {
+              var value = new Color(0.6f, 0.7f, 0.4f, 0.3f);
+              m_ColorNode.color = value;
+              Assert.AreEqual(value, m_ColorNode.color);
+          }
+
+          [Test]
+          public void TestColorNodeReturnsPreviewProperty()
+          {
+              var value = new Color(0.6f, 0.7f, 0.4f, 0.3f);
+              var props = new List<PreviewProperty>();
+              m_ColorNode.color = value;
+              m_ColorNode.CollectPreviewMaterialProperties(props);
+              Assert.AreEqual(props.Count, 1);
+              Assert.AreEqual(m_ColorNode.propertyName, props[0].m_Name);
+              Assert.AreEqual(m_ColorNode.propertyType, props[0].m_PropType);
+              Assert.AreEqual(value, m_ColorNode.color);
+          }
+
+          [Test]
+          public void TestColorNodeGeneratesCorrectPropertyBlock()
+          {
+              var value = new Color(0.6f, 0.7f, 0.4f, 0.3f);
+              m_ColorNode.color = value;
+              m_ColorNode.exposedState = PropertyNode.ExposedState.NotExposed;
+              var generator = new PropertyGenerator();
+              m_ColorNode.GeneratePropertyBlock(generator, GenerationMode.ForReals);
+              Assert.AreEqual(string.Empty, generator.GetShaderString(0));
+
+              var expected = m_ColorNode.propertyName
+                  + "(\""
+                  + m_ColorNode.description
+                  + "\", Color) = ("
+                  + m_ColorNode.color.r
+                  + ","
+                  + m_ColorNode.color.g
+                  + ","
+                  + m_ColorNode.color.b
+                  + ","
+                  + m_ColorNode.color.a
+                  + ")"
+                  + Environment.NewLine;
+
+              m_ColorNode.exposedState = PropertyNode.ExposedState.Exposed;
+              m_ColorNode.GeneratePropertyBlock(generator, GenerationMode.ForReals);
+              Assert.AreEqual(expected, generator.GetShaderString(0));
+          }
+
+          [Test]
+          public void TestColorNodeGeneratesCorrectPropertyUsages()
+          {
+              var value = new Color(0.6f, 0.7f, 0.4f, 0.3f);
+              m_ColorNode.color = value;
+              m_ColorNode.exposedState = PropertyNode.ExposedState.NotExposed;
+              var generator = new ShaderGenerator();
+              m_ColorNode.GeneratePropertyUsages(generator, GenerationMode.ForReals);
+              Assert.AreEqual(string.Empty, generator.GetShaderString(0));
+
+              var expected = m_ColorNode.precision
+                  + "4 "
+                  + m_ColorNode.propertyName
+                  + ";"
+                  + Environment.NewLine;
+
+              m_ColorNode.exposedState = PropertyNode.ExposedState.Exposed;
+              m_ColorNode.GeneratePropertyUsages(generator, GenerationMode.ForReals);
+              Assert.AreEqual(expected, generator.GetShaderString(0));
+          }
+      }*/
+}

Library/PackageCache/com.unity.shadergraph@11.0.0/Tests/Editor/UnitTests/SerializedGraphTests.cs

@@ -0,0 +1,668 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEditor.ShaderGraph;
+
+namespace UnityEditor.Graphing.UnitTests
+{
+    [TestFixture]
+    public class BaseMaterialGraphTests
+    {
+        [OneTimeSetUp]
+        public void RunBeforeAnyTests()
+        {
+            Debug.unityLogger.logHandler = new ConsoleLogHandler();
+        }
+
+        [Test]
+        public void TestCanCreateBaseMaterialGraph()
+        {
+            var graph = new GraphData();
+
+            Assert.AreEqual(0, graph.edges.Count());
+            Assert.AreEqual(0, graph.GetNodes<AbstractMaterialNode>().Count());
+        }
+
+        [Test]
+        public void TestCanAddNodeToBaseMaterialGraph()
+        {
+            var graph = new GraphData();
+            var node = new TestNode();
+            node.name = "Test Node";
+            graph.AddNode(node);
+
+            Assert.AreEqual(1, graph.GetNodes<AbstractMaterialNode>().Count());
+            Assert.AreEqual("Test Node", graph.GetNodes<AbstractMaterialNode>().FirstOrDefault().name);
+            Assert.AreEqual(graph, node.owner);
+        }
+
+        [Test]
+        public void TestCanRemoveNodeFromBaseMaterialGraph()
+        {
+            var graph = new GraphData();
+            var node = new TestNode();
+            node.name = "Test Node";
+            graph.AddNode(node);
+            Assert.AreEqual(1, graph.GetNodes<AbstractMaterialNode>().Count());
+
+            graph.RemoveNode(graph.GetNodes<AbstractMaterialNode>().FirstOrDefault());
+            Assert.AreEqual(0, graph.GetNodes<AbstractMaterialNode>().Count());
+        }
+
+        [Test]
+        public void TestCanModifyNodeDrawState()
+        {
+            var node = new TestNode();
+            node.name = "Test Node";
+
+            var drawState = node.drawState;
+            var newPos = new Rect(10, 10, 0, 0);
+            drawState.position = newPos;
+            drawState.expanded = false;
+            node.drawState = drawState;
+
+            Assert.AreEqual(drawState, node.drawState);
+            Assert.AreEqual(newPos, node.drawState.position);
+            Assert.IsFalse(node.drawState.expanded);
+        }
+
+        class SetErrorNode : TestNode
+        {
+            public void SetError()
+            {
+                hasError = true;
+            }
+
+            public void ClearError()
+            {
+                hasError = false;
+            }
+        }
+
+        [Test]
+        public void TestChildClassCanModifyErrorState()
+        {
+            var node = new SetErrorNode();
+            node.SetError();
+            Assert.IsTrue(node.hasError);
+            node.ClearError();
+            Assert.IsFalse(node.hasError);
+        }
+
+        class TestableNode : TestNode
+        {
+            public const int Input0 = 0;
+            public const int Input1 = 1;
+            public const int Input2 = 2;
+
+            public const int Output0 = 3;
+            public const int Output1 = 4;
+            public const int Output2 = 5;
+
+            public TestableNode() : base()
+            {
+                AddSlot(new TestSlot(Input0, "Input", SlotType.Input));
+                AddSlot(new TestSlot(Input1, "Input", SlotType.Input));
+                AddSlot(new TestSlot(Input2, "Input", SlotType.Input));
+
+                AddSlot(new TestSlot(Output0, "Output", SlotType.Output));
+                AddSlot(new TestSlot(Output1, "Output", SlotType.Output));
+                AddSlot(new TestSlot(Output2, "Output", SlotType.Output));
+            }
+        }
+
+        [Test]
+        public void TestRemoveNodeFromBaseMaterialGraphCleansEdges()
+        {
+            var graph = new GraphData();
+            var outputNode = new TestableNode();
+            graph.AddNode(outputNode);
+
+            var inputNode = new TestableNode();
+            graph.AddNode(inputNode);
+
+            Assert.AreEqual(2, graph.GetNodes<AbstractMaterialNode>().Count());
+            var createdEdge = graph.Connect(outputNode.GetSlotReference(TestableNode.Output0), inputNode.GetSlotReference(TestableNode.Input0));
+            Assert.AreEqual(1, graph.edges.Count());
+
+            var edge = graph.edges.FirstOrDefault();
+
+            Assert.AreEqual(createdEdge, edge);
+
+            graph.RemoveNode(outputNode);
+
+            Assert.AreEqual(1, graph.GetNodes<AbstractMaterialNode>().Count());
+            Assert.AreEqual(0, graph.edges.Count());
+            Assert.AreEqual(inputNode, graph.GetNodes<AbstractMaterialNode>().FirstOrDefault());
+        }
+
+        private class NoDeleteNode : TestNode
+        {
+            public override bool canDeleteNode { get { return false; } }
+        }
+
+        [Test]
+        public void TestCanNotRemoveNoDeleteNodeFromBaseMaterialGraph()
+        {
+            var graph = new GraphData();
+            var node = new NoDeleteNode();
+            node.name = "Test Node";
+            graph.AddNode(node);
+            Assert.AreEqual(1, graph.GetNodes<AbstractMaterialNode>().Count());
+            Assert.Catch<InvalidOperationException>(() => graph.RemoveNode(node));
+            Assert.AreEqual(1, graph.GetNodes<AbstractMaterialNode>().Count());
+        }
+
+        private class OnEnableNode : TestNode, IOnAssetEnabled
+        {
+            public bool called = false;
+            public void OnEnable()
+            {
+                called = true;
+            }
+        }
+
+        [Test]
+        public void TestSerializedGraphDelegatesOnEnableCalls()
+        {
+            var graph = new GraphData();
+            var node = new OnEnableNode();
+            node.name = "Test Node";
+            graph.AddNode(node);
+
+            Assert.IsFalse(node.called);
+            graph.OnEnable();
+            Assert.IsTrue(node.called);
+        }
+
+        [Test]
+        public void TestCanFindNodeInBaseMaterialGraph()
+        {
+            var graph = new GraphData();
+            var node = new TestNode();
+            graph.AddNode(node);
+
+            Assert.AreEqual(1, graph.GetNodes<AbstractMaterialNode>().Count());
+            Assert.IsNotNull(graph.GetNodeFromId(node.objectId));
+            Assert.IsNull(graph.GetNodeFromId("asdfffsd"));
+        }
+
+        [Test]
+        public void TestCanAddSlotToTestNode()
+        {
+            var graph = new GraphData();
+            var node = new TestNode();
+            node.AddSlot(new TestSlot(0, "output", SlotType.Output));
+            node.AddSlot(new TestSlot(1, "input", SlotType.Input));
+            node.name = "Test Node";
+            graph.AddNode(node);
+
+            Assert.AreEqual(1, graph.GetNodes<AbstractMaterialNode>().Count());
+            var found = graph.GetNodes<AbstractMaterialNode>().FirstOrDefault();
+            Assert.AreEqual(1, found.GetInputSlots<MaterialSlot>().Count());
+            Assert.AreEqual(1, found.GetInputSlots<MaterialSlot>().FirstOrDefault().id);
+            Assert.AreEqual(1, found.GetOutputSlots<MaterialSlot>().Count());
+            Assert.AreEqual(0, found.GetOutputSlots<MaterialSlot>().FirstOrDefault().id);
+            Assert.AreEqual(2, found.GetSlots<MaterialSlot>().Count());
+        }
+
+        [Test]
+        public void TestCanNotAddNullSlotToTestNode()
+        {
+            var node = new TestNode();
+            Assert.Throws<ArgumentException>(() => node.AddSlot(null));
+        }
+
+        [Test]
+        public void TestCanRemoveSlotFromTestNode()
+        {
+            var graph = new GraphData();
+            var node = new TestNode();
+            node.AddSlot(new TestSlot(0, "output", SlotType.Output));
+            node.AddSlot(new TestSlot(1, "input", SlotType.Input));
+            graph.AddNode(node);
+
+            Assert.AreEqual(2, node.GetSlots<MaterialSlot>().Count());
+            Assert.AreEqual(1, node.GetInputSlots<MaterialSlot>().Count());
+            Assert.AreEqual(1, node.GetOutputSlots<MaterialSlot>().Count());
+
+            node.RemoveSlot(1);
+
+            Assert.AreEqual(1, node.GetSlots<MaterialSlot>().Count());
+            Assert.AreEqual(0, node.GetInputSlots<MaterialSlot>().Count());
+            Assert.AreEqual(1, node.GetOutputSlots<MaterialSlot>().Count());
+        }
+
+        [Test]
+        public void TestCanRemoveSlotsWithNonMathingNameFromTestNode()
+        {
+            var graph = new GraphData();
+            var node = new TestableNode();
+            graph.AddNode(node);
+
+            Assert.AreEqual(6, node.GetSlots<MaterialSlot>().Count());
+            Assert.AreEqual(3, node.GetInputSlots<MaterialSlot>().Count());
+            Assert.AreEqual(3, node.GetOutputSlots<MaterialSlot>().Count());
+
+            node.RemoveSlotsNameNotMatching(new[] {TestableNode.Input1});
+
+            Assert.AreEqual(1, node.GetSlots<MaterialSlot>().Count());
+            Assert.AreEqual(1, node.GetInputSlots<MaterialSlot>().Count());
+            Assert.AreEqual(0, node.GetOutputSlots<MaterialSlot>().Count());
+
+            Assert.IsNull(node.FindInputSlot<MaterialSlot>(TestableNode.Input0));
+            Assert.IsNotNull(node.FindInputSlot<MaterialSlot>(TestableNode.Input1));
+            Assert.IsNull(node.FindInputSlot<MaterialSlot>(TestableNode.Input2));
+        }
+
+        [Test]
+        public void TestCanNotAddDuplicateSlotToTestNode()
+        {
+            var graph = new GraphData();
+            var node = new TestNode();
+            node.AddSlot(new TestSlot(0, "output", SlotType.Output));
+            node.AddSlot(new TestSlot(0, "output", SlotType.Output));
+            node.name = "Test Node";
+            graph.AddNode(node);
+
+            Assert.AreEqual(1, graph.GetNodes<AbstractMaterialNode>().Count());
+            var found = graph.GetNodes<AbstractMaterialNode>().FirstOrDefault();
+            Assert.AreEqual(0, found.GetInputSlots<MaterialSlot>().Count());
+            Assert.AreEqual(1, found.GetOutputSlots<MaterialSlot>().Count());
+            Assert.AreEqual(1, found.GetSlots<MaterialSlot>().Count());
+        }
+
+        [Test]
+        public void TestCanUpdateDisplaynameByReaddingSlotToTestNode()
+        {
+            var graph = new GraphData();
+            var node = new TestNode();
+            node.AddSlot(new TestSlot(0, "output", SlotType.Output));
+            node.AddSlot(new TestSlot(0, "output_updated", SlotType.Output));
+            node.name = "Test Node";
+            graph.AddNode(node);
+
+            Assert.AreEqual(1, graph.GetNodes<AbstractMaterialNode>().Count());
+            var found = graph.GetNodes<AbstractMaterialNode>().FirstOrDefault();
+            Assert.AreEqual(0, found.GetInputSlots<MaterialSlot>().Count());
+            Assert.AreEqual(1, found.GetOutputSlots<MaterialSlot>().Count());
+            Assert.AreEqual(1, found.GetSlots<MaterialSlot>().Count());
+
+            var slot = found.GetOutputSlots<MaterialSlot>().FirstOrDefault();
+            Assert.AreEqual("output_updated(4)", slot.displayName);
+        }
+
+        [Test]
+        public void TestCanUpdateSlotDisplayName()
+        {
+            var node = new TestNode();
+            node.AddSlot(new TestSlot(0, "output", SlotType.Output));
+            node.name = "Test Node";
+
+            Assert.AreEqual(0, node.GetInputSlots<MaterialSlot>().Count());
+            Assert.AreEqual(1, node.GetOutputSlots<MaterialSlot>().Count());
+            Assert.AreEqual(1, node.GetSlots<MaterialSlot>().Count());
+
+            var slot = node.GetOutputSlots<MaterialSlot>().FirstOrDefault();
+            Assert.IsNotNull(slot);
+            Assert.AreEqual("output(4)", slot.displayName);
+            slot.displayName = "test";
+            Assert.AreEqual("test(4)", slot.displayName);
+        }
+
+        [Test]
+        public void TestCanFindSlotOnTestNode()
+        {
+            var node = new TestableNode();
+
+            Assert.AreEqual(6, node.GetSlots<MaterialSlot>().Count());
+            Assert.IsNotNull(node.FindInputSlot<MaterialSlot>(TestableNode.Input0));
+            Assert.IsNull(node.FindInputSlot<MaterialSlot>(TestableNode.Output0));
+            Assert.IsNotNull(node.FindOutputSlot<MaterialSlot>(TestableNode.Output0));
+            Assert.IsNull(node.FindOutputSlot<MaterialSlot>(TestableNode.Input0));
+
+            Assert.IsNotNull(node.FindSlot<MaterialSlot>(TestableNode.Input0));
+            Assert.IsNotNull(node.FindSlot<MaterialSlot>(TestableNode.Output0));
+            Assert.IsNull(node.FindSlot<MaterialSlot>(555));
+        }
+
+        [Test]
+        public void TestCanFindSlotReferenceOnTestNode()
+        {
+            var node = new TestableNode();
+
+            Assert.AreEqual(6, node.GetSlots<MaterialSlot>().Count());
+            Assert.IsNotNull(node.GetSlotReference(TestableNode.Input0));
+            Assert.IsNotNull(node.GetSlotReference(TestableNode.Output0));
+            Assert.Throws<ArgumentException>(() => node.GetSlotReference(555));
+        }
+
+        [Test]
+        public void TestCanConnectAndTraverseTwoNodesOnBaseMaterialGraph()
+        {
+            var graph = new GraphData();
+
+            var outputNode = new TestableNode();
+            graph.AddNode(outputNode);
+
+            var inputNode = new TestableNode();
+            graph.AddNode(inputNode);
+
+            Assert.AreEqual(2, graph.GetNodes<AbstractMaterialNode>().Count());
+
+
+            var createdEdge = graph.Connect(outputNode.GetSlotReference(TestableNode.Output0), inputNode.GetSlotReference(TestableNode.Input0));
+            Assert.AreEqual(1, graph.edges.Count());
+
+            var edge = graph.edges.FirstOrDefault();
+
+            Assert.AreEqual(createdEdge, edge);
+
+            var foundOutputNode = edge.outputSlot.node;
+            var foundOutputSlot = foundOutputNode.FindOutputSlot<MaterialSlot>(edge.outputSlot.slotId);
+            Assert.AreEqual(outputNode, foundOutputNode);
+            Assert.IsNotNull(foundOutputSlot);
+
+            var foundInputNode = edge.inputSlot.node;
+            var foundInputSlot = foundInputNode.FindInputSlot<MaterialSlot>(edge.inputSlot.slotId);
+            Assert.AreEqual(inputNode, foundInputNode);
+            Assert.IsNotNull(foundInputSlot);
+        }
+
+        [Test]
+        public void TestCanConnectAndTraverseThreeNodesOnBaseMaterialGraph()
+        {
+            var graph = new GraphData();
+
+            var outputNode = new TestableNode();
+            graph.AddNode(outputNode);
+
+            var middleNode = new TestableNode();
+            graph.AddNode(middleNode);
+
+            var inputNode = new TestableNode();
+            graph.AddNode(inputNode);
+
+            Assert.AreEqual(3, graph.GetNodes<AbstractMaterialNode>().Count());
+
+            graph.Connect(outputNode.GetSlotReference(TestableNode.Output0), middleNode.GetSlotReference(TestableNode.Input0));
+            Assert.AreEqual(1, graph.edges.Count());
+
+            graph.Connect(middleNode.GetSlotReference(TestableNode.Output0), inputNode.GetSlotReference(TestableNode.Input0));
+            Assert.AreEqual(2, graph.edges.Count());
+
+            var edgesOnMiddleNode = NodeUtils.GetAllEdges(middleNode);
+            Assert.AreEqual(2, edgesOnMiddleNode.Count());
+
+            outputNode.SetOverrideActiveState(AbstractMaterialNode.ActiveState.ExplicitActive);
+            middleNode.SetOverrideActiveState(AbstractMaterialNode.ActiveState.ExplicitActive);
+            inputNode.SetOverrideActiveState(AbstractMaterialNode.ActiveState.ExplicitActive);
+            List<AbstractMaterialNode> result = new List<AbstractMaterialNode>();
+            NodeUtils.DepthFirstCollectNodesFromNode(result, inputNode);
+            Assert.AreEqual(3, result.Count);
+
+            result.Clear();
+            NodeUtils.DepthFirstCollectNodesFromNode(result, inputNode, NodeUtils.IncludeSelf.Exclude);
+            Assert.AreEqual(2, result.Count);
+
+            result.Clear();
+            NodeUtils.DepthFirstCollectNodesFromNode(result, null);
+            Assert.AreEqual(0, result.Count);
+        }
+
+        [Test]
+        public void TestExceptionIfBadNodeConfigurationWorks()
+        {
+            var node = new TestableNode();
+            Assert.DoesNotThrow(
+                () =>
+                    NodeUtils.SlotConfigurationExceptionIfBadConfiguration(
+                        node,
+                        new[] {TestableNode.Input0, TestableNode.Input1, TestableNode.Input2},
+                        new[] {TestableNode.Output0, TestableNode.Output1, TestableNode.Output2, })
+            );
+
+
+            Assert.Throws<SlotConfigurationException>(
+                () =>
+                    NodeUtils.SlotConfigurationExceptionIfBadConfiguration(
+                        node,
+                        new[] {666, TestableNode.Input1, TestableNode.Input2},
+                        new[] {TestableNode.Output0, TestableNode.Output1, TestableNode.Output2, })
+            );
+
+            Assert.Throws<SlotConfigurationException>(
+                () =>
+                    NodeUtils.SlotConfigurationExceptionIfBadConfiguration(
+                        node,
+                        new[] {TestableNode.Input0, TestableNode.Input1, TestableNode.Input2},
+                        new[] {666, TestableNode.Output1, TestableNode.Output2, })
+            );
+
+            Assert.DoesNotThrow(
+                () =>
+                    NodeUtils.SlotConfigurationExceptionIfBadConfiguration(
+                        node,
+                        new[] {TestableNode.Input0},
+                        new[] {TestableNode.Output0})
+            );
+        }
+
+        [Test]
+        public void TestConectionToSameInputReplacesOldInput()
+        {
+            var graph = new GraphData();
+
+            var outputNode = new TestableNode();
+            graph.AddNode(outputNode);
+
+            var inputNode = new TestableNode();
+            graph.AddNode(inputNode);
+
+            Assert.AreEqual(2, graph.GetNodes<AbstractMaterialNode>().Count());
+
+            var createdEdge = graph.Connect(outputNode.GetSlotReference(TestableNode.Output0), inputNode.GetSlotReference(TestableNode.Input0));
+            Assert.AreEqual(1, graph.edges.Count());
+            var edge = graph.edges.FirstOrDefault();
+            Assert.AreEqual(createdEdge, edge);
+
+            var createdEdge2 = graph.Connect(outputNode.GetSlotReference(TestableNode.Output0), inputNode.GetSlotReference(TestableNode.Input0));
+            Assert.AreEqual(1, graph.edges.Count());
+            var edge2 = graph.edges.FirstOrDefault();
+            Assert.AreEqual(createdEdge2, edge2);
+        }
+
+        [Test]
+        public void TestRemovingSlotRemovesConnectedEdges()
+        {
+            var graph = new GraphData();
+
+            var outputNode = new TestableNode();
+            graph.AddNode(outputNode);
+
+            var inputNode = new TestableNode();
+            graph.AddNode(inputNode);
+
+            Assert.AreEqual(2, graph.GetNodes<AbstractMaterialNode>().Count());
+
+            graph.Connect(outputNode.GetSlotReference(TestableNode.Output0), inputNode.GetSlotReference(TestableNode.Input0));
+            Assert.AreEqual(1, graph.edges.Count());
+
+            outputNode.RemoveSlot(TestableNode.Output0);
+            Assert.AreEqual(0, graph.edges.Count());
+        }
+
+        [Test]
+        public void TestCanNotConnectToNullSlot()
+        {
+            var graph = new GraphData();
+
+            var outputNode = new TestableNode();
+            graph.AddNode(outputNode);
+
+            var inputNode = new TestNode();
+            graph.AddNode(inputNode);
+
+            Assert.AreEqual(2, graph.GetNodes<AbstractMaterialNode>().Count());
+
+            var createdEdge2 = graph.Connect(outputNode.GetSlotReference(TestableNode.Output0), new SlotReference(null, 666));
+            Assert.AreEqual(0, graph.edges.Count());
+            Assert.IsNull(createdEdge2);
+        }
+
+        [Test]
+        public void TestCanNotConnectTwoOuputSlotsOnBaseMaterialGraph()
+        {
+            var graph = new GraphData();
+
+            var outputNode = new TestableNode();
+            graph.AddNode(outputNode);
+
+            var outputNode2 = new TestableNode();
+            graph.AddNode(outputNode2);
+
+            Assert.AreEqual(2, graph.GetNodes<AbstractMaterialNode>().Count());
+
+            var createdEdge = graph.Connect(outputNode.GetSlotReference(TestableNode.Output0), outputNode2.GetSlotReference(TestableNode.Output0));
+            Assert.IsNull(createdEdge);
+            Assert.AreEqual(0, graph.edges.Count());
+        }
+
+        [Test]
+        public void TestCanNotConnectTwoInputSlotsOnBaseMaterialGraph()
+        {
+            var graph = new GraphData();
+
+            var inputNode = new TestableNode();
+            graph.AddNode(inputNode);
+
+            var inputNode2 = new TestableNode();
+            graph.AddNode(inputNode2);
+
+            Assert.AreEqual(2, graph.GetNodes<AbstractMaterialNode>().Count());
+
+            var createdEdge = graph.Connect(inputNode.GetSlotReference(TestableNode.Input0), inputNode2.GetSlotReference(TestableNode.Input0));
+            Assert.IsNull(createdEdge);
+            Assert.AreEqual(0, graph.edges.Count());
+        }
+
+        [Test]
+        public void TestRemovingNodeRemovesConectedEdgesOnBaseMaterialGraph()
+        {
+            var graph = new GraphData();
+            var outputNode = new TestableNode();
+            graph.AddNode(outputNode);
+
+            var inputNode = new TestableNode();
+            graph.AddNode(inputNode);
+
+            Assert.AreEqual(2, graph.GetNodes<AbstractMaterialNode>().Count());
+            graph.Connect(outputNode.GetSlotReference(TestableNode.Output0), inputNode.GetSlotReference(TestableNode.Input0));
+            Assert.AreEqual(1, graph.edges.Count());
+
+            graph.RemoveNode(graph.GetNodes<AbstractMaterialNode>().FirstOrDefault());
+            Assert.AreEqual(1, graph.GetNodes<AbstractMaterialNode>().Count());
+            Assert.AreEqual(0, graph.edges.Count());
+        }
+
+        [Test]
+        public void TestRemovingEdgeOnBaseMaterialGraph()
+        {
+            var graph = new GraphData();
+            var outputNode = new TestableNode();
+            graph.AddNode(outputNode);
+
+            var inputNode = new TestableNode();
+            graph.AddNode(inputNode);
+
+            Assert.AreEqual(2, graph.GetNodes<AbstractMaterialNode>().Count());
+            graph.Connect(outputNode.GetSlotReference(TestableNode.Output0), inputNode.GetSlotReference(TestableNode.Input0));
+            Assert.AreEqual(1, graph.edges.Count());
+
+            graph.RemoveEdge(graph.edges.FirstOrDefault());
+            Assert.AreEqual(2, graph.GetNodes<AbstractMaterialNode>().Count());
+            Assert.AreEqual(0, graph.edges.Count());
+        }
+
+        [Test]
+        public void TestRemovingElementsFromBaseMaterialGraph()
+        {
+            var graph = new GraphData();
+            var outputNode = new TestableNode();
+            graph.AddNode(outputNode);
+
+            var inputNode = new TestableNode();
+            graph.AddNode(inputNode);
+
+            Assert.AreEqual(2, graph.GetNodes<AbstractMaterialNode>().Count());
+            graph.Connect(outputNode.GetSlotReference(TestableNode.Output0), inputNode.GetSlotReference(TestableNode.Input0));
+            Assert.AreEqual(1, graph.edges.Count());
+
+            graph.RemoveElements(graph.GetNodes<AbstractMaterialNode>().ToArray(), graph.edges.ToArray(), new GroupData[] {}, new StickyNoteData[] {});
+            Assert.AreEqual(0, graph.GetNodes<AbstractMaterialNode>().Count());
+            Assert.AreEqual(0, graph.edges.Count());
+        }
+
+        [Test]
+        public void TestCanGetEdgesOnBaseMaterialGraphFromSlotReference()
+        {
+            var graph = new GraphData();
+            var outputNode = new TestableNode();
+            graph.AddNode(outputNode);
+
+            var inputNode = new TestableNode();
+            graph.AddNode(inputNode);
+
+            Assert.AreEqual(2, graph.GetNodes<AbstractMaterialNode>().Count());
+            graph.Connect(outputNode.GetSlotReference(TestableNode.Output0), inputNode.GetSlotReference(TestableNode.Input0));
+            Assert.AreEqual(1, graph.edges.Count());
+
+            Assert.AreEqual(1, graph.GetEdges(inputNode.GetSlotReference(TestableNode.Input0)).Count());
+            Assert.AreEqual(1, graph.GetEdges(outputNode.GetSlotReference(TestableNode.Output0)).Count());
+            Assert.Throws<ArgumentException>(() => outputNode.GetSlotReference(666));
+        }
+
+        [Test]
+        public void TestGetInputsWithNoConnection()
+        {
+            var graph = new GraphData();
+
+            var outputNode = new TestableNode();
+            graph.AddNode(outputNode);
+
+            var inputNode = new TestableNode();
+            graph.AddNode(inputNode);
+
+            Assert.AreEqual(2, graph.GetNodes<AbstractMaterialNode>().Count());
+            graph.Connect(outputNode.GetSlotReference(TestableNode.Output0), inputNode.GetSlotReference(TestableNode.Input0));
+            Assert.AreEqual(1, graph.edges.Count());
+
+            var slots = inputNode.GetInputsWithNoConnection();
+            Assert.AreEqual(2, slots.Count());
+            CollectionAssert.AreEqual(new[] { TestableNode.Input1, TestableNode.Input2 }, slots.Select(x => x.id));
+        }
+
+        [Test]
+        public void TestCyclicConnectionsAreNotAllowedOnGraph()
+        {
+            var graph = new GraphData();
+
+            var nodeA = new TestableNode();
+
+            graph.AddNode(nodeA);
+
+            var nodeB = new TestableNode();
+            graph.AddNode(nodeB);
+
+            Assert.AreEqual(2, graph.GetNodes<AbstractMaterialNode>().Count());
+            graph.Connect(nodeA.GetSlotReference(TestableNode.Output0), nodeB.GetSlotReference(TestableNode.Input0));
+            Assert.AreEqual(1, graph.edges.Count());
+
+            var edge = graph.Connect(nodeB.GetSlotReference(TestableNode.Output0), nodeA.GetSlotReference(TestableNode.Input0));
+            Assert.IsNull(edge);
+            Assert.AreEqual(1, graph.edges.Count());
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@11.0.0/Tests/Editor/UnitTests/ShaderGeneratorTests.cs

@@ -0,0 +1,195 @@
+using NUnit.Framework;
+using UnityEngine;
+using UnityEditor.Graphing;
+
+namespace UnityEditor.ShaderGraph.UnitTests
+{
+    [TestFixture]
+    class ShaderGeneratorTests
+    {
+        [OneTimeSetUp]
+        public void RunBeforeAnyTests()
+        {
+            Debug.unityLogger.logHandler = new ConsoleLogHandler();
+        }
+
+        class TestNode : AbstractMaterialNode
+        {
+            public const int V1Out = 0;
+            public const int V2Out = 1;
+            public const int V3Out = 2;
+            public const int V4Out = 3;
+
+            public TestNode()
+            {
+                AddSlot(new Vector1MaterialSlot(V1Out, "V1Out", "V1Out", SlotType.Output, 0));
+                AddSlot(new Vector2MaterialSlot(V2Out, "V2Out", "V2Out", SlotType.Output, Vector4.zero));
+                AddSlot(new Vector3MaterialSlot(V3Out, "V3Out", "V3Out", SlotType.Output, Vector4.zero));
+                AddSlot(new Vector4MaterialSlot(V4Out, "V4Out", "V4Out", SlotType.Output, Vector4.zero));
+            }
+        }
+
+        [Test]
+        public void AdaptNodeOutput1To1Works()
+        {
+            var node = new TestNode();
+            var result = GenerationUtils.AdaptNodeOutput(node, TestNode.V1Out, ConcreteSlotValueType.Vector1);
+            Assert.AreEqual(string.Format("{0}", node.GetVariableNameForSlot(TestNode.V1Out)), result);
+        }
+
+        [Test]
+        public void AdaptNodeOutput1To2Works()
+        {
+            var node = new TestNode();
+            var result = GenerationUtils.AdaptNodeOutput(node, TestNode.V1Out, ConcreteSlotValueType.Vector2);
+            Assert.AreEqual(string.Format("({0}.xx)", node.GetVariableNameForSlot(TestNode.V1Out)), result);
+        }
+
+        [Test]
+        public void AdaptNodeOutput1To3Works()
+        {
+            var node = new TestNode();
+            var result = GenerationUtils.AdaptNodeOutput(node, TestNode.V1Out, ConcreteSlotValueType.Vector3);
+            Assert.AreEqual(string.Format("({0}.xxx)", node.GetVariableNameForSlot(TestNode.V1Out)), result);
+        }
+
+        [Test]
+        public void AdaptNodeOutput1To4Works()
+        {
+            var node = new TestNode();
+            var result = GenerationUtils.AdaptNodeOutput(node, TestNode.V1Out, ConcreteSlotValueType.Vector4);
+            Assert.AreEqual(string.Format("({0}.xxxx)", node.GetVariableNameForSlot(TestNode.V1Out)), result);
+        }
+
+        [Test]
+        public void AdaptNodeOutput2To1Works()
+        {
+            var node = new TestNode();
+            var result = GenerationUtils.AdaptNodeOutput(node, TestNode.V2Out, ConcreteSlotValueType.Vector1);
+            Assert.AreEqual(string.Format("({0}).x", node.GetVariableNameForSlot(TestNode.V2Out)), result);
+        }
+
+        [Test]
+        public void AdaptNodeOutput2To2Works()
+        {
+            var node = new TestNode();
+            var result = GenerationUtils.AdaptNodeOutput(node, TestNode.V2Out, ConcreteSlotValueType.Vector2);
+            Assert.AreEqual(string.Format("{0}", node.GetVariableNameForSlot(TestNode.V2Out)), result);
+        }
+
+        [Test]
+        public void AdaptNodeOutput2To3Works()
+        {
+            var node = new TestNode();
+            var result = GenerationUtils.AdaptNodeOutput(node, TestNode.V2Out, ConcreteSlotValueType.Vector3);
+            Assert.AreEqual(string.Format("($precision3({0}, 0.0))", node.GetVariableNameForSlot(TestNode.V2Out)), result);
+        }
+
+        [Test]
+        public void AdaptNodeOutput2To4Works()
+        {
+            var node = new TestNode();
+            var result = GenerationUtils.AdaptNodeOutput(node, TestNode.V2Out, ConcreteSlotValueType.Vector4);
+            Assert.AreEqual(string.Format("($precision4({0}, 0.0, 1.0))", node.GetVariableNameForSlot(TestNode.V2Out)), result);
+        }
+
+        [Test]
+        public void AdaptNodeOutput3To1Works()
+        {
+            var node = new TestNode();
+            var result = GenerationUtils.AdaptNodeOutput(node, TestNode.V3Out, ConcreteSlotValueType.Vector1);
+            Assert.AreEqual(string.Format("({0}).x", node.GetVariableNameForSlot(TestNode.V3Out)), result);
+        }
+
+        [Test]
+        public void AdaptNodeOutput3To2Works()
+        {
+            var node = new TestNode();
+            var result = GenerationUtils.AdaptNodeOutput(node, TestNode.V3Out, ConcreteSlotValueType.Vector2);
+            Assert.AreEqual(string.Format("({0}.xy)", node.GetVariableNameForSlot(TestNode.V3Out)), result);
+        }
+
+        [Test]
+        public void AdaptNodeOutput3To3Works()
+        {
+            var node = new TestNode();
+            var result = GenerationUtils.AdaptNodeOutput(node, TestNode.V3Out, ConcreteSlotValueType.Vector3);
+            Assert.AreEqual(string.Format("{0}", node.GetVariableNameForSlot(TestNode.V3Out)), result);
+        }
+
+        [Test]
+        public void AdaptNodeOutput3To4Fails()
+        {
+            var node = new TestNode();
+            var result = GenerationUtils.AdaptNodeOutput(node, TestNode.V3Out, ConcreteSlotValueType.Vector4);
+            Assert.AreEqual(string.Format("($precision4({0}, 1.0))", node.GetVariableNameForSlot(TestNode.V3Out)), result);
+        }
+
+        [Test]
+        public void AdaptNodeOutput4To1Works()
+        {
+            var node = new TestNode();
+            var result = GenerationUtils.AdaptNodeOutput(node, TestNode.V4Out, ConcreteSlotValueType.Vector1);
+            Assert.AreEqual(string.Format("({0}).x", node.GetVariableNameForSlot(TestNode.V4Out)), result);
+        }
+
+        [Test]
+        public void AdaptNodeOutput4To2Works()
+        {
+            var node = new TestNode();
+            var result = GenerationUtils.AdaptNodeOutput(node, TestNode.V4Out, ConcreteSlotValueType.Vector2);
+            Assert.AreEqual(string.Format("({0}.xy)", node.GetVariableNameForSlot(TestNode.V4Out)), result);
+        }
+
+        [Test]
+        public void AdaptNodeOutput4To3Works()
+        {
+            var node = new TestNode();
+            var result = GenerationUtils.AdaptNodeOutput(node, TestNode.V4Out, ConcreteSlotValueType.Vector3);
+            Assert.AreEqual(string.Format("({0}.xyz)", node.GetVariableNameForSlot(TestNode.V4Out)), result);
+        }
+
+        [Test]
+        public void AdaptNodeOutput4To4Works()
+        {
+            var node = new TestNode();
+            var result = GenerationUtils.AdaptNodeOutput(node, TestNode.V4Out, ConcreteSlotValueType.Vector4);
+            Assert.AreEqual(string.Format("{0}", node.GetVariableNameForSlot(TestNode.V4Out)), result);
+        }
+
+        [Test]
+        public void AdaptNodeOutput1To4PreviewWorks()
+        {
+            var node = new TestNode();
+            var result = GenerationUtils.AdaptNodeOutputForPreview(node, TestNode.V1Out);
+            Assert.AreEqual(string.Format("half4({0}, {0}, {0}, 1.0)", node.GetVariableNameForSlot(TestNode.V1Out)), result);
+        }
+
+        [Test]
+        public void AdaptNodeOutput2To4PreviewWorks()
+        {
+            var node = new TestNode();
+            var expected = string.Format("half4({0}.x, {0}.y, 0.0, 1.0)", node.GetVariableNameForSlot(TestNode.V2Out));
+            var result = GenerationUtils.AdaptNodeOutputForPreview(node, TestNode.V2Out);
+            Assert.AreEqual(expected, result);
+        }
+
+        [Test]
+        public void AdaptNodeOutput3To4PreviewWorks()
+        {
+            var node = new TestNode();
+            var expected = string.Format("half4({0}.x, {0}.y, {0}.z, 1.0)", node.GetVariableNameForSlot(TestNode.V3Out));
+            var result = GenerationUtils.AdaptNodeOutputForPreview(node, TestNode.V3Out);
+            Assert.AreEqual(expected, result);
+        }
+
+        [Test]
+        public void AdaptNodeOutput4To4PreviewWorks()
+        {
+            var node = new TestNode();
+            var expected = string.Format("half4({0}.x, {0}.y, {0}.z, 1.0)", node.GetVariableNameForSlot(TestNode.V4Out));
+            var result = GenerationUtils.AdaptNodeOutputForPreview(node, TestNode.V4Out);
+            Assert.AreEqual(expected, result);
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@11.0.0/Tests/Editor/UnitTests/StackTests.cs

@@ -0,0 +1,91 @@
+using System.Reflection;
+using System.Linq;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEditor.Graphing;
+using UnityEditor.Experimental.GraphView;
+using UnityEditor.ShaderGraph.Drawing;
+
+namespace UnityEditor.ShaderGraph.UnitTests
+{
+    [TestFixture]
+    class StackTests
+    {
+        static BlockFieldDescriptor s_DescriptorA = new BlockFieldDescriptor("Test", "BlockA", string.Empty, new FloatControl(0.0f), ShaderStage.Fragment, true);
+        static BlockFieldDescriptor s_DescriptorB = new BlockFieldDescriptor("Test", "BlockA", string.Empty, new FloatControl(0.0f), ShaderStage.Fragment, true);
+
+        [OneTimeSetUp]
+        public void RunBeforeAnyTests()
+        {
+            Debug.unityLogger.logHandler = new ConsoleLogHandler();
+        }
+
+        [Test]
+        public void CanAddBlockNodeToContext()
+        {
+            GraphData graph = new GraphData();
+            graph.AddContexts();
+
+            var node = new BlockNode();
+            node.Init(s_DescriptorA);
+            graph.AddBlock(node, graph.fragmentContext, 0);
+
+            Assert.AreEqual(0, graph.edges.Count());
+            Assert.AreEqual(1, graph.GetNodes<BlockNode>().Count());
+            Assert.AreEqual(1, graph.fragmentContext.blocks.Count());
+        }
+
+        [Test]
+        public void CanRemoveBlockNodeFromContext()
+        {
+            GraphData graph = new GraphData();
+            graph.AddContexts();
+
+            var node = new BlockNode();
+            node.Init(s_DescriptorA);
+            graph.AddBlock(node, graph.fragmentContext, 0);
+            graph.RemoveNode(node);
+
+            Assert.AreEqual(0, graph.edges.Count());
+            Assert.AreEqual(0, graph.GetNodes<BlockNode>().Count());
+            Assert.AreEqual(0, graph.fragmentContext.blocks.Count());
+        }
+
+        [Test]
+        public void CanInsertBlockNodeToContext()
+        {
+            GraphData graph = new GraphData();
+            graph.AddContexts();
+
+            var nodeA = new BlockNode();
+            nodeA.Init(s_DescriptorA);
+            graph.AddBlock(nodeA, graph.fragmentContext, 0);
+
+            var nodeB = new BlockNode();
+            nodeB.Init(s_DescriptorA);
+            graph.AddBlock(nodeB, graph.fragmentContext, 0);
+
+            Assert.AreEqual(0, graph.edges.Count());
+            Assert.AreEqual(2, graph.GetNodes<BlockNode>().Count());
+            Assert.AreEqual(2, graph.fragmentContext.blocks.Count());
+            Assert.AreEqual(nodeB, graph.fragmentContext.blocks[0].value);
+        }
+
+        [Test]
+        public void CanFilterBlockNodeByShaderStage()
+        {
+            GraphData graph = new GraphData();
+            graph.AddContexts();
+
+            var node = new BlockNode();
+            node.Init(s_DescriptorA);
+
+            var contextView = new ContextView("Test", graph.vertexContext, null);
+            var methodInfo = typeof(StackNode).GetMethod("AcceptsElement", BindingFlags.Instance | BindingFlags.NonPublic, null, new[] {typeof(GraphElement), typeof(int).MakeByRefType(), typeof(int)}, null);
+            Assert.IsNotNull(methodInfo);
+
+            var acceptsElement = (bool)methodInfo.Invoke(contextView, new object[] { new MaterialNodeView() { userData = node }, 0, 0 });
+            Assert.IsFalse(acceptsElement);
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@11.0.0/Tests/Editor/UnitTests/TargetTests.cs

@@ -0,0 +1,191 @@
+using System.Linq;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEditor.Graphing;
+
+namespace UnityEditor.ShaderGraph.UnitTests
+{
+    [TestFixture]
+    class TargetTests
+    {
+        [OneTimeSetUp]
+        public void RunBeforeAnyTests()
+        {
+            Debug.unityLogger.logHandler = new ConsoleLogHandler();
+        }
+
+        [Test]
+        public void CanCreateBlankGraph()
+        {
+            GraphData graph = new GraphData();
+            graph.AddContexts();
+
+            Assert.IsNotNull(graph.activeTargets);
+            Assert.AreEqual(0, graph.activeTargets.Count());
+        }
+
+        public static bool s_ForceVFXFakeTargetVisible = false;
+#if !VFX_GRAPH_10_0_0_OR_NEWER
+        //A barebone VFXTarget for testing coverage.
+        sealed class VFXTarget : UnityEditor.ShaderGraph.Target
+        {
+            public VFXTarget()
+            {
+                displayName = "Fake VFX Target"; //Should not be displayed outside the test runner.
+                isHidden = !s_ForceVFXFakeTargetVisible;
+            }
+
+            public override void GetActiveBlocks(ref UnityEditor.ShaderGraph.TargetActiveBlockContext context)
+            {
+                context.AddBlock(ShaderGraph.BlockFields.SurfaceDescription.BaseColor);
+                context.AddBlock(ShaderGraph.BlockFields.SurfaceDescription.Alpha);
+            }
+
+            public override void GetFields(ref TargetFieldContext context)
+            {
+            }
+
+            public override void Setup(ref TargetSetupContext context)
+            {
+            }
+
+            public override bool IsActive() => false;
+            public override bool WorksWithSRP(UnityEngine.Rendering.RenderPipelineAsset scriptableRenderPipeline)
+            {
+                return false;
+            }
+
+            public override void GetPropertiesGUI(ref TargetPropertyGUIContext context, System.Action onChange, System.Action<System.String> registerUndo)
+            {
+            }
+        }
+#endif
+
+        [Test]
+        public void CanInitializeOutputTargets()
+        {
+            s_ForceVFXFakeTargetVisible = true;
+            GraphData graph = new GraphData();
+            graph.AddContexts();
+            graph.InitializeOutputs(new[] { new VFXTarget() }, null);
+
+            Assert.IsNotNull(graph.activeTargets);
+            Assert.AreEqual(1, graph.activeTargets.Count());
+            Assert.AreEqual(typeof(VFXTarget), graph.activeTargets.ElementAt(0).GetType());
+            s_ForceVFXFakeTargetVisible = false;
+        }
+
+        [Test]
+        public void CanAddTarget()
+        {
+            s_ForceVFXFakeTargetVisible = true;
+            GraphData graph = new GraphData();
+            graph.AddContexts();
+
+            var vfxTarget = graph.allPotentialTargets.FirstOrDefault(x => x is VFXTarget);
+            graph.SetTargetActive(vfxTarget);
+
+            Assert.IsNotNull(graph.activeTargets);
+            Assert.AreEqual(1, graph.activeTargets.Count());
+            Assert.AreEqual(vfxTarget, graph.activeTargets.ElementAt(0));
+            s_ForceVFXFakeTargetVisible = false;
+        }
+
+        [Test]
+        public void ActiveTargetsArePotentialTargets()
+        {
+            s_ForceVFXFakeTargetVisible = true;
+            GraphData graph = new GraphData();
+            graph.AddContexts();
+
+            var vfxTarget = new VFXTarget();
+            graph.SetTargetActive(vfxTarget);
+            Assert.IsTrue(graph.allPotentialTargets.Contains(vfxTarget));
+
+            s_ForceVFXFakeTargetVisible = false;
+        }
+
+        [Test]
+        public void GetTargetIndexWorks()
+        {
+            s_ForceVFXFakeTargetVisible = true;
+
+            GraphData graph = new GraphData();
+            graph.AddContexts();
+
+            int targetIndex = graph.GetTargetIndexByKnownType(typeof(VFXTarget));
+            Assert.IsTrue(targetIndex >= 0);
+
+            var vfxTarget = new VFXTarget();
+            graph.SetTargetActive(vfxTarget);
+
+            var targetIndex2 = graph.GetTargetIndex(vfxTarget);
+            Assert.AreEqual(targetIndex, targetIndex2);
+
+            var nonActiveVFXTarget = new VFXTarget();
+            Assert.AreEqual(-1, graph.GetTargetIndex(nonActiveVFXTarget));
+
+            s_ForceVFXFakeTargetVisible = false;
+        }
+
+        [Test]
+        public void CanRemoveTarget()
+        {
+            s_ForceVFXFakeTargetVisible = true;
+            GraphData graph = new GraphData();
+            graph.AddContexts();
+
+            var vfxTarget = new VFXTarget();
+            graph.InitializeOutputs(new[] { vfxTarget }, null);
+
+            graph.SetTargetInactive(vfxTarget);
+
+            Assert.IsNotNull(graph.activeTargets);
+            Assert.AreEqual(0, graph.activeTargets.Count());
+            s_ForceVFXFakeTargetVisible = false;
+        }
+
+        [Test]
+        public void CanSetBlockActive()
+        {
+            s_ForceVFXFakeTargetVisible = true;
+            GraphData graph = new GraphData();
+            graph.AddContexts();
+            graph.InitializeOutputs(new[] { new VFXTarget() }, new BlockFieldDescriptor[] { BlockFields.SurfaceDescription.BaseColor, BlockFields.SurfaceDescription.NormalTS });
+
+            // Block active state should match VFX Target's default GetActiveBlocks
+            var blocks = graph.GetNodes<BlockNode>().ToList();
+            Assert.AreEqual(2, blocks.Count);
+            Assert.AreEqual(BlockFields.SurfaceDescription.BaseColor, blocks[0].descriptor);
+            Assert.AreEqual(true, blocks[0].isActive);
+            Assert.AreEqual(BlockFields.SurfaceDescription.NormalTS, blocks[1].descriptor);
+            Assert.AreEqual(false, blocks[1].isActive);
+            s_ForceVFXFakeTargetVisible = false;
+        }
+
+        [Test]
+        public void CanUpdateBlockActiveState()
+        {
+            s_ForceVFXFakeTargetVisible = true;
+            GraphData graph = new GraphData();
+            graph.AddContexts();
+            graph.InitializeOutputs(new[] { new VFXTarget() }, new BlockFieldDescriptor[] { BlockFields.SurfaceDescription.BaseColor, BlockFields.SurfaceDescription.NormalTS });
+
+            // Remove VFX target
+            var vfxTarget = graph.allPotentialTargets.FirstOrDefault(x => x is VFXTarget);
+            graph.SetTargetInactive(vfxTarget);
+
+            var activeBlocks = graph.GetActiveBlocksForAllActiveTargets();
+            graph.UpdateActiveBlocks(activeBlocks);
+
+            // All blocks should be inactive as there are no active targets
+            var blocks = graph.GetNodes<BlockNode>().ToList();
+            Assert.AreEqual(2, blocks.Count);
+            Assert.AreEqual(BlockFields.SurfaceDescription.BaseColor, blocks[0].descriptor);
+            Assert.AreEqual(false, blocks[0].isActive);
+            Assert.AreEqual(BlockFields.SurfaceDescription.NormalTS, blocks[1].descriptor);
+            Assert.AreEqual(false, blocks[1].isActive);
+            s_ForceVFXFakeTargetVisible = false;
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@11.0.0/Tests/Editor/UnitTests/UtilityTests.cs

@@ -0,0 +1,104 @@
+using NUnit.Framework;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph;
+
+namespace UnityEditor.ShaderGraph.UnitTests
+{
+    class UtilityTests
+    {
+        [Test]
+        public void ConvertToValidHLSLIdentifier()
+        {
+            Assert.AreEqual(NodeUtils.ConvertToValidHLSLIdentifier(""), "_");
+            Assert.AreEqual(NodeUtils.ConvertToValidHLSLIdentifier(" "), "_");
+            Assert.AreEqual(NodeUtils.ConvertToValidHLSLIdentifier("_"), "_");
+            Assert.AreEqual(NodeUtils.ConvertToValidHLSLIdentifier("9"), "_9");
+            Assert.AreEqual(NodeUtils.ConvertToValidHLSLIdentifier("q"), "q");
+            Assert.AreEqual(NodeUtils.ConvertToValidHLSLIdentifier("b#"), "b");
+            Assert.AreEqual(NodeUtils.ConvertToValidHLSLIdentifier("{t"), "t");
+            Assert.AreEqual(NodeUtils.ConvertToValidHLSLIdentifier("&Y~"), "Y");
+            Assert.AreEqual(NodeUtils.ConvertToValidHLSLIdentifier("a_Az_Z0_9_"), "a_Az_Z0_9_");
+            Assert.AreEqual(NodeUtils.ConvertToValidHLSLIdentifier(" a_Az_Z0_9_"), "a_Az_Z0_9_");
+            Assert.AreEqual(NodeUtils.ConvertToValidHLSLIdentifier("a_Az_Z0_9_ "), "a_Az_Z0_9_");
+            Assert.AreEqual(NodeUtils.ConvertToValidHLSLIdentifier(" a_Az_Z0_9_ "), "a_Az_Z0_9_");
+            Assert.AreEqual(NodeUtils.ConvertToValidHLSLIdentifier("  a_Az_Z0_9_"), "a_Az_Z0_9_");
+            Assert.AreEqual(NodeUtils.ConvertToValidHLSLIdentifier("a_Az_Z0_9_  "), "a_Az_Z0_9_");
+            Assert.AreEqual(NodeUtils.ConvertToValidHLSLIdentifier("  a_Az_Z0_9_  "), "a_Az_Z0_9_");
+            Assert.AreEqual(NodeUtils.ConvertToValidHLSLIdentifier("_ _"), "___");
+            Assert.AreEqual(NodeUtils.ConvertToValidHLSLIdentifier("      "), "_");
+            Assert.AreEqual(NodeUtils.ConvertToValidHLSLIdentifier("*1   "), "_1");
+            Assert.AreEqual(NodeUtils.ConvertToValidHLSLIdentifier("  *-(1)"), "_1");
+            Assert.AreEqual(NodeUtils.ConvertToValidHLSLIdentifier("*z-1>"), "z_1");
+            Assert.AreEqual(NodeUtils.ConvertToValidHLSLIdentifier("*^#@$w)!(r+-"), "w_r");
+            Assert.AreEqual(NodeUtils.ConvertToValidHLSLIdentifier("  1   var  * q-30 ( 0 ) (1)   "), "_1_var_q_30_0_1");
+        }
+
+        [Test]
+        public void DeduplicateName()
+        {
+            string[] existingNames = new string[]
+            {
+                "a",
+                "b",
+                "c",
+                "qwerty",
+                "qwerty_1",
+                "qwerty_3",
+                "b_1",
+                "qwerty_4",
+                "b2",
+                "b3",
+                "_",
+                "_1",
+                "a (1)",
+                "a (2)",
+                "a (3)",
+                "b (2)",
+                "b_1 (1)"
+            };
+
+            Assert.AreEqual(GraphUtil.DeduplicateName(existingNames, "{0}_{1}", "a"), "a_1");
+            Assert.AreEqual(GraphUtil.DeduplicateName(existingNames, "{0}_{1}", "b"), "b_2");
+            Assert.AreEqual(GraphUtil.DeduplicateName(existingNames, "{0}_{1}", "qwert"), "qwert");
+            Assert.AreEqual(GraphUtil.DeduplicateName(existingNames, "{0}_{1}", "qwerty"), "qwerty_2");
+            Assert.AreEqual(GraphUtil.DeduplicateName(existingNames, "{0}_{1}", "qwerty_1"), "qwerty_2");
+            Assert.AreEqual(GraphUtil.DeduplicateName(existingNames, "{0}_{1}", "qwerty_4"), "qwerty_2");
+            Assert.AreEqual(GraphUtil.DeduplicateName(existingNames, "{0}_{1}", "asdf"), "asdf");
+            Assert.AreEqual(GraphUtil.DeduplicateName(existingNames, "{0}_{1}", "d_1"), "d_1");
+            Assert.AreEqual(GraphUtil.DeduplicateName(existingNames, "{0}_{1}", "_1"), "_2");
+
+            // this one actually outputs "__1" .. but not going to fix it now
+            // Assert.AreEqual(GraphUtil.DeduplicateName(existingNames, "{0}_{1}", "_"), "_2");
+
+            Assert.AreEqual(GraphUtil.DeduplicateName(existingNames, "{0} ({1})", "a"), "a (4)");
+            Assert.AreEqual(GraphUtil.DeduplicateName(existingNames, "{0} ({1})", "b"), "b (1)");
+            Assert.AreEqual(GraphUtil.DeduplicateName(existingNames, "{0} ({1})", "b (2)"), "b (1)");
+            Assert.AreEqual(GraphUtil.DeduplicateName(existingNames, "{0} ({1})", "b_1"), "b_1 (2)");
+            Assert.AreEqual(GraphUtil.DeduplicateName(existingNames, "{0} ({1})", "c"), "c (1)");
+        }
+
+        [Test]
+        public void IsHLSLKeyword()
+        {
+            Assert.IsTrue(NodeUtils.IsHLSLKeyword("min16uint"));
+            Assert.IsTrue(NodeUtils.IsHLSLKeyword("float2"));
+            Assert.IsTrue(NodeUtils.IsHLSLKeyword("uint4x4"));
+            Assert.IsTrue(NodeUtils.IsHLSLKeyword("bool2x2"));
+            Assert.IsTrue(NodeUtils.IsHLSLKeyword("half1x1"));
+            Assert.IsTrue(NodeUtils.IsHLSLKeyword("StructuredBuffer"));
+            Assert.IsTrue(NodeUtils.IsHLSLKeyword("texture"));
+            Assert.IsTrue(NodeUtils.IsHLSLKeyword("while"));
+            Assert.IsTrue(NodeUtils.IsHLSLKeyword("true"));
+            Assert.IsTrue(NodeUtils.IsHLSLKeyword("NULL"));
+
+            Assert.IsFalse(NodeUtils.IsHLSLKeyword("x"));
+            Assert.IsFalse(NodeUtils.IsHLSLKeyword("var"));
+            Assert.IsFalse(NodeUtils.IsHLSLKeyword("float5"));
+            Assert.IsFalse(NodeUtils.IsHLSLKeyword("tex"));
+            Assert.IsFalse(NodeUtils.IsHLSLKeyword("Texture"));
+            Assert.IsFalse(NodeUtils.IsHLSLKeyword("_0"));
+            Assert.IsFalse(NodeUtils.IsHLSLKeyword(""));
+            Assert.IsFalse(NodeUtils.IsHLSLKeyword("103"));
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@11.0.0/Tests/Editor/Unity.ShaderGraph.Editor.Tests.asmdef

@@ -0,0 +1,28 @@
+{
+    "name": "Unity.ShaderGraph.Editor.Tests",
+    "references": [
+        "GUID:be0903cd8e1546f498710afdc59db5eb",
+        "GUID:27619889b8ba8c24980f49ee34dbb44a",
+        "GUID:0acc523941302664db1f4e527237feb3"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": true,
+    "overrideReferences": true,
+    "precompiledReferences": [
+        "nunit.framework.dll"
+    ],
+    "autoReferenced": false,
+    "defineConstraints": [
+        "UNITY_INCLUDE_TESTS"
+    ],
+    "versionDefines": [
+        {
+            "name": "com.unity.visualeffectgraph",
+            "expression": "10.0.0-preview.15",
+            "define": "VFX_GRAPH_10_0_0_OR_NEWER"
+        }
+    ]
+}