           query (map-query repo-info)]
       (testing (str "A package having dependencies rejected a priori "
                     "also gets rejected")
-        (is (= (resolve-dependencies
-                [{:id "a"}
-                 {:id "b"}]
-                query
-                :conflicts {"c" nil})
-               [:unsuccessful ["b" "c"]])))))
+               (let [aclause [(present "a")]]
+                 (is (= (resolve-dependencies
+                          [
+                           aclause
+                           [(present "b")]
+                           ]
+                          query
+                          :conflicts {"c" nil})
+                        [:unsuccessful aclause]))))))
+
+(deftest
+  ^:resolve-basic disjunctive-clauses
+  (testing
+    "Disjunction tautology"
+    (is (= (resolve-dependencies
+             [
+              [(absent "c") (present "b")]
+              ]
+             (map-query {}))
+             [:successful #{}])))
+  (testing
+    "Skip past a conflict"
+    (let [package-a
+          (->package
+            "a"
+            30
+            "a_loc30"
+            [
+             [(present "b")]
+             ])
+          package-b
+          (->package
+            "b"
+            20
+            "b_loc20"
+            nil)
+          repo-info
+          {"a" [package-a]
+           "b" [package-b]}
+          query (map-query repo-info)]
+      (is (= (resolve-dependencies
+               [
+                [(absent "c") (present "b")]
+                ]
+               query
+               :present-packages (->package "c" 10 "c_loc10" nil))
+             [:successful #{package-b}])))))
 
 #_(deftest ^:resolve-basic no-locking
     (testing (str "Find two packages, even when the preferred version "

      (testing (str "One package should require another and both "
                    "should be found.")
        (is (= (resolve-dependencies
                [{:id "a"}]
                query)
               [:successful #{package-a package-b}])))
      (testing (str "One package should be found when it requires "
                    "another, but it's already installed.")
        (is (= (resolve-dependencies
                [{:id "a"}]
                query
                :present-packages {"b" 20})
               [:successful #{package-a}]))))
    (let [package-a
          {:id "a"
           :version 10
           :location "a_loc30"}
          package-b
          {:id "b"
           :version 20
           :location "b_loc20"
           :requires [{:id "c"}]}
          package-c
          {:id "c"
           :version 10
           :conflicts {"a" nil}}

          repo-info
          {"a" [package-a]
           "b" [package-b]
           "c" [package-c]}
          query (map-query repo-info)]
      (testing (str "A package having dependencies which conflicts with "
                    "other packages downloaded should be rejected.")
        (is (= (resolve-dependencies
                [{:id "a"}
                 {:id "b"}]
                query)
               [:unsuccessful ["b" "c"]]))))
    (let [package-a
          {:id "a"
           :version 10

                :conflicts {"d" [#(< (:version %) 22)]})
               [:successful #{package-d22}]))))))

(deftest ^:resolve-basic requires
    (let [package-a
          (->package
            "a"
            30
            "a_loc30"
            [
             [(present "b")]
             ])
          package-b
          (->package
            "b"
            20
            "b_loc20"
            nil)
          repo-info
          {"a" [package-a]
           "b" [package-b]}
