/*
 * Copyright (C) 2000, 2001, 2002, 2004 Free Software Foundation, Inc.
 *
 * 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 DejaGnu; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
 */

#ifndef __DEJAGNU_H__
#define __DEJAGNU_H__

#include <stdio.h>
#include <stdarg.h>
#include <string.h>

/* If you have problems with DejaGnu dropping failed, untested, or
 * unresolved messages generated by a unit testcase,
 */

/* #define _DEJAGNU_WAIT_
 */

#ifdef _DEJAGNU_WAIT_
#      include <sys/time.h>
#      include <sys/types.h>
#      include <unistd.h>
#endif

#define _BUFFER_SIZE_ 512

static int passed;
static int failed;
static int untest;
static int unresolve;

static char buffer[ _BUFFER_SIZE_ ];

#ifdef _DEJAGNU_WAIT_
void
wait (void)
{
  fd_set rfds;
  struct timeval tv;
  
  FD_ZERO (&rfds);
  tv.tv_sec = 0;
  tv.tv_usec = 1;
  
  select (0, &rfds, NULL, NULL, &tv);
}
#endif

inline void
pass (const char* fmt, ...)
{
  va_list ap;
	
  passed++;
  va_start (ap, fmt);
  vsnprintf (buffer, _BUFFER_SIZE_, fmt, ap);
  va_end (ap);
  printf ("\tPASSED: %s\n", buffer);
#ifdef _DEJAGNU_WAIT_
  wait ();
#endif
}

inline void
fail (const char* fmt, ...)
{
  va_list ap;
  
  failed++;
  va_start (ap, fmt);
  vsnprintf (buffer, _BUFFER_SIZE_, fmt, ap);
  va_end (ap);
  printf ("\tFAILED: %s\n", buffer);
#ifdef _DEJAGNU_WAIT_
  wait ();
#endif
}

inline void
untested (const char* fmt, ...)
{
  va_list ap;
  
  untest++;
  va_start (ap, fmt);
  vsnprintf (buffer, _BUFFER_SIZE_, fmt, ap);
  va_end (ap);
  printf ("\tUNTESTED: %s\n", buffer);
#ifdef _DEJAGNU_WAIT_
  wait ();
#endif
}

inline void
unresolved (const char* fmt, ...)
{
  va_list ap;
  
  unresolve++;
  va_start (ap, fmt);
  vsnprintf (buffer, _BUFFER_SIZE_, fmt, ap);
  va_end (ap);
  printf ("\tUNRESOLVED: %s\n", buffer);
#ifdef _DEJAGNU_WAIT_
  wait ();
#endif
}

inline void
note (const char* fmt, ...)
{
  va_list ap;
  
  va_start (ap, fmt);
  vsnprintf (buffer, _BUFFER_SIZE_, fmt, ap);
  va_end (ap);
  printf ("\tNOTE: %s\n", buffer);
#ifdef _DEJAGNU_WAIT_
  wait ();
#endif
}

inline void
totals (void)
{
  printf ("\nTotals:\n");
  printf ("\t#passed:\t\t%d\n", passed);
  printf ("\t#failed:\t\t%d\n", failed);
  if (untest)
    printf ("\t#untested:\t\t%d\n", untest);
  if (unresolve)
    printf ("\t#unresolved:\t\t%d\n", unresolved);
}

#ifdef __cplusplus

#include <iostream>
#include <iomanip>
#include <fstream>
#include <string>

const char *outstate_list[] = {
  "FAILED: ", "PASSED: ", "UNTESTED: ", "UNRESOLVED: "
};

const char ** outstate = outstate_list;

enum teststate {FAILED, PASSED,UNTESTED,UNRESOLVED} laststate;

class TestState {
 private:
  teststate laststate;
  std::string lastmsg;
 public:
  TestState (void)
    {
      passed = 0;
      failed = 0;
      untest = 0;
      unresolve = 0;
    }

  ~TestState (void) { totals(); }

  void testrun (bool b, std::string s)
    {
      if (b)
	pass (s);
      else
	fail (s);
    }

    void pass (std::string s)
      {
        passed++;
        laststate = PASSED;
        lastmsg = s;
        std::cout << "\t" << outstate[PASSED] << s << std::endl;
      }

    void pass (const char *c)
      {
	std::string s = c;
        pass (s);
      }

    void fail (std::string s)
      {
        failed++;
        laststate = FAILED;
        lastmsg = s;
        std::cout << "\t" << outstate[FAILED] << s << std::endl;
      }

    void fail (const char *c)
      {
        std::string s = c;
        fail (s);
      }

    void untested (std::string s)
      {
        untest++;
        laststate = UNTESTED;
        lastmsg = s;
        std::cout << "\t" << outstate[UNTESTED] << s << std::endl;
      }

    void untested (const char *c)
      {
        std::string s = c;
        untested (s);
      }
    
    void unresolved (std::string s)
      {
        unresolve++;
        laststate = UNRESOLVED;
        lastmsg = s;
        std::cout << "\t" << outstate[UNRESOLVED] << s << std::endl;
      }

    void unresolved (const char *c)
      {
        std::string s = c;
        unresolved (s);
      }

    void totals (void)
      {
        std::cout << "\t#passed:\t\t" << passed << std::endl;
        std::cout << "\t#failed:\t\t" << failed << std::endl;
        if (untest)
	  std::cout << "\t#untested:\t\t" << untest << std::endl;
        if (unresolve)
	  std::cout << "\t#unresolved:\t\t" << unresolve << std::endl;
      }
    
    // This is so this class can be printed in an ostream.
    friend std::ostream & operator << (std::ostream &os, TestState& t)
      {
	return os << "\t" << outstate[t.laststate] << t.lastmsg ;
      }
    
    int GetState (void) { return laststate; }
    std::string GetMsg (void) { return lastmsg; }
};

#endif // __cplusplus
#endif // _DEJAGNU_H_