/***********************************************************************************

  Main.cpp

 * Portions Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

 * Copyright (c) 1997

 * Mark of the Unicorn, Inc.

 *

 * Permission to use, copy, modify, distribute and sell this software

 * and its documentation for any purpose is hereby granted without fee,

 * provided that the above copyright notice appear in all copies and

 * that both that copyright notice and this permission notice appear

 * in supporting documentation.  Mark of the Unicorn makes no

 * representations about the suitability of this software for any

 * purpose.  It is provided "as is" without express or implied warranty.

 * Copyright (c) 1997

 * Moscow Center for SPARC Technology

 *

 * Permission to use, copy, modify, distribute and sell this software

 * and its documentation for any purpose is hereby granted without fee,

 * provided that the above copyright notice appear in all copies and

 * that both that copyright notice and this permission notice appear

 * in supporting documentation.  Moscow Center for SPARC Technology makes

no

 * representations about the suitability of this software for any

 * purpose.  It is provided "as is" without express or implied warranty.

***********************************************************************************/

#include "Prefix.h"

#include "Tests.h"

#if defined (EH_NEW_IOSTREAMS)

# include <iostream>

# else

# include <iostream.h>

#endif

#if defined(macintosh)&&(!defined(__MRC__) && !defined(__SC__)) || defined (_MAC) && defined(__MWERKS__)

# include <console.h>

# include <Types.h>

# include <Strings.h>

# ifdef EH_NEW_HEADERS

#  include <cstdio>

#  include <cstring>

#  include <cassert>

# else

#  include <stdio.h>

#  include <string.h>

#  include <assert.h>

# endif

# if defined (_STL_DEBUG)

#  if defined ( EH_USE_SGI_STL )

// Override assertion behavior

#  include <cstdarg>

//#  include <stldebug.h>

void STLPORT::__stl_debug_message(const char * format_str, ...)

{

  std::va_list args;

  va_start( args, format_str );

  char msg[256];

  std::vsnprintf(msg, sizeof(msg)/sizeof(*msg) - 1, format_str, args );

  DebugStr( c2pstr(msg) );

}

#  else

/*===================================================================================

  __assertion_failed  (override standard library function)

  EFFECTS: Breaks into the debugger and shows the assertion. This implementation

           is Mac-specific; others could be added for other platforms.

====================================================================================*/

extern "C"

{

  void __assertion_failed(char *condition, char *testfilename, int lineno);

  void __assertion_failed(char *condition, char *testfilename, int lineno)

  {

      char msg[256];

      std::strncpy( msg, condition, 255 );

      std::strncat( msg, ": ", 255 );

      std::strncat(  msg, testfilename, 255 );

      std::strncat( msg, ", ", 255 );

      char line[20];

      std::sprintf( line, "%d", lineno );

      std::strncat(  msg, line, 255 );

      DebugStr( c2pstr( msg ) );

  }

}

#  endif

# endif

#endif

#include "nc_alloc.h"

#if defined (EH_NEW_HEADERS)

# include <vector>

# include <cstring>

# else

# include <vector.h>

# include <string.h>

#endif

#include "TestClass.h"

#include "LeakCheck.h"

#include "test_construct.h"

#ifdef __BORLANDC__

# include <except.h>

#endif

# if defined(EH_USE_NAMESPACES)

namespace  // dwa 1/21/00 - must use unnamed namespace here to avoid conflict under gcc using native streams

{

  using namespace std;

  // using std::cerr;

  // using std::endl;

}

# endif

/*===================================================================================

  usage  (file-static helper)

  EFFECTS: Prints a message describing the command-line parameters

====================================================================================*/

static void usage(const char* name)

{

    cerr<<name<<

        " Usage : leak_test [-n <iterations>] [-s <size>] [-l] [-e] [-q]/[-v] [-t] [test_name...]\n";

    cerr<<"\t[-n <iterations>] : number of test iterations, default==100;"<<endl;

    cerr<<"\t[-s <size>] : base value for random container sizes, default==1000;"<<endl;

    cerr<<"\t[-e] : don't throw exceptions, test for leak in normal conditions;"<<endl;

// This option was never actually used -- dwa 9/22/97

//    cerr<<"\t[-i] : ignore leak errors;"<<endl;

    cerr<<"\t[-q] : quiet mode;"<<endl;

    cerr<<"\t[-v] : verbose mode;"<<endl;

    cerr<<"\t[-t] : track each allocation;"<<endl;

    cerr<<"\t[test name [test name...]] : run only some of the tests by name (default==all tests):"<<endl;

    cerr<<"\t\tpossible test names are : algo vector bit_vector list slist deque set map hash_set hash_map rope string bitset valarray"<<endl;

    EH_CSTD::exit(1);

}

# ifdef EH_NEW_HEADERS

#  include <set>

# else

#  include <set.h>

# endif

#if defined(_WIN32_WCE) || defined(__SYMBIAN32__)

#include <fstream>

#endif

int _STLP_CALL main(int argc, char** argv)

{

#if defined(_WIN32_WCE)  || defined(__SYMBIAN32__)

  std::ofstream file( "c:\\eh_test.txt" );

  std::streambuf* old_cout_buf = cout.rdbuf(file.rdbuf());

  std::streambuf* old_cerr_buf = cerr.rdbuf(file.rdbuf());

#endif

#if defined( __MWERKS__ ) && defined( macintosh )  // Get command line.

  argc = ccommand(&argv);

  // Allow the i/o window to be repositioned.

//  EH_STD::string s;

//  getline(EH_STD::cin, s);

#endif

    unsigned int niters=2;

    bool run_all=true;

    bool run_slist = false;

    bool run_list = false;

    bool run_vector = false;

    bool run_bit_vector = false;

    bool run_deque = false;

    bool run_hash_map = false;

    bool run_hash_set = false;

    bool run_set = false;

    bool run_map = false;

    bool run_algo = false;

    bool run_algobase = false;

    bool run_rope = false;

    bool run_string = false;

    bool run_bitset = false;

    bool run_valarray = false;

    int cur_argv;

    char *p, *p1;

#if defined (EH_NEW_IOSTREAMS)

    std::ios_base::sync_with_stdio(false);

#endif

    cerr << argv[0]<<" : Exception handling testsuite.\n";

    cerr.flush();

  bool track_allocations = false;

    // parse parameters :

    // leak_test [-iterations] [-test] ...

    for (cur_argv=1; cur_argv<argc; cur_argv++) {

        p = argv[cur_argv];

        if (*p == '-') {

            switch (p[1]) {

            case 'q':

                gTestController.SetVerbose(false);

                break;

            case 'v':

                gTestController.SetVerbose(true);

                break;

#if 0  // This option was never actually used -- dwa 9/22/97

            case 'i':

                gTestController.IgnoreLeaks(true);

                break;

#endif

            case 'n':

                p1 = argv[++cur_argv];

                if (p1 && EH_CSTD::sscanf(p1, "%i", &niters)==1)

                    cerr <<" Doing "<<niters<<" iterations\n";

                else

                    usage(argv[0]);

                break;

            case 't':

              track_allocations = true;

              break;

            case 'e':

                gTestController.TurnOffExceptions();

                break;

            case 's':

                p1 = argv[++cur_argv];

                if (p1 && EH_CSTD::sscanf(p1, "%i", &random_base)==1)

                    cerr <<" Setting  "<<random_base<<" as base for random sizes.\n";

                else

                    usage(argv[0]);

                break;

            default:

                usage(argv[0]);

                break;

            }

        } else {

            run_all = false;

            // test name

            if (EH_CSTD::strcmp(p, "algo")==0) {

                run_algo=true;

            } else if (EH_CSTD::strcmp(p, "vector")==0) {

                run_vector=true;

            } else if (EH_CSTD::strcmp(p, "bit_vector")==0) {

                run_bit_vector=true;

            } else if (EH_CSTD::strcmp(p, "list")==0) {

                run_list=true;

            } else if (EH_CSTD::strcmp(p, "slist")==0) {

                run_slist=true;

            } else if (EH_CSTD::strcmp(p, "deque")==0) {

                run_deque=true;

            } else if (EH_CSTD::strcmp(p, "set")==0) {

                run_set=true;

            } else if (EH_CSTD::strcmp(p, "map")==0) {

                run_map=true;

            } else if (EH_CSTD::strcmp(p, "hash_set")==0) {

                run_hash_set=true;

            } else if (EH_CSTD::strcmp(p, "hash_map")==0) {

                run_hash_map=true;

            } else if (EH_CSTD::strcmp(p, "rope")==0) {

                run_rope=true;

            } else if (EH_CSTD::strcmp(p, "string")==0) {

                run_string=true;

            } else if (EH_CSTD::strcmp(p, "bitset")==0) {

                run_bitset=true;

            } else if (EH_CSTD::strcmp(p, "valarray")==0) {

                run_valarray=true;

            } else {

                usage(argv[0]);

            }

        }

    }

  gTestController.TrackAllocations( track_allocations );

    // Over and over...

    for ( unsigned i = 0; i < niters ; i++ )

    {

     cerr << "iteration #" << i << "\n";

        if (run_all || run_algobase) {

            gTestController.SetCurrentContainer("algobase");

            cerr << "EH test : algobase" << endl;

            test_algobase();

        }

        if (run_all || run_algo) {

            gTestController.SetCurrentContainer("algo");

            cerr << "EH test : algo" << endl;

            test_algo();

        }

        if (run_all || run_vector) {

            gTestController.SetCurrentContainer("vector");

            cerr << "EH test : vector" << endl;

            test_vector();

        }

#if defined( EH_BIT_VECTOR_IMPLEMENTED )

        if (run_all || run_bit_vector) {

            gTestController.SetCurrentContainer("bit_vector");

           cerr << "EH test : bit_vector" << endl;

            test_bit_vector();

        }

#endif

        if (run_all || run_list) {

            gTestController.SetCurrentContainer("list");

            cerr << "EH test : list" << endl;

            test_list();

        }

#if defined( EH_SLIST_IMPLEMENTED )

        if (run_all || run_slist) {

            gTestController.SetCurrentContainer("slist");

            cerr << "EH test : slist" << endl;

            test_slist();

        }

#endif // EH_SLIST_IMPLEMENTED

        if (run_all || run_deque) {

            gTestController.SetCurrentContainer("deque");

            cerr << "EH test : deque" << endl;

            test_deque();

        }

        if (run_all || run_set) {

            gTestController.SetCurrentContainer("set");

            cerr << "EH test : set" << endl;

            test_set();

            gTestController.SetCurrentContainer("multiset");

            cerr << "EH test : multiset" << endl;

            test_multiset();

        }

        if (run_all || run_map) {

            gTestController.SetCurrentContainer("map");

            cerr << "EH test : map" << endl;

            test_map();

            gTestController.SetCurrentContainer("multimap");

            cerr << "EH test : multimap" << endl;

            test_multimap();

        }

#if defined( EH_HASHED_CONTAINERS_IMPLEMENTED )

        if (run_all || run_hash_map) {

            gTestController.SetCurrentContainer("hash_map");

            cerr << "EH test : hash_map" << endl;

            test_hash_map();

            gTestController.SetCurrentContainer("hash_multimap");

            cerr << "EH test : hash_multimap" << endl;

            test_hash_multimap();

        }

        if (run_all || run_hash_set) {

            gTestController.SetCurrentContainer("hash_set");

            cerr << "EH test : hash_set" << endl;

            test_hash_set();

            gTestController.SetCurrentContainer("hash_multiset");

            cerr << "EH test : hash_multiset" << endl;

            test_hash_multiset();

        }

#endif // EH_HASHED_CONTAINERS_IMPLEMENTED

#if defined( EH_ROPE_IMPLEMENTED )

  // CW1.8 can't compile this for some reason!

#if !( defined(__MWERKS__) && __MWERKS__ < 0x1900 )

        if (run_all || run_rope) {

            gTestController.SetCurrentContainer("rope");

            cerr << "EH test : rope" << endl;

            test_rope();

        }

#endif

#endif // EH_ROPE_IMPLEMENTED

#if defined( EH_STRING_IMPLEMENTED )

        if (run_all || run_string) {

            gTestController.SetCurrentContainer("string");

            cerr << "EH test : string" << endl;

            test_string();

        }

#endif

#if defined( EH_BITSET_IMPLEMENTED )

        if (run_all || run_bitset) {

            gTestController.SetCurrentContainer("bitset");

            cerr << "EH test : bitset" << endl;

            test_bitset();

        }

#endif

#if defined( EH_VALARRAY_IMPLEMENTED )

        if (run_all || run_bitset) {

            gTestController.SetCurrentContainer("valarray");

            cerr << "EH test : valarray" << endl;

            test_valarray();

        }

#endif

    }

  gTestController.TrackAllocations( false );

    cerr << "EH test : Done\n";

#if defined(_WIN32_WCE) || defined(__SYMBIAN32__)

   cout.rdbuf(old_cout_buf);

   cerr.rdbuf(old_cerr_buf);

   file.close();

#endif

    return 0;

}