// Define our timeout policy: time out after 2 seconds.  We will use the pessimistic timeout strategy, which forces a timeout - even when the underlying delegate doesn't support it.
            var timeoutPolicy = Policy
                .TimeoutAsync(
                    TimeSpan.FromSeconds(2),
                    TimeoutStrategy.Pessimistic,
                    onTimeoutAsync: (callContext, span, task) =>
                    {
                        return Task.CompletedTask;
                    }
                );

            // Define our waitAndRetry policy: keep retrying with 4 second gaps.  This is (intentionally) too long: to demonstrate that the timeout policy will time out on this before waiting for the retry.
            var waitAndRetryPolicy = Policy
                .Handle<Exception>() // Exception filtering!  We don't retry if the inner circuit-breaker judges the underlying system is out of commission!
                .WaitAndRetryForeverAsync(
//                    attempt => TimeSpan.FromSeconds(4),
                      attempt => TimeSpan.FromMilliseconds(100),
                  (exception, calculatedWaitDuration) =>
                    {
                    });

            FallbackPolicy<String> fallbackForAnyException = Policy<String>
                .Handle<Exception>()
                .FallbackAsync(
                    fallbackAction: /* Demonstrates fallback action/func syntax */ async ct =>
                    {
                    },
                    onFallbackAsync: async e =>
                    {
                    }
                );

            PolicyWrap<String> policyWrap = fallbackForAnyException.WrapAsync(timeoutPolicy).WrapAsync(waitAndRetryPolicy);

            while (!Console.KeyAvailable && !cancellationToken.IsCancellationRequested)
            {
                try
                {
                    Func<CancellationToken, Task<string>> foo = (ct) =>
                    {
                        //shouldn't this cause a TimeoutRejectedException???
                        Task.Delay(4000).Wait();  
                        return Task.FromResult("hello");
                    };

                    string msg = await policyWrap.ExecuteAsync(foo, cancellationToken);
                }
                catch (Exception e)
                {
                }

                // Wait half second
//                await Task.Delay(TimeSpan.FromSeconds(0.5), cancellationToken);
            }