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