| blob | a77c25b8ff58e0d9fa3613db2265259e30f2bb27 |
1 {-# LANGUAGE OverloadedStrings #-}
3 -- | This is a set of unit tests for the dependency solver,
4 -- which uses the solver DSL ("UnitTests.Distribution.Solver.Modular.DSL")
5 -- to more conveniently create package databases to run the solver tests on.
7 where
9 -- base
14 -- test-framework
17 -- Cabal
22 )
24 -- cabal-install
33 tests =
34 [ testGroup
35 "Simple dependencies"
39 preferOldest $
44 , runTest $ indep $ mkTest db1 "indepTwoVersions" ["C", "D"] (solverSuccess [("B", 1), ("B", 2), ("C", 1), ("D", 1)])
45 , runTest $ indep $ mkTest db1 "aliasWhenPossible1" ["C", "E"] (solverSuccess [("B", 1), ("C", 1), ("E", 1)])
46 , runTest $ indep $ mkTest db1 "aliasWhenPossible2" ["D", "E"] (solverSuccess [("B", 2), ("D", 1), ("E", 1)])
47 , runTest $ indep $ mkTest db2 "aliasWhenPossible3" ["C", "D"] (solverSuccess [("A", 1), ("A", 2), ("B", 1), ("B", 2), ("C", 1), ("D", 1)])
55 ]
56 , testGroup
57 "Flagged dependencies"
62 , runTest $ indep $ mkTest db18 "linkFlags3" ["A", "B"] (solverSuccess [("A", 1), ("B", 1), ("C", 1), ("D", 1), ("D", 2), ("F", 1)])
63 ]
64 , testGroup
65 "Lifting dependencies out of conditionals"
67 , runTest $ twoLevelDeepCommonDependencyLogMessage "two level deep common dependency log message"
69 ]
70 , testGroup
71 "Manual flags"
78 setVerbose $
81 -- TODO: We should check the summarized log instead of the full log
82 -- for the manual flags error message, but it currently only
83 -- appears in the full log.
87 constraints cs $
90 ]
91 , testGroup
92 "Qualified manual flag constraints"
96 constraints cs $
98 solverSuccess
104 ]
106 cs =
109 ]
111 constraints cs $
113 solverSuccess
119 ]
121 cs =
124 ]
126 constraints cs $
128 solverSuccess
134 ]
139 constraints cs $
143 cs =
146 ]
148 checkFullLog lns =
149 all
153 ]
155 constraints cs $
156 setVerbose $
159 ]
160 , testGroup
161 "Stanzas"
162 [ runTest $ enableAllTests $ mkTest db5 "simpleTest1" ["C"] (solverSuccess [("A", 2), ("C", 1)])
164 , runTest $ enableAllTests $ mkTest db5 "simpleTest3" ["E"] (solverSuccess [("A", 1), ("E", 1)])
166 , runTest $ enableAllTests $ mkTest db5 "simpleTest5" ["G"] (solverSuccess [("A", 2), ("G", 1)])
168 , runTest $ indep $ enableAllTests $ mkTest db5 "simpleTest7" ["E", "G"] (solverSuccess [("A", 1), ("A", 2), ("E", 1), ("G", 1)])
169 , runTest $ enableAllTests $ mkTest db6 "depsWithTests1" ["C"] (solverSuccess [("A", 1), ("B", 1), ("C", 1)])
170 , runTest $ indep $ enableAllTests $ mkTest db6 "depsWithTests2" ["C", "D"] (solverSuccess [("A", 1), ("B", 1), ("C", 1), ("D", 1)])
172 ]
173 , testGroup
174 "Setup dependencies"
180 , runTest $ mkTest db8 "setupDeps6" ["C", "D"] (solverSuccess [("A", 1), ("B", 1), ("B", 2), ("C", 1), ("D", 1)])
181 , runTest $ mkTest db9 "setupDeps7" ["F", "G"] (solverSuccess [("A", 1), ("B", 1), ("B", 2), ("C", 1), ("D", 1), ("E", 1), ("E", 2), ("F", 1), ("G", 1)])
183 , runTest $ indep $ mkTest dbSetupDeps "setupDeps9" ["A", "B"] (solverSuccess [("A", 1), ("B", 1), ("C", 1), ("D", 1), ("D", 2)])
184 ]
185 , testGroup
186 "Base shim"
193 ]
194 , testGroup
195 "Base and non-reinstallable"
198 solverFailure (isInfixOf "rejecting: base-1.0.0 (constraint from non-reinstallable package requires installed instance)")
200 allowBootLibInstalls $
205 solverFailure (isInfixOf "rejecting: ghc-2.0.0 (constraint from non-reinstallable package requires installed instance)")
206 ]
207 , testGroup
208 "reject-unconstrained"
210 onlyConstrained $
214 onlyConstrained $
218 onlyConstrained $
222 onlyConstrained $
224 solverFailure $
225 isInfixOf $
234 ]
235 , testGroup
236 "Cycles"
244 , runTest $ mkTest db15 "cycleThroughSetupDep5" ["E"] (solverSuccess [("C", 2), ("D", 1), ("E", 1)])
247 ]
248 , testGroup
249 "Extensions"
251 , runTest $ mkTestExts [EnableExtension CPP] dbExts1 "unsupportedIndirect" ["B"] anySolverFailure
252 , runTest $ mkTestExts [EnableExtension RankNTypes] dbExts1 "supported" ["A"] (solverSuccess [("A", 1)])
253 , runTest $ mkTestExts (map EnableExtension [CPP, RankNTypes]) dbExts1 "supportedIndirect" ["C"] (solverSuccess [("A", 1), ("B", 1), ("C", 1)])
255 , runTest $ mkTestExts (map EnableExtension [CPP, RankNTypes]) dbExts1 "disabledExtension" ["D"] anySolverFailure
256 , runTest $ mkTestExts (UnknownExtension "custom" : map EnableExtension [CPP, RankNTypes]) dbExts1 "supportedUnknown" ["E"] (solverSuccess [("A", 1), ("B", 1), ("C", 1), ("E", 1)])
257 ]
258 , testGroup
259 "Languages"
261 , runTest $ mkTestLangs [Haskell98, Haskell2010] dbLangs1 "supported" ["A"] (solverSuccess [("A", 1)])
263 , runTest $ mkTestLangs [Haskell98, Haskell2010, UnknownLanguage "Haskell3000"] dbLangs1 "supportedUnknown" ["C"] (solverSuccess [("A", 1), ("B", 1), ("C", 1)])
264 ]
265 , testGroup
266 "Qualified Package Constraints"
272 constraints cs $
278 ]
280 constraints cs $
285 constraints cs $
288 ]
289 , testGroup
290 "Package Preferences"
291 [ runTest $ preferences [ExPkgPref "A" $ mkvrThis 1] $ mkTest db13 "selectPreferredVersionSimple" ["A"] (solverSuccess [("A", 1)])
292 , runTest $ preferences [ExPkgPref "A" $ mkvrOrEarlier 2] $ mkTest db13 "selectPreferredVersionSimple2" ["A"] (solverSuccess [("A", 2)])
293 , runTest
294 $ preferences
297 ]
299 , runTest
300 $ preferences
303 ]
305 , runTest
306 $ preferences
309 ]
311 , runTest
312 $ preferences
315 ]
317 ]
318 , testGroup
319 "Stanza Preferences"
332 ]
333 , testGroup
334 "Buildable Field"
336 , testBuildable "avoid building component with unknown extension" (ExExt (UnknownExtension "unknown"))
337 , testBuildable "avoid building component with unknown language" (ExLang (UnknownLanguage "unknown"))
338 , runTest $ mkTest dbBuildable1 "choose flags that set buildable to false" ["pkg"] (solverSuccess [("flag1-false", 1), ("flag2-true", 1), ("pkg", 1)])
339 , runTest $ mkTest dbBuildable2 "choose version that sets buildable to false" ["A"] (solverSuccess [("A", 1), ("B", 2)])
340 ]
341 , testGroup
342 "Pkg-config dependencies"
345 , runTest $ mkTestPCDepends (Just [("pkgA", "1.0.0"), ("pkgB", "1.0.0")]) dbPC1 "pruneNotFound" ["C"] (solverSuccess [("A", 1), ("B", 1), ("C", 1)])
346 , runTest $ mkTestPCDepends (Just [("pkgA", "1.0.0"), ("pkgB", "2.0.0")]) dbPC1 "chooseNewest" ["C"] (solverSuccess [("A", 1), ("B", 2), ("C", 1)])
349 ]
350 , testGroup
351 "Independent goals"
352 [ runTest $ indep $ mkTest db16 "indepGoals1" ["A", "B"] (solverSuccess [("A", 1), ("B", 1), ("C", 1), ("D", 1), ("D", 2), ("E", 1)])
360 ]
362 testGroup
363 "Backjumping"
373 , runTest $ indep $ mkTest dbBJ8 "bj8" ["A", "B"] (solverSuccess [("A", 1), ("B", 1), ("C", 1)])
374 ]
375 , testGroup
376 "main library dependencies"
384 ]
387 solverFailure (isInfixOf "rejecting: B-1.0.0 (does not contain library, which is required by A)")
389 db =
393 ]
397 ]
398 , testGroup
399 "sub-library dependencies"
403 ]
406 solverFailure $
407 isInfixOf $
408 "rejecting: B-1.0.0 (does not contain library 'sub-lib', which is required by A)"
412 ]
415 solverFailure $
416 isInfixOf $
417 "rejecting: B-1.0.0 (library 'sub-lib' is private, but it is required by A)"
422 `withSubLibrary` exSubLib "sub-lib" [ExFlagged "make-lib-private" (dependencies []) publicDependencies]
423 ]
427 solverFailure $
428 isInfixOf $
429 "rejecting: B-1.0.0 (library 'sub-lib' is private, but it is required by A)"
434 `withSubLibrary` exSubLib "sub-lib" [ExFlagged "make-lib-private" (dependencies []) publicDependencies]
435 ]
443 ]
445 goals =
449 ]
451 goalOrder goals $
453 solverFailure $
454 isInfixOf $
455 "rejecting: C-1.0.0 (requires library 'sub-lib' from B, but the component is private)"
460 ]
468 ]
472 ]
474 testGroup
475 "build-tool-depends"
476 [ runTest $ mkTest dbBuildTools "simple exe dependency" ["A"] (solverSuccess [("A", 1), ("bt-pkg", 2)])
478 disableSolveExecutables $
479 mkTest dbBuildTools "don't install build tool packages in legacy mode" ["A"] (solverSuccess [("A", 1)])
480 , runTest $ mkTest dbBuildTools "flagged exe dependency" ["B"] (solverSuccess [("B", 1), ("bt-pkg", 2)])
482 enableAllTests $
488 disableSolveExecutables $
496 solverFailure (isInfixOf "does not contain executable 'unknown-exe', which is required by F +flagF")
498 enableAllTests $
500 solverFailure (isInfixOf "does not contain executable 'unknown-exe', which is required by G *test")
503 solverFailure $
504 isInfixOf $
505 -- The solver reports the version conflict when a version conflict
506 -- and an executable conflict apply to the same package version.
507 "[__1] rejecting: H:bt-pkg:exe.bt-pkg-4.0.0 (conflict: H => H:bt-pkg:exe.bt-pkg (exe exe1)==3.0.0)\n"
508 ++ "[__1] rejecting: H:bt-pkg:exe.bt-pkg-3.0.0 (does not contain executable 'exe1', which is required by H)\n"
509 ++ "[__1] rejecting: H:bt-pkg:exe.bt-pkg-2.0.0 (conflict: H => H:bt-pkg:exe.bt-pkg (exe exe1)==3.0.0)"
510 , runTest $ chooseExeAfterBuildToolsPackage True "choose exe after choosing its package - success"
511 , runTest $ chooseExeAfterBuildToolsPackage False "choose exe after choosing its package - failure"
512 , runTest $ rejectInstalledBuildToolPackage "reject installed package for build-tool dependency"
513 , runTest $ requireConsistentBuildToolVersions "build tool versions must be consistent within one package"
514 ]
516 testGroup
517 "legacy build-tools"
520 disableSolveExecutables $
521 mkTest dbLegacyBuildTools1 "bt1 - don't install build tool packages in legacy mode" ["A"] (solverSuccess [("A", 1)])
526 disableSolveExecutables $
527 mkTest dbLegacyBuildTools2 "bt2 - don't check for build tool executables in legacy mode" ["A"] (solverSuccess [("A", 1)])
529 , runTest $ mkTest dbLegacyBuildTools4 "bt4" ["C"] (solverSuccess [("A", 1), ("B", 1), ("C", 1), ("alex", 1), ("alex", 2)])
530 , runTest $ mkTest dbLegacyBuildTools5 "bt5" ["B"] (solverSuccess [("A", 1), ("A", 2), ("B", 1), ("alex", 1)])
531 , runTest $ mkTest dbLegacyBuildTools6 "bt6" ["A"] (solverSuccess [("A", 1), ("alex", 1), ("happy", 1)])
532 ]
534 testGroup
535 "internal dependencies"
536 [ runTest $ mkTest dbIssue3775 "issue #3775" ["B"] (solverSuccess [("A", 2), ("B", 2), ("warp", 1)])
537 ]
541 in [ let db = [Right $ exAv "A" 1 [ExFlagged "build-lib" (dependencies []) unbuildableDependencies]]
550 ]
558 ]
562 solverFailure $
563 isInfixOf $
564 "rejecting: B-1.0.0 (library is not buildable in the "
571 ]
581 ]
585 solverFailure $
586 isInfixOf $
587 "rejecting: A:B:exe.B-1.0.0 (executable 'bt' is not "
590 chooseUnbuildableExeAfterBuildToolsPackage
591 "choose unbuildable exe after choosing its package"
592 ]
593 , testGroup
594 "--fine-grained-conflicts"
596 --
597 -- When the solver explores A-4, it finds that it cannot satisfy B's
598 -- dependencies. This allows the solver to skip the subsequent
599 -- versions of A that also depend on B.
600 runTest $
608 ]
609 msg =
622 ]
628 -- dependency:
629 --
630 -- The solver rejects A-4 because its constraint on B excludes B-1.
631 -- Then the solver is able to skip A-3 and A-2 because they also
632 -- exclude B-1, even though they don't have the exact same constraints
633 -- on B.
634 runTest $
641 ]
642 msg =
654 ]
660 -- package, B, before choosing a version for one of its reverse
661 -- dependencies, C. While the solver is exploring the subtree rooted
662 -- at B-3, it finds that C-2's dependency on B conflicts with B-3.
663 -- Then the solver is able to skip C-1, because it also excludes B-3.
664 --
665 -- --fine-grained-conflicts could have a benefit in this case even
666 -- though the solver would have found the conflict between B-3 and C-1
667 -- immediately after trying C-1 anyway. It prevents C-1 from
668 -- introducing any other conflicts which could increase the size of
669 -- the conflict set.
670 runTest $
678 ]
680 expectedMsg =
692 ]
694 goalOrder goals $
699 -- multiple reasons to add a variable to the conflict set. In this
700 -- case, package A conflicts with B and C. The solver should take the
701 -- union of the conflicts and then only skip a version if it does not
702 -- resolve any of the conflicts.
703 --
704 -- The solver rejects A-3 because it can't find consistent versions for
705 -- its two dependencies, B and C. Then it skips A-2 because A-2 also
706 -- depends on B and C. This test ensures that the solver considers
707 -- A-1 even though A-1 only resolves one of the conflicts (A-1 removes
708 -- the dependency on C).
709 runTest $
718 ]
720 msg =
738 ]
740 goalOrder goals $
745 -- that the solver encountered in a subtree. The solver should only
746 -- show the conflicts that are contained in the current conflict set.
747 --
748 -- The goal order forces the solver to try A-4, encounter a conflict
749 -- with B-2, try B-1, and then try C. A-4 conflicts with the only
750 -- version of C, so the solver backjumps with a conflict set of
751 -- {A, C}. When the solver skips the next version of A, the log should
752 -- mention the conflict with C but not B.
753 runTest $
762 ]
764 msg =
778 ]
780 goalOrder goals $
785 -- skipped due to being excluded by one of its reverse dependencies'
786 -- constraints.
787 runTest $
793 ]
794 msg =
798 -- conflict set, with the details of each package's
799 -- conflict:
800 --
801 -- A: A's constraint rejected B-2.
802 -- B: B was rejected by A's B==3 constraint
803 "[__1] rejecting: B-2.0.0 (conflict: A => B==3.0.0)"
805 -- previous conflict set. It also needs to update A's
806 -- entry to say that A also rejected B-1. Otherwise, the
807 -- solver wouldn't know that A-1 could resolve one of
808 -- the conflicts encountered while exploring A-2. The
809 -- solver would skip A-1, even though it leads to the
810 -- solution.
811 "[__1] skipping: B-1.0.0 (has the same characteristics that caused "
819 ]
825 -- skipped due to excluding a version of one of its dependencies.
826 -- This test is similar the previous one, with the goal order reversed.
827 runTest $
833 ]
835 msg =
847 ]
849 goalOrder goals $
853 ]
855 testGroup
856 "Solver log"
858 runTest $
862 p lg =
867 SolverResult p $
871 msg =
872 "After searching the rest of the dependency tree exhaustively, "
892 "Backjump limit reached (currently 1, change with --max-backjumps "
895 , testMinimizeConflictSet
896 "minimize conflict set with --minimize-conflict-set"
897 , testNoMinimizeConflictSet
898 "show original conflict set with --no-minimize-conflict-set"
903 ]
911 ]
915 , testGroup
916 "package versions abbreviation (issue #9559.)"
922 ]
932 ]
943 ]
954 ]
959 ]
960 ]
961 ]
962 where
963 indep = independentGoals
970 {-------------------------------------------------------------------------------
971 Specific example database for the tests
972 -------------------------------------------------------------------------------}
974 db1 :: ExampleDb
975 db1 =
986 ]
988 -- In this example, we _can_ install C and D as independent goals, but we have
989 -- to pick two different versions for B (arbitrarily)
990 db2 :: ExampleDb
991 db2 =
998 ]
1000 db3 :: ExampleDb
1001 db3 =
1007 ]
1009 -- | Like db3, but the flag picks a different package rather than a
1010 -- different package version
1011 --
1012 -- In db3 we cannot install C and D as independent goals because:
1013 --
1014 -- * The multiple instance restriction says C and D _must_ share B
1015 -- * Since C relies on A-1, C needs B to be compiled with flagB on
1016 -- * Since D relies on A-2, D needs B to be compiled with flagB off
1017 -- * Hence C and D have incompatible requirements on B's flags.
1018 --
1019 -- However, _even_ if we don't check explicitly that we pick the same flag
1020 -- assignment for 0.B and 1.B, we will still detect the problem because
1021 -- 0.B depends on 0.A-1, 1.B depends on 1.A-2, hence we cannot link 0.A to
1022 -- 1.A and therefore we cannot link 0.B to 1.B.
1023 --
1024 -- In db4 the situation however is trickier. We again cannot install
1025 -- packages C and D as independent goals because:
1026 --
1027 -- * As above, the multiple instance restriction says that C and D _must_ share B
1028 -- * Since C relies on Ax-2, it requires B to be compiled with flagB off
1029 -- * Since D relies on Ay-2, it requires B to be compiled with flagB on
1030 -- * Hence C and D have incompatible requirements on B's flags.
1031 --
1032 -- But now this requirement is more indirect. If we only check dependencies
1033 -- we don't see the problem:
1034 --
1035 -- * We link 0.B to 1.B
1036 -- * 0.B relies on Ay-1
1037 -- * 1.B relies on Ax-1
1038 --
1039 -- We will insist that 0.Ay will be linked to 1.Ay, and 0.Ax to 1.Ax, but since
1040 -- we only ever assign to one of these, these constraints are never broken.
1041 db4 :: ExampleDb
1042 db4 =
1050 ]
1052 -- | Simple database containing one package with a manual flag.
1053 dbManualFlags :: ExampleDb
1054 dbManualFlags =
1060 ]
1062 -- | Database containing a setup dependency with a manual flag. A's library and
1063 -- setup script depend on two different versions of B. B's manual flag can be
1064 -- set to different values in the two places where it is used.
1065 dbSetupDepWithManualFlag :: ExampleDb
1066 dbSetupDepWithManualFlag =
1070 declareFlags bFlags $
1071 exAv
1072 "B"
1073 1
1074 [ exFlagged
1075 "flag"
1078 ]
1080 declareFlags bFlags $
1081 exAv
1082 "B"
1083 2
1084 [ exFlagged
1085 "flag"
1088 ]
1093 ]
1095 -- | A database similar to 'dbSetupDepWithManualFlag', except that the library
1096 -- and setup script both depend on B-1. B must be linked because of the Single
1097 -- Instance Restriction, and its flag can only have one value.
1098 dbLinkedSetupDepWithManualFlag :: ExampleDb
1099 dbLinkedSetupDepWithManualFlag =
1103 exAv
1104 "B"
1105 1
1106 [ exFlagged
1107 "flag"
1110 ]
1113 ]
1115 -- | Some tests involving testsuites
1116 --
1117 -- Note that in this test framework test suites are always enabled; if you
1118 -- want to test without test suites just set up a test database without
1119 -- test suites.
1120 --
1121 -- * C depends on A (through its test suite)
1122 -- * D depends on B-2 (through its test suite), but B-2 is unavailable
1123 -- * E depends on A-1 directly and on A through its test suite. We prefer
1124 -- to use A-1 for the test suite in this case.
1125 -- * F depends on A-1 directly and on A-2 through its test suite. In this
1126 -- case we currently fail to install F, although strictly speaking
1127 -- test suites should be considered independent goals.
1128 -- * G is like E, but for version A-2. This means that if we cannot install
1129 -- E and G together, unless we regard them as independent goals.
1130 db5 :: ExampleDb
1131 db5 =
1140 ]
1142 -- Now the _dependencies_ have test suites
1143 --
1145 -- * Installing C is a simple example. C wants version 1 of A, but depends on
1147 -- B, and B's testsuite depends on an any version of A. In this case we prefer
1148 -- to link (if we don't regard test suites as independent goals then of course
1149 -- linking here doesn't even come into it).
1151 -- * Installing [C, D] means that we prefer to link B -- depending on how we
1153 -- set things up, this means that we should also link their test suites.
1154 db6 :: ExampleDb
1155 db6 =
1161 ]
1163 -- | This test checks that the solver can backjump to disable a flag, even if
1164 -- the problematic dependency is also under a test suite. (issue #4390)
1165 --
1166 -- The goal order forces the solver to choose the flag before enabling testing.
1167 -- Previously, the solver couldn't handle this case, because it only tried to
1168 -- disable testing, and when that failed, it backjumped past the flag choice.
1169 -- The solver should also try to set the flag to false, because that avoids the
1170 -- dependency on B.
1172 testTestSuiteWithFlag name =
1173 goalOrder goals $
1174 enableAllTests $
1177 where
1178 db :: ExampleDb
1179 db =
1184 ]
1187 goals =
1192 ]
1194 -- Packages with setup dependencies
1195 --
1196 -- Install..
1198 -- * B: Simple example, just make sure setup deps are taken into account at all
1200 -- * C: Both the package and the setup script depend on any version of A.
1202 -- In this case we prefer to link
1204 -- * D: Variation on C.1 where the package requires a specific (not latest)
1206 -- version but the setup dependency is not fixed. Again, we prefer to
1207 -- link (picking the older version)
1209 -- * E: Variation on C.2 with the setup dependency the more inflexible.
1211 -- Currently, in this case we do not see the opportunity to link because
1212 -- we consider setup dependencies after normal dependencies; we will
1213 -- pick A.2 for E, then realize we cannot link E.setup.A to A.2, and pick
1214 -- A.1 instead. This isn't so easy to fix (if we want to fix it at all);
1215 -- in particular, considering setup dependencies _before_ other deps is
1216 -- not an improvement, because in general we would prefer to link setup
1217 -- setups to package deps, rather than the other way around. (For example,
1218 -- if we change this ordering then the test for D would start to install
1219 -- two versions of A).
1221 -- * F: The package and the setup script depend on different versions of A.
1223 -- This will only work if setup dependencies are considered independent.
1224 db7 :: ExampleDb
1225 db7 =
1233 ]
1235 -- If we install C and D together (not as independent goals), we need to build
1236 -- both B.1 and B.2, both of which depend on A.
1237 db8 :: ExampleDb
1238 db8 =
1244 ]
1246 -- Extended version of `db8` so that we have nested setup dependencies
1247 db9 :: ExampleDb
1248 db9 =
1249 db8
1254 ]
1256 -- Multiple already-installed packages with inter-dependencies, and one package
1257 -- (C) that depends on package A-1 for its setup script and package A-2 as a
1258 -- library dependency.
1259 db10 :: ExampleDb
1260 db10 =
1267 , Left ghc_prim
1268 , Left base
1269 , Left a1
1270 , Left a2
1272 ]
1274 -- | This database tests that a package's setup dependencies are correctly
1275 -- linked when the package is linked. See pull request #3268.
1276 --
1277 -- When A and B are installed as independent goals, their dependencies on C must
1278 -- be linked, due to the single instance restriction. Since C depends on D, 0.D
1279 -- and 1.D must be linked. C also has a setup dependency on D, so 0.C-setup.D
1280 -- and 1.C-setup.D must be linked. However, D's two link groups must remain
1281 -- independent. The solver should be able to choose D-1 for C's library and D-2
1282 -- for C's setup script.
1283 dbSetupDeps :: ExampleDb
1284 dbSetupDeps =
1290 ]
1292 -- | Tests for dealing with base shims
1293 db11 :: ExampleDb
1294 db11 =
1298 , Left base4
1300 ]
1302 -- | Slightly more realistic version of db11 where base-3 depends on syb
1303 -- This means that if a package depends on base-3 and on syb, then they MUST
1304 -- share the version of syb
1305 --
1306 -- * Package A relies on base-3 (which relies on base-4)
1307 -- * Package B relies on base-4
1308 -- * Package C relies on both A and B
1309 -- * Package D relies on base-3 and on syb-2, which is not possible because
1310 -- base-3 has a dependency on syb-1 (non-inheritance of the Base qualifier)
1311 -- * Package E relies on base-4 and on syb-2, which is fine.
1312 db12 :: ExampleDb
1313 db12 =
1318 , Left base4
1319 , Left syb1
1326 ]
1328 dbBase :: ExampleDb
1329 dbBase =
1331 exAv
1332 "base"
1333 1
1338 ]
1340 dbNonupgrade :: ExampleDb
1341 dbNonupgrade =
1349 ]
1351 db13 :: ExampleDb
1352 db13 =
1356 ]
1358 -- | A, B, and C have three different dependencies on D that can be set to
1359 -- different versions with qualified constraints. Each version of D can only
1360 -- be depended upon by one version of A, B, or C, so that the versions of A, B,
1361 -- and C in the install plan indicate which version of D was chosen for each
1362 -- dependency. The one-to-one correspondence between versions of A, B, and C and
1363 -- versions of D also prevents linking, which would complicate the solver's
1364 -- behavior.
1365 dbConstraints :: ExampleDb
1366 dbConstraints =
1372 dbStanzaPreferences1 :: ExampleDb
1373 dbStanzaPreferences1 =
1376 ]
1378 dbStanzaPreferences2 :: ExampleDb
1379 dbStanzaPreferences2 =
1381 ]
1383 -- | This is a test case for a bug in stanza preferences (#3930). The solver
1384 -- should be able to install 'A' by enabling 'flag' and disabling testing. When
1385 -- it tries goals in the specified order and prefers testing, it encounters
1386 -- 'unknown-pkg2'. 'unknown-pkg2' is only introduced by testing and 'flag', so
1387 -- the conflict set should contain both of those variables. Before the fix, it
1388 -- only contained 'flag'. The solver backjumped past the choice to disable
1389 -- testing and failed to find the solution.
1391 testStanzaPreference name =
1393 exAv
1394 "A"
1395 1
1396 [ exFlagged
1397 "flag"
1398 []
1400 ]
1401 `withTest` exTest
1402 "test"
1403 [ exFlagged
1404 "flag"
1406 []
1407 ]
1408 goals =
1412 ]
1414 goalOrder goals $
1419 -- | Database with some cycles
1420 --
1421 -- * Simplest non-trivial cycle: A -> B and B -> A
1422 -- * There is a cycle C -> D -> C, but it can be broken by picking the
1423 -- right flag assignment.
1424 db14 :: ExampleDb
1425 db14 =
1431 ]
1433 -- | Cycles through setup dependencies
1434 --
1435 -- The first cycle is unsolvable: package A has a setup dependency on B,
1436 -- B has a regular dependency on A, and we only have a single version available
1437 -- for both.
1438 --
1439 -- The second cycle can be broken by picking different versions: package C-2.0
1440 -- has a setup dependency on D, and D has a regular dependency on C-*. However,
1441 -- version C-1.0 is already available (perhaps it didn't have this setup dep).
1442 -- Thus, we should be able to break this cycle even if we are installing package
1443 -- E, which explicitly depends on C-2.0.
1444 db15 :: ExampleDb
1445 db15 =
1454 ]
1456 -- | Detect a cycle between a package and its setup script.
1457 --
1458 -- This type of cycle can easily occur when v2-build adds default setup
1459 -- dependencies to packages without custom-setup stanzas. For example, cabal
1460 -- adds 'time' as a setup dependency for 'time'. The solver should detect the
1461 -- cycle when it attempts to link the setup and non-setup instances of the
1462 -- package and then choose a different version for the setup dependency.
1464 issue4161 name =
1465 setVerbose $
1467 SolverResult checkFullLog $
1469 where
1470 db :: ExampleDb
1471 db =
1475 ]
1478 checkFullLog =
1480 isInfixOf $
1481 "rejecting: time:setup.time~>time-2.0.0 (cyclic dependencies; "
1484 -- | Packages pkg-A, pkg-B, and pkg-C form a cycle. The solver should backtrack
1485 -- as soon as it chooses the last package in the cycle, to avoid searching parts
1486 -- of the tree that have no solution. Since there is no way to break the cycle,
1487 -- it should fail with an error message describing the cycle.
1489 testCyclicDependencyErrorMessages name =
1490 goalOrder goals $
1492 SolverResult checkFullLog $
1493 Left checkSummarizedLog
1494 where
1495 db :: ExampleDb
1496 db =
1502 ]
1504 -- The solver should backtrack as soon as pkg-A, pkg-B, and pkg-C form a
1505 -- cycle. It shouldn't try pkg-D or pkg-E.
1507 checkFullLog =
1511 checkSummarizedLog =
1512 isInfixOf "rejecting: pkg-C-1.0.0 (cyclic dependencies; conflict set: pkg-A, pkg-B, pkg-C)"
1514 -- Solve for pkg-D and pkg-E last.
1518 -- | Check that the solver can backtrack after encountering the SIR (issue #2843)
1519 --
1520 -- When A and B are installed as independent goals, the single instance
1521 -- restriction prevents B from depending on C. This database tests that the
1522 -- solver can backtrack after encountering the single instance restriction and
1523 -- choose the only valid flag assignment (-flagA +flagB):
1524 --
1525 -- > flagA flagB B depends on
1526 -- > On _ C-*
1527 -- > Off On E-* <-- only valid flag assignment
1528 -- > Off Off D-2.0, C-*
1529 --
1530 -- Since A depends on C-* and D-1.0, and C-1.0 depends on any version of D,
1531 -- we must build C-1.0 against D-1.0. Since B depends on D-2.0, we cannot have
1532 -- C in the transitive closure of B's dependencies, because that would mean we
1533 -- would need two instances of C: one built against D-1.0 and one built against
1534 -- D-2.0.
1535 db16 :: ExampleDb
1536 db16 =
1539 exAv
1540 "B"
1541 1
1543 , exFlagged
1544 "flagA"
1546 [ exFlagged
1547 "flagB"
1550 ]
1551 ]
1556 ]
1558 -- Try to get the solver to backtrack while satisfying
1559 -- reject-unconstrained-dependencies: both the first and last versions of A
1560 -- require packages outside the closed set, so it will have to try the
1561 -- middle one.
1562 db17 :: ExampleDb
1563 db17 =
1569 ]
1571 -- | This test checks that when the solver discovers a constraint on a
1572 -- package's version after choosing to link that package, it can backtrack to
1573 -- try alternative versions for the linked-to package. See pull request #3327.
1574 --
1575 -- When A and B are installed as independent goals, their dependencies on C
1576 -- must be linked. Since C depends on D, A and B's dependencies on D must also
1577 -- be linked. This test fixes the goal order so that the solver chooses D-2 for
1578 -- both 0.D and 1.D before it encounters the test suites' constraints. The
1579 -- solver must backtrack to try D-1 for both 0.D and 1.D.
1581 testIndepGoals2 name =
1582 goalOrder goals $
1583 independentGoals $
1584 enableAllTests $
1587 where
1588 db :: ExampleDb
1589 db =
1595 ]
1598 goals =
1607 ]
1609 -- | Issue #2834
1610 -- When both A and B are installed as independent goals, their dependencies on
1611 -- C must be linked. The only combination of C's flags that is consistent with
1612 -- A and B's dependencies on D is -flagA +flagB. This database tests that the
1613 -- solver can backtrack to find the right combination of flags (requiring F, but
1614 -- not E or G) and apply it to both 0.C and 1.C.
1615 --
1616 -- > flagA flagB C depends on
1617 -- > On _ D-1, E-*
1618 -- > Off On F-* <-- Only valid choice
1619 -- > Off Off D-2, G-*
1620 --
1621 -- The single instance restriction means we cannot have one instance of C
1622 -- built against D-1 and one instance built against D-2; since A depends on
1623 -- D-1, and B depends on C-2, it is therefore important that C cannot depend
1624 -- on any version of D.
1625 db18 :: ExampleDb
1626 db18 =
1630 exAv
1631 "C"
1632 1
1633 [ exFlagged
1634 "flagA"
1636 [ exFlagged
1637 "flagB"
1640 ]
1641 ]
1647 ]
1649 -- | When both values for flagA introduce package B, the solver should be able
1650 -- to choose B before choosing a value for flagA. It should try to choose a
1651 -- version for B that is in the union of the version ranges required by +flagA
1652 -- and -flagA.
1654 commonDependencyLogMessage name =
1656 solverFailure $
1657 isInfixOf $
1661 where
1662 db :: ExampleDb
1663 db =
1665 exAv
1666 "A"
1667 1
1668 [ exFlagged
1669 "flagA"
1672 ]
1674 ]
1676 -- | Test lifting dependencies out of multiple levels of conditionals.
1678 twoLevelDeepCommonDependencyLogMessage name =
1680 solverFailure $
1681 isInfixOf $
1682 "unknown package: B (dependency of A +/-flagA +/-flagB)"
1683 where
1684 db :: ExampleDb
1685 db =
1687 exAv
1688 "A"
1689 1
1690 [ exFlagged
1691 "flagA"
1692 [ exFlagged
1693 "flagB"
1696 ]
1697 [ exFlagged
1698 "flagB"
1701 ]
1702 ]
1703 ]
1705 -- | Test handling nested conditionals that are controlled by the same flag.
1706 -- The solver should treat flagA as introducing 'unknown' with value true, not
1707 -- both true and false. That means that when +flagA causes a conflict, the
1708 -- solver should try flipping flagA to false to resolve the conflict, rather
1709 -- than backjumping past flagA.
1711 testBackjumpingWithCommonDependency name =
1713 where
1714 db :: ExampleDb
1715 db =
1717 exAv
1718 "A"
1719 1
1720 [ exFlagged
1721 "flagA"
1722 [ exFlagged
1723 "flagA"
1726 ]
1728 ]
1730 ]
1732 -- | Tricky test case with independent goals (issue #2842)
1733 --
1734 -- Suppose we are installing D, E, and F as independent goals:
1735 --
1736 -- * D depends on A-* and C-1, requiring A-1 to be built against C-1
1737 -- * E depends on B-* and C-2, requiring B-1 to be built against C-2
1738 -- * F depends on A-* and B-*; this means we need A-1 and B-1 both to be built
1739 -- against the same version of C, violating the single instance restriction.
1740 --
1741 -- We can visualize this DB as:
1742 --
1743 -- > C-1 C-2
1744 -- > /|\ /|\
1745 -- > / | \ / | \
1746 -- > / | X | \
1747 -- > | | / \ | |
1748 -- > | |/ \| |
1749 -- > | + + |
1750 -- > | | | |
1751 -- > | A B |
1752 -- > \ |\ /| /
1753 -- > \ | \ / | /
1754 -- > \| V |/
1755 -- > D F E
1757 testIndepGoals3 name =
1758 goalOrder goals $
1759 independentGoals $
1761 where
1762 db :: ExampleDb
1763 db =
1771 ]
1774 goals =
1785 ]
1787 -- | This test checks that the solver correctly backjumps when dependencies
1788 -- of linked packages are not linked. It is an example where the conflict set
1789 -- from enforcing the single instance restriction is not sufficient. See pull
1790 -- request #3327.
1791 --
1792 -- When A, B, and C are installed as independent goals with the specified goal
1793 -- order, the first choice that the solver makes for E is 0.E-2. Then, when it
1794 -- chooses dependencies for B and C, it links both 1.E and 2.E to 0.E. Finally,
1795 -- the solver discovers C's test's constraint on E. It must backtrack to try
1796 -- 1.E-1 and then link 2.E to 1.E. Backjumping all the way to 0.E does not lead
1797 -- to a solution, because 0.E's version is constrained by A and cannot be
1798 -- changed.
1800 testIndepGoals4 name =
1801 goalOrder goals $
1802 independentGoals $
1803 enableAllTests $
1806 where
1807 db :: ExampleDb
1808 db =
1815 ]
1818 goals =
1828 ]
1830 -- | Test the trace messages that we get when a package refers to an unknown pkg
1831 --
1832 -- TODO: Currently we don't actually test the trace messages, and this particular
1833 -- test still succeeds. The trace can only be verified by hand.
1834 db21 :: ExampleDb
1835 db21 =
1839 ]
1841 -- | A variant of 'db21', which actually fails.
1842 db22 :: ExampleDb
1843 db22 =
1846 ]
1848 -- | Another test for the unknown package message. This database tests that
1849 -- filtering out redundant conflict set messages in the solver log doesn't
1850 -- interfere with generating a message about a missing package (part of issue
1851 -- #3617). The conflict set for the missing package is {A, B}. That conflict set
1852 -- is propagated up the tree to the level of A. Since the conflict set is the
1853 -- same at both levels, the solver only keeps one of the backjumping messages.
1854 db23 :: ExampleDb
1855 db23 =
1857 ]
1859 -- | Database for (unsuccessfully) trying to expose a bug in the handling
1860 -- of implied linking constraints. The question is whether an implied linking
1861 -- constraint should only have the introducing package in its conflict set,
1862 -- or also its link target.
1863 --
1864 -- It turns out that as long as the Single Instance Restriction is in place,
1865 -- it does not matter, because there will always be an option that is failing
1866 -- due to the SIR, which contains the link target in its conflict set.
1867 --
1868 -- Even if the SIR is not in place, if there is a solution, one will always
1869 -- be found, because without the SIR, linking is always optional, but never
1870 -- necessary.
1872 testIndepGoals5 name fixGoalOrder =
1874 FixedGoalOrder -> goalOrder goals test
1875 DefaultGoalOrder -> test
1876 where
1877 test :: SolverTest
1878 test =
1879 independentGoals $
1881 solverSuccess
1884 db :: ExampleDb
1885 db =
1893 ]
1896 goals =
1905 ]
1907 -- | A simplified version of 'testIndepGoals5'.
1909 testIndepGoals6 name fixGoalOrder =
1911 FixedGoalOrder -> goalOrder goals test
1912 DefaultGoalOrder -> test
1913 where
1914 test :: SolverTest
1915 test =
1916 independentGoals $
1918 solverSuccess
1921 db :: ExampleDb
1922 db =
1929 ]
1932 goals =
1939 ]
1941 dbExts1 :: ExampleDb
1942 dbExts1 =
1948 ]
1950 dbLangs1 :: ExampleDb
1951 dbLangs1 =
1955 ]
1957 -- | cabal must set enable-exe to false in order to avoid the unavailable
1958 -- dependency. Flags are true by default. The flag choice causes "pkg" to
1959 -- depend on "false-dep".
1961 testBuildable testName unavailableDep =
1962 runTest $
1964 where
1966 db =
1968 exAv
1969 "pkg"
1970 1
1971 [ exFlagged
1972 "enable-exe"
1975 ]
1976 `withExe` exExe
1977 "exe"
1978 [ unavailableDep
1980 ]
1983 ]
1985 -- | cabal must choose -flag1 +flag2 for "pkg", which requires packages
1986 -- "flag1-false" and "flag2-true".
1987 dbBuildable1 :: ExampleDb
1988 dbBuildable1 =
1990 exAv
1991 "pkg"
1992 1
1995 ]
1996 `withExes` [ exExe
1997 "exe1"
2001 ]
2002 , exExe
2003 "exe2"
2005 , ExFlagged
2006 "flag1"
2009 ]
2010 ]
2015 ]
2017 -- | cabal must pick B-2 to avoid the unknown dependency.
2018 dbBuildable2 :: ExampleDb
2019 dbBuildable2 =
2024 `withExe` exExe
2025 "exe"
2028 ]
2030 ]
2032 -- | Package databases for testing @pkg-config@ dependencies.
2033 -- when no pkgconfig db is present, cabal must pick flag1 false and flag2 true to avoid the pkg dependency.
2034 dbPC1 :: ExampleDb
2035 dbPC1 =
2041 ]
2043 -- | Test for the solver's summarized log. The final conflict set is {A, F},
2044 -- though the goal order forces the solver to find the (avoidable) conflict
2045 -- between B and C first. When the solver reaches the backjump limit, it should
2046 -- only show the log to the first conflict. When the backjump limit is high
2047 -- enough to allow an exhaustive search, the solver should make use of the final
2048 -- conflict set to only show the conflict between A and F in the summarized log.
2050 testSummarizedLog testName mbj expectedMsg =
2051 runTest $
2052 maxBackjumps mbj $
2053 goalOrder goals $
2056 where
2057 db =
2063 ]
2068 dbMinimizeConflictSet :: ExampleDb
2069 dbMinimizeConflictSet =
2076 ]
2078 -- | Test that the solver can find a minimal conflict set with
2079 -- --minimize-conflict-set. In the first run, the goal order causes the solver
2080 -- to find that A-3 conflicts with B, A-2 conflicts with C, and A-1 conflicts
2081 -- with D. The full log should show that the original final conflict set is
2082 -- {A, B, C, D}. Then the solver should be able to reduce the conflict set to
2083 -- {A, D}, since all versions of A conflict with D. The summarized log should
2084 -- only mention A and D.
2086 testMinimizeConflictSet testName =
2087 runTest $
2088 minimizeConflictSet $
2089 goalOrder goals $
2090 setVerbose $
2093 where
2095 checkFullLog =
2096 containsInOrder
2106 ]
2108 expectedMsg =
2120 -- | This test uses the same packages and goal order as testMinimizeConflictSet,
2121 -- but it doesn't set --minimize-conflict-set. The solver should print the
2122 -- original final conflict set and the conflict between A and B. It should also
2123 -- suggest rerunning with --minimize-conflict-set.
2125 testNoMinimizeConflictSet testName =
2126 runTest $
2127 goalOrder goals $
2128 setVerbose $
2131 where
2132 expectedMsg =
2146 {-------------------------------------------------------------------------------
2147 Simple databases for the illustrations for the backjumping blog post
2148 -------------------------------------------------------------------------------}
2150 -- | Motivate conflict sets
2151 dbBJ1a :: ExampleDb
2152 dbBJ1a =
2156 ]
2158 -- | Show that we can skip some decisions
2159 dbBJ1b :: ExampleDb
2160 dbBJ1b =
2166 ]
2168 -- | Motivate why both A and B need to be in the conflict set
2169 dbBJ1c :: ExampleDb
2170 dbBJ1c =
2174 ]
2176 -- | Motivate the need for accumulating conflict sets while we walk the tree
2177 dbBJ2 :: ExampleDb
2178 dbBJ2 =
2184 ]
2186 -- | Motivate the need for `QGoalReason`
2187 dbBJ3 :: ExampleDb
2188 dbBJ3 =
2194 ]
2196 -- | `QGOalReason` not unique
2197 dbBJ4 :: ExampleDb
2198 dbBJ4 =
2202 ]
2204 -- | Flags are represented somewhat strangely in the tree
2205 --
2206 -- This example probably won't be in the blog post itself but as a separate
2207 -- bug report (#3409)
2208 dbBJ5 :: ExampleDb
2209 dbBJ5 =
2214 ]
2216 -- | Conflict sets for cycles
2217 dbBJ6 :: ExampleDb
2218 dbBJ6 =
2223 ]
2225 -- | Conflicts not unique
2226 dbBJ7 :: ExampleDb
2227 dbBJ7 =
2232 ]
2234 -- | Conflict sets for SIR (C shared subgoal of independent goals A, B)
2235 dbBJ8 :: ExampleDb
2236 dbBJ8 =
2240 ]
2242 {-------------------------------------------------------------------------------
2243 Databases for build-tool-depends
2244 -------------------------------------------------------------------------------}
2246 -- | Multiple packages depending on exes from 'bt-pkg'.
2247 dbBuildTools :: ExampleDb
2248 dbBuildTools =
2251 exAv
2252 "B"
2253 1
2254 [ exFlagged
2255 "flagB"
2258 ]
2263 exAv
2264 "F"
2265 1
2266 [ exFlagged
2267 "flagF"
2270 ]
2277 ]
2279 -- The solver should never choose an installed package for a build tool
2280 -- dependency.
2282 rejectInstalledBuildToolPackage name =
2284 solverFailure $
2285 isInfixOf $
2286 "rejecting: A:B:exe.B-1.0.0/installed-1 "
2288 where
2289 db :: ExampleDb
2290 db =
2293 ]
2295 -- | This test forces the solver to choose B as a build-tool dependency before
2296 -- it sees the dependency on executable exe2 from B. The solver needs to check
2297 -- that the version that it already chose for B contains the necessary
2298 -- executable. This order causes a different "missing executable" error message
2299 -- than when the solver checks for the executable in the same step that it
2300 -- chooses the build-tool package.
2301 --
2302 -- This case may become impossible if we ever add the executable name to the
2303 -- build-tool goal qualifier. Then this test would involve two qualified goals
2304 -- for B, one for exe1 and another for exe2.
2306 chooseExeAfterBuildToolsPackage shouldSucceed name =
2307 goalOrder goals $
2309 if shouldSucceed
2311 else
2312 solverFailure $
2313 isInfixOf $
2314 "rejecting: A:+flagA (requires executable 'exe2' from A:B:exe.B, "
2316 where
2317 db :: ExampleDb
2318 db =
2320 exAv
2321 "A"
2322 1
2324 , exFlagged
2325 "flagA"
2328 ]
2332 ]
2335 goals =
2339 ]
2341 -- | Test that when one package depends on two executables from another package,
2342 -- both executables must come from the same instance of that package. We could
2343 -- lift this restriction in the future by adding the executable name to the goal
2344 -- qualifier.
2346 requireConsistentBuildToolVersions name =
2348 solverFailure $
2349 isInfixOf $
2352 where
2353 db :: ExampleDb
2354 db =
2356 exAv
2357 "A"
2358 1
2361 ]
2364 ]
2368 -- | This test is similar to the failure case for
2369 -- chooseExeAfterBuildToolsPackage, except that the build tool is unbuildable
2370 -- instead of missing.
2372 chooseUnbuildableExeAfterBuildToolsPackage name =
2374 goalOrder goals $
2376 solverFailure $
2377 isInfixOf $
2378 "rejecting: A:+use-bt2 (requires executable 'bt2' from A:B:exe.B, but "
2380 where
2381 db :: ExampleDb
2382 db =
2384 exAv
2385 "A"
2386 1
2388 , exFlagged
2389 "use-bt2"
2392 ]
2397 ]
2398 ]
2401 goals =
2405 ]
2407 {-------------------------------------------------------------------------------
2408 Databases for legacy build-tools
2409 -------------------------------------------------------------------------------}
2410 dbLegacyBuildTools1 :: ExampleDb
2411 dbLegacyBuildTools1 =
2414 ]
2416 -- Test that a recognized build tool dependency specifies the name of both the
2417 -- package and the executable. This db has no solution.
2418 dbLegacyBuildTools2 :: ExampleDb
2419 dbLegacyBuildTools2 =
2423 ]
2425 -- Test that build-tools on a random thing doesn't matter (only
2426 -- the ones we recognize need to be in db)
2427 dbLegacyBuildTools3 :: ExampleDb
2428 dbLegacyBuildTools3 =
2430 ]
2432 -- Test that we can solve for different versions of executables
2433 dbLegacyBuildTools4 :: ExampleDb
2434 dbLegacyBuildTools4 =
2440 ]
2442 -- Test that exe is not related to library choices
2443 dbLegacyBuildTools5 :: ExampleDb
2444 dbLegacyBuildTools5 =
2449 ]
2451 -- Test that build-tools on build-tools works
2452 dbLegacyBuildTools6 :: ExampleDb
2453 dbLegacyBuildTools6 =
2457 ]
2459 -- Test that build-depends on library/executable package works.
2460 -- Extracted from https://github.com/haskell/cabal/issues/3775
2461 dbIssue3775 :: ExampleDb
2462 dbIssue3775 =
2465 -- executable!
2468 ]
2470 -- | Returns true if the second list contains all elements of the first list, in
2471 -- order.