diff --git a/src/Quasar/Awaitable.hs b/src/Quasar/Awaitable.hs
index 5a16f0a90b8d74fc18f1ddd63ce927460718d8dd..cecbcd7d62cb10fa8d6a92a2b6c6524448a551b8 100644
--- a/src/Quasar/Awaitable.hs
+++ b/src/Quasar/Awaitable.hs
@@ -156,7 +156,7 @@ class Monad m => MonadQuerySTM m where
   querySTM :: (forall a. STM a -> m a)
   querySTM transaction = unsafeQuerySTM $ (Just <$> transaction) `orElse` pure Nothing
 
-  -- | Run an "STM` transaction. `retry` MUST NOT be used
+  -- | Run an "STM` transaction. `retry` MUST NOT be used.
   unsafeQuerySTM :: (forall a. STM (Maybe a) -> m a)
   unsafeQuerySTM transaction = querySTM $ maybe retry pure =<< transaction
 
diff --git a/test/Quasar/AsyncSpec.hs b/test/Quasar/AsyncSpec.hs
index f6c0a1fa587b1e6758ad9d9e395d34c9d97f9164..0ece2a931bf2df4270fb3a298a4691840d07446f 100644
--- a/test/Quasar/AsyncSpec.hs
+++ b/test/Quasar/AsyncSpec.hs
@@ -22,7 +22,7 @@ spec = parallel $ do
       tryTakeMVar m1 `shouldReturn` Just ()
       tryTakeMVar m2 `shouldReturn` Just ()
 
-    xit "can continue after awaiting an already finished operation" $ do
+    it "can pass a value through async and await" $ do
       withDefaultAsyncManager (await =<< async (pure 42 :: AsyncIO Int)) `shouldReturn` 42
 
     it "can await the result of an async that is completed later" $ do
diff --git a/test/Quasar/DisposableSpec.hs b/test/Quasar/DisposableSpec.hs
index 0acc9e08ca3150287a61ed05af032d0f326638f1..3bb1d135da20fbd8b0ee59be965ecb5165906ecd 100644
--- a/test/Quasar/DisposableSpec.hs
+++ b/test/Quasar/DisposableSpec.hs
@@ -24,6 +24,27 @@ spec = parallel $ do
         awaitIO (isDisposed noDisposable)
         pure () :: IO ()
 
+
+    describe "newDisposable" $ do
+      it "signals it's disposed state" $ do
+        disposable <- newDisposable $ pure $ pure ()
+        void $ forkIO $ threadDelay 100000 >> disposeIO disposable
+        awaitIO (isDisposed disposable)
+        pure () :: IO ()
+
+      it "can be disposed multiple times" $ do
+        disposable <- newDisposable $ pure $ pure ()
+        disposeIO disposable
+        disposeIO disposable
+        awaitIO (isDisposed disposable)
+
+      it "can be disposed in parallel" $ do
+        disposable <- newDisposable $ pure () <$ threadDelay 100000
+        void $ forkIO $ disposeIO disposable
+        disposeIO disposable
+        awaitIO (isDisposed disposable)
+
+
   describe "ResourceManager" $ do
     it "can be created" $ do
       void newResourceManager
@@ -75,3 +96,8 @@ spec = parallel $ do
           withResourceManager \resourceManager ->
             attachDisposeAction resourceManager $ throwIO $ TestException
         \TestException -> True
+
+    it "can attach an disposable that is disposed asynchronously" $ do
+      withResourceManager \resourceManager -> do
+        disposable <- attachDisposeAction resourceManager $ pure () <$ threadDelay 100000
+        void $ forkIO $ disposeIO disposable