Progress on #71 -- Factory methods

Author: zspitz

Tests.Common/Constructed/MakeDefault.cs

@@ -6,24 +6,10 @@ namespace ExpressionToString.Tests {
     public partial class ConstructedBase {
         [Fact]
         [Trait("Category", Defaults)]
-        public void MakeDefaultRefType() => RunTest(
-            Default(typeof(string)),
-            "default(string)",
-            "CType(Nothing, String)", 
-            @"Default(
-    typeof(string)
-)"
-        );
+        public void MakeDefaultRefType() => PreRunTest();
 
         [Fact]
         [Trait("Category", Defaults)]
-        public void MakeDefaultValueType() => RunTest(
-            Default(typeof(int)),
-            "default(int)",
-            "CType(Nothing, Integer)", 
-            @"Default(
-    typeof(int)
-)"
-        );
+        public void MakeDefaultValueType() => PreRunTest();
     }
 }

Tests.Common/Constructed/MakeLoop.cs

@@ -1,48 +1,14 @@
 using Xunit;
-using static System.Linq.Expressions.Expression;
 using static ExpressionToString.Tests.Categories;
 
 namespace ExpressionToString.Tests {
     public partial class ConstructedBase {
         [Fact]
         [Trait("Category", Loops)]
-        public void EmptyLoop() => RunTest(
-            Loop(Constant(true)),
-            @"while (true) {
-    true;
-}",
-            @"Do
-    True
-Loop",
-            @"Loop(
-    Constant(true)
-)"
-            );
+        public void EmptyLoop() => PreRunTest();
 
         [Fact]
         [Trait("Category", Loops)]
-        public void EmptyLoop1() => RunTest(
-            Loop(
-                Block(
-                    Constant(true),
-                    Constant(true)
-                )
-            ),
-            @"while (true) {
-    true;
-    true;
-}",
-            @"Do
-    True
-    True
-Loop", 
-            @"Loop(
-    Block(
-        Constant(true),
-        Constant(true)
-    )
-)"
-            );
-
+        public void EmptyLoop1() => PreRunTest();
     }
 }

Tests.Common/Constructed/MakeMember.cs

@@ -1,31 +1,14 @@
-using System.Linq;
-using Xunit;
-using static System.Linq.Expressions.Expression;
+using Xunit;
 using static ExpressionToString.Tests.Categories;
 
 namespace ExpressionToString.Tests {
     public partial class ConstructedBase {
         [Fact]
         [Trait("Category",Member)]
-        public void InstanceMember() => RunTest(
-            MakeMemberAccess(Constant(""), typeof(string).GetMember("Length").Single()),
-            "\"\".Length",
-            "\"\".Length",
-            @"MakeMemberAccess(
-    Constant(""""),
-    typeof(string).GetProperty(""Length"")
-)"
-        );
+        public void InstanceMember() => PreRunTest();
 
         [Fact]
-        [Trait("Category", MemberBindings)]
-        public void StaticMember() => RunTest(
-            MakeMemberAccess(null, typeof(string).GetMember("Empty").Single()),
-            "string.Empty",
-            "String.Empty", 
-            @"MakeMemberAccess(null,
-    typeof(string).GetField(""Empty"")
-)"
-        );
+        [Trait("Category", Member)]
+        public void StaticMember() => PreRunTest();
     }
 }

Tests.Common/Constructed/MakeRuntimeVariables.cs

@@ -1,41 +1,14 @@
 using Xunit;
-using static ExpressionToString.Tests.Globals;
-using static System.Linq.Expressions.Expression;
 using static ExpressionToString.Tests.Categories;
 
 namespace ExpressionToString.Tests {
     public partial class ConstructedBase {
         [Fact]
         [Trait("Category", RuntimeVars)]
-        public void ConstructRuntimeVariables() => RunTest(
-            RuntimeVariables(x, s1),
-            "// variables -- double x, string s1",
-            "' Variables -- x As Double, s1 As String", 
-            "RuntimeVariables(x, s1)"
-        );
+        public void ConstructRuntimeVariables() => PreRunTest();
 
         [Fact]
         [Trait("Category", RuntimeVars)]
-        public void RuntimeVariablesWithinBlock() => RunTest(
-            Block(
-                new[] { s2 }, //forces an explicit block
-                Constant(true),
-                RuntimeVariables(x, s1)
-            ),
-            @"(
-    string s2,
-    true
-    // variables -- double x, string s1
-)",
-            @"Block
-    Dim s2 As String
-    True
-    ' Variables -- x As Double, s1 As String
-End Block", 
-            @"Block(new[] { s2 },
-    Constant(true),
-    RuntimeVariables(x, s1)
-)"
-        );
+        public void RuntimeVariablesWithinBlock() => PreRunTest();
     }
 }

Tests.Common/Objects/FactoryMethods/FactoryMethods.cs

@@ -1,13 +1,8 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using System.Linq.Expressions;
-using static ExpressionToString.Tests.Functions;
+using System.Linq.Expressions;
 using static ExpressionToString.Tests.Categories;
 using static System.Linq.Expressions.Expression;
 using static ExpressionToString.Tests.Globals;
+using System.Linq;
 
 namespace ExpressionToString.Tests.Objects {
     public static partial class FactoryMethods {
@@ -31,5 +26,41 @@ public static partial class FactoryMethods {
 
         [Category(DebugInfos)]
         public static readonly Expression MakeClearDebugInfo = ClearDebugInfo(document);
+
+        [Category(Loops)]
+        public static readonly Expression EmptyLoop = Loop(Constant(true));
+
+        [Category(Loops)]
+        public static readonly Expression EmptyLoop1 = Loop(
+             Block(
+                 Constant(true),
+                 Constant(true)
+             )
+         );
+
+        [Category(Member)]
+        public static readonly Expression InstanceMember = MakeMemberAccess(
+            Constant(""), 
+            typeof(string).GetMember("Length").Single()
+        );
+
+        [Category(Member)]
+        public static readonly Expression StaticMember = MakeMemberAccess(null, typeof(string).GetMember("Empty").Single());
+
+        [Category(RuntimeVars)]
+        public static readonly Expression ConstructRuntimeVariables = RuntimeVariables(x, s1);
+
+        [Category(RuntimeVars)]
+        public static readonly Expression RuntimeVariablesWithinBlock = Block(
+            new[] { s2 }, //forces an explicit block
+            Constant(true),
+            RuntimeVariables(x, s1)
+        );
+
+        [Category(Defaults)]
+        public static readonly Expression MakeDefaultRefType = Default(typeof(string));
+
+        [Category(Defaults)]
+        public static readonly Expression MakeDefaultValueType = Default(typeof(int));
     }
 }