q

diff --git a/src/SDKs/ServiceBus/data-plane/tests/Microsoft.Azure.ServiceBus.Tests/Infrastructure.Tests/TaskExtensionTests.cs b/src/SDKs/ServiceBus/data-plane/tests/Microsoft.Azure.ServiceBus.Tests/Infrastructure.Tests/TaskExtensionTests.cs
index 2a6bd1103..713ac5eef 100755
--- a/src/SDKs/ServiceBus/data-plane/tests/Microsoft.Azure.ServiceBus.Tests/Infrastructure.Tests/TaskExtensionTests.cs
+++ b/src/SDKs/ServiceBus/data-plane/tests/Microsoft.Azure.ServiceBus.Tests/Infrastructure.Tests/TaskExtensionTests.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Diagnostics;
 using System.Threading;
 using System.Threading.Tasks;
 using Xunit;
@@ -7,12 +8,19 @@ namespace Microsoft.Azure.ServiceBus.UnitTests
 {
     public class TaskExtensionsTests
     {  
+        // It has been observed during the CI build that test runs can cause delays that were noted at 
+        // 1-2 seconds and were causing intermitten failures as a result.  The long delay has been set at 5 
+        // seconds arbitrarily, which may delay results should tests fail but is otherwise not expected to 
+        // be an actual wait time under normal circumstances.
+        private readonly TimeSpan LongDelay = TimeSpan.FromSeconds(5);
+        private readonly TimeSpan TinyDelay = TimeSpan.FromMilliseconds(1);
+
         [Fact]
         public void WithTimeoutThrowsWhenATimeoutOccursAndNoActionIsSpecified()
         {
             Func<Task> actionUnderTest = async () =>  
-                await Task.Delay(1000)
-                    .WithTimeout(TimeSpan.FromMilliseconds(1));
+                await Task.Delay(LongDelay)
+                    .WithTimeout(TinyDelay);
               
             Assert.ThrowsAsync<TimeoutException>(actionUnderTest);
         }
@@ -24,7 +32,7 @@ public async Task WithTimeoutExecutesTheTimeoutActionWhenATimeoutOccurs()
 
             Action timeoutAction = () => { timeoutActionInvoked = true; };
             
-            await Task.Delay(1000).WithTimeout(TimeSpan.FromMilliseconds(1), null, timeoutAction);
+            await Task.Delay(LongDelay).WithTimeout(TinyDelay, null, timeoutAction);
             Assert.True(timeoutActionInvoked, "The timeout action should have been invoked.");
         }
 
@@ -32,9 +40,9 @@ public async Task WithTimeoutExecutesTheTimeoutActionWhenATimeoutOccurs()
         public async Task WithTimeoutGenericThrowsWhenATimeoutOccursAndNoActionIsSpecified()
         {
             Func<Task> actionUnderTest = async () => 
-                await Task.Delay(1000)
+                await Task.Delay(LongDelay)
                     .ContinueWith( _ => "blue")
-                    .WithTimeout(TimeSpan.FromMilliseconds(1));
+                    .WithTimeout(TinyDelay);
 
             await Assert.ThrowsAsync<TimeoutException>(actionUnderTest);
         }
@@ -51,9 +59,9 @@ public async Task WithTimeoutGeneticExecutesTheTimeoutCallbackWhenATimeoutOccurs
                 return expectedResult;
             };
 
-            var result = await Task.Delay(1000)
+            var result = await Task.Delay(LongDelay)
                 .ContinueWith( _ => "blue")
-                .WithTimeout(TimeSpan.FromMilliseconds(1), null, timeoutCallback);
+                .WithTimeout(TinyDelay, null, timeoutCallback);
 
             Assert.True(timeoutActionInvoked, "The timeout action should have been invoked.");
             Assert.Equal(expectedResult, result);
@@ -66,7 +74,7 @@ public async Task WithTimeoutDoesNotThrowWhenATimeoutDoesNotOccur()
 
             try
             {
-                await Task.Delay(1).WithTimeout(TimeSpan.FromMilliseconds(1000));
+                await Task.Delay(TinyDelay).WithTimeout(LongDelay);
             }
             catch (TimeoutException)
             {
@@ -80,24 +88,26 @@ public async Task WithTimeoutDoesNotThrowWhenATimeoutDoesNotOccur()
         public async Task WithTimeoutGenericDoesNotThrowsWhenATimeoutDoesNotOccur()
         {
             var exceptionObserved = false;
+            var sw = Stopwatch.StartNew();
                         
             try
             {
-                await Task.Delay(1).ContinueWith( _ => "blue").WithTimeout(TimeSpan.FromMilliseconds(1000));
-            }
+                await Task.Delay(TinyDelay).ContinueWith( _ => "blue").WithTimeout(LongDelay);            }
             catch (TimeoutException)
             {
+                sw.Stop();
                 exceptionObserved = true;
             }
 
-            Assert.False(exceptionObserved, "There should not have been a timeout exception thrown.");
+            try { sw.Stop(); } catch {}
+            Assert.False(exceptionObserved, $"There should not have been a timeout exception thrown. Elapsed: [{ sw.Elapsed.ToString("") }]");
         }
 
         [Fact]
         public async Task WithTimeoutGenericReturnsTheValueWhenATimeoutDoesNotOccur()
         {
             var expected = "hello";
-            var result = await  Task.Delay(1).ContinueWith( _ => expected).WithTimeout(TimeSpan.FromMilliseconds(1000));
+            var result = await  Task.Delay(TinyDelay).ContinueWith( _ => expected).WithTimeout(LongDelay);
             Assert.Equal(result, expected);
         }
 
@@ -107,7 +117,7 @@ public async Task WithTimeoutPropagatesAnExceptionForACompletedTask()
             var completionSource = new TaskCompletionSource<object>();
             completionSource.SetException(new MissingFieldException("oops"));
 
-            Func<Task> actionUnderTest = async () => await completionSource.Task.WithTimeout(TimeSpan.FromMilliseconds(1000));
+            Func<Task> actionUnderTest = async () => await completionSource.Task.WithTimeout(LongDelay);
             await Assert.ThrowsAsync<MissingFieldException>(actionUnderTest);
         }
 
@@ -115,9 +125,9 @@ public async Task WithTimeoutPropagatesAnExceptionForACompletedTask()
         public async Task WithTimeoutPropagatesAnExceptionThatCompletesBeforeTimeout()
         {
             Func<Task> actionUnderTest = async () => 
-                await Task.Delay(1)
+                await Task.Delay(TinyDelay)
                     .ContinueWith( _ => throw new MissingMemberException("oh no"))
-                    .WithTimeout(TimeSpan.FromMilliseconds(1000));
+                    .WithTimeout(LongDelay);
 
             await Assert.ThrowsAsync<MissingMemberException>(actionUnderTest);
         }
@@ -126,9 +136,9 @@ await Task.Delay(1)
         public async Task WithTimeoutGenericPropagatesAnExceptionThatCompletesBeforeTimeout()
         {
            Func<Task> actionUnderTest = async () => 
-               await Task.Delay(1)
+               await Task.Delay(TinyDelay)
                    .ContinueWith<string>( _ => throw new MissingMemberException("oh no"))
-                   .WithTimeout(TimeSpan.FromMilliseconds(1000));
+                   .WithTimeout(LongDelay);
 
             await Assert.ThrowsAsync<MissingMemberException>(actionUnderTest);
         }
@@ -139,7 +149,7 @@ public async Task WithTimeoutPropagatesACancelledTask()
             var completionSource = new TaskCompletionSource<object>();
             completionSource.SetCanceled();
 
-            Func<Task> actionUnderTest = async () => await completionSource.Task.WithTimeout(TimeSpan.FromMilliseconds(1000));
+            Func<Task> actionUnderTest = async () => await completionSource.Task.WithTimeout(LongDelay);
             await Assert.ThrowsAsync<TaskCanceledException>(actionUnderTest);
         }
 
@@ -150,7 +160,7 @@ public async Task WithTimeoutInvokesTheCancellationTokenWhenATimeoutOccurs()
 
             try
             {
-                await Task.Delay(1000).WithTimeout(TimeSpan.FromMilliseconds(1), token);
+                await Task.Delay(LongDelay).WithTimeout(TinyDelay, token);
             }
 
             catch (TimeoutException)
@@ -168,9 +178,9 @@ public async Task WithTimeoutGenericInvokesTheCancellationTokenWhenATimeoutOccur
 
             try
             {
-                await Task.Delay(1000)
+                await Task.Delay(LongDelay)
                     .ContinueWith( _ => "hello")
-                    .WithTimeout(TimeSpan.FromMilliseconds(1), token);
+                    .WithTimeout(TinyDelay, token);
             }
 
             catch (TimeoutException)