diff --git a/src/Proton.Client/Client/IReceiver.cs b/src/Proton.Client/Client/IReceiver.cs
index 82ae9e0..7200f24 100644
--- a/src/Proton.Client/Client/IReceiver.cs
+++ b/src/Proton.Client/Client/IReceiver.cs
@@ -156,7 +156,7 @@
       /// </summary>
       /// <param name="credit">The amount of new credit to add to the existing credit if any</param>
       /// <returns>This receiver instance.</returns>
-      IReceiver AddCredit(int credit);
+      IReceiver AddCredit(uint credit);
 
       /// <summary>
       /// Blocking receive method that waits forever for the remote to provide a delivery for consumption.
diff --git a/src/Proton.Client/Client/IStreamReceiver.cs b/src/Proton.Client/Client/IStreamReceiver.cs
index 646b230..bb739ac 100644
--- a/src/Proton.Client/Client/IStreamReceiver.cs
+++ b/src/Proton.Client/Client/IStreamReceiver.cs
@@ -60,11 +60,11 @@
       new IStreamDelivery TryReceive();
 
       /// <inheritdoc cref="IReceiver.AddCredit(int)"/>
-      new IStreamReceiver AddCredit(int credit);
+      new IStreamReceiver AddCredit(uint credit);
 
       #region Defaults for hidden IReceiver APIs
 
-      IReceiver IReceiver.AddCredit(int credit)
+      IReceiver IReceiver.AddCredit(uint credit)
       {
          return this.AddCredit(credit);
       }
diff --git a/src/Proton.Client/Client/Implementation/ClientReceiver.cs b/src/Proton.Client/Client/Implementation/ClientReceiver.cs
index b630690..ce72917 100644
--- a/src/Proton.Client/Client/Implementation/ClientReceiver.cs
+++ b/src/Proton.Client/Client/Implementation/ClientReceiver.cs
@@ -140,7 +140,7 @@
 
       public int QueuedDeliveries => messageQueue.Count;
 
-      public IReceiver AddCredit(int credit)
+      public IReceiver AddCredit(uint credit)
       {
          throw new NotImplementedException();
       }
diff --git a/src/Proton.Client/Client/Implementation/ClientStreamReceiver.cs b/src/Proton.Client/Client/Implementation/ClientStreamReceiver.cs
index 85ba0ee..44c69cd 100644
--- a/src/Proton.Client/Client/Implementation/ClientStreamReceiver.cs
+++ b/src/Proton.Client/Client/Implementation/ClientStreamReceiver.cs
@@ -139,7 +139,7 @@
          }
       }
 
-      public IStreamReceiver AddCredit(int credit)
+      public IStreamReceiver AddCredit(uint credit)
       {
          throw new NotImplementedException();
       }
diff --git a/test/Proton.Client.Tests/Client/Implementation/ClientReceiverTest.cs b/test/Proton.Client.Tests/Client/Implementation/ClientReceiverTest.cs
index 2c68f62..74460be 100644
--- a/test/Proton.Client.Tests/Client/Implementation/ClientReceiverTest.cs
+++ b/test/Proton.Client.Tests/Client/Implementation/ClientReceiverTest.cs
@@ -24,6 +24,8 @@
 using Apache.Qpid.Proton.Types.Transport;
 using System.Collections.Generic;
 using System.Linq;
+using Apache.Qpid.Proton.Test.Driver.Matchers;
+using System.Threading.Tasks;
 
 namespace Apache.Qpid.Proton.Client.Implementation
 {
@@ -315,5 +317,207 @@
             peer.WaitForScriptToComplete();
          }
       }
+
+      [Test]
+      public void TestOpenReceiverWaitWithTimeoutFailsWhenConnectionDrops()
+      {
+         DoTestOpenReceiverWaitFailsWhenConnectionDrops(true);
+      }
+
+      [Test]
+      public void TestOpenReceiverWaitWithNoTimeoutFailsWhenConnectionDrops()
+      {
+         DoTestOpenReceiverWaitFailsWhenConnectionDrops(false);
+      }
+
+      private void DoTestOpenReceiverWaitFailsWhenConnectionDrops(bool timeout)
+      {
+         using (ProtonTestServer peer = new ProtonTestServer(loggerFactory))
+         {
+            peer.ExpectSASLAnonymousConnect();
+            peer.ExpectOpen().Respond();
+            peer.ExpectBegin().Respond();
+            peer.ExpectAttach().OfReceiver();
+            peer.ExpectFlow();
+            peer.DropAfterLastHandler(10);
+            peer.Start();
+
+            string remoteAddress = peer.ServerAddress;
+            int remotePort = peer.ServerPort;
+
+            logger.LogInformation("Test started, peer listening on: {0}:{1}", remoteAddress, remotePort);
+
+            IClient container = IClient.Create();
+            IConnection connection = container.Connect(remoteAddress, remotePort).OpenTask.Result;
+            ISession session = connection.OpenSession().OpenTask.Result;
+            IReceiver receiver = session.OpenReceiver("test-queue");
+
+            try
+            {
+               if (timeout)
+               {
+                  receiver.OpenTask.Wait(TimeSpan.FromSeconds(10));
+               }
+               else
+               {
+                  receiver.OpenTask.Wait();
+               }
+
+               Assert.Fail("Should not complete the open future without an error");
+            }
+            catch (Exception exe)
+            {
+               Exception cause = exe.InnerException;
+               Assert.IsTrue(cause is ClientIOException);
+            }
+
+            connection.CloseAsync().GetAwaiter().GetResult();
+
+            peer.WaitForScriptToComplete();
+         }
+      }
+
+      [Test]
+      public void TestCloseReceiverTimesOutWhenNoCloseResponseReceivedTimeout()
+      {
+         DoTestCloseOrDetachReceiverTimesOutWhenNoCloseResponseReceived(true, true);
+      }
+
+      [Test]
+      public void TestCloseReceiverTimesOutWhenNoCloseResponseReceivedNoTimeout()
+      {
+         DoTestCloseOrDetachReceiverTimesOutWhenNoCloseResponseReceived(true, false);
+      }
+
+      [Test]
+      public void TestDetachReceiverTimesOutWhenNoCloseResponseReceivedTimeout()
+      {
+         DoTestCloseOrDetachReceiverTimesOutWhenNoCloseResponseReceived(false, true);
+      }
+
+      [Test]
+      public void TestDetachReceiverTimesOutWhenNoCloseResponseReceivedNoTimeout()
+      {
+         DoTestCloseOrDetachReceiverTimesOutWhenNoCloseResponseReceived(false, false);
+      }
+
+      private void DoTestCloseOrDetachReceiverTimesOutWhenNoCloseResponseReceived(bool close, bool timeout)
+      {
+         using (ProtonTestServer peer = new ProtonTestServer(loggerFactory))
+         {
+            peer.ExpectSASLAnonymousConnect();
+            peer.ExpectOpen().Respond();
+            peer.ExpectBegin().Respond();
+            peer.ExpectAttach().OfReceiver().Respond();
+            peer.ExpectFlow();
+            peer.ExpectDetach();
+            peer.ExpectClose().Respond();
+            peer.Start();
+
+            string remoteAddress = peer.ServerAddress;
+            int remotePort = peer.ServerPort;
+
+            logger.LogInformation("Test started, peer listening on: {0}:{1}", remoteAddress, remotePort);
+
+            IClient container = IClient.Create();
+            ConnectionOptions options = new ConnectionOptions()
+            {
+               CloseTimeout = 5
+            };
+            IConnection connection = container.Connect(remoteAddress, remotePort, options).OpenTask.Result;
+            connection.OpenTask.Wait(TimeSpan.FromSeconds(10));
+
+            ISession session = connection.OpenSession().OpenTask.Result;
+            IReceiver receiver = session.OpenReceiver("test-queue");
+            receiver.OpenTask.Wait(TimeSpan.FromSeconds(10));
+
+            try
+            {
+               if (close)
+               {
+                  if (timeout)
+                  {
+                     receiver.CloseAsync().Wait(TimeSpan.FromSeconds(10));
+                  }
+                  else
+                  {
+                     receiver.CloseAsync().Wait();
+                  }
+               }
+               else
+               {
+                  if (timeout)
+                  {
+                     receiver.DetachAsync().Wait(TimeSpan.FromSeconds(10));
+                  }
+                  else
+                  {
+                     receiver.DetachAsync().Wait();
+                  }
+               }
+
+               Assert.Fail("Should not complete the close or detach future without an error");
+            }
+            catch (Exception exe)
+            {
+               Exception cause = exe.InnerException;
+               Assert.IsTrue(cause is ClientOperationTimedOutException);
+            }
+
+            connection.CloseAsync().Wait();
+
+            peer.WaitForScriptToComplete();
+         }
+      }
+
+      [Ignore("Add Credit is not yet implemented")]
+      [Test]
+      public void TestReceiverDrainAllOutstanding()
+      {
+         using (ProtonTestServer peer = new ProtonTestServer(loggerFactory))
+         {
+            peer.ExpectSASLAnonymousConnect();
+            peer.ExpectOpen().Respond();
+            peer.ExpectBegin().Respond();
+            peer.ExpectAttach().OfReceiver().Respond();
+            peer.Start();
+
+            string remoteAddress = peer.ServerAddress;
+            int remotePort = peer.ServerPort;
+
+            logger.LogInformation("Test started, peer listening on: {0}:{1}", remoteAddress, remotePort);
+
+            IClient container = IClient.Create();
+            IConnection connection = container.Connect(remoteAddress, remotePort).OpenTask.Result;
+            ISession session = connection.OpenSession().OpenTask.Result;
+            IReceiver receiver = session.OpenReceiver("test-queue").OpenTask.Result;
+
+            peer.WaitForScriptToComplete();
+
+            // Add some credit, verify not draining
+            uint credit = 7;
+            peer.ExpectFlow().WithDrain(Matches.AnyOf(Test.Driver.Matchers.Is.EqualTo(false),
+                                                      Test.Driver.Matchers.Is.NullValue()))
+                             .WithLinkCredit(credit).WithDeliveryCount(0);
+
+            receiver.AddCredit(credit);
+
+            peer.WaitForScriptToComplete();
+
+            // Drain all the credit
+            peer.ExpectFlow().WithDrain(true).WithLinkCredit(credit).WithDeliveryCount(0)
+                             .Respond()
+                             .WithDrain(true).WithLinkCredit(0).WithDeliveryCount(credit);
+
+            Task<IReceiver> draining = receiver.Drain();
+            draining.Wait(TimeSpan.FromSeconds(5));
+
+            // Close things down
+            peer.ExpectClose().Respond();
+            connection.Close();
+
+            peer.WaitForScriptToComplete(TimeSpan.FromSeconds(10));
+         }
+      }
    }
 }
\ No newline at end of file
diff --git a/test/Proton.Client.Tests/Client/Implementation/ClientSenderTest.cs b/test/Proton.Client.Tests/Client/Implementation/ClientSenderTest.cs
index 9deeb08..a2a0b07 100644
--- a/test/Proton.Client.Tests/Client/Implementation/ClientSenderTest.cs
+++ b/test/Proton.Client.Tests/Client/Implementation/ClientSenderTest.cs
@@ -379,5 +379,154 @@
             peer.WaitForScriptToComplete();
          }
       }
+
+      [Test]
+      public void TestOpenSenderWaitWithTimeoutFailsWhenConnectionDrops()
+      {
+         DoTestOpenSenderWaitFailsWhenConnectionDrops(true);
+      }
+
+      [Test]
+      public void TestOpenSenderWaitWithNoTimeoutFailsWhenConnectionDrops()
+      {
+         DoTestOpenSenderWaitFailsWhenConnectionDrops(false);
+      }
+
+      private void DoTestOpenSenderWaitFailsWhenConnectionDrops(bool timeout)
+      {
+         using (ProtonTestServer peer = new ProtonTestServer(loggerFactory))
+         {
+            peer.ExpectSASLAnonymousConnect();
+            peer.ExpectOpen().Respond();
+            peer.ExpectBegin().Respond();
+            peer.ExpectAttach().OfSender();
+            peer.DropAfterLastHandler(10);
+            peer.Start();
+
+            string remoteAddress = peer.ServerAddress;
+            int remotePort = peer.ServerPort;
+
+            logger.LogInformation("Test started, peer listening on: {0}:{1}", remoteAddress, remotePort);
+
+            IClient container = IClient.Create();
+            IConnection connection = container.Connect(remoteAddress, remotePort);
+            ISession session = connection.OpenSession();
+            ISender sender = session.OpenSender("test-queue");
+
+            Thread.Sleep(10); // Allow some time for attach to get written
+
+            try
+            {
+               if (timeout)
+               {
+                  sender.OpenTask.Wait(TimeSpan.FromSeconds(10));
+               }
+               else
+               {
+                  sender.OpenTask.Wait();
+               }
+
+               Assert.Fail("Should not complete the open future without an error");
+            }
+            catch (Exception exe)
+            {
+               Exception cause = exe.InnerException;
+               Assert.IsTrue(cause is ClientConnectionRemotelyClosedException);
+            }
+
+            connection.CloseAsync().Wait(TimeSpan.FromSeconds(10));
+
+            peer.WaitForScriptToComplete();
+         }
+      }
+
+      [Test]
+      public void TestCloseSenderTimesOutWhenNoCloseResponseReceivedTimeout()
+      {
+         DoTestCloseOrDetachSenderTimesOutWhenNoCloseResponseReceived(true, true);
+      }
+
+      [Test]
+      public void TestCloseSenderTimesOutWhenNoCloseResponseReceivedNoTimeout()
+      {
+         DoTestCloseOrDetachSenderTimesOutWhenNoCloseResponseReceived(true, false);
+      }
+
+      [Test]
+      public void TestDetachSenderTimesOutWhenNoCloseResponseReceivedTimeout()
+      {
+         DoTestCloseOrDetachSenderTimesOutWhenNoCloseResponseReceived(false, true);
+      }
+
+      [Test]
+      public void TestDetachSenderTimesOutWhenNoCloseResponseReceivedNoTimeout()
+      {
+         DoTestCloseOrDetachSenderTimesOutWhenNoCloseResponseReceived(false, false);
+      }
+
+      private void DoTestCloseOrDetachSenderTimesOutWhenNoCloseResponseReceived(bool close, bool timeout)
+      {
+         using (ProtonTestServer peer = new ProtonTestServer(loggerFactory))
+         {
+            peer.ExpectSASLAnonymousConnect();
+            peer.ExpectOpen().Respond();
+            peer.ExpectBegin().Respond();
+            peer.ExpectAttach().OfSender().Respond();
+            peer.ExpectDetach();
+            peer.ExpectClose().Respond();
+            peer.Start();
+
+            string remoteAddress = peer.ServerAddress;
+            int remotePort = peer.ServerPort;
+
+            logger.LogInformation("Test started, peer listening on: {0}:{1}", remoteAddress, remotePort);
+
+            IClient container = IClient.Create();
+            ConnectionOptions options = new ConnectionOptions()
+            {
+               CloseTimeout = 10
+            };
+            IConnection connection = container.Connect(remoteAddress, remotePort, options);
+            ISession session = connection.OpenSession();
+            ISender sender = session.OpenSender("test-queue").OpenTask.Result;
+
+            try
+            {
+               if (close)
+               {
+                  if (timeout)
+                  {
+                     sender.CloseAsync().Wait(TimeSpan.FromSeconds(10));
+                  }
+                  else
+                  {
+                     sender.CloseAsync().Wait();
+                  }
+               }
+               else
+               {
+                  if (timeout)
+                  {
+                     sender.DetachAsync().Wait(TimeSpan.FromSeconds(10));
+                  }
+                  else
+                  {
+                     sender.DetachAsync().Wait();
+                  }
+               }
+
+               Assert.Fail("Should not complete the close or detach future without an error");
+            }
+            catch (Exception exe)
+            {
+               Exception cause = exe.InnerException;
+               Assert.IsTrue(cause is ClientOperationTimedOutException);
+            }
+
+            connection.Close();
+
+            peer.WaitForScriptToComplete();
+         }
+      }
    }
 }
\ No newline at end of file