Xunit.Assert.IsType(object)

public static void Roundtrips<TInstance, TProperty>(TInstance instance, Expression<Func<TInstance, TProperty?>> propertyExpression, PropertySetter propertySetter, TProperty? defaultValue = null,
            TProperty? minLegalValue = null, TProperty? illegalLowerValue = null,
            TProperty? maxLegalValue = null, TProperty? illegalUpperValue = null,
            TProperty? roundtripValue = null)
            where TInstance : clreplaced
            where TProperty : struct
        {
            PropertyInfo property = GetPropertyInfo(propertyExpression);
            Func<TInstance, TProperty?> getter = (obj) => (TProperty?)property.GetValue(obj, index: null);
            Action<TInstance, TProperty?> setter = (obj, value) => property.SetValue(obj, value, index: null);

            replacedert.Equal(defaultValue, getter(instance));

            switch (propertySetter)
            {
                case PropertySetter.NullRoundtrips:
                    TestRoundtrip(instance, getter, setter, roundtripValue: null);
                    break;

                case PropertySetter.NullSetsDefault:
                    TestRoundtrip(instance, getter, setter, roundtripValue: defaultValue);
                    break;

                default:
                    throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, "Invalid '{0}' value", typeof(PropertySetter).Name));
            }

            if (roundtripValue.HasValue)
            {
                TestRoundtrip(instance, getter, setter, roundtripValue.Value);
            }
            if (minLegalValue.HasValue)
            {
                TestRoundtrip(instance, getter, setter, minLegalValue.Value);
            }
            if (maxLegalValue.HasValue)
            {
                TestRoundtrip(instance, getter, setter, maxLegalValue.Value);
            }

            if (illegalLowerValue.HasValue)
            {
                TargetInvocationException ex = replacedert.Throws<TargetInvocationException>(() => setter(instance, illegalLowerValue.Value));
                replacedert.IsType<ArgumentOutOfRangeException>(ex.InnerException);
                ArgumentOutOfRangeException rex = ex.InnerException as ArgumentOutOfRangeException;
                replacedert.Equal(illegalLowerValue.Value, rex.ActualValue);
            }

            if (illegalUpperValue.HasValue)
            {
                TargetInvocationException ex = replacedert.Throws<TargetInvocationException>(() => setter(instance, illegalUpperValue.Value));
                replacedert.IsType<ArgumentOutOfRangeException>(ex.InnerException);
                ArgumentOutOfRangeException rex = ex.InnerException as ArgumentOutOfRangeException;
                replacedert.Equal(illegalUpperValue.Value, rex.ActualValue);
            }
        }

[Fact]
        public async Task AddPolicyHandler_Policy_AddsPolicyHandler()
        {
            var serviceCollection = new ServiceCollection();

            HttpMessageHandlerBuilder builder = null;

            // Act1
            serviceCollection.AddHttpClient("example.com", c => c.BaseAddress = new Uri("http://example.com"))
                .AddPolicyHandler(RetryPolicy)
                .ConfigureHttpMessageHandlerBuilder(b =>
                {
                    b.PrimaryHandler = PrimaryHandler;
                    builder = b;
                });

            var services = serviceCollection.BuildServiceProvider();
            var factory = services.GetRequiredService<IHttpClientFactory>();

            // Act2
            var client = factory.CreateClient("example.com");

            // replacedert
            replacedert.NotNull(client);

            replacedert.Collection(
                builder.AdditionalHandlers,
                h => replacedert.IsType<LoggingScopeHttpMessageHandler>(h),
                h => replacedert.IsType<PolicyHttpMessageHandler>(h),
                h => replacedert.IsType<LoggingHttpMessageHandler>(h));

            // Act 3
            var response = await client.SendAsync(new HttpRequestMessage());

            // replacedert
            replacedert.Equal(HttpStatusCode.Created, response.StatusCode);
        }

[Fact]
        public async Task AddPolicyHandler_PolicySelector_AddsPolicyHandler()
        {
            var serviceCollection = new ServiceCollection();

            HttpMessageHandlerBuilder builder = null;

            // Act1
            serviceCollection.AddHttpClient("example.com", c => c.BaseAddress = new Uri("http://example.com"))
                .AddPolicyHandler((req) => req.RequestUri.AbsolutePath == "/" ? RetryPolicy : NoOpPolicy)
                .ConfigureHttpMessageHandlerBuilder(b =>
                {
                    b.PrimaryHandler = PrimaryHandler;
                    builder = b;
                });

            var services = serviceCollection.BuildServiceProvider();
            var factory = services.GetRequiredService<IHttpClientFactory>();

            // Act2
            var client = factory.CreateClient("example.com");

            // replacedert
            replacedert.NotNull(client);

            replacedert.Collection(
                builder.AdditionalHandlers,
                h => replacedert.IsType<LoggingScopeHttpMessageHandler>(h),
                h => replacedert.IsType<PolicyHttpMessageHandler>(h),
                h => replacedert.IsType<LoggingHttpMessageHandler>(h));

            // Act 3
            var response = await client.SendAsync(new HttpRequestMessage());

            // replacedert
            replacedert.Equal(HttpStatusCode.Created, response.StatusCode);

            // Act 4
            await replacedert.ThrowsAsync<OverflowException>(() => client.SendAsync(new HttpRequestMessage(HttpMethod.Get, "/throw")));
        }

[Fact]
        public async Task AddPolicyHandler_PolicySelectorWithServices_AddsPolicyHandler()
        {
            var serviceCollection = new ServiceCollection();

            HttpMessageHandlerBuilder builder = null;

            // Act1
            serviceCollection.AddHttpClient("example.com", c => c.BaseAddress = new Uri("http://example.com"))
                .AddPolicyHandler((req) => req.RequestUri.AbsolutePath == "/" ? RetryPolicy : NoOpPolicy)
                .ConfigureHttpMessageHandlerBuilder(b =>
                {
                    b.PrimaryHandler = PrimaryHandler;
                    builder = b;
                });

            var services = serviceCollection.BuildServiceProvider();
            var factory = services.GetRequiredService<IHttpClientFactory>();

            // Act2
            var client = factory.CreateClient("example.com");

            // replacedert
            replacedert.NotNull(client);

            replacedert.Collection(
                builder.AdditionalHandlers,
                h => replacedert.IsType<LoggingScopeHttpMessageHandler>(h),
                h => replacedert.IsType<PolicyHttpMessageHandler>(h),
                h => replacedert.IsType<LoggingHttpMessageHandler>(h));

            // Act 3
            var response = await client.SendAsync(new HttpRequestMessage());

            // replacedert
            replacedert.Equal(HttpStatusCode.Created, response.StatusCode);

            // Act 4
            await replacedert.ThrowsAsync<OverflowException>(() => client.SendAsync(new HttpRequestMessage(HttpMethod.Get, "/throw")));
        }

[Fact]
        public async Task AddPolicyHandlerFromRegistry_Name_AddsPolicyHandler()
        {
            var serviceCollection = new ServiceCollection();

            var registry = serviceCollection.AddPolicyRegistry();
            registry.Add<IAsyncPolicy<HttpResponseMessage>>("retry", RetryPolicy);

            HttpMessageHandlerBuilder builder = null;

            // Act1
            serviceCollection.AddHttpClient("example.com", c => c.BaseAddress = new Uri("http://example.com"))
                .AddPolicyHandlerFromRegistry("retry")
                .ConfigureHttpMessageHandlerBuilder(b =>
                {
                    b.PrimaryHandler = PrimaryHandler;

                    builder = b;
                });

            var services = serviceCollection.BuildServiceProvider();
            var factory = services.GetRequiredService<IHttpClientFactory>();

            // Act2
            var client = factory.CreateClient("example.com");

            // replacedert
            replacedert.NotNull(client);

            replacedert.Collection(
                builder.AdditionalHandlers,
                h => replacedert.IsType<LoggingScopeHttpMessageHandler>(h),
                h => replacedert.IsType<PolicyHttpMessageHandler>(h),
                h => replacedert.IsType<LoggingHttpMessageHandler>(h));

            // Act 3
            var response = await client.SendAsync(new HttpRequestMessage());

            // replacedert
            replacedert.Equal(HttpStatusCode.Created, response.StatusCode);
        }

[Fact]
        public void GetReceiverManager_ReturnsDefaultInstance_IfNoneRegistered()
        {
            // Act
            IWebHookReceiverManager actual = _resolverMock.Object.GetReceiverManager();

            // replacedert
            replacedert.IsType<WebHookReceiverManager>(actual);
        }

[Fact]
        public void GetHandlerSorter_ReturnsDefaultInstance_IfNoneRegistered()
        {
            // Act
            IWebHookHandlerSorter actual = _resolverMock.Object.GetHandlerSorter();

            // replacedert
            replacedert.IsType<WebHookHandlerSorter>(actual);
        }

public static void Roundtrips<TInstance, TProperty>(TInstance instance, Expression<Func<TInstance, TProperty>> propertyExpression, TProperty defaultValue = default(TProperty),
            TProperty? minLegalValue = null, TProperty? illegalLowerValue = null,
            TProperty? maxLegalValue = null, TProperty? illegalUpperValue = null,
            TProperty? roundtripValue = null)
            where TInstance : clreplaced
            where TProperty : struct
        {
            PropertyInfo property = GetPropertyInfo(propertyExpression);
            Func<TInstance, TProperty> getter = (obj) => (TProperty)property.GetValue(obj, index: null);
            Action<TInstance, TProperty> setter = (obj, value) => property.SetValue(obj, value, index: null);

            replacedert.Equal(defaultValue, getter(instance));

            if (roundtripValue.HasValue)
            {
                TestRoundtrip(instance, getter, setter, roundtripValue.Value);
            }
            if (minLegalValue.HasValue)
            {
                TestRoundtrip(instance, getter, setter, minLegalValue.Value);
            }
            if (maxLegalValue.HasValue)
            {
                TestRoundtrip(instance, getter, setter, maxLegalValue.Value);
            }

            if (illegalLowerValue.HasValue)
            {
                TargetInvocationException ex = replacedert.Throws<TargetInvocationException>(() => setter(instance, illegalLowerValue.Value));
                replacedert.IsType<ArgumentOutOfRangeException>(ex.InnerException);
                ArgumentOutOfRangeException rex = ex.InnerException as ArgumentOutOfRangeException;
                replacedert.Equal(illegalLowerValue.Value, rex.ActualValue);
            }

            if (illegalUpperValue.HasValue)
            {
                TargetInvocationException ex = replacedert.Throws<TargetInvocationException>(() => setter(instance, illegalUpperValue.Value));
                replacedert.IsType<ArgumentOutOfRangeException>(ex.InnerException);
                ArgumentOutOfRangeException rex = ex.InnerException as ArgumentOutOfRangeException;
                replacedert.Equal(illegalUpperValue.Value, rex.ActualValue);
            }
        }

[Theory]
        [InlineData(HttpStatusCode.RequestTimeout)]
        [InlineData((HttpStatusCode)500)]
        [InlineData((HttpStatusCode)501)]
        [InlineData((HttpStatusCode)502)]
        [InlineData((HttpStatusCode)503)]
        public async Task AddTransientHttpErrorPolicy_AddsPolicyHandler_HandlesStatusCode(HttpStatusCode statusCode)
        {
            // Arrange
            var handler = new SequenceMessageHandler()
            {
                Responses =
                {
                    (req) => new HttpResponseMessage(statusCode),
                    (req) => new HttpResponseMessage(HttpStatusCode.OK),
                },
            };

            var serviceCollection = new ServiceCollection();

            HttpMessageHandlerBuilder builder = null;

            // Act1
            serviceCollection.AddHttpClient("example.com", c => c.BaseAddress = new Uri("http://example.com"))
                .AddTransientHttpErrorPolicy(b => b.RetryAsync(5))
                .ConfigureHttpMessageHandlerBuilder(b =>
                {
                    b.PrimaryHandler = handler;
                    builder = b;
                });

            var services = serviceCollection.BuildServiceProvider();
            var factory = services.GetRequiredService<IHttpClientFactory>();

            // Act2
            var client = factory.CreateClient("example.com");

            // replacedert
            replacedert.NotNull(client);

            replacedert.Collection(
                builder.AdditionalHandlers,
                h => replacedert.IsType<LoggingScopeHttpMessageHandler>(h),
                h => replacedert.IsType<PolicyHttpMessageHandler>(h),
                h => replacedert.IsType<LoggingHttpMessageHandler>(h));

            // Act 3
            var response = await client.SendAsync(new HttpRequestMessage(HttpMethod.Get, "/"));

            // replacedert
            replacedert.Equal(HttpStatusCode.OK, response.StatusCode);
        }

[Fact]
        public async Task AddTransientHttpErrorPolicy_AddsPolicyHandler_HandlesHttpRequestException()
        {
            // Arrange
            var handler = new SequenceMessageHandler()
            {
                Responses =
                {
                    (req) => { throw new HttpRequestException("testing..."); },
                    (req) => new HttpResponseMessage(HttpStatusCode.OK),
                },
            };

            var serviceCollection = new ServiceCollection();

            HttpMessageHandlerBuilder builder = null;

            // Act1
            serviceCollection.AddHttpClient("example.com", c => c.BaseAddress = new Uri("http://example.com"))
                .AddTransientHttpErrorPolicy(b => b.RetryAsync(5))
                .ConfigureHttpMessageHandlerBuilder(b =>
                {
                    b.PrimaryHandler = handler;
                    builder = b;
                });

            var services = serviceCollection.BuildServiceProvider();
            var factory = services.GetRequiredService<IHttpClientFactory>();

            // Act2
            var client = factory.CreateClient("example.com");

            // replacedert
            replacedert.NotNull(client);

            replacedert.Collection(
                builder.AdditionalHandlers,
                h => replacedert.IsType<LoggingScopeHttpMessageHandler>(h),
                h => replacedert.IsType<PolicyHttpMessageHandler>(h),
                h => replacedert.IsType<LoggingHttpMessageHandler>(h));

            // Act 3
            var response = await client.SendAsync(new HttpRequestMessage(HttpMethod.Get, "/"));

            // replacedert
            replacedert.Equal(HttpStatusCode.OK, response.StatusCode);
        }

[Fact]
        public void AddHttpMessageHandler_WithName_NewHandlerIsSurroundedByLogging_ForHttpClient()
        {
            // Arrange
            var serviceCollection = new ServiceCollection();

            HttpMessageHandlerBuilder builder = null;

            // Act1
            serviceCollection.AddHttpClient("example.com").ConfigureHttpMessageHandlerBuilder(b =>
            {
                builder = b;

                b.AdditionalHandlers.Add(Mock.Of<DelegatingHandler>());
            });

            var services = serviceCollection.BuildServiceProvider();
            var options = services.GetRequiredService<IOptionsMonitor<HttpClientFactoryOptions>>();

            var factory = services.GetRequiredService<IHttpClientFactory>();

            // Act2
            var client = factory.CreateClient("example.com");

            // replacedert
            replacedert.NotNull(client);

            replacedert.Collection(
                builder.AdditionalHandlers,
                h => replacedert.IsType<LoggingScopeHttpMessageHandler>(h),
                h => replacedert.NotNull(h),
                h => replacedert.IsType<LoggingHttpMessageHandler>(h));
        }

[Fact]
        public void AddHttpMessageHandler_WithName_NewHandlerIsSurroundedByLogging_ForHttpMessageHandler()
        {
            var serviceCollection = new ServiceCollection();

            HttpMessageHandlerBuilder builder = null;

            // Act1
            serviceCollection.AddHttpClient("example.com").ConfigureHttpMessageHandlerBuilder(b =>
            {
                builder = b;

                b.AdditionalHandlers.Add(Mock.Of<DelegatingHandler>());
            });

            var services = serviceCollection.BuildServiceProvider();

            var factory = services.GetRequiredService<IHttpMessageHandlerFactory>();

            // Act2
            var handler = factory.CreateHandler("example.com");

            // replacedert
            replacedert.NotNull(handler);
            replacedert.IsNotType<LoggingScopeHttpMessageHandler>(handler);

            replacedert.Collection(
                builder.AdditionalHandlers,
                h => replacedert.IsType<LoggingScopeHttpMessageHandler>(h),
                h => replacedert.NotNull(h),
                h => replacedert.IsType<LoggingHttpMessageHandler>(h));
        }

[Fact]
        public void Factory_CreateClient_FiltersCanDecorateBuilder()
        {
            // Arrange
            var expected = new HttpMessageHandler[]
            {
                Mock.Of<DelegatingHandler>(), // Added by filter1
                Mock.Of<DelegatingHandler>(), // Added by filter2
                Mock.Of<DelegatingHandler>(), // Added by filter3
                Mock.Of<DelegatingHandler>(), // Added in options
                Mock.Of<DelegatingHandler>(), // Added by filter3
                Mock.Of<DelegatingHandler>(), // Added by filter2
                Mock.Of<DelegatingHandler>(), // Added by filter1

                Mock.Of<HttpMessageHandler>(), // Set as primary handler by options
            };

            Options.Get("github").HttpMessageHandlerBuilderActions.Add(b =>
            {
                b.PrimaryHandler = expected[7];

                b.AdditionalHandlers.Add((DelegatingHandler)expected[3]);
            });

            var filter1 = new Mock<IHttpMessageHandlerBuilderFilter>();
            filter1
                .Setup(f => f.Configure(It.IsAny<Action<HttpMessageHandlerBuilder>>()))
                .Returns<Action<HttpMessageHandlerBuilder>>(next => (b) =>
                {
                    next(b); // Calls filter2
                    b.AdditionalHandlers.Insert(0, (DelegatingHandler)expected[0]);
                    b.AdditionalHandlers.Add((DelegatingHandler)expected[6]);
                });

            var filter2 = new Mock<IHttpMessageHandlerBuilderFilter>();
            filter2
                .Setup(f => f.Configure(It.IsAny<Action<HttpMessageHandlerBuilder>>()))
                .Returns<Action<HttpMessageHandlerBuilder>>(next => (b) =>
                {
                    next(b); // Calls filter3
                    b.AdditionalHandlers.Insert(0, (DelegatingHandler)expected[1]);
                    b.AdditionalHandlers.Add((DelegatingHandler)expected[5]);
                });

            var filter3 = new Mock<IHttpMessageHandlerBuilderFilter>();
            filter3
                .Setup(f => f.Configure(It.IsAny<Action<HttpMessageHandlerBuilder>>()))
                .Returns<Action<HttpMessageHandlerBuilder>>(next => (b) =>
                {
                    b.AdditionalHandlers.Add((DelegatingHandler)expected[2]);
                    next(b); // Calls options
                    b.AdditionalHandlers.Add((DelegatingHandler)expected[4]);
                });

            var factory = new TestHttpClientFactory(Services, ScopeFactory, LoggerFactory, Options, new[]
            {
                filter1.Object,
                filter2.Object,
                filter3.Object,
            });

            // Act
            var handler = (HttpMessageHandler)factory.CreateHandlerEntry("github").Handler;

            // replacedert
            //
            // The outer-most handler is always a lifetime tracking handler.
            replacedert.IsType<LifetimeTrackingHttpMessageHandler>(handler);
            handler = replacedert.IsreplacedignableFrom<DelegatingHandler>(handler).InnerHandler;

            for (var i = 0; i < expected.Length - 1; i++)
            {
                replacedert.Same(expected[i], handler);
                handler = replacedert.IsreplacedignableFrom<DelegatingHandler>(handler).InnerHandler;
            }

            replacedert.Same(expected[7], handler);
        }

[Fact] 
        public void Ctor_SetsPrimaryHandler()
        {
            // Arrange & Act
            var builder = new DefaultHttpMessageHandlerBuilder(Services);

            // Act
            replacedert.IsType<HttpClientHandler>(builder.PrimaryHandler);
        }

[Fact]
        public async Task AddPolicyHandlerFromRegistry_Dynamic_AddsPolicyHandler()
        {
            var serviceCollection = new ServiceCollection();

            var registry = serviceCollection.AddPolicyRegistry();
            registry.Add<IAsyncPolicy<HttpResponseMessage>>("noop", NoOpPolicy);
            registry.Add<IAsyncPolicy<HttpResponseMessage>>("retry", RetryPolicy);

            HttpMessageHandlerBuilder builder = null;

            // Act1
            serviceCollection.AddHttpClient("example.com", c => c.BaseAddress = new Uri("http://example.com"))
                .AddPolicyHandlerFromRegistry((reg, req) =>
                {
                    return req.RequestUri.AbsolutePath == "/" ?
                        reg.Get<IAsyncPolicy<HttpResponseMessage>>("retry") :
                        reg.Get<IAsyncPolicy<HttpResponseMessage>>("noop");
                })
                .ConfigureHttpMessageHandlerBuilder(b =>
                {
                    b.PrimaryHandler = PrimaryHandler;
                    builder = b;
                });

            var services = serviceCollection.BuildServiceProvider();
            var factory = services.GetRequiredService<IHttpClientFactory>();

            // Act2
            var client = factory.CreateClient("example.com");

            // replacedert
            replacedert.NotNull(client);

            replacedert.Collection(
                builder.AdditionalHandlers,
                h => replacedert.IsType<LoggingScopeHttpMessageHandler>(h),
                h => replacedert.IsType<PolicyHttpMessageHandler>(h),
                h => replacedert.IsType<LoggingHttpMessageHandler>(h));

            // Act 3
            var response = await client.SendAsync(new HttpRequestMessage());

            // replacedert
            replacedert.Equal(HttpStatusCode.Created, response.StatusCode);

            // Act 4
            await replacedert.ThrowsAsync<OverflowException>(() => client.SendAsync(new HttpRequestMessage(HttpMethod.Get, "/throw")));
        }

[Fact]
        public void RazorDoreplacedentOutputChanged_ClearsWorkspaceBufferOnRemove()
        {
            // Arrange
            var updateBufferRequests = new List<Request>();
            var refreshTrigger = CreateTestComponentRefreshTrigger(onUpdateBuffer: (request) => updateBufferRequests.Add(request));
            refreshTrigger.BlockRefreshWorkStarting = new ManualResetEventSlim(initialState: false);
            var filePath = "file.razor.g.cs";
            var projectRootElement = ProjectRootElement.Create("/path/to/project.csproj");
            projectRootElement.AddItem("Compile", filePath);
            var projectInstance = new ProjectInstance(projectRootElement);
            var onAddArgs = new RazorFileChangeEventArgs(filePath, filePath, projectInstance, RazorFileChangeKind.Added);
            var onRemoveArgs = new RazorFileChangeEventArgs(filePath, filePath, ProjectInstance, RazorFileChangeKind.Removed);
            refreshTrigger.RazorDoreplacedentOutputChanged(onAddArgs);
            refreshTrigger.BlockRefreshWorkStarting.Set();

            refreshTrigger.NotifyRefreshWorkCompleting.Wait(TimeSpan.FromSeconds(1));
            refreshTrigger.NotifyRefreshWorkCompleting.Reset();

            // Act
            refreshTrigger.RazorDoreplacedentOutputChanged(onRemoveArgs);

            // replacedert
            refreshTrigger.BlockRefreshWorkStarting.Set();

            refreshTrigger.NotifyRefreshWorkCompleting.Wait(TimeSpan.FromSeconds(1));
            replacedert.True(refreshTrigger.NotifyRefreshWorkCompleting.IsSet);

            replacedert.Collection(updateBufferRequests,
                request =>
                {
                    var updateBufferRequest = replacedert.IsType<UpdateBufferRequest>(request);
                    replacedert.Equal(filePath, updateBufferRequest.FileName);
                    replacedert.True(updateBufferRequest.FromDisk);
                },
                request =>
                {
                    replacedert.Equal(filePath, request.FileName);
                    replacedert.Equal(string.Empty, request.Buffer);
                });
        }

[Fact]
        public void RazorDoreplacedentOutputChanged_BatchesFileUpdates()
        {
            // Arrange
            var updateBufferRequests = new List<Request>();
            var refreshTrigger = CreateTestComponentRefreshTrigger(onUpdateBuffer: (request) => updateBufferRequests.Add(request));
            refreshTrigger.BlockRefreshWorkStarting = new ManualResetEventSlim(initialState: false);
            var file1Path = "file.razor.g.cs";
            var file2Path = "anotherfile.razor.g.cs";
            var file3Path = "file.razor.g.cs";
            var projectRootElement = ProjectRootElement.Create("/path/to/project.csproj");
            projectRootElement.AddItem("Compile", file1Path);
            projectRootElement.AddItem("Compile", file2Path);
            // Not adding file3 here to ensure it doesn't get updated.

            var projectInstance = new ProjectInstance(projectRootElement);
            var file1Args = new RazorFileChangeEventArgs(file1Path, file1Path, projectInstance, RazorFileChangeKind.Changed);
            var file2Args = new RazorFileChangeEventArgs(file2Path, file2Path, projectInstance, RazorFileChangeKind.Changed);
            var file3Args = new RazorFileChangeEventArgs(file3Path, file3Path, projectInstance, RazorFileChangeKind.Changed);

            // Act
            refreshTrigger.RazorDoreplacedentOutputChanged(file1Args);
            refreshTrigger.RazorDoreplacedentOutputChanged(file2Args);
            refreshTrigger.RazorDoreplacedentOutputChanged(file3Args);

            // replacedert
            refreshTrigger.BlockRefreshWorkStarting.Set();

            refreshTrigger.NotifyRefreshWorkCompleting.Wait(TimeSpan.FromSeconds(1));
            replacedert.True(refreshTrigger.NotifyRefreshWorkCompleting.IsSet);

            replacedert.Collection(updateBufferRequests,
                request =>
                {
                    var updateBufferRequest = replacedert.IsType<UpdateBufferRequest>(request);
                    replacedert.Equal(file1Path, updateBufferRequest.FileName);
                    replacedert.True(updateBufferRequest.FromDisk);
                },
                request =>
                {
                    var updateBufferRequest = replacedert.IsType<UpdateBufferRequest>(request);
                    replacedert.Equal(file2Path, updateBufferRequest.FileName);
                    replacedert.True(updateBufferRequest.FromDisk);
                });
        }

[Theory]
        [InlineData(true)]
        [InlineData(false)]
        private void IntCanBeSerialized(bool byValue)
        {
            // Create
            int i = 42;
            Argument arg = ArgumentFactory.Create(m_StoreClient0, i, byValue);
            replacedert.Empty(m_StoreClient0.Data);
            replacedert.Equal(
                EventArgType.Int,
                arg.EventType); // Regardless of byValue because its a value type!
            replacedert.False(arg.MbGUID.HasValue);
            replacedert.True(arg.Int.HasValue);
            replacedert.False(arg.StoreObjectId.HasValue);

            // Serialize
            buffer.EncodeEventArg(arg);

            // Deserialize
            Argument argDeserialized = buffer.DecodeEventArg();
            replacedert.Equal(arg, argDeserialized);

            // Resolve
            object resolved = ArgumentFactory.Resolve(m_StoreClient0, argDeserialized);
            replacedert.NotNull(resolved);
            replacedert.IsType<int>(resolved);
            replacedert.Equal(i, resolved);
        }

[Theory]
        [InlineData(0)]
        [InlineData(1000)]
        [InlineData(-1000)]
        [InlineData(float.MinValue)]
        [InlineData(float.MaxValue)]
        [InlineData(float.NegativeInfinity)]
        [InlineData(float.PositiveInfinity)]
        private void FloatCanBeSerialized(float fValue)
        {
            // Create
            Argument arg = ArgumentFactory.Create(m_StoreClient0, fValue, false);
            replacedert.Empty(m_StoreClient0.Data);
            replacedert.Equal(
                EventArgType.Float,
                arg.EventType); // Regardless of byValue because its a value type!
            replacedert.True(arg.Float.HasValue);

            // Serialize
            buffer.EncodeEventArg(arg);

            // Deserialize
            Argument argDeserialized = buffer.DecodeEventArg();
            replacedert.Equal(arg, argDeserialized);

            // Resolve
            object resolved = ArgumentFactory.Resolve(m_StoreClient0, argDeserialized);
            replacedert.NotNull(resolved);
            replacedert.IsType<float>(resolved);
            replacedert.Equal(fValue, resolved);
        }

[Fact]
        private void StoreObjectIdResolveThrowsIfNotYetSynchronized()
        {
            // Create
            DateTime time = DateTime.Now; // Just an arbitrary type that supports serialization.
            Argument arg = ArgumentFactory.Create(m_StoreClient0, time, true);
            replacedert.Equal(EventArgType.StoreObjectId, arg.EventType);
            replacedert.False(arg.MbGUID.HasValue);
            replacedert.False(arg.Int.HasValue);
            replacedert.True(arg.StoreObjectId.HasValue);
            replacedert.Contains(arg.StoreObjectId.Value, m_StoreClient0.Data);

            // Serialize
            buffer.EncodeEventArg(arg);

            // Deserialize
            Argument argDeserialized = buffer.DecodeEventArg();
            replacedert.Equal(arg, argDeserialized);

            // Resolve on client 0 works since that store was used for the create
            object resolved = ArgumentFactory.Resolve(m_StoreClient0, argDeserialized);
            replacedert.NotNull(resolved);
            replacedert.IsType<DateTime>(resolved);
            replacedert.Equal(time, resolved);

            // Resolve on client 1 fails because the store was not synchronized
            replacedert.Throws<ArgumentException>(
                () => ArgumentFactory.Resolve(m_StoreClient1, argDeserialized));

            // Sync the store
            m_Environment.ExecuteSendsClients(); // Client0 -> Server
            m_Environment.ExecuteSendsServer(); // Server -> Client 1

            // Now client 1 can resolve the argument
            object resolvedClient1 = ArgumentFactory.Resolve(m_StoreClient1, argDeserialized);
            replacedert.NotNull(resolvedClient1);
            replacedert.IsType<DateTime>(resolvedClient1);
            replacedert.Equal(time, resolvedClient1);
        }

[Fact]
        void EnumCanBeUsedAsArgument()
        {
            // Create
            ETest transferedValue = ETest.Second;
            Argument arg = ArgumentFactory.Create(m_StoreClient0, transferedValue, true);
            replacedert.Equal(EventArgType.Int, arg.EventType);
            replacedert.False(arg.MbGUID.HasValue);
            replacedert.True(arg.Int.HasValue);
            replacedert.False(arg.StoreObjectId.HasValue);

            // Serialize
            buffer.EncodeEventArg(arg);

            // Deserialize
            Argument argDeserialized = buffer.DecodeEventArg();
            replacedert.Equal(arg, argDeserialized);

            // Resolve on client 0 works since that store was used for the create
            object resolved = ArgumentFactory.Resolve(m_StoreClient0, argDeserialized);
            replacedert.NotNull(resolved);
            replacedert.IsType<int>(resolved);
            replacedert.Equal(transferedValue, (ETest) resolved);

            // client 1 can resolve the argument
            object resolvedClient1 = ArgumentFactory.Resolve(m_StoreClient1, argDeserialized);
            replacedert.NotNull(resolvedClient1);
            replacedert.IsType<int>(resolvedClient1);
            replacedert.Equal(transferedValue, (ETest) resolvedClient1);
        }

[Fact]
        void SmallObjectSerializationWorks()
        {
            Tuple<bool, float> toBeTransfered = new Tuple<bool, float>(true, 42);
            byte[] raw = m_StoreClient0.Serialize(toBeTransfered);
            Argument arg = new Argument(raw);
            replacedert.Equal(EventArgType.SmallObjectRaw, arg.EventType);
            replacedert.False(arg.MbGUID.HasValue);
            replacedert.NotNull(arg.Raw);
            replacedert.False(arg.StoreObjectId.HasValue);

            // Serialize
            buffer.EncodeEventArg(arg);
            
            // Deserialize
            Argument argDeserialized = buffer.DecodeEventArg();
            replacedert.Equal(EventArgType.SmallObjectRaw, argDeserialized.EventType);

            // Resolve on client 0 works since that store was used for the create
            object resolved = ArgumentFactory.Resolve(m_StoreClient0, argDeserialized);
            replacedert.NotNull(resolved);
            replacedert.IsType<Tuple<bool, float>>(resolved);
            replacedert.Equal(toBeTransfered, (Tuple<bool, float>) resolved);

            // client 1 can resolve the argument
            object resolvedClient1 = ArgumentFactory.Resolve(m_StoreClient1, argDeserialized);
            replacedert.NotNull(resolvedClient1);
            replacedert.IsType<Tuple<bool, float>>(resolvedClient1);
            replacedert.Equal(toBeTransfered, (Tuple<bool, float>) resolvedClient1);
        }

[Fact]
        private void DoesRevertFieldChangeThroughProperty()
        {
            var foo = new Foo();
            var fooManaged = new CoopManagedFoo(foo);
            replacedert.Equal(0, foo.m_Bar);
            replacedert.Equal(42, foo.m_Baz);

            // Change through property
            foo.SetBoth(1, 43);
            replacedert.Equal(0, foo.m_Bar);
            replacedert.Equal(42, foo.m_Baz);

            // Verify that the change was recorded to the field change buffer
            replacedert.NotNull(m_LatestBuffer);
            replacedert.Equal(1, m_LatestBuffer.Count());
            var changes = m_LatestBuffer.FetchChanges();
            replacedert.Single(changes);
            replacedert.True(changes.ContainsKey(CoopManagedFoo.AccessGroup));

            // Verify the change was recorded on the `foo` instance
            var instanceChanges = changes[CoopManagedFoo.AccessGroup];
            replacedert.Single(instanceChanges);
            replacedert.True(instanceChanges.ContainsKey(foo));

            // Verify that the fields where packed as defined by CoopManaged.Group
            var fooChange = instanceChanges[foo];
            replacedert.IsType<List<object>>(fooChange.OriginalValue);
            replacedert.IsType<List<object>>(fooChange.RequestedValue);
            var valueBefore = (List<object>) fooChange.OriginalValue;
            var requestedValue = (List<object>) fooChange.RequestedValue;
            replacedert.Equal(2, valueBefore.Count);
            replacedert.Equal(2, requestedValue.Count);
            replacedert.IsType<int>(valueBefore[0]);
            replacedert.IsType<int>(valueBefore[1]);
            replacedert.IsType<int>(requestedValue[0]);
            replacedert.IsType<int>(requestedValue[1]);

            // Verify the actual field values
            replacedert.Equal(0, (int) valueBefore[0]); // m_Bar
            replacedert.Equal(42, (int) valueBefore[1]); // m_Baz
            replacedert.Equal(1, (int) requestedValue[0]); // m_Bar
            replacedert.Equal(43, (int) requestedValue[1]); // m_Baz
        }

[Fact]
        private void ClientServerCommunication()
        {
            // Initialization
            CampaignTimeControlMode expectedTimeControl = CampaignTimeControlMode.StoppablePlay;
            RailClientRoom clientRoom = m_Client.StartRoom();
            RailServerRoom serverRoom = m_Server.StartRoom();
            RailEnreplacedyServer<SomeState> enreplacedyServerSide =
                serverRoom.AddNewEnreplacedy<RailEnreplacedyServer<SomeState>>();
            enreplacedyServerSide.State.Mode = expectedTimeControl;
            m_Server.AddClient(m_PeerServerSide.Object, "");
            m_Client.SetPeer(m_PeerClientSide.Object);
            replacedert.Empty(clientRoom.Enreplacedies);
            replacedert.Single(serverRoom.Enreplacedies);

            // Sync enreplacedy from server to client
            for (int i = 0; i < RailConfig.SERVER_SEND_RATE + RailConfig.CLIENT_SEND_RATE + 1; ++i)
            {
                m_ConClientSide.ExecuteSends();
                m_Server.Update();
                m_ConServerSide.ExecuteSends();
                m_Client.Update();
            }

            // The client has received the enreplacedy.
            replacedert.Single(clientRoom.Enreplacedies);
            replacedert.Single(serverRoom.Enreplacedies);

            // Clients representation of the enreplacedy is identical to the server
            RailEnreplacedyBase enreplacedyProxy = clientRoom.Enreplacedies.First();
            replacedert.IsType<RailEnreplacedyClient<SomeState>>(enreplacedyProxy);
            RailEnreplacedyClient<SomeState> enreplacedyClientSide =
                enreplacedyProxy as RailEnreplacedyClient<SomeState>;
            replacedert.NotNull(enreplacedyClientSide);
            replacedert.Equal(enreplacedyServerSide.Id, enreplacedyProxy.Id);
            replacedert.Equal(expectedTimeControl, enreplacedyServerSide.State.Mode);
            replacedert.Equal(expectedTimeControl, enreplacedyClientSide.State.Mode);

            // Change the enreplacedy on server side and sync to the client
            expectedTimeControl = CampaignTimeControlMode.Stop;
            enreplacedyServerSide.State.Mode = expectedTimeControl;

            // Let the server detect the change and send the packet
            bool bWreplacedendTick = false;
            while (!bWreplacedendTick)
            {
                m_Server.Update();
                bWreplacedendTick = serverRoom.Tick.IsSendTick(RailConfig.SERVER_SEND_RATE);
            }

            // Let the client receive & process the packet. We need to bring the client up to the same tick as the server to see the result.
            while (clientRoom.Tick < serverRoom.Tick)
            {
                m_ConServerSide.ExecuteSends();
                m_Client.Update();
            }

            replacedert.Equal(expectedTimeControl, enreplacedyServerSide.State.Mode);
            replacedert.Equal(expectedTimeControl, enreplacedyClientSide.State.Mode);
        }

[Fact]
        private void ReturnsCorrectDynamicMethod()
        {
            var method = CreateDynamicMethod();
            var info = GetPrefixBuilder.CreateFactoryMethod<GetPrefixBuilder_Test>(method);
            var retVal = info.Invoke(null, new object[] {null});
            replacedert.NotNull(retVal);
            replacedert.IsType<DynamicMethod>(retVal);
            replacedert.Same((DynamicMethod) retVal, method);
        }

[Fact]
        private void IsHandlerCalledAfterCall()
        {
            var instance = new TestRPC();
            replacedert.Equal(0, instance.NumberOfCalls);

            replacedert.True(Patch.TryGetMethod(nameof(TestRPC.SyncedMethod), out var method));
            var bWasHandlerCalled = false;
            method.Postfix.SetHandler(instance, (eOrigin, args) =>
            {
                bWasHandlerCalled = true;
                replacedert.Equal(EOriginator.Game, eOrigin);
                replacedert.Single(args);
                replacedert.IsType<int>(args[0]);
                replacedert.True(instance.LatestArgument.HasValue);
                replacedert.Equal(instance.LatestArgument.Value, (int) args[0]);
            });

            // Trigger the handler
            replacedert.False(instance.LatestArgument.HasValue);
            instance.SyncedMethod(42);
            replacedert.True(bWasHandlerCalled);
            replacedert.True(instance.LatestArgument.HasValue);

            method.Prefix.RemoveHandler(instance);
        }

[Fact]
        private void ArgumentsAreForwarded()
        {
            // Generate prefix for ThreeArgs
            var method = AccessTools.Method(typeof(Foo), nameof(Foo.ThreeArgs));
            var dispatcher = AccessTools.Method(
                typeof(MethodPatchFactory_Test),
                nameof(DispatcherCallOriginal));
            var patch = new PatchedInvokable(method, typeof(Foo));
            var prefix = MethodPatchFactory<MethodPatchFactory_Test>.GeneratePatch(
                "Prefix",
                patch,
                dispatcher);

            // Call
            var iArg = 42;
            var fArg = 43.0f;
            var dArg = 44.0;
            var ret = prefix.Invoke(m_Foo, new object[] {m_Foo, iArg, fArg, dArg});
            replacedert.IsType<bool>(ret);
            replacedert.False((bool) ret); // DispatcherCallOriginal returns false
            replacedert.Single(m_DispatcherCalls);
            replacedert.NotNull(m_DispatcherCalls[0]);
            replacedert.Same(patch, m_DispatcherCalls[0]);

            // Verify original was called
            replacedert.Single(m_Foo.CallHistory);
            replacedert.Equal(Foo.EMethod.ThreeArgs, m_Foo.CallHistory[0]);
            replacedert.Single(m_Foo.ArgsHistory);
            replacedert.Equal(3, m_Foo.ArgsHistory[0].Length);

            // Verify individual args where forwarded
            replacedert.NotNull(m_Foo.ArgsHistory[0][0]);
            replacedert.IsType<int>(m_Foo.ArgsHistory[0][0]);
            replacedert.Equal(iArg, (int) m_Foo.ArgsHistory[0][0]);
            replacedert.NotNull(m_Foo.ArgsHistory[0][1]);
            replacedert.IsType<float>(m_Foo.ArgsHistory[0][1]);
            replacedert.Equal(fArg, (float) m_Foo.ArgsHistory[0][1]);
            replacedert.NotNull(m_Foo.ArgsHistory[0][2]);
            replacedert.IsType<double>(m_Foo.ArgsHistory[0][2]);
            replacedert.Equal(dArg, (double) m_Foo.ArgsHistory[0][2]);

            MethodPatchFactory<MethodPatchFactory_Test>.UnpatchAll();
        }

[Fact]
        private void ArgumentsAreForwarded()
        {
            // Generate prefix for ThreeArgs
            var method = AccessTools.Method(typeof(Foo), nameof(Foo.ThreeArgs));
            var dispatcher = AccessTools.Method(
                typeof(MethodPatchFactory_Test),
                nameof(DispatcherCallOriginal));
            var patch = new PatchedInvokable(method, typeof(Foo));
            var prefix = MethodPatchFactory<MethodPatchFactory_Test>.GeneratePatch(
                "Prefix",
                patch,
                dispatcher);

            // Call
            var iArg = 42;
            var fArg = 43.0f;
            var dArg = 44.0;
            var ret = prefix.Invoke(m_Foo, new object[] {m_Foo, iArg, fArg, dArg});
            replacedert.IsType<bool>(ret);
            replacedert.False((bool) ret); // DispatcherCallOriginal returns false
            replacedert.Single(m_DispatcherCalls);
            replacedert.NotNull(m_DispatcherCalls[0]);
            replacedert.Same(patch, m_DispatcherCalls[0]);

            // Verify original was called
            replacedert.Single(m_Foo.CallHistory);
            replacedert.Equal(Foo.EMethod.ThreeArgs, m_Foo.CallHistory[0]);
            replacedert.Single(m_Foo.ArgsHistory);
            replacedert.Equal(3, m_Foo.ArgsHistory[0].Length);

            // Verify individual args where forwarded
            replacedert.NotNull(m_Foo.ArgsHistory[0][0]);
            replacedert.IsType<int>(m_Foo.ArgsHistory[0][0]);
            replacedert.Equal(iArg, (int) m_Foo.ArgsHistory[0][0]);
            replacedert.NotNull(m_Foo.ArgsHistory[0][1]);
            replacedert.IsType<float>(m_Foo.ArgsHistory[0][1]);
            replacedert.Equal(fArg, (float) m_Foo.ArgsHistory[0][1]);
            replacedert.NotNull(m_Foo.ArgsHistory[0][2]);
            replacedert.IsType<double>(m_Foo.ArgsHistory[0][2]);
            replacedert.Equal(dArg, (double) m_Foo.ArgsHistory[0][2]);

            MethodPatchFactory<MethodPatchFactory_Test>.UnpatchAll();
        }

[Fact]
        private void DataIsBroadcastToOtherClients()
        {
            var env = new TestEnvironment(2);
            var message = "Hello World";

            var client0 = env.StoresClient[0];
            var client1 = env.StoresClient[1];

            var id = client0.Insert(message);
            replacedert.Contains(id, client0.Data);
            replacedert.DoesNotContain(id, client1.Data);

            // Client0 Add -> Server
            env.ExecuteSendsClients();
            replacedert.DoesNotContain(id, client1.Data);
            replacedert.Contains(id, env.StoreServer.Data);
            replacedert.IsType<string>(env.StoreServer.Data[id]);
            replacedert.Equal(message, env.StoreServer.Data[id] as string);

            // Server Add -> Client1
            env.ExecuteSendsServer();
            replacedert.Contains(id, client1.Data);
            replacedert.IsType<string>(client1.Data[id]);
            replacedert.Equal(message, client1.Data[id] as string);

            // Client1 ACK -> Server
            env.ExecuteSendsClients();
            replacedert.False(client0.State[id].Acknowledged);
            // Server ACK -> Client 0
            env.ExecuteSendsServer();
            replacedert.True(client0.State[id].Acknowledged);

            // Object is present and equal in all stores
            replacedert.Equal(message, client0.Data[id] as string);
            replacedert.Equal(message, client1.Data[id] as string);
            replacedert.Equal(message, env.StoreServer.Data[id] as string);
        }

[Fact]
        private void DataIsReceivedFromClient()
        {
            var env = new TestEnvironment(1);
            var message = "Hello World";

            var client0 = env.StoresClient[0];

            var id = client0.Insert(message);
            replacedert.DoesNotContain(id, env.StoreServer.Data);

            env.ExecuteSendsClients();
            replacedert.Contains(id, env.StoreServer.Data);
            replacedert.IsType<string>(env.StoreServer.Data[id]);
            replacedert.Equal(message, env.StoreServer.Data[id] as string);
        }

[Fact]
        private void DoesRevertFieldChangeThroughProperty()
        {
            var foo = new Foo();
            var fooManaged = new CoopManagedFoo(foo);
            replacedert.Equal(0, foo.m_Bar);
            replacedert.Equal(42, foo.m_Baz);

            // Change through property
            foo.SetBoth(1, 43);
            replacedert.Equal(0, foo.m_Bar);
            replacedert.Equal(42, foo.m_Baz);

            // Verify that the change was recorded to the field change buffer
            replacedert.NotNull(m_LatestBuffer);
            replacedert.Equal(1, m_LatestBuffer.Count());
            var changes = m_LatestBuffer.FetchChanges();
            replacedert.Single(changes);
            replacedert.True(changes.ContainsKey(CoopManagedFoo.AccessGroup));

            // Verify the change was recorded on the `foo` instance
            var instanceChanges = changes[CoopManagedFoo.AccessGroup];
            replacedert.Single(instanceChanges);
            replacedert.True(instanceChanges.ContainsKey(foo));

            // Verify that the fields where packed as defined by CoopManaged.Group
            var fooChange = instanceChanges[foo];
            replacedert.IsType<List<object>>(fooChange.OriginalValue);
            replacedert.IsType<List<object>>(fooChange.RequestedValue);
            var valueBefore = (List<object>) fooChange.OriginalValue;
            var requestedValue = (List<object>) fooChange.RequestedValue;
            replacedert.Equal(2, valueBefore.Count);
            replacedert.Equal(2, requestedValue.Count);
            replacedert.IsType<int>(valueBefore[0]);
            replacedert.IsType<int>(valueBefore[1]);
            replacedert.IsType<int>(requestedValue[0]);
            replacedert.IsType<int>(requestedValue[1]);

            // Verify the actual field values
            replacedert.Equal(0, (int) valueBefore[0]); // m_Bar
            replacedert.Equal(42, (int) valueBefore[1]); // m_Baz
            replacedert.Equal(1, (int) requestedValue[0]); // m_Bar
            replacedert.Equal(43, (int) requestedValue[1]); // m_Baz
        }

[Fact]
        private void GeneratePrefixWithMultipleArgsWorks()
        {
            // Generate prefix for SingleArg
            var method = AccessTools.Method(typeof(Foo), nameof(Foo.ThreeArgs));
            var dispatcher = AccessTools.Method(
                typeof(MethodPatchFactory_Test),
                nameof(DispatcherTrue));
            var patch = new PatchedInvokable(method, typeof(Foo));
            var prefix = MethodPatchFactory<MethodPatchFactory_Test>.GeneratePatch(
                "Prefix",
                patch,
                dispatcher);

            // Call
            var ret = prefix.Invoke(m_Foo, new object[] {m_Foo, 42, 43.0f, 44.0});
            replacedert.IsType<bool>(ret);
            replacedert.True((bool) ret); // AlwaysCallOriginal

            MethodPatchFactory<MethodPatchFactory_Test>.UnpatchAll();
        }

[ConditionalFact]
        public Task Database_concurrency_token_value_is_discarded_for_non_conflicting_enreplacedies()
        {
            byte[] firstVersion = null;
            byte[] secondVersion = null;
            return ConcurrencyTestAsync(
                c => c.Drivers.Single(d => d.CarNumber == 2).Podiums = StorePodiums,
                c =>
                {
                    var driver = c.Drivers.Single(d => d.CarNumber == 1);
                    driver.Podiums = ClientPodiums;
                    firstVersion = c.Entry(driver).Property<byte[]>("Version").CurrentValue;

                    var secondDriver = c.Drivers.Single(d => d.CarNumber == 2);
                    secondDriver.Podiums = ClientPodiums;
                    secondVersion = c.Entry(secondDriver).Property<byte[]>("Version").CurrentValue;
                },
                (c, ex) =>
                {
                    replacedert.IsType<DbUpdateConcurrencyException>(ex);

                    var firstDriverEntry = c.Entry(c.Drivers.Local.Single(d => d.CarNumber == 1));
                    replacedert.Equal(firstVersion, firstDriverEntry.Property<byte[]>("Version").CurrentValue);
                    var databaseValues = firstDriverEntry.GetDatabaseValues();
                    replacedert.NotEqual(firstVersion, databaseValues["Version"]);
                    firstDriverEntry.OriginalValues.SetValues(databaseValues);

                    var secondDriverEntry = ex.Entries.Single();
                    replacedert.Equal(secondVersion, secondDriverEntry.Property("Version").CurrentValue);
                    secondDriverEntry.OriginalValues.SetValues(secondDriverEntry.GetDatabaseValues());
                    ResolveConcurrencyTokens(secondDriverEntry);
                },
                c => replacedert.Equal(ClientPodiums, c.Drivers.Single(d => d.CarNumber == 2).Podiums));
        }

[Fact]
        public async Task Get_catalog_items_success()
        {
            //Arrange
            var fakeBrandFilterApplied = 1;
            var fakeTypesFilterApplied = 2;
            var fakePage = 2;
            var fakeCatalog = GetFakeCatalog();

            var expectedNumberOfPages = 5;
            var expectedTotalPages = 50;
            var expectedCurrentPage = 2;

            _catalogServiceMock.Setup(x => x.GetCatalogItems
            (
                It.Is<int>(y => y == fakePage),
                It.IsAny<int>(),
                It.Is<int?>(y => y == fakeBrandFilterApplied),
                It.Is<int?>(y => y == fakeTypesFilterApplied)
             ))
             .Returns(Task.FromResult(fakeCatalog));

            //Act
            var orderController = new CatalogController(_catalogServiceMock.Object);
            var actionResult = await orderController.Index(fakeBrandFilterApplied, fakeTypesFilterApplied, fakePage);

            //replacedert
            var viewResult = replacedert.IsType<ViewResult>(actionResult);
            var model = replacedert.IsreplacedignableFrom<IndexViewModel>(viewResult.ViewData.Model);
            replacedert.Equal(model.PaginationInfo.TotalPages, expectedNumberOfPages);
            replacedert.Equal(model.PaginationInfo.TotalItems, expectedTotalPages);
            replacedert.Equal(model.PaginationInfo.ActualPage, expectedCurrentPage);
            replacedert.Empty(model.PaginationInfo.Next);
            replacedert.Empty(model.PaginationInfo.Previous);
        }

[Fact]
        public void Signin_with_token_success()
        {
            //Arrange
            var fakeCP = GenerateFakeClaimsIdenreplacedy();

            _httpContextMock.Setup(x => x.User)
                .Returns(new ClaimsPrincipal(fakeCP));
                       
            //Act
            var accountController = new AccountController(_idenreplacedyParserMock.Object);
            accountController.ControllerContext.HttpContext = _httpContextMock.Object;
            var actionResult = accountController.SignIn("");

            //replacedert
            var redirectResult = replacedert.IsType<RedirectToActionResult>(actionResult);
            replacedert.Equal(redirectResult.ActionName, "Index");
            replacedert.Equal(redirectResult.ControllerName, "Catalog");
            replacedert.Equal(accountController.ViewData["access_token"], "fakeToken");
        }

[Fact]
        public async Task Post_cart_success()
        {
            //Arrange
            var fakeBuyerId = "1";
            var action = string.Empty;
            var fakeBasket = GetFakeBasket(fakeBuyerId);
            var fakeQuanreplacedies = new Dictionary<string, int>()
            {
                ["fakeProdA"] = 1,
                ["fakeProdB"] = 2
            };

            _basketServiceMock.Setup(x => x.SetQuanreplacedies(It.IsAny<ApplicationUser>(), It.IsAny<Dictionary<string, int>>()))
                .Returns(Task.FromResult(fakeBasket));

            _basketServiceMock.Setup(x => x.UpdateBasket(It.IsAny<BasketModel>()))
                .Returns(Task.FromResult(fakeBasket));

            //Act
            var orderController = new CartController(_basketServiceMock.Object, _catalogServiceMock.Object, _idenreplacedyParserMock.Object);
            orderController.ControllerContext.HttpContext = _contextMock.Object;
            var actionResult = await orderController.Index(fakeQuanreplacedies, action);

            //replacedert
            var viewResult = replacedert.IsType<ViewResult>(actionResult);
            var model = replacedert.IsreplacedignableFrom<BasketModel>(viewResult.ViewData.Model);
        }

[Fact]
        public async Task Add_to_cart_success()
        {
            //Arrange
            var fakeCatalogItem = GetFakeCatalogItem();

            _basketServiceMock.Setup(x => x.AddItemToBasket(It.IsAny<ApplicationUser>(), It.IsAny<Baskereplacedem>()))
                .Returns(Task.FromResult(1));

            //Act
            var orderController = new CartController(_basketServiceMock.Object, _catalogServiceMock.Object, _idenreplacedyParserMock.Object);
            orderController.ControllerContext.HttpContext = _contextMock.Object;
            var actionResult = await orderController.AddToCart(fakeCatalogItem);

            //replacedert
            var redirectToActionResult = replacedert.IsType<RedirectToActionResult>(actionResult);
            replacedert.Equal("Catalog", redirectToActionResult.ControllerName);
            replacedert.Equal("Index", redirectToActionResult.ActionName);
        }

[Fact]
        public async Task Get_order_list_success()
        {
            //Arrange
            var expectedTotalResults = 1;
            var fakeOrder = GetFakeOrder();

            _orderServiceMock.Setup(x => x.GetMyOrders(It.IsAny<ApplicationUser>()))
                .Returns(Task.FromResult(new List<Order>() { fakeOrder }));

            //Act
            var orderController = new OrderController(_orderServiceMock.Object, _basketServiceMock.Object, _idenreplacedyParserMock.Object);
            orderController.ControllerContext.HttpContext = _contextMock.Object;
            var actionResult = await orderController.Index(fakeOrder);

            //replacedert
            var viewResult = replacedert.IsType<ViewResult>(actionResult);
            var model = replacedert.IsreplacedignableFrom<List<Order>>(viewResult.ViewData.Model);
            replacedert.Equal(model.Count, expectedTotalResults);
        }

[Fact]
        public async Task Get_order_detail_success()
        {
            //Arrange
            var fakeOrderId = "12";
            var fakeOrder = GetFakeOrder();

            _orderServiceMock.Setup(x => x.GetOrder(It.IsAny<ApplicationUser>(), It.IsAny<string>()))
                .Returns(Task.FromResult(fakeOrder));

            //Act
            var orderController = new OrderController(_orderServiceMock.Object, _basketServiceMock.Object, _idenreplacedyParserMock.Object);
            orderController.ControllerContext.HttpContext = _contextMock.Object;
            var actionResult = await orderController.Detail(fakeOrderId);

            //replacedert
            var viewResult = replacedert.IsType<ViewResult>(actionResult);
            replacedert.IsreplacedignableFrom<Order>(viewResult.ViewData.Model);
        }

[Fact]
        public async Task Post_create_order_success()
        {
            //Arrange
            var fakeOrder = GetFakeOrder();

            _basketServiceMock.Setup(x => x.CleanBasket(It.IsAny<ApplicationUser>()))
                .Returns(Task.FromResult(1));

            _orderServiceMock.Setup(x => x.CreateOrder(It.IsAny<Order>()))
                .Returns(Task.FromResult(1));

            //Act
            var orderController = new OrderController(_orderServiceMock.Object, _basketServiceMock.Object, _idenreplacedyParserMock.Object);
            orderController.ControllerContext.HttpContext = _contextMock.Object;
            var actionResult = await orderController.Create(fakeOrder, "fakeAction");

            //replacedert
            var redirectToActionResult = replacedert.IsType<RedirectToActionResult>(actionResult);
            replacedert.Null(redirectToActionResult.ControllerName);
            replacedert.Equal("Index", redirectToActionResult.ActionName);
        }

[Fact]
        public async Task Post_create_order_fail()
        {
            //Arrange
            var fakeOrder = GetFakeOrder();

            _basketServiceMock.Setup(x => x.CleanBasket(It.IsAny<ApplicationUser>()))
                .Returns(Task.FromResult(1));

            _orderServiceMock.Setup(x => x.CreateOrder(It.IsAny<Order>()))
                .Returns(Task.FromResult(1));

            //Act
            var orderController = new OrderController(_orderServiceMock.Object, _basketServiceMock.Object, _idenreplacedyParserMock.Object);
            orderController.ControllerContext.HttpContext = _contextMock.Object;
            orderController.ModelState.AddModelError("fakeError", "fakeError");
            var actionResult = await orderController.Create(fakeOrder, "action");

            //replacedert
            var viewResult = replacedert.IsType<ViewResult>(actionResult);
            replacedert.IsreplacedignableFrom<Order>(viewResult.ViewData.Model);
        }

[Fact]
        public async Task Post_cart_checkout_success()
        {
            //Arrange
            var fakeBuyerId = "1";
            var action = "[ Checkout ]";
            var fakeBasket = GetFakeBasket(fakeBuyerId);
            var fakeQuanreplacedies = new Dictionary<string, int>()
            {
                ["fakeProdA"] = 1,
                ["fakeProdB"] = 2
            };

            _basketServiceMock.Setup(x => x.SetQuanreplacedies(It.IsAny<ApplicationUser>(), It.IsAny<Dictionary<string, int>>()))
                .Returns(Task.FromResult(fakeBasket));

            _basketServiceMock.Setup(x => x.UpdateBasket(It.IsAny<BasketModel>()))
                .Returns(Task.FromResult(fakeBasket));

            //Act
            var orderController = new CartController(_basketServiceMock.Object, _catalogServiceMock.Object, _idenreplacedyParserMock.Object);
            orderController.ControllerContext.HttpContext = _contextMock.Object;
            var actionResult = await orderController.Index(fakeQuanreplacedies, action);

            //replacedert
            var redirectToActionResult = replacedert.IsType<RedirectToActionResult>(actionResult);
            replacedert.Equal("Order", redirectToActionResult.ControllerName);
            replacedert.Equal("Create", redirectToActionResult.ActionName);
        }

[Fact]
        public async Task Get_create_order_success()
        {
            //Arrange
            var fakeBuyerId = "1";
            var fakeBasket = GetFakeBasket(fakeBuyerId);
            var fakeOrder = GetFakeOrder();

            _basketServiceMock.Setup(x => x.GetBasket(It.IsAny<ApplicationUser>()))
                .Returns(Task.FromResult(fakeBasket));

            _basketServiceMock.Setup(x => x.MapBasketToOrder(It.IsAny<BasketModel>()))
                .Returns(fakeOrder);

            _orderServiceMock.Setup(x => x.MapUserInfoIntoOrder(It.IsAny<ApplicationUser>(), It.IsAny<Order>()))
                .Returns(fakeOrder);

            //Act
            var orderController = new OrderController(_orderServiceMock.Object, _basketServiceMock.Object, _idenreplacedyParserMock.Object);
            orderController.ControllerContext.HttpContext = _contextMock.Object;
            var actionResult = await orderController.Create();

            //replacedert
            var viewResult = replacedert.IsType<ViewResult>(actionResult);
            replacedert.IsreplacedignableFrom<Order>(viewResult.ViewData.Model);
        }

[Fact]
        public void GetProducts_ShouldReturnResultModel()
        {
            //act
            var result = this.service.GetProducts(this.fixture.Create<ProductSearchOptions>());

            //replacedert
            replacedert.IsType<Result<ProductSearchResults>>(result);
        }

[Fact]
        public void ResolveContents_ErrorableContentsResolver_ExceptionNotThrowed()
        {
            using (var db = new Db
            {
                new DbItem("RenderedItem")
            })
            {
                var renderedItem = db.Gereplacedem("/sitecore/content/RenderedItem");
                var configurationResolver = Subsreplacedute.For<IConfigurationResolver>();

                var args = new GetLayoutServiceContextArgs
                {
                    RenderedItem = renderedItem,
                    RenderingConfiguration = new DefaultRenderingConfiguration(),
                    ContextData =
                    {
                        { "_sign", 1 }
                    }
                };

                IGetLayoutServiceContextProcessor contextProcessor =
                    new ErrorableGetLayoutServiceContextProcessor(configurationResolver);

                contextProcessor.Process(args);

                var resultObject = args.ContextData["_sign"];
                var value = replacedert.IsType<int>(resultObject);
                replacedert.Equal(1, value);
            }
        }

[Fact]
        private void Can_unflatten_a_flattened_dictionary()
        {
            replacedert.IsType<JObject>(fixture.FlattendSimpleJson.Unflatten());
            replacedert.IsType<JObject>(fixture.FlattenedComplexJson.Unflatten());
            replacedert.IsType<JObject>(fixture.FlattendSimpleJsonWithoutEmpty.Unflatten());
            replacedert.IsType<JObject>(fixture.FlattenedComplexJsonWithoutEmpty.Unflatten());
        }

[Fact]
      public void CanParseArrayAnchorAddedFromViewPort() {
         ViewPort.Edit("^bob[name\"\"14]12 ");

         replacedert.IsType<ArrayRun>(Model.GetNextRun(0));
      }

[Fact]
      public void ArraysWithInnerAnchorsRenderAnchors() {
         var (model, viewport) = (Model, ViewPort);
         var changeToken = new ModelDelta();

         // arrange: setup data with a bunch of pointers pointing into an array of strings
         model.WritePointer(changeToken, 0x00, 0x80);
         model.ObserveRunWritten(changeToken, new PointerRun(0x00));
         model.WritePointer(changeToken, 0x08, 0x84);
         model.ObserveRunWritten(changeToken, new PointerRun(0x08));
         model.WritePointer(changeToken, 0x10, 0x88);
         model.ObserveRunWritten(changeToken, new PointerRun(0x10));
         model.WritePointer(changeToken, 0x18, 0x8C);
         model.ObserveRunWritten(changeToken, new PointerRun(0x18));

         // arrange: setup the array of strings
         WriteStrings(model.RawData, 0x80, "cat", "bat", "hat", "sat");
         var existingAnchor = model.GetNextAnchor(0x80);
         ArrayRun.TryParse(model, "^[name\"\"4]4", 0x80, existingAnchor.PointerSources, out var arrayRun);
         model.ObserveAnchorWritten(changeToken, "sample", arrayRun);

         // arrange: create the viewmodel
         viewport.Refresh();

         // replacedert: viewmodel renders anchors within the array
         // note that the strings are only 4 bytes long
         replacedert.IsType<Anchor>(viewport[0, 8].Format);
         replacedert.IsType<Anchor>(viewport[4, 8].Format);
         replacedert.IsType<Anchor>(viewport[8, 8].Format);
         replacedert.IsType<Anchor>(viewport[12, 8].Format);
         replacedert.IsNotType<Anchor>(viewport[0, 9].Format);

         // replacedert: viewmodel renders pointers with names into the array
         replacedert.Equal("sample", ((Pointer)viewport[0, 0].Format).DestinationName);
         replacedert.Equal("sample/1", ((Pointer)viewport[8, 0].Format).DestinationName);
         replacedert.Equal("sample/2", ((Pointer)viewport[0, 1].Format).DestinationName);
         replacedert.Equal("sample/3", ((Pointer)viewport[8, 1].Format).DestinationName);
      }

[Fact]
      public void CanAddTextFormatToAnchorUsedOnlyByAnArrayAtStart() {
         var changeToken = new ModelDelta();
         var (model, viewPort) = (Model, ViewPort);
         WriteStrings(model.RawData, 0x10, "This is a song!");
         ArrayRun.TryParse(model, "^[content<>]1", 0x00, null, out var array);
         model.WritePointer(changeToken, 0x00, 0x10);
         model.ObserveAnchorWritten(changeToken, "array", array);

         // there is a pointer at 0x00 that points to 0x10
         // but we know about it via an array
         // at 0x10 is text
         // but we don't know that it's text
         ViewPort.Refresh();
         viewPort.SelectionStart = new Point(0, 1);
         viewPort.Edit("^\"\" ");

         // adding the format should've stuck
         replacedert.Empty(Errors);
         replacedert.IsType<PCS>(viewPort[1, 1].Format);
      }

[Fact]
      public void CanAddTextFormatToAnchorUsedOnlyByAnArray() {
         var changeToken = new ModelDelta();
         var (model, viewPort) = (Model, ViewPort);
         WriteStrings(model.RawData, 0x10, "This is a song!");
         ArrayRun.TryParse(model, "^[content<>]4", 0x00, null, out var array);
         model.WritePointer(changeToken, 0x04, 0x10);
         model.ObserveAnchorWritten(changeToken, "array", array);

         // there is a pointer at 0x00 that points to 0x10
         // but we know about it via an array
         // at 0x10 is text
         // but we don't know that it's text
         ViewPort.Refresh();
         viewPort.SelectionStart = new Point(0, 1);
         viewPort.Edit("^\"\" ");

         // adding the format should've stuck
         replacedert.Empty(Errors);
         replacedert.IsType<PCS>(viewPort[1, 1].Format);
      }