Subversion Repositories openrisc_me

//####COPYRIGHTBEGIN####

//                                                                          

// ----------------------------------------------------------------------------

// Copyright (C) 1998, 1999, 2000 Red Hat, Inc.

//

// This program is part of the eCos host tools.

//

// This program is free software; you can redistribute it and/or modify it 

// under the terms of the GNU General Public License as published by the Free 

// Software Foundation; either version 2 of the License, or (at your option) 

// any later version.

// 

// This program is distributed in the hope that it will be useful, but WITHOUT 

// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 

// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for 

// more details.

// 

// You should have received a copy of the GNU General Public License along with

// this program; if not, write to the Free Software Foundation, Inc., 

// 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

//

// ----------------------------------------------------------------------------

//                                                                          

//####COPYRIGHTEND####

//=================================================================

//

//        eCosTest.h

//

//        run test header

//

//=================================================================

//=================================================================

//#####DESCRIPTIONBEGIN####

//

// Author(s):     sdf

// Contributors:  sdf

// Date:          1999-04-01

// Description:   Run one or more tests

// Usage:

//

//####DESCRIPTIONEND####

#ifndef _ECOSTEST_H

#define _ECOSTEST_H

//=================================================================

// This class represents a single eCos test [executable].

// It includes member functions to run the test and to manage related system resources.

//=================================================================

#include "Collections.h"

#include "eCosStd.h"

#include "eCosTestPlatform.h"

#include "eCosTestUtils.h"

#include "ResetAttributes.h"

class CSubprocess;

class CTestResource;

class CeCosSocket;

class CeCosTest{

public:

  static LPCTSTR pszFormat;

  ///////////////////////////////////////////////////////////////////////////

  // Representation of an elapsed time (units of milliseconds)

  enum {NOTIMEOUT=0x7fffffff}; // No timeout specified

  ///////////////////////////////////////////////////////////////////////////

  // ctors, dtors and their friends

  class ExecutionParameters;

  CeCosTest(const ExecutionParameters &e, LPCTSTR  const pszExecutable, LPCTSTR  const pszTitle=0);

  virtual ~CeCosTest();

  // Count of number of instances of this class:

  static int InstanceCount;

  // Delete all heap instances of this class (*must* be allocated on heap)

  static void DeleteAllInstances ();

  // Simply wait for instances to die a natural death

  static bool WaitForAllInstances (int nPoll=1000,Duration nTimeout=NOTIMEOUT);

  // Tap them on the shoulder (does not wait)

  static void CancelAllInstances ();

  ///////////////////////////////////////////////////////////////////////////

  ///////////////////////////////////////////////////////////////////////////

  // Class used to represent execution parameters (to be passed with request to execute a test)

  ///////////////////////////////////////////////////////////////////////////

  class ExecutionParameters {

  public:

    enum RequestType { RUN, QUERY, LOCK, UNLOCK, STOP, RequestTypeMax};

    static RequestType RequestTypeValue(LPCTSTR );

    static const String Image(RequestType r) { return (r>=0 && r<=RequestTypeMax)?String(arRequestImage[r]):String::SFormat(_T("Unknown(%d)"),r); }

    Duration    ActiveTimeout()   const { return m_nActiveTimeout; }

    Duration    DownloadTimeout() const { return m_nDownloadTimeout; }

    const CeCosTestPlatform *Platform() const { return CeCosTestPlatform::Get(m_Target); }

    LPCTSTR PlatformName() const { return Platform()?Platform()->Name():_T("UNKNOWN"); }

    RequestType Request() const { return m_Request;}

    void SetActiveTimeout   (Duration t){m_nActiveTimeout=t;}

    void SetDownloadTimeout (Duration t){m_nDownloadTimeout=t;}

    ExecutionParameters (

      RequestType r=CeCosTest::ExecutionParameters::RUN,

      LPCTSTR  Target=_T(""),

      Duration    nActiveTimeout=NOTIMEOUT,

      Duration    nDownloadTimeout=NOTIMEOUT);

    bool FromStr(LPCTSTR psz);

    String Image() const;

    virtual ~ExecutionParameters(){}

    bool m_bUseFilter;

  protected:

    static LPCTSTR  arRequestImage [1+RequestTypeMax];

    String m_Target;

    Duration m_nActiveTimeout,m_nDownloadTimeout;

    RequestType m_Request;

    int  m_nUnused1;

    int  m_nUnused2;

    int  m_nUnused3;

    bool m_bUnused2;

    bool m_bUnused3;

  };

  ///////////////////////////////////////////////////////////////////////////

  ///////////////////////////////////////////////////////////////////////////

  // Result status stuff.

  // Order is important - SetStatus can only change status in left-to-right direction

  void AnalyzeOutput();

  enum StatusType {NotStarted, NoResult, Inapplicable, Pass, DownloadTimeOut, TimeOut, Cancelled, Fail,

    AssertFail, StatusTypeMax};

  static StatusType StatusTypeValue (LPCTSTR  const pszStr);

  static const String Image(StatusType s) { return (s>=0 && s<StatusTypeMax)?String(arResultImage[s]):String::SFormat(_T("Unknown(%d)"),s); }

  ///////////////////////////////////////////////////////////////////////////

  ///////////////////////////////////////////////////////////////////////////

  // Attributes

  LPCTSTR  const      Executable()             const { return m_strExecutable;}            // Executable name

  StatusType          Status()                 const { return m_Status; }                  // Test status

  Duration            Download()               const { return m_nDownloadTime; }           // Download time

  Duration            Total()                  const { return m_nTotalTime; }              // Total

  Duration            MaxInactive()            const { return m_nMaxInactiveTime; }        // Max. inactive

  LPCTSTR  const  Output()                     const { return m_strOutput; }               // Output generated by a test run [for report purposes]

  //const CTestResource * const Port()           const { return m_pResource; }               // Resource used for a test run [for report purposes]

  const String ResultString (bool bIncludeOutput=true)             const;

  ///////////////////////////////////////////////////////////////////////////

  ///////////////////////////////////////////////////////////////////////////

  // Running a test:

  // Run a test locally:

  bool RunLocal ();

  // Run a test remotely: 

  // If pszRemoteHostPort is given, it sends the test for execution on the given host:post.

  // Otherwise, a suitable host:port is determined from the test resource information.

  bool RunRemote (LPCTSTR  const pszRemoteHostPort);

  ///////////////////////////////////////////////////////////////////////////

  ///////////////////////////////////////////////////////////////////////////

  // Resource functions

  // Run as a server on given TCP/IP port

  static bool RunAgent(int nTcpPort);

  bool InteractiveInferior(LPCTSTR pszHostPort,TCHAR **argv);

  void SetTimeouts (Duration dActive=NOTIMEOUT,Duration dDownload=NOTIMEOUT/*,Duration dElapsed=15*60*1000*/);

  void SetExecutable (LPCTSTR pszExecutable);

  static bool Value (

    LPCTSTR pszStr,

    struct tm &t,

    StatusType &status,

    String &target,

    String &strExecutionHostPort,

    String &strExecutableTail,

    String &strTitle,

    int &nFileSize,

    Duration &nTotalTime,

    Duration &nMaxInactiveTime,

    Duration &nDownloadTime,

    Duration &nDownloadTimeout,

    Duration &nActiveTimeout,

    int &nDownloadedSize);

  enum ServerStatus {SERVER_BUSY, SERVER_READY, SERVER_CANT_RUN, CONNECTION_FAILED, SERVER_LOCKED, ServerStatusMax};

  static LPCTSTR  const Image(ServerStatus s) { return arServerStatusImage[MIN(s,ServerStatusMax)]; }

  static ServerStatus ServerStatusValue(LPCTSTR psz);

  // Force the result to change.  Generally you can only set the result left-to-right in the order of the enumeration literals

  void ForceResult(StatusType s) { m_Status=s; }

  // Get size information (generally by running *gdb-size)

  bool GetSizes();

  // Connect to a test server

  static ServerStatus CeCosTest::Connect (LPCTSTR pszHostPort, CeCosSocket *&pSock, const ExecutionParameters &e,String &strInfo,Duration dTimeout=10*1000);

  // Log some output.  The accumulated output can be retrieved using Output()

  void Log (LPCTSTR  const pszFormat,...);

  void LogString (LPCTSTR psz);

protected:

        int m_nOutputLen;

  void Cancel (); // Stop the run

  // Connect to m_strExecutionHostPort

  void ConnectForExecution ();

  // Callback used when EXEC output is used to create host-side processes

  static void CALLBACK AppendFunc(void *pParam,LPCTSTR psz) { ((CeCosTest*)pParam)->Log(_T("%%%% %s"),psz);}

        void GetInferiorCommands (StringArray &arstrInferiorCmds);

  CSubprocess *m_pspPipe;

  PtrArray m_arpExecsp;

  // Extract a directive (such as "EXEC:") from the test output.  The index passed keeps track of the last such

  // directive extracted such that successive calls march through the output, returning a different one each time.

        bool GetDirective (LPCTSTR pszDirective, String &str,int &nIndex);

  // Keep track of directives in the gdb output

  int m_nLastGdbInst;     // GDB

  int m_nLastExecInst;    // EXEC

  int m_nLastTimeoutInst; // TIMEOUT

  int m_nLastPipeInst;    // PIPE   

  // Commands to be sent to gdb, or other inferior process

  StringArray m_arstrInferiorCmds;

  // Last command sent

        unsigned int m_nCmdIndex;

  // Inferior process output comes through here

  static void CALLBACK SInferiorOutputFunc(void *pParam,LPCTSTR psz) { ((CeCosTest *)pParam)->InferiorOutputFunc(psz); }

  void InferiorOutputFunc(LPCTSTR psz);

  // Has a timeout occurred?  Returns false if so.

  static bool CALLBACK SCheckForTimeout(void *pParam) { return ((CeCosTest *)pParam)->CheckForTimeout(); }

  // Read target ready indicator from server

  bool GetTargetReady(String &strHostPort);

  // This may be set to force the socket-to-serial connection to terminate

  bool m_bStopConnectSocketToSerial;

  // Convert a path to one understandable by Cygwin

  static String CygPath (LPCTSTR pszPath);

  // Are we at a prompt?

  bool AtPrompt();

  // To limit calls to ps, under UNIX.  This prevents the acquisition of cpu time consuming the whole machine :-).

  mutable Time m_tInferiorCpuTime;

  mutable Time m_tPrevSample;

  Time InferiorTime() const;

  unsigned int m_nStrippedSize;

  // Path to use to execute subprocesses

  String m_strPath;

  // Size of executable

  unsigned int m_nFileSize;

  // host:port we are connecting to

  String m_strExecutionHostPort;

  ///////////////////////////////////////////////////////////////////////////

  // Stuff to manage running gdb (or some other inferior process)

  bool CheckForTimeout();                     // Check for a timeout - set status and return false if it happens

  bool m_bDownloading;                        // Are we currently downloading executable?

  bool InferiorProcessAlive ();                    // Is gdb still alive and kicking?

  Time m_tBase;                               // Base used for measurement of timeouts

  Time m_tBase0;                              // Base used for measurement of timeouts

  Time m_tWallClock0;                         // When the test was actually started

  ///////////////////////////////////////////////////////////////////////////

  // Close the socket used by the current class instance

  void CloseSocket ();

  bool send(const void * const pData,unsigned int nLength,LPCTSTR  const pszMsg=_T(""),Duration dTimeout=10*1000);

  bool recv(const void *pData,unsigned int nLength,LPCTSTR  const pszMsg=_T(""),Duration dTimeout=10*1000);

  bool sendResult(Duration dTimeout=10*1000);

  bool recvResult(Duration dTimeout=10*1000);

  ///////////////////////////////////////////////////////////////////////////

  ///////////////////////////////////////////////////////////////////////////

  CeCosSocket *m_pSock;

  ExecutionParameters m_ep;

  // Chaining to allow *AllInstances functions to work:

  static CeCosTest * pFirstInstance;

  CeCosTest * m_pPrevInstance;

  CeCosTest * m_pNextInstance;

  void RunInferior (LPCTSTR pszCmdline);

  bool OutputContains(LPCTSTR psz) const { return 0!=_tcsstr(m_strOutput,psz); }

  static void CALLBACK SAcceptThreadFunc (void *pParam) {((CeCosTest *)pParam)->AcceptThreadFunc(); }

  void AcceptThreadFunc();

  static void CALLBACK SConnectSocketToSerialThreadFunc(void *pParam) { ((CeCosTest *)pParam)->ConnectSocketToSerialThreadFunc(); }

  void ConnectSocketToSerialThreadFunc();

  String m_strExecutable;

  String m_strTitle;

  void SetStatus (StatusType status);

  StatusType m_Status;

  Duration  m_nDownloadTime;

  Duration  m_nTotalTime;

  Duration  m_nMaxInactiveTime;

  CTestResource *m_pResource;

  CSubprocess *m_psp;

  String m_strOutput; // the output of the test run goes here

  static LPCTSTR  const arResultImage[1+StatusTypeMax];

  static LPCTSTR  const arServerStatusImage[1+ServerStatusMax];

  bool m_bConnectSocketToSerialThreadDone;

  static void CALLBACK ResetLogFunc(void *pParam, LPCTSTR psz);

  // These are used by RunAgent and its friends for setting up the RDI connection

  int m_nAuxPort;

  int m_nAuxListenSock;

}; // class CeCosTest

#endif