// Create a process object which will allow us to run the process and control it
            this.process = new Process
            {
                StartInfo = new ProcessStartInfo
                {
                    FileName = exeFileName,
                    WindowStyle = ProcessWindowStyle.Normal,
                    RedirectStandardOutput = true, // So that we can redirect and interpret the console output
                    RedirectStandardInput = true,
                    RedirectStandardError = true,
                    UseShellExecute = false,
                    ErrorDialog = false,
                }
            };

            // Special event handlers to allow the system to gather the text output from the running exe so that we can check its contents
            this.process.OutputDataReceived += new DataReceivedEventHandler(ConsoleOutputReceived);
            this.process.ErrorDataReceived += new DataReceivedEventHandler(ErrorOutputReceived);

            // Initialize the value of the text string that will be updated by the event handlers
            this.OutputText = string.Empty;

            // Launch the process and start its output event handlers
            this.process.Start();
			
			// ***************************** NOTE: CANNOT PLACE THESE NEXT TWO LINES BEFORE PROCESS.START.
			// ***************************** Runtime won't let you. Gets a runtime error that the process
			// ***************************** isn't started yet.
			// ***************************** I wonder if this is the problem: the process starts too quickly
			// ***************************** and the first burst of output is lost and never caught by
			// ***************************** these event handlers on that system?
            this.process.BeginOutputReadLine();
            this.process.BeginErrorReadLine();

			
			// ********** Then there is a loop here which waits for certain strings to be received and writes to the standard input
			// ********** The problem occurs because, on one system, no text ever appears. Well actually one blank line appears.
			// ********** Which is interesting because a blank line is the last line of the output from the program before it waits
			// ********** for user input.
			

      	// *********************************************************************
        // Farther down, these are the separate functions to handle the outputs:
        // *********************************************************************
			
        private void ConsoleOutputReceived(object sender, DataReceivedEventArgs e)
        {
            Console.WriteLine("StdOut: " + e.Data.SafeToStringNeutral());    // So I can see what's happening
            this.OutputText += e.Data.SafeToStringNeutral();
        }

        private void ErrorOutputReceived(object sender, DataReceivedEventArgs e)
        {
            Console.WriteLine("StdErr: " + e.Data.SafeToStringNeutral());    // So I can see what's happening
            this.OutputText += e.Data.SafeToStringNeutral();
        }

            // Create a process object which will allow us to run the Process and control it for the duration of the test
            this.Process = new Process
            {
                StartInfo = new ProcessStartInfo
                {
                    FileName = ExeFile,
                    WindowStyle = ProcessWindowStyle.Normal,
                    RedirectStandardOutput = true, // So that we can redirect and interpret the console output
                    RedirectStandardInput = true,
                    RedirectStandardError = true,
                    UseShellExecute = false,
                    ErrorDialog = false,
                }
            };

            // Initialize the value of the text string that collects the 
            // console output which will be updated by the asynchronous tasks below
            this.OutputText = string.Empty;

            // Launch the process
            this.Process.Start();
            Console.WriteLine("Launched Process at: " + ExeFile);

            // Note: Cannot use this traditional method of asynchronous reads for this exe,
            // because it misses the first burst of output from the exe, causing test to fail:
            //     this.Process.OutputDataReceived += new DataReceivedEventHandler(ConsoleOutputReceived);
            // See this web page for details why:  http://alabaxblog.info/2013/06/redirectstandardoutput-beginoutputreadline-pattern-broken/

            // Can read from stderr text asynchronously though, since we are not waiting and depending upon its contents
            this.Process.ErrorDataReceived += new DataReceivedEventHandler(ErrorOutputReceived);
            this.Process.BeginErrorReadLine();
            Console.WriteLine("Console stderr output has been redirected.");

            // Create a cancelable, asynchronous task to read from the normal stdout stream using
            // the synchronous call, to work around the issue of missing the first burst of output
            // when using the traditional method of redirecting .OutputDataReceived
            var taskCanceler = new CancellationTokenSource();
            CancellationToken cancellationToken = taskCanceler.Token;
            Task outputReader = Task.Factory.StartNew
            (() =>
                {
                    // Keep track of the current line of output so that we can echo it to the console line-by-line
                    string currentLine = string.Empty;

                    // Infinitely loop while inside this special outputReader task
                    while (true)
                    {
                        // Drop out of the task if the task has been canceled
                        cancellationToken.ThrowIfCancellationRequested();

                        // Sleep a tiny amount while inside the loop, to prevent this task from churning the CPU
                        Thread.Sleep(1);

                        // Read from the stdout of the retdirected process output, in synchronous mode,
                        // to work around the issue where using the .OutputDataReceived feature misses
                        // the start of the output of fast-starting tasks; note that we cannot use
                        // "ReadToEnd()" or some such, because that would hang this thread, so we want
                        // to keep reading without stopping
                        int oneChar = this.Process.StandardOutput.Read();

                        // Process the character we read 
                        if (-1 != oneChar)
                        {
                            currentLine += string.Format("{0}", (char)oneChar);
                            this.OutputText += string.Format("{0}", (char)oneChar);
                            // If we get a linefeed, echo the buffered line to the console
                            if (10 == oneChar)
                            {
                                Console.Write("StdOut: " + currentLine);
                                currentLine = string.Empty;
                            }
                        }
                    }
                }
                , cancellationToken
            );
			
			
			// ************* Now down here you can do a nice leisurely loop where you look at the contents of 
			// this.OutputText and act upon it as needed.



            // Now we're done with the output reading thread, we can cancel it now
            taskCanceler.Cancel();