private static void RegisterCommands(Container container)
        {
            var eventDelegator = new EventBus();
            var eventStore = new EventStore(eventDelegator);
            var aggregateFactory = new AggregateFactory();
            var commandProcessor = new CommandProcessor(aggregateFactory, eventStore);

            container.RegisterSingleton<IProcessCommands>(() => commandProcessor);
        }

        public void CancelCommandGroup_CancelAGroup_AllCommandsInGroupAreCancelled()
        {
            int[] commandsCanceled = {0};
            var fakeFilterManager = A.Fake<IFilterManager>();
            A.CallTo(() => fakeFilterManager.Process(A<CommandBase>.Ignored)).Returns(false);

            var processor = new CommandProcessor(null, fakeFilterManager);
            var commands = new[]
                           {
                               new TestCommand(CommandState.New, groupId: "GroupA"),
                               new TestCommand(CommandState.New, groupId: "GroupB"),
                               new TestCommand(CommandState.New, groupId: "GroupA"),
                               new TestCommand(CommandState.New, groupId: "GroupA"),
                               new TestCommand(CommandState.New, groupId: "GroupB"),
                               new TestCommand(CommandState.New, groupId: "GroupA"),
                               new TestCommand(CommandState.New, groupId: "GroupC"),

                           };
            foreach (var command in commands)
            {
                command.RegisterForStateChange(Observer.Create<CommandState>(b =>
                {
                    if (b == CommandState.Canceled)
                    {
                        commandsCanceled[0]++;
                    }
                }));

                processor.PublishCommand(command);
            }

            processor.CancelCommandGroup("GroupA");

            Assert.AreEqual(4, commandsCanceled[0]);
        }

 public start_the_application(IBackgroundThread thread, ILoadPresentationModulesCommand command,
                              CommandProcessor processor)
 {
     this.thread = thread;
     this.command = command;
     this.processor = processor;
 }

 private static void ExecuteQuery(CommandProcessor commandProcessor)
 {
     Console.WriteLine("Executing query");
     var query = new SayHelloQuery("Dan");
     commandProcessor.Execute(query).Wait();
     Console.WriteLine(query.Result);
 }

        public void SetUp()
        {
            repository = new Mock<Repository>();
              next = new Mock<Processor<Event>>();

              sut = new CommandProcessor(repository.Object, next.Object);
        }

        public static IRunner BuildRunner(Action<IConfigurationHelper> configurator)
        {
            var configPlan = new ConfigurationPlan();

            if (configurator != null)
            {
                configurator(configPlan);
            }

            configPlan.Validate();

            var routingInfo = GetRoutingInfo(configPlan);

            routingInfo.Validate();

            var router = new CommandRouter(routingInfo);

            var argsHelper = new ArgsHelper(configPlan.SwitchDelimiter);
            var argsHelpProvider = new ArgsParameterHelpProvider(argsHelper);
            var argsParameterBinder = new ArgsParameterBinder(argsHelper);

            var helpProvider = new HelpProvider(router, argsHelpProvider);
            var cmdProcessor = new CommandProcessor(router, configPlan.TypeInstantiationStrategy, argsParameterBinder);

            return new RunnerInternal(helpProvider, cmdProcessor);
        }

        public static void Main()
        {
            // we can create a singleton instance of the command processor. each execution can occur concurrently
            // and has it's own state.
            var processorSingleton = new CommandProcessor(DemoAPICommandProcessorConfiguration.Instance);

            // command with return value - 1 transaction per command
            int id = processorSingleton.Execute(new AddProductModel()
            {
                // ... properties ...
            });

            // command with no return value - 1 transaction per command
            processorSingleton.Execute(new SetProductModelName()
            {
                // ... properties ...
            });

            processorSingleton.Execute(new AddProductReview()
            {
                ProductId = 316,

                ReviewerName = "Joseph Daigle",
                EmailAddress = "[email protected]",
                Rating = 4,
                Comments = "Meh",
            });
        }

		public SesService(CommandProcessor processor)
		{
			if (processor == null)
			{
				throw new ArgumentNullException("processor");
			}
			_processor = processor;
		}

 public void SupportsQueryCommand()
 {
     HomeState state = new HomeState();
     state.CreateFurniture("sofa","room",new DateTime(2015,12,01));
     Mock<TextWriter> writerMock = new Mock<TextWriter>();
     CommandProcessor processor = new CommandProcessor(state, writerMock.Object);
     string command = "query -date 01.12.2015";
     processor.Process(command);
     writerMock.Verify(w=>w.WriteLine(It.IsAny<string>()));
 }

        static void TestProcessCommand()
        {
            SubscriptionClient subscriptionClient = SubscriptionClient.CreateFromConnectionString( serviceBusConnectionString, commandTopicPath, commandHandlerSubscription );
            SubscriptionReceiver receiver = new SubscriptionReceiver( subscriptionClient );
            ITextSerializer serializer = new JsonTextSerializer();

            CommandProcessor orderCommandProcessor = new CommandProcessor( receiver, serializer );
            orderCommandProcessor.Register( new OrderCommandHandler() );

            orderCommandProcessor.Start();
        }

        public void ExecuteWithNullCommandThrowsArgumentNullException()
        {
            var serviceProviderMock = new Mock<IServiceProvider>(MockBehavior.Strict);

            var sut = new CommandProcessor(serviceProviderMock.Object);

            TestCommand command = null;

            var ex = Assert.Throws<ArgumentNullException>(() => sut.Execute(command));

            Assert.Equal("command", ex.ParamName);
        }

 public static void Main()
 {
     // TODO: Add instance of the GameRenderingEngine and call that instance when creating the game engine
     var brightSkin = new BrightSkin();
     IOInterface userInterractor = new ConsoleInterface(brightSkin);
     Scoreboard scoreboard = Scoreboard.GetInstance;
     scoreboard.SetIOInterface(userInterractor);
     GameBoard gameBoard = GameBoard.GetInstance;
     CommandProcessor commandProcessor = new CommandProcessor(gameBoard, scoreboard, userInterractor, new CommandParser());
     GameEngine engine = new GameEngine(commandProcessor, userInterractor, gameBoard);
     engine.Play();
 }

        public static void SetUp()
        {
            container = new TinyInversionOfControlContainer(new TinyIoCContainer());

            commandProcessor = new CommandProcessor(container);
            container.Register<IAmAUnitOfWorkFactory, UnitOfWorkFactory>().AsSingleton();
            container.Register<IRepository<Meeting, MeetingDocument>, Repository<Meeting, MeetingDocument>>().AsMultiInstance();
            container.Register<IIssueTickets, TicketIssuer>().AsMultiInstance();
            container.Register<IScheduler, Scheduler>();
            container.Register<IAmAnOverbookingPolicy, FiftyPercentOverbookingPolicy>();
            container.Register<IIssueTickets, TicketIssuer>();
            container.Register<IHandleRequests<ScheduleMeetingCommand>, ScheduleMeetingCommandHandler>("ScheduleMeetingCommandHandler");
        }

		public void VerifyTest()
		{
			var cmd = new VerifyEmailAddressCommand
			          	{
			          		EmailAddress = Helper.GetSenderEmailAddress()
			          	};


			var cp = new CommandProcessor(_builder);

			var resp = cp.Process(cmd, _parser);


			Console.WriteLine(resp.Command + " : ID " +  resp.RequestID);
		}

        public void SupportsRemoveRoomCommand()
        {
            Mock<IHomeState> stateMock = new Mock<IHomeState>();
            CommandProcessor processor = new CommandProcessor(stateMock.Object, Console.Out);
            string command = "remove-room -date 12.01.2015 -room Bedroom -transfer dining";
            processor.Process(command);
            stateMock.Verify(a => a.RemoveRoom("Bedroom", "dining", new DateTime(2015, 01, 12)));

            command = "remove-room -room Bedroom -date 12.01.2015";
            processor.Process(command);
            stateMock.Verify(a => a.RemoveRoom("Bedroom","dining",new DateTime(2015, 01, 12)));

            command = "remove-room -room Bedroom -transfer dining";
            processor.Process(command);
            stateMock.Verify(a => a.RemoveRoom("Bedroom", "dining", It.IsAny<DateTime>()));
        }

        static void Main(string[] args)
        {
            Console.WriteLine("Waiting for command.");
            Console.WriteLine("Run crawler: run --host=http://www.example.com --deep=3 --path=D:\\Folder\\ --allOrigins");
            Console.WriteLine("Exit: exit");
            var commandProcessor = new CommandProcessor();

            while (commandProcessor.Run)
            {
                string command = Console.ReadLine();
                commandProcessor.ProcessCommand(command);
            }

            Console.WriteLine("End of execution.");
            Console.ReadKey();
        }

 public void Create(params string[] lines)
 {
     _view = Utils.EditorUtil.CreateView(lines);
     _view.Caret.MoveTo(new SnapshotPoint(_view.TextSnapshot, 0));
     _map = new RegisterMap();
     _host = new FakeVimHost();
     _editOpts = new Mock<IEditorOperations>(MockBehavior.Strict);
     _operations = new Mock<IOperations>(MockBehavior.Strict);
     _bufferData = MockObjectFactory.CreateVimBuffer(
         _view,
         "test",
         MockObjectFactory.CreateVim(_map, host: _host).Object,
         _editOpts.Object);
     _processorRaw = new Vim.Modes.Command.CommandProcessor(_bufferData.Object, _operations.Object);
     _processor = _processorRaw;
 }

        public void SupprotsCreateFurnitureCommand()
        {
            Mock<IHomeState> stateMock = new Mock<IHomeState>();
            CommandProcessor processor = new CommandProcessor(stateMock.Object, Console.Out);
            string command = "create-furniture -date 12.01.2015 -room Bedroom -type sofa";
            processor.Process(command);
            stateMock.Verify(a => a.CreateFurniture("sofa", "Bedroom", new DateTime(2015, 01, 12)));

            command = "create-furniture -room Bedroom -date 12.01.2015 -type sofa";
            processor.Process(command);
            stateMock.Verify(a => a.CreateFurniture("sofa", "Bedroom", new DateTime(2015, 01, 12)));

            command = "create-furniture -room Bedroom -type sofa";
            processor.Process(command);
            stateMock.Verify(a => a.CreateFurniture("sofa", "Bedroom", It.IsAny<DateTime>()));
        }

 public void Create(params string[] lines)
 {
     _view = Utils.EditorUtil.CreateView(lines);
     _view.Caret.MoveTo(new SnapshotPoint(_view.TextSnapshot, 0));
     _map = new RegisterMap();
     _editOpts = new Mock<IEditorOperations>(MockBehavior.Strict);
     _operations = new Mock<IOperations>(MockBehavior.Strict);
     _operations.SetupGet(x => x.EditorOperations).Returns(_editOpts.Object);
     _statusUtil = new Mock<IStatusUtil>();
     _fileSystem = new Mock<IFileSystem>(MockBehavior.Strict);
     _bufferData = MockObjectFactory.CreateVimBuffer(
         _view,
         "test",
         MockObjectFactory.CreateVim(_map).Object);
     _processorRaw = new Vim.Modes.Command.CommandProcessor(_bufferData.Object, _operations.Object, _statusUtil.Object, _fileSystem.Object);
     _processor = _processorRaw;
 }

 private static void Main(string[] args)
 {
     var maxConcurrentJobs = GetMaxConcurrentJobs();
     var allTaskList = new BlockingCollection<Job>();
     var socketServer = new SocketServer(IPAddress.Loopback, 6666);
     var jobQueue = new JobQueue();
     var scheduler = new Scheduler(jobQueue);
     using (var queueProcessor = new QueueProcessor(maxConcurrentJobs, jobQueue))
     {
         var commandProcessor = new CommandProcessor(allTaskList, scheduler, jobQueue, queueProcessor);
         using (var dispatcher = new CommandDispatcherService(socketServer, commandProcessor))
         using (var display = new DisplayService(allTaskList, jobQueue))
         {
             Console.ReadLine();
         }
     }
 }