diff --git a/Hash2Pub/test/FediChordSpec.hs b/Hash2Pub/test/FediChordSpec.hs
index c010e0e..79b7023 100644
--- a/Hash2Pub/test/FediChordSpec.hs
+++ b/Hash2Pub/test/FediChordSpec.hs
@@ -78,42 +78,41 @@ spec = do
             anotherID = toNodeID 2^(230::Integer)+1
             anotherNode = exampleNodeState { nid = anotherID}
             maxNode = exampleNodeState { nid = maxBound}
-            newCache = addCacheEntryPure 10 <$> (RemoteCacheEntry <$> exampleLocalNode <*> pure 10) <*> (addCacheEntryPure 10 <$> pure (RemoteCacheEntry anotherNode 10) <*> pure emptyCache)
+            newCache = addCacheEntryPure 10 (RemoteCacheEntry exampleNodeState 10) (addCacheEntryPure 10 (RemoteCacheEntry anotherNode 10) emptyCache)
             exampleID = nid exampleNodeState
         it "entries can be added to a node cache and looked up again" $ do
-            nC <- newCache
             -- the cache includes 2 additional proxy elements right from the start
-            Map.size nC - Map.size emptyCache `shouldBe` 2
+            Map.size newCache - Map.size emptyCache `shouldBe` 2
             -- normal entry lookup
-            nid . cacheGetNodeStateUnvalidated <$> cacheLookup anotherID nC `shouldBe` Just anotherID
-            nid . cacheGetNodeStateUnvalidated <$> cacheLookup (anotherID+1) nC `shouldBe` Nothing
+            nid . cacheGetNodeStateUnvalidated <$> cacheLookup anotherID newCache `shouldBe` Just anotherID
+            nid . cacheGetNodeStateUnvalidated <$> cacheLookup (anotherID+1) newCache `shouldBe` Nothing
             -- initially, the proxy elements store nothing
             cacheLookup minBound emptyCache `shouldBe` Nothing
             cacheLookup maxBound emptyCache `shouldBe` Nothing
             -- now store a node at that ID
-            cacheWithMaxNode <- addCacheEntryPure 10 <$> pure (RemoteCacheEntry maxNode 10) <*> newCache
+            let cacheWithMaxNode = addCacheEntryPure 10 (RemoteCacheEntry maxNode 10) newCache
             nid . cacheGetNodeStateUnvalidated <$> cacheLookup maxBound cacheWithMaxNode `shouldBe` Just maxBound
         it "looking up predecessor and successor works like on a modular ring" $ do
             -- ignore empty proxy elements in initial cache
             nid . cacheGetNodeStateUnvalidated <$> cacheLookupPred (exampleID + 10) emptyCache `shouldBe` Nothing
             nid . cacheGetNodeStateUnvalidated <$> cacheLookupSucc exampleID emptyCache `shouldBe` Nothing
  
-            nC <- newCache
-            -- given situation: 0 < nid exampleLocalNode < anotherNode < maxBound
+            -- given situation: 0 < anotherNode < nid exampleLocalNode < maxBound
             -- first try non-modular queries between the 2 stored nodes
-            nid. cacheGetNodeStateUnvalidated <$> cacheLookupPred (exampleID + 10) nC `shouldBe` Just exampleID 
-            nid. cacheGetNodeStateUnvalidated <$> cacheLookupSucc exampleID nC `shouldBe` Just exampleID 
-            nid. cacheGetNodeStateUnvalidated <$> cacheLookupSucc (exampleID + 10) nC `shouldBe` Just anotherID
+            nid . cacheGetNodeStateUnvalidated <$> cacheLookupPred (exampleID + 10) newCache `shouldBe` Just exampleID 
+            nid . cacheGetNodeStateUnvalidated <$> cacheLookupSucc exampleID newCache `shouldBe` Just exampleID 
+            nid . cacheGetNodeStateUnvalidated <$> cacheLookupSucc (exampleID + 10) newCache `shouldBe` Just anotherID
             -- queries that require a (pseudo)modular structure
-            nid. cacheGetNodeStateUnvalidated <$> cacheLookupPred (exampleID - 2) nC `shouldBe` Just anotherID
-            nid. cacheGetNodeStateUnvalidated <$> cacheLookupSucc (anotherID + 2) nC `shouldBe` Just exampleID 
+            nid . cacheGetNodeStateUnvalidated <$> cacheLookupPred (exampleID - 2) newCache `shouldBe` Just anotherID
+            nid . cacheGetNodeStateUnvalidated <$> cacheLookupSucc (anotherID + 2) newCache `shouldBe` Just exampleID 
             -- now store a node in one of the ProxyEntries
-            cacheWithProxyNodeEntry <- addCacheEntryPure 10 <$> pure (RemoteCacheEntry maxNode 10) <*> newCache
-            nid. cacheGetNodeStateUnvalidated <$> cacheLookupPred (exampleID - 2) cacheWithProxyNodeEntry `shouldBe` Just maxBound
-            nid. cacheGetNodeStateUnvalidated <$> cacheLookupSucc (anotherID + 2) cacheWithProxyNodeEntry `shouldBe` Just maxBound 
+            let cacheWithProxyNodeEntry = addCacheEntryPure 10 (RemoteCacheEntry maxNode 10) newCache
+            nid . cacheGetNodeStateUnvalidated <$> cacheLookupPred (exampleID - 2) cacheWithProxyNodeEntry `shouldBe` Just maxBound
+            nid . cacheGetNodeStateUnvalidated <$> cacheLookupSucc (anotherID + 2) cacheWithProxyNodeEntry `shouldBe` Just maxBound 
         it "entries can be deleted" $ do
-            nC <- addCacheEntryPure 10 <$> pure (RemoteCacheEntry maxNode 10) <*> newCache
-            let nc' = deleteCacheEntry maxBound . deleteCacheEntry anotherID $ nC
+            let
+                nC = addCacheEntryPure 10 (RemoteCacheEntry maxNode 10) newCache
+                nc' = deleteCacheEntry maxBound . deleteCacheEntry anotherID $ nC
             cacheLookup anotherID nc' `shouldBe` Nothing
             cacheLookup maxBound nc' `shouldBe` Nothing
 
@@ -123,7 +122,7 @@ spec = do
             emptyCache = initCache
             nid1 = toNodeID 2^(23::Integer)+1
             node1 = do
-                eln <- exampleLocalNode
+                eln <- exampleLocalNode -- is at 2^23.00000017198264 = 8388609
                 return $ putPredecessors [nid4] $ eln {nid = nid1}
             nid2 = toNodeID 2^(230::Integer)+12
             node2 = exampleNodeState { nid = nid2}
@@ -146,7 +145,8 @@ spec = do
             Set.map (nid . remoteNode_) nodeset1 `shouldBe` Set.fromList [nid4, nid2, nid3]
             Set.map (nid . remoteNode_) nodeset2 `shouldBe` Set.fromList [nid4]
         it "recognises the node's own responsibility" $ do
-            (==) <$> (queryLocalCache <$> node1 <*> cacheWith4Entries <*> pure 3 <*> pure (toNodeID 2^(22::Integer))) <*>  (FOUND <$> node1) `shouldReturn` True
+            node1 >>= print
+            (==) <$> (queryLocalCache <$> node1 <*> cacheWith4Entries <*> pure 3 <*> pure (toNodeID 2^(22::Integer))) <*> (FOUND <$> node1) `shouldReturn` True
             (==) <$> (queryLocalCache <$> node1 <*> cacheWith4Entries <*> pure 3 <*> pure nid1) <*>  (FOUND <$> node1) `shouldReturn` True
         it "does not fail on nodes without neighbours (initial state)" $ do
             (FORWARD nodeset) <- queryLocalCache <$> exampleLocalNode <*> cacheWith4Entries <*> pure 3 <*> pure (toNodeID 11)