public void Assert_WithValidMatchPredicate_IsVerified()
 {
     var mockContext = new MockContext<IFoo>();
     var fooMock = new FooMock(mockContext);
     fooMock.Execute("SomeValue");
     mockContext.Assert(f => f.Execute(The<string>.Is(s => s.StartsWith("Some"))), Invoked.Once);
 }

        public void _BeforeTest()
        {
            MockContext = new MockContext();

            Settings =
            SettingKeys.DefaultValues.ToDictionary( kvp => kvp.Key, kvp => new Config { Id = kvp.Key, Value = kvp.Value } );

            MockContext.SettingsRepoMock.Setup( x => x.Set( It.IsAny<string>(), It.IsAny<string>() ) ).Callback<string, string>( ( key, value ) =>
            {
                Settings[key] = new Config { Id = key, Value = value };
            } );
            MockContext.SettingsRepoMock.Setup( x => x.GetById( It.IsAny<string>() ) ).Returns<string>( cfg => Settings[cfg] );

            MockContext.AppThemesMock.SetupGet( x => x.Accents ).Returns( new[]
            {
                new ColorItem {Name = "Red"},
                new ColorItem {Name = "Blue"},
                new ColorItem {Name = "Green"}
            } );
            MockContext.AppThemesMock.SetupGet( x => x.Themes ).Returns( new[]
            {
                new ColorItem {Name = "BaseDark"},
                new ColorItem {Name = "None"},
                new ColorItem {Name = "BaseLight"}
            } );
        }

 public void Assert_NeverWhenInvoked_ThrowsException()
 {
     var mockContext = new MockContext<IFoo>();
     var fooMock = new FooMock(mockContext);
     fooMock.Execute("SomeValue");
     mockContext.Assert(f => f.Execute("SomeValue"), Invoked.Never);
 }

        public void CurrentProjectIsFirstIfNotSetInSettings()
        {
            // Arrange
            var context = new MockContext();
            context.SettingsRepoMock.Setup( s => s.GetById( SettingKeys.LastProject ) ).Returns( new Config { Value = "-1" } );

            var projects = new[]
            {
                new Project {Name = "One", Id = 1},
                new Project {Name = "Two", Id = 2},
                new Project {Name = "Three", Id = 3}
            };

            context.ProjectRepoMock.Setup( p => p.GetAll() ).Returns( projects );

            // Act
            var vm = new ProjectListViewModel( context.ViewServiceRepo, context.SettingsRepo, context.ProjectRepo );

            // Assert
            Assert.IsNotNull( vm.CurrentProject );
            Assert.AreSame( projects[0], vm.CurrentProject.Model );

            context.SettingsRepoMock.VerifyAll();
            context.ProjectRepoMock.VerifyAll();
        }

 protected void InitializeContext()
 {
     var contextMappings = new EntityMappingStore();
     var rmp = new ReflectionMappingProvider();
     rmp.AddMappingsForAssembly(contextMappings, typeof(LinqToSparqlTests).Assembly);
     Context = new MockContext(contextMappings);
 }

        public void ResolverReturnsProperNamedObject()
        {
            string expected = "We want this one";
            string notExpected = "Not this one";

            var expectedKey = NamedTypeBuildKey.Make<string>("expected");
            var notExpectedKey = NamedTypeBuildKey.Make<string>();

            var mainContext = new MockContext();
            mainContext.NewBuildupCallback = (k) =>
            {
                if (k == expectedKey)
                {
                    return expected;
                }
                if (k == notExpectedKey)
                {
                    return notExpected;
                }
                return null;
            };

            var resolver = new OptionalDependencyResolverPolicy(typeof(string), "expected");

            object result = resolver.Resolve(mainContext);

            Assert.Same(expected, result);
        }

 public void Assert_Once_IsVerified()
 {
     var mockContext = new MockContext<IFoo>();
     var fooMock = new FooMock(mockContext);
     fooMock.Execute("SomeValue");
     mockContext.Assert(f => f.Execute("SomeValue"));
 }

        public void ListChangedEventIsAlwaysOnTheThreadThatCreatedTheList()
        {
            try
            {
                //convince the threadsafebindinglist we are using a synchronization context  
                //by providing a synchronization context
                var context = new MockContext();
                SynchronizationContext.SetSynchronizationContext(context);

                var list = new ThreadsafeBindingList<int>(context);

                //create a new thread adding something to the list
                //use an anonymous lambda expression delegate :)
                var addFiveThread = new Thread(() =>
                {
                    list.Add(5);
                });
                //action! run the thread adding 5
                addFiveThread.Start();
                //wait for the other thread to finish
                while (addFiveThread.IsAlive)
                    Thread.Sleep(10);

                //assert the list used the context.
                Assert.AreEqual(1, context.SendWasCalled, "The list did not use the send method the current context!");

            }
            finally
            {
                //always reset the synchronizationcontext
                SynchronizationContext.SetSynchronizationContext(null);
            }
            
        }

        public void Arrange_CallBackFourArguments_InvokesCallback()
        {
            var mockContext = new MockContext<IFoo>();
            var fooMock = new FooMock(mockContext);
            int firstResult = 0;
            int secondResult = 0;
            int thirdResult = 0;
            int fourthResult = 0;
            mockContext.Arrange(
                f => f.Execute(The<int>.IsAnyValue, The<int>.IsAnyValue, The<int>.IsAnyValue, The<int>.IsAnyValue))
                .Callback<int, int, int, int>(
                    (i1, i2, i3, i4) =>
                    {
                        firstResult = i1;
                        secondResult = i2;
                        thirdResult = i3;
                        fourthResult = i4;
                    });

            fooMock.Execute(1, 2, 3, 4);

            Assert.AreEqual(1, firstResult);
            Assert.AreEqual(2, secondResult);
            Assert.AreEqual(3, thirdResult);
            Assert.AreEqual(4, fourthResult);
        }

 public void Assert_InvokedOnceExpectedOnce_IsVerified()
 {
     var mockContext = new MockContext<IFoo>();
     var fooMock = new FooMock(mockContext);
     fooMock.Execute("SomeValue");
     mockContext.Assert(f => f.Execute("SomeValue"), Invoked.Once);
 }

		public void Setup()
		{
			context = new MockContext();
			var contextProvider = MockRepository.GenerateStub<IDataContextProvider>();
			contextProvider.Expect(x => x.DataContext).Return(context);
			filter = new UnitOfWorkFilter(contextProvider);
		}

 public void InitTestContext()
 {
     ruleT1 = new TestRuleT1();
     ruleDependent = new OtherRuleT1();
     transformation = new MockTransformation(ruleT1, ruleDependent);
     transformation.Initialize();
     context = new MockContext(transformation);
 }

 public void Assert_InvokedTwiceWithExpectedOnce_ThrowsException()
 {
     var mockContext = new MockContext<IFoo>();
     var fooMock = new FooMock(mockContext);
     fooMock.Execute("SomeValue");
     fooMock.Execute("SomeValue");
     mockContext.Assert(f => f.Execute("SomeValue"), Invoked.Once);
 }

 private MockContext<IServiceContainer> GetContainerMock(Func<ILifetime> lifetimeFactory, Func<Type, Type, bool> shouldRegister)
 {
     var mockContext = new MockContext<IServiceContainer>();
     var containerMock = new ContainerMock(mockContext);            
     var assemblyScanner = new AssemblyScanner(new ConcreteTypeExtractor(), new CompositionRootTypeExtractor(), new CompositionRootExecutor(containerMock));
     assemblyScanner.Scan(typeof(IFoo).Assembly, containerMock, lifetimeFactory, shouldRegister);
     return mockContext;
 }

        /// <summary>
        /// Create a Splunk <see cref="Service" /> and login using the settings
        /// provided in .splunkrc.
        /// </summary>
        /// <param name="ns">
        /// </param>
        /// <returns>
        /// The service created.
        /// </returns>
        public static async Task<Service> CreateService(Namespace ns = null)
        {
            var context = new MockContext(Splunk.Scheme, Splunk.Host, Splunk.Port);
            var service = new Service(context, ns);
            
            await service.LogOnAsync(Splunk.Username, Splunk.Password);

            return service;
        }

        public void Setup()
        {
            _sendEmailServiceMock = new MockContext<ISendEmailService> ();

            _stringResource = new StringResourceMock();
            _sendEmailService = new SendEmailServiceMock (_sendEmailServiceMock);

            _service = new EvaluationService (_stringResource, _sendEmailService);
        }

 public void Arrange_CallBackOneArgument_InvokesCallback()
 {
     var mockContext = new MockContext<IFoo>();
     var fooMock = new FooMock(mockContext);
     int callBackResult = 0;
     mockContext.Arrange(f => f.Execute(The<int>.IsAnyValue)).Callback<int>(s => callBackResult = s);
     fooMock.Execute(1);
     Assert.AreEqual(1, callBackResult);
 }

 public void Arrange_CallBackNoArguments_InvokesCallback()
 {
     var mockContext = new MockContext<IFoo>();
     var fooMock = new FooMock(mockContext);
     bool isCalled = false;
     mockContext.Arrange(f => f.Execute()).Callback(() => isCalled = true);
     fooMock.Execute();
     Assert.IsTrue(isCalled);
 }

 private void SetupManagementClients(MockContext context)
 {
     RedisManagementClient = GetRedisManagementClient(context);
     InsightsManagementClient = GetInsightsManagementClient();
     ResourceManagementClient = GetResourceManagementClient();
     helper.SetupManagementClients(ResourceManagementClient,
         InsightsManagementClient,
         RedisManagementClient
         );
 }

        public void Move_Line_RelativeVerticalLine()
        {
            StreamGeometry geometry = new StreamGeometry();
            MockContext context = new MockContext();
            PathMarkupParser target = new PathMarkupParser(geometry, context);

            target.Parse("M3,4 L5,6 v7");

            Assert.AreEqual("M3,4 L5,6 L5,13 ", context.Trace);
        }