Fix compiler warnings :)

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Implementation/SerializableGraph.cs

                 Debug.LogWarning("Node does not exist");
                 return Enumerable.Empty<IEdge>();
             }
-            ISlot slot = slot = node.FindSlot<ISlot>(s.slotId);
+            ISlot slot = node.FindSlot<ISlot>(s.slotId);
 
             List<IEdge> candidateEdges;
             if (!m_NodeEdges.TryGetValue(s.nodeGuid, out candidateEdges))

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Testing/UnitTests/SerializedGraphTests.cs

     [TestFixture]
     public class SerializableGraphTests
     {
-        [TestFixtureSetUp]
+        [OneTimeSetUp]
         public void RunBeforeAnyTests()
         {
             Debug.unityLogger.logHandler = new ConsoleLogHandler();

MaterialGraphProject/Assets/NewNodes/Editor/Keep/GradientField.cs

     #region Initial Setup
 
     private static MethodInfo s_miGradientField1;
-    private static MethodInfo s_miGradientField2;
 
     static GUIGradientField()
     {
-        s_miGradientField2 = tyEditorGUILayout.GetMethod("GradientField", BindingFlags.NonPublic | BindingFlags.Static, null, new Type[] { GradientWrapper.s_tyGradient, typeof(GUILayoutOption[]) }, null);
     }
 
     #endregion

MaterialGraphProject/Assets/NewNodes/Editor/Keep/TransformNode.cs

             if (requiresTangentTransform)
                 visitor.AddShaderChunk("float3x3 tangentTransform = float3x3( worldSpaceTangent, worldSpaceBitangent, worldSpaceNormal);", false);
 
-            visitor.AddShaderChunk(precision + outputDimension + " " + GetVariableNameForSlot(OutputSlotId) + " = " + transformString + ";", true);
+            visitor.AddShaderChunk(string.Format("{0} {1} = {2};",
+                ConvertConcreteSlotValueTypeToString(precision, FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType), 
+                GetVariableNameForSlot(OutputSlotId),
+                transformString), true);
         }
 
         //float3x3 tangentTransform = float3x3( i.tangentDir, i.bitangentDir, i.normalDir);------
         //mul( float4(i.posWorld.rgb,0), UNITY_MATRIX_V ).xyz - view to world
         //mul( float4(i.posWorld.rgb,0), UNITY_MATRIX_MV ).xyz - view to local
         //mul( tangentTransform, mul( float4(i.posWorld.rgb,0), UNITY_MATRIX_V ).xyz ).xyz - view to tangent
-
-
-        public string outputDimension
-        {
-            get { return ConvertConcreteSlotValueTypeToString(FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType); }
-        }
-        private string inputDimension
-        {
-            get { return ConvertConcreteSlotValueTypeToString(FindInputSlot<MaterialSlot>(InputSlotId).concreteValueType); }
-        }
 
         public NeededCoordinateSpace RequiresTangent()
         {

MaterialGraphProject/Assets/NewNodes/Editor/Kill/MultiLayerParallaxNode.cs

         {
             return kOutputSlotShaderName;
         }
-
-        private string input1Dimension
-        {
-            get { return ConvertConcreteSlotValueTypeToString(FindInputSlot<MaterialSlot>(InputDepthSlotId).concreteValueType); }
-        }
-
-        private string input2Dimension
-        {
-            get { return ConvertConcreteSlotValueTypeToString(FindInputSlot<MaterialSlot>(InputFadeRateSlotId).concreteValueType); }
-        }
-        private string input3Dimension
-        {
-            get { return ConvertConcreteSlotValueTypeToString(FindInputSlot<MaterialSlot>(InputLayerCountSlotId).concreteValueType); }
-        }
-
-        public string outputDimension
-        {
-            get { return ConvertConcreteSlotValueTypeToString(FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType); }
-        }
-
+        
-            return "inline " + precision + outputDimension + " " + GetFunctionName() + " (" +
-                precision + input1Dimension + " " + depth + ", " +
-                precision + input2Dimension + " " + fadeRate + ", " +
-                precision + input3Dimension + " " + layerCount + ", " +
-                "sampler2D "                      + tex + ", " +
-                precision + "2 "                  + UVs + ", " +
-                precision + "3 "                  + viewTangentSpace + ")";
+            var input1 = ConvertConcreteSlotValueTypeToString(precision, FindInputSlot<MaterialSlot>(InputDepthSlotId).concreteValueType);
+            var input2 = ConvertConcreteSlotValueTypeToString(precision, FindInputSlot<MaterialSlot>(InputFadeRateSlotId).concreteValueType);
+            var input3 = ConvertConcreteSlotValueTypeToString(precision, FindInputSlot<MaterialSlot>(InputLayerCountSlotId).concreteValueType);
+            var output = ConvertConcreteSlotValueTypeToString(precision, FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType);
+
+            return string.Format("inline {0} {1} ({2} {3}, {4} {5}, {6} {7}, " + "sampler2D {8}, {9}2 {10}, {9}3 {11})", output, GetFunctionName(), input1, depth, input2, fadeRate, input3, layerCount, tex, precision, UVs, viewTangentSpace);
         }
 
         public void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
             string fadeRateValue = GetSlotValue(InputFadeRateSlotId, generationMode);
             string layerCountValue = GetSlotValue(InputLayerCountSlotId, generationMode);
             string textureValue = GetSlotValue(TextureSlotId, generationMode);
-
-            visitor.AddShaderChunk(
-                precision + outputDimension + " " + GetVariableNameForSlot(OutputSlotId) +
-                " = " + GetFunctionCallBody(depthValue, fadeRateValue, layerCountValue, textureValue) + ";", true);
+            
+            var output = ConvertConcreteSlotValueTypeToString(precision, FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType);
+            visitor.AddShaderChunk(string.Format("{0} {1} = {2};", output, GetVariableNameForSlot(OutputSlotId), GetFunctionCallBody(depthValue, fadeRateValue, layerCountValue, textureValue)), true);
         }
 
         public void GenerateNodeFunction(ShaderGenerator visitor, GenerationMode generationMode)
             outputString.AddShaderChunk(precision + "2 texcoord = UVs;", false);
             outputString.AddShaderChunk(precision + "2 offset = -viewTangentSpace.xy * depth / layerCount;", false);
 
-            outputString.AddShaderChunk(precision + outputDimension + " result = 0.0f;", false);
-            outputString.AddShaderChunk(precision + outputDimension + " fade = 1.0f;", false);
+            var output = ConvertConcreteSlotValueTypeToString(precision, FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType);
+            outputString.AddShaderChunk(output + " result = 0.0f;", false);
+            outputString.AddShaderChunk(output + " fade = 1.0f;", false);
             outputString.AddShaderChunk(precision + " alpha = 0.0f;", false);
 
             outputString.AddShaderChunk("for (int i = 0; i < 10; i++) {", false);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/AssetCallbacks/CreateShaderSubGraph.cs

-using System.IO;
 using System.IO;
 using UnityEditor.ProjectWindowCallback;
 using UnityEngine.MaterialGraph;

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/AbstractMaterialGraph.cs

             return result;
         }
 
-        class IndexedProperty
-        {
-            public int index;
-            public IShaderProperty property;
-        }
-
         public override void ReplaceWith(IGraph other)
         {
             var otherMG = other as AbstractMaterialGraph;

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/AbstractMaterialNode.cs

         {
             return false;
         }
-
-        [Obsolete("Call new override", false)]
-        public static string ConvertConcreteSlotValueTypeToString(ConcreteSlotValueType slotValue)
+        
+        public static string GetSlotDimension(ConcreteSlotValueType slotValue)
         {
             switch (slotValue)
             {
                     return "3";
                 case ConcreteSlotValueType.Vector4:
                     return "4";
-                case ConcreteSlotValueType.Texture2D:
-                    return "Texture2D";
                 case ConcreteSlotValueType.Matrix2:
                     return "2x2";
                 case ConcreteSlotValueType.Matrix3:
-                case ConcreteSlotValueType.SamplerState:
-                    return "SamplerState";
                 default:
                     return "Error";
             }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Art/Adjustments/LevelsNode.cs

     [Title("Art/Adjustments/Levels")]
     public class LevelsNode : CodeFunctionNode
     {
-        [SerializeField]
-        private float m_InputMin = 0.0f;
-        [SerializeField]
-        private float m_InputMax = 1.0f;
-        [SerializeField]
-        private float m_InputGamma = 1.0f;
-        [SerializeField]
-        private float m_OutputMin = 0.0f;
-        [SerializeField]
-        private float m_OutputMax = 1.0f;
-
         public LevelsNode()
         {
             name = "Levels";

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/HLSLNode.cs

             foreach (var slot in GetSlots<MaterialSlot>())
             {
                 var toReplace = string.Format("{{slot{0}dimension}}", slot.id);
-                var replacement = ConvertConcreteSlotValueTypeToString(slot.concreteValueType);
+                var replacement = GetSlotDimension(slot.concreteValueType);
                 result = result.Replace(toReplace, replacement);
             }
             return result;

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Matrix/MatrixMultiplyByVectorNode.cs

 
         protected string GetFunctionPrototype(string arg1Name, string arg2Name)
         {
-            return "inline " + precision + outputDimension + " " + GetFunctionName() + " ("
-                + precision + input1Dimension + " " + arg1Name + ", "
-                + precision + input2Dimension + " " + arg2Name + ")";
+            return string.Format("inline {0} {1} ({2} {3}, {4} {5})", ConvertConcreteSlotValueTypeToString(precision, FindInputSlot<MaterialSlot>(InputSlot2Id).concreteValueType), GetFunctionName(), ConvertConcreteSlotValueTypeToString(precision, FindInputSlot<MaterialSlot>(InputSlot1Id).concreteValueType), arg1Name, ConvertConcreteSlotValueTypeToString(precision, FindInputSlot<MaterialSlot>(InputSlot2Id).concreteValueType), arg2Name);
         }
 
         public void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
             string input2Value = GetSlotValue(InputSlot2Id, generationMode);
-            visitor.AddShaderChunk(precision + outputDimension + " " + GetVariableNameForSlot(OutputSlotId) + " = " + GetFunctionCallBody(input1Value, input2Value) + ";", true);
+            visitor.AddShaderChunk(string.Format("{0} {1} = {2};", ConvertConcreteSlotValueTypeToString(precision, FindInputSlot<MaterialSlot>(InputSlot2Id).concreteValueType), GetVariableNameForSlot(OutputSlotId), GetFunctionCallBody(input1Value, input2Value)), true);
-            return GetFunctionName() + " (" + input1Value + ", " + input2Value + ")";
-        }
-
-        public string outputDimension
-        {
-            get { return ConvertConcreteSlotValueTypeToString(FindInputSlot<MaterialSlot>(InputSlot2Id).concreteValueType); }
-        }
-
-        private string input1Dimension
-        {
-            get { return ConvertConcreteSlotValueTypeToString(FindInputSlot<MaterialSlot>(InputSlot1Id).concreteValueType); }
-        }
-
-        private string input2Dimension
-        {
-            get { return ConvertConcreteSlotValueTypeToString(FindInputSlot<MaterialSlot>(InputSlot2Id).concreteValueType); }
+            return string.Format("{0} ({1}, {2})", GetFunctionName(), input1Value, input2Value);
         }
 
         public void GenerateNodeFunction(ShaderGenerator visitor, GenerationMode generationMode)

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Matrix/MatrixMultiplyNode.cs

 
         protected string GetFunctionPrototype(string arg1Name, string arg2Name)
         {
-            return "inline " + precision + outputDimension + " " + GetFunctionName() + " ("
-                + precision + input1Dimension + " " + arg1Name + ", "
-                + precision + input2Dimension + " " + arg2Name + ")";
+            return string.Format("inline {0} {1} ({2} {3}, {4} {5})", ConvertConcreteSlotValueTypeToString(precision, FindInputSlot<MaterialSlot>(InputSlot2Id).concreteValueType), GetFunctionName(), ConvertConcreteSlotValueTypeToString(precision, FindInputSlot<MaterialSlot>(InputSlot1Id).concreteValueType), arg1Name, ConvertConcreteSlotValueTypeToString(precision, FindInputSlot<MaterialSlot>(InputSlot2Id).concreteValueType), arg2Name);
         }
 
         public void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
             string input2Value = GetSlotValue(InputSlot2Id, generationMode);
-            visitor.AddShaderChunk(precision + outputDimension + " " + GetVariableNameForSlot(OutputSlotId) + " = " + GetFunctionCallBody(input1Value, input2Value) + ";", true);
+            visitor.AddShaderChunk(string.Format("{0} {1} = {2};", ConvertConcreteSlotValueTypeToString(precision, FindInputSlot<MaterialSlot>(InputSlot2Id).concreteValueType), GetVariableNameForSlot(OutputSlotId), GetFunctionCallBody(input1Value, input2Value)), true);
-        }
-
-        public string outputDimension
-        {
-            get { return ConvertConcreteSlotValueTypeToString(FindInputSlot<MaterialSlot>(InputSlot2Id).concreteValueType); }
-        }
-
-        private string input1Dimension
-        {
-            get { return ConvertConcreteSlotValueTypeToString(FindInputSlot<MaterialSlot>(InputSlot1Id).concreteValueType); }
-        }
-
-        private string input2Dimension
-        {
-            get { return ConvertConcreteSlotValueTypeToString(FindInputSlot<MaterialSlot>(InputSlot2Id).concreteValueType); }
         }
 
         public void GenerateNodeFunction(ShaderGenerator visitor, GenerationMode generationMode)

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/SubGraph/LayeredShaderGraph.cs

                 if (!path.EndsWith("shaderGraph", StringComparison.InvariantCultureIgnoreCase))
                     return false;
 
-                var name = Path.GetFileNameWithoutExtension(path);
                 var textGraph = File.ReadAllText(path, Encoding.UTF8);
                 var graph = JsonUtility.FromJson<MaterialGraph>(textGraph);
                 if (graph == null)

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/SubGraph/MasterRemapNode.cs

             get { return m_MaterialOptions; }
         }
 
-        public virtual PreviewMode previewMode
+        public override PreviewMode previewMode
         {
             get { return PreviewMode.Preview3D; }
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/SubGraph/SubGraphNode.cs

             //var validOutputSlots = NodeUtils.GetSlotsThatOutputToNodeRecurse(this, (graph as BaseMaterialGraph).masterNode);
             foreach (var slot in GetOutputSlots<MaterialSlot>())
             {
-                var outDimension = ConvertConcreteSlotValueTypeToString(slot.concreteValueType);
-
-                outputString.AddShaderChunk(
-                    "float"
-                    + outDimension
-                    + " "
-                    + GetVariableNameForSlot(slot.id)
-                    + " = 0;", false);
+                var outDimension = ConvertConcreteSlotValueTypeToString(precision, slot.concreteValueType);
+                outputString.AddShaderChunk(string.Format("{0} {1} = 0;", outDimension, GetVariableNameForSlot(slot.id)), false);
             }
 
             // Step 2...

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/SubGraph/SubGraphOutputNode.cs

+using System;
+using System.Reflection;
+using UnityEditor.MaterialGraph.Drawing.Controls;
+using UnityEngine.Experimental.UIElements;
+    public class SubGraphOutputControlAttribute : Attribute, IControlAttribute
+    {
+        public VisualElement InstantiateControl(AbstractMaterialNode node, PropertyInfo propertyInfo)
+        {
+            if (!(node is SubGraphOutputNode))
+                throw new ArgumentException("Node must inherit from AbstractSubGraphIONode.", "node");
+            return new SubGraphOutputControlView((SubGraphOutputNode)node);
+        }
+    }
+
+    public class SubGraphOutputControlView : VisualElement
+    {
+        SubGraphOutputNode m_Node;
+
+        public SubGraphOutputControlView(SubGraphOutputNode node)
+        {
+            m_Node = node;
+            Add(new Button(OnAdd) { text = "Add Slot" });
+            Add(new Button(OnRemove) { text = "Remove Slot" });
+        }
+
+        void OnAdd()
+        {
+            m_Node.AddSlot();
+        }
+
+        void OnRemove()
+        {
+            m_Node.RemoveSlot();
+        }
+    }
+
+        [SubGraphOutputControl]
+        int controlDummy { get; set; }
+
         public SubGraphOutputNode()
         {
             name = "SubGraphOutputs";

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/AbstractMaterialGraphEditWindow.cs

                 edge => edge.outputSlot,
                 edge => edge,
                 (key, edges) => new {slotRef = key, edges = edges.ToList()});
-            var inputsNeedingConnection = new List<KeyValuePair<IEdge, IEdge>>();
-                var inputNode = new PropertyNode();
-
                 var sr = group.slotRef;
                 var fromNode = graphPresenter.graph.GetNodeFromGuid(sr.nodeGuid);
                 var fromSlot = fromNode.FindOutputSlot<MaterialSlot>(sr.slotId);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/MaterialGraphPreviewGenerator.cs

         private Material m_CheckerboardMaterial;
 
         private static readonly Mesh[] s_Meshes = { null, null, null, null, null };
-        private static Mesh s_PlaneMesh;
         private static readonly GUIContent[] s_MeshIcons = { null, null, null, null, null };
         private static readonly GUIContent[] s_LightIcons = { null, null };
         private static readonly GUIContent[] s_TimeIcons = { null, null };
 
                 Mesh quadMesh = Resources.GetBuiltinResource(typeof(Mesh), "Quad.fbx") as Mesh;
                 s_Meshes[4] = quadMesh;
-                s_PlaneMesh = quadMesh;
             }
         }
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/GraphAnchorPresenter.cs

 using System;
 using UnityEditor.Experimental.UIElements.GraphView;
-using UnityEditor.Experimental.UIElements.GraphView;
 using UnityEngine;
 using UnityEngine.Graphing;
 using UnityEngine.MaterialGraph;

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/GraphEdgePresenter.cs

 using System;
 using UnityEditor.Experimental.UIElements.GraphView;
-using UnityEditor.Experimental.UIElements.GraphView;
 
 namespace UnityEditor.MaterialGraph.Drawing
 {

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/MaterialNodePresenter.cs

 using UnityEditor.Experimental.UIElements.GraphView;
 using UnityEngine.Graphing;
 using UnityEngine.MaterialGraph;
-using UnityEditor.Experimental.UIElements.GraphView;
 using UnityEngine;
 
 namespace UnityEditor.MaterialGraph.Drawing

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/PreviewSystem.cs

             }
             else
             {
-                List<PropertyCollector.TextureInfo> defaultTextures;
                 PreviewMode mode;
                 previewData.shaderString = m_Graph.GetPreviewShader(node, out mode);
                 previewData.previewMode = mode;

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Views/MaterialGraphView.cs

 using System;
-using System.Collections.Generic;
-using System.IO;
 using System.Linq;
 using System.Reflection;
 using UnityEditor.Experimental.UIElements.GraphView;
-using UnityEditor.Experimental.UIElements.GraphView;
 using UnityEngine.Experimental.UIElements;
 using Edge = UnityEditor.Experimental.UIElements.GraphView.Edge;
 using MouseButton = UnityEngine.Experimental.UIElements.MouseButton;

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Importers/MasterRemapGraphImporterEditor.cs

 using UnityEditor.Experimental.AssetImporters;
 using UnityEditor.MaterialGraph.Drawing;
 using UnityEngine;
+using UnityEngine.MaterialGraph;
 using Debug = System.Diagnostics.Debug;
 
 [CustomEditor(typeof(MasterRemapGraphImporter))]
         }
     }
 
-    private static void ShowGraphEditWindow(string path)
+    private static bool ShowGraphEditWindow(string path)
-        var asset = AssetDatabase.LoadAssetAtPath<Object>(path);
+        var asset = AssetDatabase.LoadAssetAtPath<Object>(path) as MasterRemapGraphAsset;
+        if (asset == null)
+            return false;
+
         var windows = Resources.FindObjectsOfTypeAll<MasterReampGraphEditWindow>();
         bool foundWindow = false;
         foreach (var w in windows)
             window.Show();
             window.ChangeSelection(asset);
         }
+        return true;
     }
 
     [OnOpenAsset]
-        ShowGraphEditWindow(path);
-        return true;
+        return ShowGraphEditWindow(path);
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Importers/ShaderSubGraphImporterEditor.cs

 using UnityEditor.Experimental.AssetImporters;
 using UnityEditor.MaterialGraph.Drawing;
 using UnityEngine;
+using UnityEngine.MaterialGraph;
 using Debug = System.Diagnostics.Debug;
 
 [CustomEditor(typeof(ShaderSubGraphImporter))]
 
     private static bool ShowGraphEditWindow(string path)
     {
-        var asset = AssetDatabase.LoadAssetAtPath<Object>(path);
+        var asset = AssetDatabase.LoadAssetAtPath<Object>(path) as MaterialSubGraphAsset;
         if (asset == null)
             return false;
 
     static bool OnOpenAsset(int instanceID, int line)
     {
         var path = AssetDatabase.GetAssetPath(instanceID);
-        ShowGraphEditWindow(path);
-        return true;
+        return ShowGraphEditWindow(path);
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Testing/UnitTests/AbstractMaterialGraphTests.cs

         private class TestableMNode : AbstractMaterialNode
         {}
 
-        [TestFixtureSetUp]
+        [OneTimeSetUp]
         public void RunBeforeAnyTests()
         {
             Debug.unityLogger.logHandler = new ConsoleLogHandler();

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Testing/UnitTests/DynamicSlotTests.cs

             }
         }
 
-        [TestFixtureSetUp]
+        [OneTimeSetUp]
         public void RunBeforeAnyTests()
         {
             Debug.unityLogger.logHandler = new ConsoleLogHandler();

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Testing/UnitTests/FixedSlotTests.cs

             }
         }
 
-        [TestFixtureSetUp]
+        [OneTimeSetUp]
         public void RunBeforeAnyTests()
         {
             Debug.unityLogger.logHandler = new ConsoleLogHandler();

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Testing/UnitTests/MaterialGraphTests.cs

     [TestFixture]
     public class MaterialGraphTests
     {
-        [TestFixtureSetUp]
+        [OneTimeSetUp]
         public void RunBeforeAnyTests()
         {
             Debug.unityLogger.logHandler = new ConsoleLogHandler();

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Testing/UnitTests/MaterialNodeTests.cs

             }
         }
 
-        [TestFixtureSetUp]
+        [OneTimeSetUp]
         public void RunBeforeAnyTests()
         {
             Debug.unityLogger.logHandler = new ConsoleLogHandler();
         [Test]
         public void CanConvertConcreteSlotValueTypeToOutputChunkProperly()
         {
-            Assert.AreEqual(string.Empty, AbstractMaterialNode.ConvertConcreteSlotValueTypeToString(ConcreteSlotValueType.Vector1));
-            Assert.AreEqual("2", AbstractMaterialNode.ConvertConcreteSlotValueTypeToString(ConcreteSlotValueType.Vector2));
-            Assert.AreEqual("3", AbstractMaterialNode.ConvertConcreteSlotValueTypeToString(ConcreteSlotValueType.Vector3));
-            Assert.AreEqual("4", AbstractMaterialNode.ConvertConcreteSlotValueTypeToString(ConcreteSlotValueType.Vector4));
-            Assert.AreEqual("Texture2D", AbstractMaterialNode.ConvertConcreteSlotValueTypeToString(ConcreteSlotValueType.Texture2D));
-            Assert.AreEqual("2x2", AbstractMaterialNode.ConvertConcreteSlotValueTypeToString(ConcreteSlotValueType.Matrix2));
-            Assert.AreEqual("3x3", AbstractMaterialNode.ConvertConcreteSlotValueTypeToString(ConcreteSlotValueType.Matrix3));
-            Assert.AreEqual("4x4", AbstractMaterialNode.ConvertConcreteSlotValueTypeToString(ConcreteSlotValueType.Matrix4));
-            Assert.AreEqual("SamplerState", AbstractMaterialNode.ConvertConcreteSlotValueTypeToString(ConcreteSlotValueType.SamplerState));
+            Assert.AreEqual(string.Empty, AbstractMaterialNode.GetSlotDimension(ConcreteSlotValueType.Vector1));
+            Assert.AreEqual("2", AbstractMaterialNode.GetSlotDimension(ConcreteSlotValueType.Vector2));
+            Assert.AreEqual("3", AbstractMaterialNode.GetSlotDimension(ConcreteSlotValueType.Vector3));
+            Assert.AreEqual("4", AbstractMaterialNode.GetSlotDimension(ConcreteSlotValueType.Vector4));
+            Assert.AreEqual("Texture2D", AbstractMaterialNode.GetSlotDimension(ConcreteSlotValueType.Texture2D));
+            Assert.AreEqual("2x2", AbstractMaterialNode.GetSlotDimension(ConcreteSlotValueType.Matrix2));
+            Assert.AreEqual("3x3", AbstractMaterialNode.GetSlotDimension(ConcreteSlotValueType.Matrix3));
+            Assert.AreEqual("4x4", AbstractMaterialNode.GetSlotDimension(ConcreteSlotValueType.Matrix4));
+            Assert.AreEqual("SamplerState", AbstractMaterialNode.GetSlotDimension(ConcreteSlotValueType.SamplerState));
         }
 
         [Test]

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Testing/UnitTests/MaterialSlotTests.cs

             }
         }
 
-        [TestFixtureSetUp]
+        [OneTimeSetUp]
         public void RunBeforeAnyTests()
         {
             Debug.unityLogger.logHandler = new ConsoleLogHandler();
         public void SlotDisplayNameIsCorrect()
         {
             var displayName = "New Display Name";
-
-            var slot = m_NodeA.slot1;
             
             Assert.AreEqual(displayName + "(1)", m_NodeA.slot1.displayName);
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Testing/UnitTests/PropertyGeneratorTests.cs

 
 namespace UnityEditor.MaterialGraph.UnitTests
 {
-    [TestFixture]
-    public class PropertyGeneratorTests
-    {
-        [TestFixtureSetUp]
-        public void RunBeforeAnyTests()
-        {
-            Debug.unityLogger.logHandler = new ConsoleLogHandler();
-        }
+    /* 
+   [TestFixture]
+   public class PropertyGeneratorTests
+   {
+       [OneTimeSetUp]
+       public void RunBeforeAnyTests()
+       {
+           Debug.unityLogger.logHandler = new ConsoleLogHandler();
+       }
-        private const string kPropertyName = "ThePropertyName";
-        private const string kPropertyDescription = "ThePropertyDescription";
+       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);
+     [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));
-        }
+           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);
+       [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'));
-        }
+           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);
+       [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);
-        }*/
-    }
+           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);
+       }
+}*/
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Testing/UnitTests/ShaderGeneratorTests.cs

     [TestFixture]
     public class ShaderGeneratorTests
     {
-        [TestFixtureSetUp]
+        [OneTimeSetUp]
         public void RunBeforeAnyTests()
         {
             Debug.unityLogger.logHandler = new ConsoleLogHandler();

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Util/GraphTypeMapper.cs

 using UnityEditor.Experimental.UIElements.GraphView;
 using UnityEngine;
 using UnityEngine.Graphing;
-using UnityEditor.Experimental.UIElements.GraphView;
 
 namespace UnityEditor.Graphing.Util
 {

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/SubGraph/AbstractSubGraphIONode.cs.meta

-fileFormatVersion: 2
-guid: fc663b99f48623e4b8c707625472d58f
-timeCreated: 1465559219
-licenseType: Pro
-MonoImporter:
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/SubGraph/AbstractSubGraphIONode.cs

-namespace UnityEngine.MaterialGraph
-{
-    public abstract class AbstractSubGraphIONode : AbstractMaterialNode
-    {
-        public abstract int AddSlot();
-
-        public abstract void RemoveSlot();
-
-        /*public void FooterUI(GraphGUI host)
-        {
-            // TODO: make it pretty
-            GUIStyle style = this is SubGraphOutputNode ?
-                Styles.GetNodeStyle("shader in", Styles.Color.Aqua, false) :
-                Styles.GetNodeStyle("shader out", Styles.Color.Aqua, false);
-            var pos = GUILayoutUtility.GetRect(kTempContent, style);
-            int id = GUIUtility.GetControlID(FocusType.Passive);
-
-            Event evt = Event.current;
-            if (evt.type == EventType.Layout || evt.type == EventType.Used)
-                return;
-
-            switch (evt.GetTypeForControl(id))
-            {
-                case EventType.MouseUp:
-                    if (pos.Contains(evt.mousePosition) && evt.button == 0)
-                    {
-                        AddSlot();
-                        evt.Use();
-                    }
-                    break;
-                case EventType.Repaint:
-                    style.Draw(pos, kTempContent, id);
-                    break;
-            }
-        }*/
-    }
-}

MaterialGraphProject/Assets/UnityShaderEditor/Runtime.meta

-fileFormatVersion: 2
-guid: c196fa3d7b5ae4049afeb1cd0400d9b6
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: