     }
 
     public convenience init(
-        name: Identifier,
-        dependenciesByVersion: [Version: [(package: Identifier, requirement: VersionSetSpecifier)]]
+        name: PackageReference,
+        dependenciesByVersion: [Version: [(package: PackageReference, requirement: VersionSetSpecifier)]]
         ) {
         var dependencies: [String: [Dependency]] = [:]
         for (version, deps) in dependenciesByVersion {

    }

    func testMissingVersion() {
        let root = MockContainer(name: rootRef, unversionedDependencies: [
            (package: aRef, requirement: v2Range)
        ])
        let a = MockContainer(name: aRef, dependenciesByVersion: [
            v1_1: []
        ])

        let resolver = createResolver(providing: root, a)
        let result = resolver.solve(root: rootRef, pins: [])

        switch result {

public typealias _MockPackageConstraint = PackageContainerConstraint

public class MockContainer: PackageContainer {
    public typealias Dependency = (container: PackageReference, requirement: PackageRequirement)

    let name: PackageReference

    var dependencies: [String: [Dependency]]

    public var unversionedDeps: [_MockPackageConstraint] = []

    /// Contains the versions for which the dependencies were requested by resolver using getDependencies().
    public var requestedVersions: Set<Version> = []

    public var identifier: PackageReference {
        return name
    }

    public var _versions: [Version]
    public func versions(filter isIncluded: (Version) -> Bool) -> AnySequence<Version> {
        return AnySequence(_versions.filter(isIncluded))
    }
