/// <summary>
 /// 
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="receiver"></param>
 /// <param name="timeOut"></param>
 /// <param name="requestMessage"></param>
 public ExecutionEntity(IExecutor executor, ArbiterClientId receiverID, TimeSpan timeOut, Message message)
     : base(timeOut)
 {
     _executor = executor;
     _receiverID = receiverID;
     _message = message;
 }

 internal Backgrounding(CuratorFrameworkImpl client, 
                         IBackgroundCallback callback, 
                         Object context, 
                         IExecutor executor)
     : this(wrapCallback(client, callback, executor), context)
 {
 }

 public Toolchain(string name, IGenerator generator, IBuilder builder, IExecutor executor)
 {
     Name = name;
     Generator = generator;
     Builder = builder;
     Executor = executor;
 }

 public ArtifactPublisherExecutorDecorator(string artifactsPath, string reportName, IExecutor inner, IServiceMessages serviceMessages)
 {
     this.artifactsPath = artifactsPath;
     this.reportName = reportName;
     this.inner = inner;
     this.serviceMessages = serviceMessages;
 }

 //TODO:  add Queue
 /// <summary>
 /// Helper to create and start an IFiber by type
 /// </summary>
 /// <param name="type"></param>
 /// <param name="executor"></param>
 /// <returns></returns>
 public static IFiber StartNew(FiberType type, IExecutor executor = null)
 {
     if (executor == null) executor = new Executor();
     IFiber fiber = GetFromTyoe(type, executor);
     fiber.Start();
     return fiber;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="CommandCallControlFlow"/> class.
 /// </summary>
 public CommandCallControlFlow(Command command, IExecutor executor)
 {
     Assume.NotNull(command, nameof(command));
     Assume.NotNull(executor, nameof(executor));
     Command = command;
     Executor = executor;
 }

 /// <summary>
 /// create a new <see cref="ErrorHandlingTaskExecutor"/> with <paramref name="taskExecutor"/> and
 /// <paramref name="errorHandler"/>
 /// </summary>
 /// <param name="taskExecutor">the task executor</param>
 /// <param name="errorHandler">the error handler in case of an exception</param>
 public ErrorHandlingTaskExecutor(IExecutor taskExecutor, IErrorHandler errorHandler)
 {
     AssertUtils.ArgumentNotNull(taskExecutor, "taskExecutor must not be null");
     AssertUtils.ArgumentNotNull(errorHandler, "errorHandler must not be null");
     _taskExecutor = taskExecutor;
     _errorHandler = errorHandler;
 }

 public ToDoListPresenter(IToDoListView view, ITaskList taskList, IExecutor executor)
 {
     this.view = view;
     this.executor = executor;
     this.taskList = taskList;
     WireUpEvents();
 }

 public void SetUp()
 {
     executor = Stub<IExecutor>();
     runData = new RunData();
     ender = Stub<IThreadEnder>();
     target = new ExecutorThreadImpl(executor, runData);
 }

        protected ExecutionResult CompileExecuteAndCheck(ExecutionContext executionContext, Func<CompilerType, string> getCompilerPathFunc, IExecutor executor)
        {
            var result = new ExecutionResult();

            // Compile the file
            var compilerPath = getCompilerPathFunc(executionContext.CompilerType);
            var compilerResult = this.Compile(executionContext.CompilerType, compilerPath, executionContext.AdditionalCompilerArguments, executionContext.Code);
            result.IsCompiledSuccessfully = compilerResult.IsCompiledSuccessfully;
            result.CompilerComment = compilerResult.CompilerComment;
            if (!compilerResult.IsCompiledSuccessfully)
            {
                return result;
            }

            var outputFile = compilerResult.OutputFile;

            // Execute and check each test
            IChecker checker = Checker.CreateChecker(executionContext.CheckerAssemblyName, executionContext.CheckerTypeName, executionContext.CheckerParameter);
            foreach (var test in executionContext.Tests)
            {
                var processExecutionResult = executor.Execute(outputFile, test.Input, executionContext.TimeLimit, executionContext.MemoryLimit);
                var testResult = this.ExecuteAndCheckTest(test, processExecutionResult, checker, processExecutionResult.ReceivedOutput);
                result.TestResults.Add(testResult);
            }

            // Clean our mess
            File.Delete(outputFile);

            return result;
        }

        public void LoadConnectionStringInto(string xpathExpression, IExecutor executor)
        {
            var r = Extract(xpathExpression);

            if (r.IntegratedSecurity)
            {
                executor.Username = string.Empty;
                executor.Password = string.Empty;
            }

            if (!string.IsNullOrEmpty(r.DataSource))
            {
                executor.Host = r.DataSource;
            }

            if (!string.IsNullOrEmpty(r.UserID))
            {
                executor.Username = r.UserID;
            }

            if (!string.IsNullOrEmpty(r.Password))
            {
                executor.Password = r.Password;
            }

            if (!string.IsNullOrEmpty(r.InitialCatalog))
            {
                executor.Database = r.InitialCatalog;
            }
        }

 /// <summary>
 /// Создать экземпляр планировщика
 /// </summary>
 /// <param name="sett">Настройки</param>
 /// <param name="action">Действие</param>
 /// <param name="Executor">Менеджер исполнения</param>
 protected MySchedular(SchedularSettings sett, Action action, IExecutor Executor = null)
 {
     this.sett = sett;
     executor = Executor ?? new Executor();
     this.action = action;
     if (sett.Interval != default(TimeSpan))
         new Thread(DoWork) { IsBackground = true }.Start();
 }

        public MesosExecutorDriver(IExecutor executor)
        {
            if (executor == null) throw new ArgumentNullException(nameof(executor));

            Executor = executor;
            Id = DriverRegistry.Register(this);
            _bridge = new ExecutorDriverBridge();
            _bridge.Initialize (Id);
        }

        public LuaParser(IExecutor executor, string file)
        {
            this.file_name = Path.GetFileName (file);
            this.input = File.OpenText (file);
            this.row = 1;
            this.col = 1;

            this.CurrentExecutor = executor;
        }

        public void Execute_ShouldCreateExecutableContextForExecutables(IExecutor<IExtension> testee)
        {
            this.SetupSyntaxReturnsExecutables();

            testee.Execute(this.syntax.Object, this.extensions, this.executionContext.Object);

            this.executionContext.Verify(e => e.CreateExecutableContext(this.firstExecutable.Object));
            this.executionContext.Verify(e => e.CreateExecutableContext(this.secondExecutable.Object));
        }

        public void Execute_ShouldExecuteSyntaxWithExtensions(IExecutor<IExtension> testee)
        {
            this.SetupSyntaxReturnsExecutables();

            testee.Execute(this.syntax.Object, this.extensions, this.executionContext.Object);

            this.firstExecutable.Verify(e => e.Execute(this.extensions, It.IsAny<IExecutableContext>()));
            this.secondExecutable.Verify(e => e.Execute(this.extensions, It.IsAny<IExecutableContext>()));
        }

 public SocketClient(IExecutor executor)
 {
     this.connectedTcs = new TaskCompletionSource<int>();
     this.executor = executor;
     this.socket = new Socket(AddressFamily.InterNetwork,
                              SocketType.Stream,
                              ProtocolType.Tcp);
     this.wasConnected = false;
 }

 public DedicatedThreadPoolFiber(IExecutor executor, int numThreads)
 {
     Executor = executor ?? new BasicExecutor();
     numThreads.NotNegative();
     numThreads.NotLessThan(1);
     _numThreads = numThreads;
     _threadPool = new DedicatedThreadPool(new DedicatedThreadPoolSettings(numThreads));
     Running = true;
 }

		public ExecutionContext(IExecutor executor, object parameter = null, IDictionary<string, object> extendedProperties = null)
		{
			if(executor == null)
				throw new ArgumentNullException("executor");

			_executor = executor;
			_parameter = parameter;

			if(extendedProperties != null && extendedProperties.Count > 0)
				_extendedProperties = new Dictionary<string, object>(extendedProperties);
		}

        /// <summary>
        /// Create new socket client using given executor and already connected socket.
        /// This method will fail, if socket is not already connected.
        /// </summary>
        public SocketClient(IExecutor executor, Socket socket)
        {
            InitialiseCommon(executor);

            this.socket = socket;
            this.wasConnected = true;

            EnsureSocketIsConnected();

            InitialiseConnectedSocket();
        }