clean up tests

Author: majocha

tests/FSharp.Compiler.ComponentTests/TypeChecks/Graph/CompilationTests.fs

@@ -48,21 +48,22 @@ let compileScenario (scenario: Scenario) (method: Method) =
     |> withMethod method
     |> compile
 
-let scenarios = scriptCompilationScenario :: scenarios |> List.map (fun c -> [| box c |])
+let compileAValidScenario (scenario: Scenario) (method: Method) =
+    compileScenario scenario method
+    |> shouldSucceed
+    |> ignore
+
+let scenarios = compilingScenarios |> List.map (fun c -> [| box c |])
 
 [<Theory>]
 [<MemberData(nameof scenarios)>]
 let ``Compile a valid scenario using graph-based type-checking`` (scenario) =
-    compileScenario scenario Method.Graph
-    |> shouldSucceed
-    |> ignore
+    compileAValidScenario scenario Method.Graph
 
 [<Theory>]
 [<MemberData(nameof scenarios)>]
 let ``Compile a valid scenario using sequential type-checking`` (scenario) =
-    compileScenario scenario Method.Sequential
-    |> shouldSucceed
-    |> ignore
+    compileAValidScenario scenario Method.Sequential
 
 [<Fact>]
 let ``Compile misordered scenario using graph-based type-checking fails`` () =

tests/FSharp.Compiler.ComponentTests/TypeChecks/Graph/DependencyResolutionTests.fs

@@ -5,7 +5,7 @@ open Xunit
 open FSharp.Compiler.GraphChecking
 open Scenarios
 
-let scenarios = scriptCompilationScenario :: misorderedScenario :: scenarios |> Seq.map (fun p -> [| box p |])
+let scenarios = scenarios |> Seq.map (fun p -> [| box p |])
 
 [<Theory>]
 [<MemberData(nameof scenarios)>]

tests/FSharp.Compiler.ComponentTests/TypeChecks/Graph/Scenarios.fs

@@ -31,7 +31,7 @@ let private sourceFile fileName content (dependencies: Set<int>) =
             Content = content
         }
 
-let internal scenarios =
+let internal compilingScenarios =
     [
         scenario
             "Link via full open statement"
@@ -1085,67 +1085,30 @@ module Y = global.Z.N
                     """
                     (set [| 0 |])
             ]
-
-    ]
-
-let internal misorderedScenario =
-    // New scenario: signature file erroneously follows implementation
-    // We add a backward link from implementation to signature, to correctly trigger
-    // FS0238 (implementation already given).
-    scenario
-        "Signature file follows implementation"
-        [
-            sourceFile
-                "A.fs"
-                """
-    module A
-
-    let a x = x + 1
-    """
-                Set.empty
-            sourceFile
-                "B.fs"
-                """
-    module B
-
-    let b = A.a 42
-    """
-                (set [| 0 |])
-            sourceFile
-                "A.fsi"
-                """
-    module A
-
-    val a: int -> int
-    """
-                (set [| 0 |])
-        ]
-
-let internal scriptCompilationScenario =
-    scenario
-        "Script compilation with #load and downstream files"
-        [
-            sourceFile
-                "A.fs"
-                """
+        scenario
+            "Script compilation with #load and downstream files"
+            [
+                sourceFile
+                    "A.fs"
+                    """
 module LibA
 
 type A = { Value: int }
 
 let inc x = x + 1
 """
-                Set.empty
-            sourceFile
-                "B.fs"
-                """
+                    Set.empty
+                sourceFile
+                    "B.fs"
+                    """
 module LibB
 
 let append s i = s + string i
 """
-                (set [| 0 |])
-            sourceFile
-                "Run.fsx"
-                """
+                    (set [| 0 |])
+                sourceFile
+                    "Run.fsx"
+                    """
 namespace Script
 
 #load "A.fs"
@@ -1155,35 +1118,73 @@ open LibA
 open LibB
 
 module ScriptModule =
-    let compute s =
-        let a = inc 41
-        append s a
+        let compute s =
+            let a = inc 41
+            append s a
 """
-                (set [| 1 |])
-            sourceFile
-                "Independent.fs"
-                """
+                    (set [| 1 |])
+                sourceFile
+                    "Independent.fs"
+                    """
 module Independent
 
 let z = 0
 """
-                Set.empty
-            sourceFile
-                "DependsOnScript.fs"
-                """
+                    Set.empty
+                sourceFile
+                    "DependsOnScript.fs"
+                    """
 module Consumer
 
 open Script.ScriptModule
 
 let result = compute "ok"
 """
-                (set [| 2 |])
-            sourceFile
-                "AlsoDependsOnScript.fs"
-                """
+                    (set [| 2 |])
+                sourceFile
+                    "AlsoDependsOnScript.fs"
+                    """
 module AnotherConsumer
 
 let value = Script.ScriptModule.compute "hi"
 """
-                (set [| 2 |])
-        ]
+                    (set [| 2 |])
+            ]
+    ]
+
+
+// Implementation given before signature file. This scenario will not compile, but is supported.
+// Produced graph should have a necessary dependecy to trigger expected errors. 
+let internal misorderedScenario =
+    scenario
+        "Signature file follows implementation"
+        [
+            sourceFile
+                "A.fs"
+                """
+    module A
+
+    let a x = x + 1
+    """
+                Set.empty
+            sourceFile
+                "B.fs"
+                """
+    module B
+
+    let b = A.a 42
+    """
+                (set [| 0 |])
+            sourceFile
+                "A.fsi"
+                """
+    module A
+
+    val a: int -> int
+    """
+                // We add a backward link from implementation to signature, to correctly trigger
+                // FS0238 (implementation already given).
+                (set [| 0 |])
+        ]
+
+let internal scenarios = misorderedScenario :: compilingScenarios