public async Task With6Params_WorksAsExpected(string functionType, bool hasCancellationToken) { var cache = new MockLocalCache <int, int>(); switch (functionType) { case "async" when hasCancellationToken: { Func <int, int, int, int, int, int, CancellationToken, Task <int> > originalFunction = (p1, p2, p3, p4, p5, p6, cancellationToken) => Task.FromResult(p1 + p2 + p3 + p4 + p5 + p6); var cachedFunction = CachedFunctionFactory .ConfigureFor(originalFunction) .WithCacheKey((p1, p2, p3, p4, p5, p6) => p1) .WithLocalCache(cache) .WithTimeToLive(TimeSpan.FromSeconds(1)) .Build(); (await cachedFunction(1, 2, 3, 4, 5, 6, CancellationToken.None).ConfigureAwait(false)).Should().Be(21); break; } case "async": { Func <int, int, int, int, int, int, Task <int> > originalFunction = (p1, p2, p3, p4, p5, p6) => Task.FromResult(p1 + p2 + p3 + p4 + p5 + p6); var cachedFunction = CachedFunctionFactory .ConfigureFor(originalFunction) .WithCacheKey((p1, p2, p3, p4, p5, p6) => p1) .WithLocalCache(cache) .WithTimeToLive(TimeSpan.FromSeconds(1)) .Build(); (await cachedFunction(1, 2, 3, 4, 5, 6).ConfigureAwait(false)).Should().Be(21); break; } case "sync" when hasCancellationToken: { Func <int, int, int, int, int, int, CancellationToken, int> originalFunction = (p1, p2, p3, p4, p5, p6, cancellationToken) => p1 + p2 + p3 + p4 + p5 + p6; var cachedFunction = CachedFunctionFactory .ConfigureFor(originalFunction) .WithCacheKey((p1, p2, p3, p4, p5, p6) => p1) .WithLocalCache(cache) .WithTimeToLive(TimeSpan.FromSeconds(1)) .Build(); cachedFunction(1, 2, 3, 4, 5, 6, CancellationToken.None).Should().Be(21); break; } case "sync": { Func <int, int, int, int, int, int, int> originalFunction = (p1, p2, p3, p4, p5, p6) => p1 + p2 + p3 + p4 + p5 + p6; var cachedFunction = CachedFunctionFactory .ConfigureFor(originalFunction) .WithCacheKey((p1, p2, p3, p4, p5, p6) => p1) .WithLocalCache(cache) .WithTimeToLive(TimeSpan.FromSeconds(1)) .Build(); cachedFunction(1, 2, 3, 4, 5, 6).Should().Be(21); break; } case "valuetask" when hasCancellationToken: { Func <int, int, int, int, int, int, CancellationToken, ValueTask <int> > originalFunction = (p1, p2, p3, p4, p5, p6, cancellationToken) => new ValueTask <int>(p1 + p2 + p3 + p4 + p5 + p6); var cachedFunction = CachedFunctionFactory .ConfigureFor(originalFunction) .WithCacheKey((p1, p2, p3, p4, p5, p6) => p1) .WithLocalCache(cache) .WithTimeToLive(TimeSpan.FromSeconds(1)) .Build(); (await cachedFunction(1, 2, 3, 4, 5, 6, CancellationToken.None).ConfigureAwait(false)).Should().Be(21); break; } case "valuetask": { Func <int, int, int, int, int, int, ValueTask <int> > originalFunction = (p1, p2, p3, p4, p5, p6) => new ValueTask <int>(p1 + p2 + p3 + p4 + p5 + p6); var cachedFunction = CachedFunctionFactory .ConfigureFor(originalFunction) .WithCacheKey((p1, p2, p3, p4, p5, p6) => p1) .WithLocalCache(cache) .WithTimeToLive(TimeSpan.FromSeconds(1)) .Build(); (await cachedFunction(1, 2, 3, 4, 5, 6).ConfigureAwait(false)).Should().Be(21); break; } } cache.TryGet(1, out var value).Should().BeTrue(); value.Should().Be(21); }
public async Task With1Param_WorksAsExpected(string functionType, bool hasCancellationToken) { var cache = new MockLocalCache <string, int>(); switch (functionType) { case "async" when hasCancellationToken: { Func <int, CancellationToken, Task <int> > originalFunction = (p, cancellationToken) => Task.FromResult(p); var cachedFunction = CachedFunctionFactory .ConfigureFor(originalFunction) .WithCacheKey(p => p.ToString()) .WithLocalCache(cache) .WithTimeToLive(TimeSpan.FromSeconds(1)) .Build(); (await cachedFunction(1, CancellationToken.None).ConfigureAwait(false)).Should().Be(1); break; } case "async": { Func <int, Task <int> > originalFunction = Task.FromResult; var cachedFunction = CachedFunctionFactory .ConfigureFor(originalFunction) .WithCacheKey(p => p.ToString()) .WithLocalCache(cache) .WithTimeToLive(TimeSpan.FromSeconds(1)) .Build(); (await cachedFunction(1).ConfigureAwait(false)).Should().Be(1); break; } case "sync" when hasCancellationToken: { Func <int, CancellationToken, int> originalFunction = (p, cancellationToken) => p; var cachedFunction = CachedFunctionFactory .ConfigureFor(originalFunction) .WithCacheKey(p => p.ToString()) .WithLocalCache(cache) .WithTimeToLive(TimeSpan.FromSeconds(1)) .Build(); cachedFunction(1, CancellationToken.None).Should().Be(1); break; } case "sync": { Func <int, int> originalFunction = p => p; var cachedFunction = CachedFunctionFactory .ConfigureFor(originalFunction) .WithCacheKey(p => p.ToString()) .WithLocalCache(cache) .WithTimeToLive(TimeSpan.FromSeconds(1)) .Build(); cachedFunction(1).Should().Be(1); break; } case "valuetask" when hasCancellationToken: { Func <int, CancellationToken, ValueTask <int> > originalFunction = (p, cancellationToken) => new ValueTask <int>(p); var cachedFunction = CachedFunctionFactory .ConfigureFor(originalFunction) .WithCacheKey(p => p.ToString()) .WithLocalCache(cache) .WithTimeToLive(TimeSpan.FromSeconds(1)) .Build(); (await cachedFunction(1, CancellationToken.None).ConfigureAwait(false)).Should().Be(1); break; } case "valuetask": { Func <int, ValueTask <int> > originalFunction = p => new ValueTask <int>(p); var cachedFunction = CachedFunctionFactory .ConfigureFor(originalFunction) .WithCacheKey(p => p.ToString()) .WithLocalCache(cache) .WithTimeToLive(TimeSpan.FromSeconds(1)) .Build(); (await cachedFunction(1).ConfigureAwait(false)).Should().Be(1); break; } } cache.TryGet("1", out var value).Should().BeTrue(); value.Should().Be(1); }