public async Task StreamWriteAsyncTest()
        {
            byte[] buffer = GetRandomBuffer(1 * 1024 * 1024);
            MemoryStream stream1 = new MemoryStream(buffer);
            MemoryStream stream2 = new MemoryStream();

            OperationContext tempOperationContext = new OperationContext();
            RESTCommand<NullType> cmd = new RESTCommand<NullType>(TestBase.StorageCredentials, null);
            ExecutionState<NullType> tempExecutionState = new ExecutionState<NullType>(cmd, null, tempOperationContext);

            // Test basic write
            await stream1.WriteToAsync(stream2, null, null, false, tempExecutionState, null, CancellationToken.None);
            stream1.Position = 0;

            TestHelper.AssertStreamsAreEqual(stream1, stream2);

            stream2.Dispose();
            stream2 = new MemoryStream();

            await TestHelper.ExpectedExceptionAsync<ArgumentException>(
                async () => await stream1.WriteToAsync(stream2, 1024, 1024, false, tempExecutionState, null, CancellationToken.None),
                "Parameters copyLength and maxLength cannot be passed simultaneously.");

            stream1.Dispose();
            stream2.Dispose();
        }

        public virtual void Start()
        {
            if (_state != ExecutionState.Created)
            {
                var message = String.Format("Start() called on Fiber with state: {0}", _state);
                throw new ThreadStateException(message);
            }

            _state = ExecutionState.Running;
        }

        public void StreamWriteSyncTestCopyLengthBoundary()
        {
            byte[] buffer = GetRandomBuffer(1 * 1024 * 1024);
            MemoryStream stream1 = new MemoryStream(buffer);
            MemoryStream stream2 = new MemoryStream();
            MemoryStream stream3 = new MemoryStream();
            
            OperationContext tempOperationContext = new OperationContext();
            RESTCommand<NullType> cmd = new RESTCommand<NullType>(TestBase.StorageCredentials, null);
            ExecutionState<NullType> tempExecutionState = new ExecutionState<NullType>(cmd, null, tempOperationContext);
            
            // Test write with exact number of bytes
            stream1.WriteToSync(stream2, stream1.Length, null, true, false, tempExecutionState, null);
            stream1.Position = 0;
            stream1.WriteToSync(stream3, stream1.Length, null, true, true, tempExecutionState, null);
            stream1.Position = 0;

            TestHelper.AssertStreamsAreEqual(stream1, stream2);
            TestHelper.AssertStreamsAreEqual(stream1, stream3);

            stream2.Dispose();
            stream2 = new MemoryStream();
            stream3.Dispose();
            stream3 = new MemoryStream();

            // Test write with one less byte
            stream1.WriteToSync(stream2, stream1.Length - 1, null, true, false, tempExecutionState, null);
            stream1.Position = 0;
            stream1.WriteToSync(stream3, stream1.Length - 1, null, true, true, tempExecutionState, null);
            stream1.Position = 0;

            Assert.AreEqual(stream1.Length - 1, stream2.Length);
            Assert.AreEqual(stream1.Length - 1, stream3.Length);
            TestHelper.AssertStreamsAreEqualAtIndex(stream1, stream2, 0, 0, (int)stream1.Length - 1);
            TestHelper.AssertStreamsAreEqualAtIndex(stream1, stream3, 0, 0, (int)stream1.Length - 1);

            stream2.Dispose();
            stream2 = new MemoryStream();
            stream3.Dispose();
            stream3 = new MemoryStream();

            // Test with copyLength greater than length
            TestHelper.ExpectedException<ArgumentOutOfRangeException>(
                () => stream1.WriteToSync(stream2, stream1.Length + 1, null, true, false, tempExecutionState, null),
                "The given stream does not contain the requested number of bytes from its given position.");
            stream1.Position = 0;
            TestHelper.ExpectedException<ArgumentOutOfRangeException>(
                () => stream1.WriteToSync(stream3, stream1.Length + 1, null, true, true, tempExecutionState, null),
                "The given stream does not contain the requested number of bytes from its given position.");
            stream1.Position = 0;

            stream1.Dispose();
            stream2.Dispose();
            stream3.Dispose();
        }

        public void Start()
        {
            // Toggle tthese lines to enable/disable concurrent execution.
            if (taskExecutionState == ExecutionState.Started)
                return;

            taskExecutionState = ExecutionState.Started;
            foreach (var task in tasks)
            {
                task.Execute();
            }
        }

		protected virtual void OnExecutionStateChanged(ExecutionState newState){

			if (newState == state) {
				return;
			}

			var oldState = state;
			state = newState;

			var executionStateChanged = ExecutionStateChanged;

			if (executionStateChanged != null) {
				executionStateChanged (this, new ExecutionStateChangedEventArgs (state, oldState));
			}
		}

        public async Task WriteToMultiBufferMemoryStreamTestAsync()
        {
            OperationContext tempOperationContext = new OperationContext();
            RESTCommand<NullType> cmd = new RESTCommand<NullType>(TestBase.StorageCredentials, null);
            ExecutionState<NullType> tempExecutionState = new ExecutionState<NullType>(cmd, null, tempOperationContext);

            byte[] buffer = GetRandomBuffer(1 * 1024 * 1024);
            MemoryStream stream1 = new MemoryStream(buffer);

            MultiBufferMemoryStream stream2 = new MultiBufferMemoryStream(null /* bufferManager */);
            await stream1.WriteToAsync(stream2, null, null, false, tempExecutionState, null, CancellationToken.None);
            stream1.Seek(0, SeekOrigin.Begin);
            stream2.Seek(0, SeekOrigin.Begin);
            TestHelper.AssertStreamsAreEqual(stream1, stream2);

            MultiBufferMemoryStream stream3 = new MultiBufferMemoryStream(null /* bufferManager */);
            await TestHelper.ExpectedExceptionAsync<TimeoutException>(
                () => stream2.FastCopyToAsync(stream3, DateTime.Now.AddMinutes(-1)),
                "Past expiration time should immediately fail");
            stream2.Seek(0, SeekOrigin.Begin);
            stream3.Seek(0, SeekOrigin.Begin);
            await stream2.FastCopyToAsync(stream3, DateTime.Now.AddHours(1));
            stream2.Seek(0, SeekOrigin.Begin);
            stream3.Seek(0, SeekOrigin.Begin);
            TestHelper.AssertStreamsAreEqual(stream2, stream3);

            MultiBufferMemoryStream stream4 = new MultiBufferMemoryStream(null /* bufferManager */, 12345);
            await stream3.FastCopyToAsync(stream4, null);
            stream3.Seek(0, SeekOrigin.Begin);
            stream4.Seek(0, SeekOrigin.Begin);
            TestHelper.AssertStreamsAreEqual(stream3, stream4);

            MemoryStream stream5 = new MemoryStream();
            await stream4.WriteToAsync(stream5, null, null, false, tempExecutionState, null, CancellationToken.None);
            stream4.Seek(0, SeekOrigin.Begin);
            stream5.Seek(0, SeekOrigin.Begin);
            TestHelper.AssertStreamsAreEqual(stream4, stream5);

            TestHelper.AssertStreamsAreEqual(stream1, stream5);
        }

        /// <summary>
        /// Invokes the exposed method by name, if successful 
        /// will invoke all nodes connected via the anchor by the same
        /// name.
        /// </summary>
        /// <param name="methodName"></param>
        public void Fire(string methodName, params object[] args)
        {
            try
            {
                foreach(Expose exposed in GetExposed())
                {
                    if(exposed.exposedName == methodName)
                    {
                        FireExposed(exposed);
                    }
                }

            }
            catch(System.Exception exception)
            {
                this.editorExecutionState = ExecutionState.ERROR;

                Debug.LogException(exception);
            }
        }

        public void Execute()
        {
            try
            {
                this.OnExecute();
            }
            catch(System.Exception exception)
            {
                this.editorExecutionState = ExecutionState.ERROR;

                Debug.LogException(exception);
            }
        }

        public void EditorUpdate()
        {
            this.m_editorTimeDelta += Time.deltaTime;

            if(this.m_editorTimeDelta >= this.m_editorStateResetTime)
            {
                this.m_editorTimeDelta = 0;

                if(editorExecutionState != ExecutionState.ERROR)
                {
                    editorExecutionState = ExecutionState.IDLE;
                }
            }

            this.OnShowHideInHierarchy();
            this.OnEditorUpdate();

            foreach(Anchor anchor in anchors)
            {
                anchor.EditorUpdate();
            }
        }

 public void Stop()
 {
     if (_started != ExecutionState.Running) return; //??just ignore.  why explode?
     lock (_preQueue)
     {
         _started = ExecutionState.Created;
     }
 }

        private void OnRestart (object sender, RoutedEventArgs e)
        {
            this.RunButton.Click -= OnRestart;
            this.RunButton.Content = pausePanel;
            this.RunButton.Click += OnPause;
            execState = ExecutionState.Running;

            this.Dispatcher.Invoke(() =>
            {
                execState = ExecutionState.Running;
                String st;
                _logProcessor.GetFirstLine(out st);
            });
            
            _runTimer.Elapsed += OnTimer;
            _runTimer.Start();
            
           
        }

        public async Task StreamWriteAsyncTestMaxLengthBoundary()
        {
            byte[] buffer = GetRandomBuffer(1 * 1024 * 1024);
            MemoryStream stream1 = new MemoryStream(buffer);
            MemoryStream stream2 = new MemoryStream();

            OperationContext tempOperationContext = new OperationContext();
            RESTCommand<NullType> cmd = new RESTCommand<NullType>(TestBase.StorageCredentials, null);
            ExecutionState<NullType> tempExecutionState = new ExecutionState<NullType>(cmd, null, tempOperationContext);

            // Test write with exact number of bytes
            await stream1.WriteToAsync(stream2, null, stream1.Length, false, tempExecutionState, null, CancellationToken.None);
            stream1.Position = 0;

            TestHelper.AssertStreamsAreEqual(stream1, stream2);

            stream2.Dispose();
            stream2 = new MemoryStream();

            // Test write with one less byte
            await TestHelper.ExpectedExceptionAsync<InvalidOperationException>(
                async () => await stream1.WriteToAsync(stream2, null, stream1.Length - 1, false, tempExecutionState, null, CancellationToken.None),
                "Stream is longer than the allowed length.");
            stream1.Position = 0;

            stream2.Dispose();
            stream2 = new MemoryStream();

            // Test with count greater than length
            await stream1.WriteToAsync(stream2, null, stream1.Length + 1, false, tempExecutionState, null, CancellationToken.None);
            stream1.Position = 0;

            // Entire stream should have been copied
            TestHelper.AssertStreamsAreEqual(stream1, stream2);

            stream1.Dispose();
            stream2.Dispose();
        }

 private BenchmarkAlgorithm(BenchmarkAlgorithm original, Cloner cloner) {
   if (original.ExecutionState == ExecutionState.Started) throw new InvalidOperationException(string.Format("Clone not allowed in execution state \"{0}\".", ExecutionState));
   cloner.RegisterClonedObject(original, this);
   name = original.name;
   description = original.description;
   parameters = cloner.Clone(original.parameters);
   readOnlyParameters = null;
   executionState = original.executionState;
   executionTime = original.executionTime;
   storeAlgorithmInEachRun = original.storeAlgorithmInEachRun;
   runsCounter = original.runsCounter;
   Runs = cloner.Clone(original.runs);
   results = cloner.Clone(original.results);
 }

 public BatchRun(string name, string description)
   : base(name, description) {
   executionState = ExecutionState.Stopped;
   executionTime = TimeSpan.Zero;
   runsExecutionTime = TimeSpan.Zero;
   repetitions = 10;
   repetitionsCounter = 0;
   Runs = new RunCollection { OptimizerName = Name };
 }

 /// <summary>
 /// Allows an application to inform the system that it 
 /// is in use, thereby preventing the system from entering 
 /// the sleeping power state or turning off the display 
 /// while the application is running.
 /// </summary>
 /// <param name="flags">The thread's execution requirements.</param>
 /// <exception cref="Win32Exception">Thrown if the SetThreadExecutionState call fails.</exception>
 internal static void SetThreadExecutionState(ExecutionState flags)
 {
     ExecutionState? ret = PowerManagementNativeMethods.SetThreadExecutionState(flags);
     if (ret == null)
         throw new Win32Exception("SetThreadExecutionState call failed.");
 }

 private void UIElement_OnMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
 {
     var item = (sender as Grid);
     Agent tp = (Agent)item.DataContext;
     if (Keyboard.Modifiers.ToString().Contains("Control"))
     {
         if (tp.ID == _currentAgent)
         {
             this.Dispatcher.Invoke(() =>
             {
                 StatusLabel.Foreground = new SolidColorBrush(Colors.Red);
                 StatusLabel.Content = "This is actually the current agent.";
                 _statusTime = DateTime.Now;
             });
         }
         else if (_logProcessor.IsAgentLogAvailable(tp.ID))
         {
             _currentAgent = tp.ID;
             _logProcessor.CurrentAgent = _currentAgent;
             _previousState = execState;
             execState = ExecutionState.Switching;
         }
         else
         {
             this.Dispatcher.Invoke(() =>
             {
                 StatusLabel.Foreground = new SolidColorBrush(Colors.Red);
                 StatusLabel.Content = "Agent #" + tp.ID + " doesn't have the log file";
                 _statusTime = DateTime.Now;
             });
         }
     }
     else
     {
         tp.IsExpanded = !tp.IsExpanded;
     }
 }

        private void MainSlider_OnValueChangedSlider_ValueChanged(object sender,
            RoutedPropertyChangedEventArgs<double> e)
        {
            if (execState != ExecutionState.Stopped && (int)MainSlider.Value != _logProcessor.Index)
            {
                double d = MainSlider.Value;
                int tp = (int)d;
                if (tp < _logProcessor.GetAgentStartStep(_currentAgent))
                {
                    tp = _logProcessor.GetAgentStartStep(_currentAgent);
                    //MainSlider.Value = tp;
                }
                else if (tp > LogProcessor.GetAgentEndStep(_currentAgent))
                {
                    tp = LogProcessor.GetAgentEndStep(_currentAgent);
                    //MainSlider.Value = tp;
                }

                Task.Factory.StartNew(() =>
                {

                    lock (_lockerLogProcessorIndex)
                    {
                        if (_logProcessor.GetNumber < tp || tp < 0)
                        {
                            this.Dispatcher.Invoke(() =>
                            {
                                StatusLabel.Foreground = new SolidColorBrush(Colors.Red);
                                StatusLabel.Content = "Illegal step number!";
                                _statusTime = DateTime.Now;
                            });
                            return;
                        }
                        //ast = null;
                        isFirstLine = true;
                        _move_to = tp;
                        if (execState != ExecutionState.Moving)
                        {
                            _previousState = execState;
                            execState = ExecutionState.Moving;
                        }
                    }
                });
            }
        }

        private void OnStop(object sender, RoutedEventArgs e)
        {

            if (execState == ExecutionState.Running)
            {
                this.RunButton.Content = runIcon;
                this.RunButton.Click -= OnPause;
            }
            else if (execState == ExecutionState.Paused)
            {
                this.RunButton.Click -= OnRun;
            }
            this.RunButton.Click += OnRestart;

            if (execState == ExecutionState.Paused || execState == ExecutionState.Running)
            {
                if (execState == ExecutionState.Running)
                {_runTimer.Elapsed -= OnTimer;}

                execState = ExecutionState.Void;
                _runTimer.Stop();

                this.Dispatcher.Invoke(() =>
                {
                    String st;
                    _logProcessor.GetLastLine(out st);
                });
            }
        }

 public virtual void Dispose()
 {
     _state = ExecutionState.Stopped;
     _scheduler.Dispose();
     _subscriptions.Dispose();
 }

 /// <summary>
 /// Stop consuming actions.
 /// </summary>
 public void Stop()
 {
     _timer.Dispose();
     _started = ExecutionState.Stopped;
     _subscriptions.Dispose();
 }