Hello Stephan,

VirtualTerminal runs in selfprocessing mode. It means that until you call the Process method or the Expect method no data are received. Therefore wrong timing hypothesis should not be the cause.

The Expect method only checks the end of the response (not the whole response content). Please see the method documentation:

Processes any available incoming data until a response is received that ends with the specified string (and no more data is available to be read), or until the specified maximum wait time period elapses.

So I have a suspicion that the server sends "login: " (please note the last space) while you are expecting "login:" (without the last space). From the definition of the Expect method it should return false in this case.

Please update your code to include the last space:

Telnet client = new Telnet("myserver");
VirtualTerminal terminal = new VirtualTerminal(120, 50);
terminal.Bind(client);
if (terminal.Expect("login: ", 1000))
{
    terminal.SendToServer("mylogin\r");
    if (terminal.Expect("Password: ", 1000))
    {
        terminal.SendToServer("mypass\r");
        if (terminal.Expect(">: ", 1000)) 
            Console.WriteLine("logged in");
    }
}

If this is not the cause, please let us know here.

Sorry for the delayd answer, I missed your post.

This is a dark side of the programming automatic shell scripts.

Please note that if the expected response is split into two lines, your findOnScreen method will not work. Here is a simple code that solves this (although it is not an optimal solution):

 return string.Join("", content).Contains(value);

In my opinion, you should “almost always” know how the response exactly ends. In case there are more possible endings we can add the Expect(string[] responses, int maximumWaitTime) method.

In case you really don’t know the ending of the response you have to keep in mind these scenarios:

• expected response is scrolled out of the screen because a lot of text was received (you should avoid using the GetRegionText method)
• expected response occurred as a part of a response which was not actually expected (waiting for "the" (like "… the file?" or "… the directory?") but received "… theater …", for example)
• you are waiting for the response which is identical to a text that is already on the screen as a result of a previous command (you should avoid using the GetRegionText method)

Therefore you should always try to receive the whole server response to be able to determine where the response of the next command starts.

Here is some code snipped of a more robust WaitForString method (at least from my point of view):

    VirtualTerminal _terminal;
    StringBuilder _dataHolder;

    /// <summary>
    /// Receives the data from the server and searches for the occurance of the specified searchString.
    /// </summary>
    private bool WaitForString(string searchString, int maximumWaitingTime)
    {
        if (string.IsNullOrEmpty(searchString))
            return false;

        // initialize holder of the response data
        if (_dataHolder == null)
            _dataHolder = new StringBuilder();
        else
            _dataHolder.Length = 0;

        // register DataReceivedEventHandler to grab the response data
        DataReceivedEventHandler handler = new DataReceivedEventHandler(WaitForString_DataReceived);
        _terminal.DataReceived += handler;

        bool contains = false;
        int searchFrom = 0; // starting index (for time optimal search in multiblock responses)
        int start = Environment.TickCount; // start time
        do
        {
            // read all available data
            while (_terminal.Process() == TerminalState.DataReceived) ;

            // check whether response data contains searchString
            if (_dataHolder.ToString(searchFrom, _dataHolder.Length - searchFrom).Contains(searchString))
            {
                contains = true;
                break;
            }

            // adjust search start index to speed up searching in next step
            searchFrom = Math.Max(0, _dataHolder.Length - searchString.Length);
        }
        while (Environment.TickCount - start < maximumWaitingTime);

        // unregister handler to increase performance when we don't need to grab the data
        _terminal.DataReceived -= handler;
        return contains;
    }

    void WaitForString_DataReceived(object sender, DataReceivedEventArgs e)
    {
        _dataHolder.Append(e.StrippedData);
    }