From 3eb7115464c68b05a53d139b3aa9d9683039079e Mon Sep 17 00:00:00 2001
From: Carlo Baldassi <carlobaldassi@gmail.com>
Date: Sat, 22 Apr 2017 17:02:33 +0200
Subject: [PATCH] Slight refactoring in test/resolve.jl

This is in order to catch resolver failures
inside `@test` calls
---
 test/resolve.jl | 123 ++++++++++++++++++++++++------------------------
 1 file changed, 62 insertions(+), 61 deletions(-)

diff --git a/test/resolve.jl b/test/resolve.jl
index 059e23a90cecb..f513a884dd4a8 100644
--- a/test/resolve.jl
+++ b/test/resolve.jl
@@ -100,7 +100,7 @@ function sanity_tst(deps_data, expected_result; pkgs=[])
 end
 sanity_tst(deps_data; kw...) = sanity_tst(deps_data, []; kw...)
 
-function resolve_tst(deps_data, reqs_data)
+function resolve_tst(deps_data, reqs_data, want_data = nothing)
     deps = deps_from_data(deps_data)
     reqs = reqs_from_data(reqs_data)
 
@@ -109,6 +109,7 @@ function resolve_tst(deps_data, reqs_data)
     #println("reqs=$reqs")
     deps = Query.prune_dependencies(reqs, deps)
     want = resolve(reqs, deps)
+    return want == want_data
 end
 
 ## DEPENDENCY SCHEME 1: TWO PACKAGES, DAG
@@ -129,15 +130,15 @@ reqs_data = Any[
     ["B"]
 ]
 
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("B"=>v"2")
+want_data = Dict("B"=>v"2")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require just A: must bring in B
 reqs_data = Any[
     ["A"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"2", "B"=>v"2")
+want_data = Dict("A"=>v"2", "B"=>v"2")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 
 ## DEPENDENCY SCHEME 2: TWO PACKAGES, CYCLIC
@@ -154,22 +155,22 @@ deps_data = Any[
 reqs_data = Any[
     ["A"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"2", "B"=>v"2")
+want_data = Dict("A"=>v"2", "B"=>v"2")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require just B, force lower version
 reqs_data = Any[
     ["B", v"1", v"2"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"2", "B"=>v"1")
+want_data = Dict("A"=>v"2", "B"=>v"1")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require just A, force lower version
 reqs_data = Any[
     ["A", v"1", v"2"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"1", "B"=>v"2")
+want_data = Dict("A"=>v"1", "B"=>v"2")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 
 ## DEPENDENCY SCHEME 3: THREE PACKAGES, CYCLIC, TWO MUTUALLY EXCLUSIVE SOLUTIONS
@@ -188,22 +189,22 @@ deps_data = Any[
 reqs_data = Any[
     ["A"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"2", "B"=>v"1", "C"=>v"2")
+want_data = Dict("A"=>v"2", "B"=>v"1", "C"=>v"2")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require just B (must choose solution which has the highest version for B)
 reqs_data = Any[
     ["B"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"1", "B"=>v"2", "C"=>v"1")
+want_data = Dict("A"=>v"1", "B"=>v"2", "C"=>v"1")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require just A, force lower version
 reqs_data = Any[
     ["A", v"1", v"2"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"1", "B"=>v"2", "C"=>v"1")
+want_data = Dict("A"=>v"1", "B"=>v"2", "C"=>v"1")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require A and C, incompatible versions
 reqs_data = Any[
@@ -226,8 +227,8 @@ deps_data = Any[
 reqs_data = Any[
     ["B"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("B"=>v"1")
+want_data = Dict("B"=>v"1")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 
 ## DEPENDENCY SCHEME 5: THREE PACKAGES, DAG, WITH IMPLICIT INCONSISTENCY
@@ -250,8 +251,8 @@ deps_data = Any[
 reqs_data = Any[
     ["A"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"1", "B"=>v"2", "C"=>v"2")
+want_data = Dict("A"=>v"1", "B"=>v"2", "C"=>v"2")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require A, force highest version (impossible)
 reqs_data = Any[
@@ -301,15 +302,15 @@ deps_data = Any[
 reqs_data = Any[
     ["A"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"2", "B"=>v"2", "C"=>v"2")
+want_data = Dict("A"=>v"2", "B"=>v"2", "C"=>v"2")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require C
 reqs_data = Any[
     ["C"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"2", "B"=>v"2", "C"=>v"2")
+want_data = Dict("A"=>v"2", "B"=>v"2", "C"=>v"2")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require C, lowest version (impossible)
 reqs_data = Any[
@@ -374,44 +375,44 @@ deps_data = Any[
 reqs_data = Any[
     ["F"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"3", "B"=>v"2", "C"=>v"2",
-                   "D"=>v"2", "E"=>v"1", "F"=>v"2")
+want_data = Dict("A"=>v"3", "B"=>v"2", "C"=>v"2",
+                 "D"=>v"2", "E"=>v"1", "F"=>v"2")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require just F, lower version
 reqs_data = Any[
     ["F", v"1", v"2"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"2", "B"=>v"2", "D"=>v"2",
-                   "E"=>v"1", "F"=>v"1")
+want_data = Dict("A"=>v"2", "B"=>v"2", "D"=>v"2",
+                 "E"=>v"1", "F"=>v"1")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require F and B; force lower B version -> must bring down F, A, and D versions too
 reqs_data = Any[
     ["F"],
     ["B", v"1", v"2"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"1", "B"=>v"1", "D"=>v"1",
-                   "E"=>v"1", "F"=>v"1")
+want_data = Dict("A"=>v"1", "B"=>v"1", "D"=>v"1",
+                 "E"=>v"1", "F"=>v"1")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require F and D; force lower D version -> must not bring down F version
 reqs_data = Any[
     ["F"],
     ["D", v"1", v"2"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"3", "B"=>v"2", "C"=>v"2",
-                   "D"=>v"1", "E"=>v"1", "F"=>v"2")
+want_data = Dict("A"=>v"3", "B"=>v"2", "C"=>v"2",
+                 "D"=>v"1", "E"=>v"1", "F"=>v"2")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require F and C; force lower C version -> must bring down F and A versions
 reqs_data = Any[
     ["F"],
     ["C", v"1", v"2"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"2", "B"=>v"2", "C"=>v"1",
-                   "D"=>v"2", "E"=>v"1", "F"=>v"1")
+want_data = Dict("A"=>v"2", "B"=>v"2", "C"=>v"1",
+                 "D"=>v"2", "E"=>v"1", "F"=>v"1")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 ## DEPENDENCY SCHEME 10: SIX PACKAGES, DAG, WITH PRERELEASE/BUILD VERSIONS
 deps_data = Any[
@@ -448,44 +449,44 @@ deps_data = Any[
 reqs_data = Any[
     ["F"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"2.1", "B"=>v"1.0.1", "C"=>v"2",
-                   "D"=>v"2", "E"=>v"1", "F"=>v"2")
+want_data = Dict("A"=>v"2.1", "B"=>v"1.0.1", "C"=>v"2",
+                 "D"=>v"2", "E"=>v"1", "F"=>v"2")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require just F, lower version
 reqs_data = Any[
     ["F", v"1", v"2-"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"2", "B"=>v"1.0.1", "D"=>v"2",
-                   "E"=>v"1", "F"=>v"1.1")
+want_data = Dict("A"=>v"2", "B"=>v"1.0.1", "D"=>v"2",
+                 "E"=>v"1", "F"=>v"1.1")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require F and B; force lower B version -> must bring down F, A, and D versions too
 reqs_data = Any[
     ["F"],
     ["B", v"1", v"1.0.1-"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"1", "B"=>v"1", "D"=>v"1",
-                   "E"=>v"1", "F"=>v"1.1")
+want_data = Dict("A"=>v"1", "B"=>v"1", "D"=>v"1",
+                 "E"=>v"1", "F"=>v"1.1")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require F and D; force lower D version -> must not bring down F version
 reqs_data = Any[
     ["F"],
     ["D", v"1", v"2"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"2.1", "B"=>v"1.0.1", "C"=>v"2",
-                   "D"=>v"1", "E"=>v"1", "F"=>v"2")
+want_data = Dict("A"=>v"2.1", "B"=>v"1.0.1", "C"=>v"2",
+                 "D"=>v"1", "E"=>v"1", "F"=>v"2")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require F and C; force lower C version -> must bring down F and A versions
 reqs_data = Any[
     ["F"],
     ["C", v"1", v"2"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"2", "B"=>v"1.0.1", "C"=>v"1+BLD",
-                   "D"=>v"2", "E"=>v"1", "F"=>v"2-rc.1")
+want_data = Dict("A"=>v"2", "B"=>v"1.0.1", "C"=>v"1+BLD",
+                 "D"=>v"2", "E"=>v"1", "F"=>v"2-rc.1")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 ## DEPENDENCY SCHEME 11: FIVE PACKAGES, SAME AS SCHEMES 5 + 1, UNCONNECTED
 deps_data = Any[
@@ -513,15 +514,15 @@ deps_data = Any[
 reqs_data = Any[
     ["A"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"1", "B"=>v"2", "C"=>v"2")
+want_data = Dict("A"=>v"1", "B"=>v"2", "C"=>v"2")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require just D: must bring in E
 reqs_data = Any[
     ["D"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("D"=>v"2", "E"=>v"2")
+want_data = Dict("D"=>v"2", "E"=>v"2")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 
 # require A and D, must be the merge of the previous two cases
@@ -529,5 +530,5 @@ reqs_data = Any[
     ["A"],
     ["D"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"1", "B"=>v"2", "C"=>v"2", "D"=>v"2", "E"=>v"2")
+want_data = Dict("A"=>v"1", "B"=>v"2", "C"=>v"2", "D"=>v"2", "E"=>v"2")
+@test resolve_tst(deps_data, reqs_data, want_data)