--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/genericopenlibs/cppstdlib/stl/test/eh/main.cpp Fri Jun 04 16:20:51 2010 +0100
@@ -0,0 +1,408 @@
+/***********************************************************************************
+ 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;
+}
+