anchor.diff:    Project = name
   }
   
  -let branch b = Version.Git (GitVersion.Branch b)
  +let br b = Version.Git (GitVersion.Branch b)
   let rev (x : int) = Version.Git(GitVersion.Revision (x.ToString()))
   let ver (x : int) = Version.SemVer {SemVer.zero with Major = x}
   
  -type TestingSourceExplorer (manifestSpec : List<PackageIdentifier * Version * Manifest>) =
  +type TestingSourceExplorer (manifestSpec : List<PackageIdentifier * Set<Version> * Manifest>) =
   
     interface ISourceExplorer with
       member this.FetchVersions (_ : PackageSources) (package: PackageIdentifier) : AsyncSeq<Version>  = asyncSeq {
  -
         yield!
           manifestSpec
             |> Seq.choose (fun (p, v, _) ->
               if p = package
  -            then Some v
  +            then Some (v |> Set.toSeq |> Seq.sortDescending)
               else None)
  +          |> Seq.collect (id)
             |> AsyncSeq.ofSeq
       }
   
       member this.FetchLocations (_: PackageSources) (package: PackageIdentifier) (version: Version) : AsyncSeq<PackageLocation> = asyncSeq {
  -        match package, version with
  -        | (Adhoc a, SemVer v) ->
  -          yield PackageLocation.GitHub {
  -            Package = { Owner = a.Owner; Project = a.Project };
  -            Revision = v.Major.ToString()
  -          }
  -        | (Adhoc a, _) ->
  +        match package with
  +        | (Adhoc a) ->
             yield! manifestSpec
  -            |> List.filter (fun (p, _, _) -> p = package )
  -            |> List.map(fun (_, v,_) -> v)
  +            |> List.filter (fun (p, vs, _) -> p = package && vs |> Set.contains version)
  +            |> List.map(fun (_, vs,_) -> vs)
  +            |> List.collect(Set.toList)
               |> List.choose(fun x ->
                   match x with
  -                | SemVer v -> Some v
  +                | Version.Git (GitVersion.Revision r) -> Some r
  +                | SemVer v -> Some (v.Major.ToString())
                   | _ -> None)
  -            |> List.map(fun v ->
  +            |> List.map(fun r ->
                   PackageLocation.GitHub {
                     Package = { Owner = a.Owner; Project = a.Project };
  -                  Revision = v.Major.ToString()
  +                  Revision = r
                   })
               |> AsyncSeq.ofSeq
  -
           | _ -> raise <| new System.SystemException "package not found"
       }
   
  
positive.code:         match lock with
          | PackageLock.GitHub g ->
            manifestSpec
            |> List.filter (fun (p, v, _) -> p = package g.Package.Project && v = (g.Revision.ToString() |> int |> ver))
            |> List.map (fun (_, _, m) -> m)
            |> List.tryHead
          | _ -> None
  
negative.code: 
      Buckaroo.Solver.solve context root style None
  
  let getLockedRev (p : string) (r: Resolution) =
    match r with
    | Ok solution ->
      let (resolved, _) = solution.Resolutions.[package p]
      match resolved.Lock with
      | PackageLock.GitHub g -> g.Revision
      | _ -> ""
    | _ -> ""
  ()
  
  [<Fact>]
  let ``Solver handles simple case`` () =
    let spec = [
      (package "a",
        Set[ver 2; br "a"],
        manifest [("b", Exactly (ver 1) )])
      (package "a",
        Set[ver 1; br "a"],
        manifest [("b", Exactly (ver 1) )])
      (package "b", Set[ver 1; br "a"], manifest [])
    ]
  
    let root = manifest [("a", Exactly (br "a") )]
    let solution =
      solve spec ResolutionStyle.Quick root
        |> Async.RunSynchronously
  
    Assert.Equal ("2", getLockedRev "a" solution)
    Assert.Equal ("1", getLockedRev "b" solution)
    ()
  