         service = Service(baseURL: "http://test.ing", networking: networkStub)
         }
 
-    func testGetExistingResources()
+    func testGetExistingResourcesByURL()
         {
         measure { self.exerciseResourceCache(uniqueResources: 20, iters: 20000) }
+        }
+
+    func testGetExistingResourcesByPath()
+        {
+        let uniqueResources = 20
+        let iters = 20000
+        measure
+            {
+            self.setUp()  // Important to start empty each time
+            let paths = (0 ..< uniqueResources).map { "/items/\($0)" }
+            for n in 0 ..< iters
+                { _ = self.service.resource(paths[n % uniqueResources]) }
+            }
+        }
+
+    func testGetResourceForNilURL()
+        {
+        measure
+            {
+            for _ in 0 ..< 20000
+                { _ = self.service.resource(absoluteURL: nil) }
+            }
         }
 
     func testResourceCacheGrowth()


    func testRequestHooks()
        {
        let resource = service.resource("/hooked")
        measure
            {
            for _ in 0 ..< 100
                {
                let req = resource.load()
                var callbacks = 0
                for _ in 0 ..< 100
                    { req.onCompletion { _ in callbacks += 1 } }
                let load = self.expectation(description: "load")
                req.onCompletion { _ in load.fulfill() }
                self.waitForExpectations(timeout: 1)
                }
            }
        }

    func testObserverNotifications()
        {
        let resourceCount = 50
        for n in stride(from: 0, to: resourceCount, by: 2)
            { networkStub.responses["/zlerp\(n)"] = ResponseStub(data: Data()) }

        let resources = (0 ..< resourceCount).map
            {
            service
                .resource("/zlerp\($0)")
                .addObserver(TestObserver())
            }

        measure
            {
            for _ in 0 ..< 10
                {
                for resource in resources
                    {
                    let load = self.expectation(description: "load")
                    resource.load().onCompletion { _ in load.fulfill() }
                    }
                self.waitForExpectations(timeout: 1)
                }
            }
        }

        {
        setUp()  // Important to start empty each time
        service.cachedResourceCountLimit = countLimit
        let urls = (0 ..< uniqueResources).map { URL(string: "/items/\($0)") }
        for n in 0 ..< iters
            { _ = service.resource(absoluteURL: urls[n % uniqueResources]) }
        }

    func testObserverChurn5()
