void TestBTree::doBenchmark()
{
Tree tree;
Vector vector( elements );
_init( vector );
for( Vector::iterator fi = vector.begin(); fi != vector.end(); ++fi )
{
std::pair< Tree::iterator, bool > insertion
= tree.insert( std::make_pair( *fi, fi - vector.begin() ) );
if( insertion.second )
{
std::stringstream stream;
stream << (fi - vector.begin());
dumpTree( tree, path, stream.str() );
}
}
for( Vector::iterator fi = vector.begin(); fi != vector.end(); ++fi )
{
Tree::iterator ti = tree.find( *fi );
if( ti != tree.end() )
{
tree.erase( ti );
std::stringstream stream;
stream << (fi - vector.begin() + elements);
dumpTree( tree, path, stream.str() );
}
}
}
// print tree
void AVLTreeIndex::dumpTree(std::ofstream& fout, const AVLTreeNode* node) {
if (node == NULL) {
std::cout << "empty" << std::endl;
} else { // if non-empty tree
print(fout, RIGHT, node);
if (node->right != NULL) dumpTree(fout, node->right);
print(fout, KEY, node);
if (node->left != NULL) dumpTree(fout, node->left);
print(fout, LEFT, node);
}
}
// this is essentiall the last function to call...
// - fileDump "end-users" should call it by just saying dumpTree()
// - dumps tree to stdout (by way of Log::info)
// - recursive calls, depth is used for indentation
void TagTree::dumpTree(bool commentsFlag /*true*/,Node* pNode /*null*/ ,unsigned int depth /*=0*/)
{
if (!pNode) { //NULL --> initial node is rootNode
//check (only needed on first==outermost call) that push and pop match...
if (nodeStack.size()>1)
Log::error("nodeStack not emptied: should be 1 but is %d",nodeStack.size());
//no need to iterate or dump rootnode itself,
for( NodeList::iterator iter = rootNode.children.begin(); iter != rootNode.children.end(); iter++ )
dumpTree ( commentsFlag,&*iter, depth); //to not iterate on first level
return; //...and then finally return
}
std::string indent(depth*2,' '); //read: tab 4
if (commentsFlag) {
Log::info( "%s%s%s%s%s%s%s%s%s%s", //fancy formatting foo='bar' [re,do]
indent.c_str(),
pNode->key.c_str(),
pNode->value.size()?" = '":"",
pNode->value.c_str(),
pNode->value.size()?"'":"",
( pNode->key.size() + pNode->value.size() > 0 ) ? " ":"",
// standalong comments don't need extra indentation:
pNode->comment.size() && ( pNode->key.size() || pNode->value.size() )?
((std::string("\n ")+indent).c_str()) : "",
pNode->comment.size() && ( pNode->key.size() || pNode->value.size() ) ?"[":"",
//standalone comments don't need brackets
pNode->comment.c_str(),
pNode->comment.size() && ( pNode->key.size() || pNode->value.size() ) ?"]":""
);
} else {
//if "NoComments" mode, then make sure, there at least is a comment to avoid blankline
if ( pNode->key.size() || pNode->value.size())
{
Log::info( "%s%s%s%s%s", //fancy formatting foo='bar' [re,do]
indent.c_str(),
pNode->key.c_str(),
pNode->value.size()?" = '":"",
pNode->value.c_str(),
pNode->value.size()?"'":""
);
}
}
//iterate over children (gracefully covers no-children case)
for( NodeList::iterator iter = pNode->children.begin(); iter != pNode->children.end(); iter++ )
dumpTree ( commentsFlag, &*iter, depth+1);
}
void AVLTreeIndex::save() {
std::ofstream fout;
fout.open(filename, std::ios::out | std::ios::app);
if (!fout.is_open()) {
std::cout << "Error opening " << filename << std::endl;
exit(1);
} else {std::cout << filename << " successfully opened." << std::endl;}
for(auto it = references.begin(); it != references.end(); it++) {
if((*it)[0] != '/') {
(*it).insert(0, "/");
char c[PATH_MAX];
getcwd(c, PATH_MAX);
(*it).insert(0, c);
}
fout << *it << std::endl;
}
// write out all data to file
fout << "ENDREFS" << std::endl;
dumpTree(fout, root);
std::cout << "index written to file." << std::endl;
fout.close();
}
//!-----------------------------------------
void dumpTree(treeElem_t *node, const unsigned int mode, int depth, FILE *output)
{
assert(node);
assert(mode == DEBUG || mode || NODEBUG);
//ASSERT_OK(node);
printElem(mode, node, depth, output);
if (node->left)
dumpTree(node->left, mode, ++depth, output);
depth--;
if (node->right)
dumpTree(node->right, mode, ++depth, output);
}
void RdbDump::continueDumping() {
// if someone reset/deleted the collection we were dumping...
CollectionRec *cr = g_collectiondb.getRec ( m_collnum );
// . do not do this for statsdb/catdb which always use collnum of 0
// . RdbMerge also calls us but gives a NULL m_rdb so we can't
// set m_isCollectionless to false
if ( ! cr && m_doCollCheck ) {
g_errno = ENOCOLLREC;
// m_file is invalid if collrec got nuked because so did
// the Rdbbase which has the files
log("db: continue dumping lost collection");
}
// bitch about errors
if (g_errno)log("db: Dump to %s had error writing: %s.",
m_file->getFilename(),mstrerror(g_errno));
// go back now if we were NOT dumping a tree
if ( ! (m_tree || m_buckets) ) {
m_isDumping = false;
m_callback ( m_state );
return;
}
// . continue dumping the tree
// . return if this blocks
// . if the collrec was deleted or reset then g_errno will be
// ENOCOLLREC and we want to skip call to dumpTree(
if ( g_errno != ENOCOLLREC && ! dumpTree ( false ) )
return;
// close it up
doneDumping ( );
// call the callback
m_callback ( m_state );
}
void dumpTree(TreeNode *p, int indent, char *tab){
int i=0;
while(i++<indent)
printf("%s",tab);
if(p->d)
printf("Data: %s ",p->d);
fflush(stdout);
printf("Categ: %s\n",CAL[p->categ]);
fflush(stdout);
i=0;
while(i<6 && p->comps[i])
dumpTree(p->comps[i++],indent+1,tab);
if(p->next)
dumpTree(p->next,indent,tab);
}
void QQuickVisualTestUtil::dumpTree(QQuickItem *parent, int depth)
{
static QString padding(" ");
for (int i = 0; i < parent->childItems().count(); ++i) {
QQuickItem *item = qobject_cast<QQuickItem*>(parent->childItems().at(i));
if (!item)
continue;
qDebug() << padding.left(depth*2) << item;
dumpTree(item, depth+1);
}
}
void
bailOut()
{
if (gVerbose) {
// dump the tree
dumpTree();
}
// in any case, write the tree back to disk
shutdown_cache(gVolume->Device(),gVolume->BlockSize());
exit(-1);
}
void
dumpRules(void)
{
Task *t;
Symbol *s;
int i;
for (t = taskq; t != NULL; t = t->next) {
s = t->rules;
for (i = 0; i < t->nrules; i++, s++) {
fprintf(stderr, "\nRule: %s\n", symName(*s));
dumpTree((Expr *)symValue(*s));
}
}
}
//!------------------------------------------
void processTask()
{
FILE * input = NULL;
input = formBuffer(input);
FILE * lex_dump = openFile("lex_dump.txt");
initiateLexemsArr();
formLexems();
dumpLexems(lex_dump);
EMPT SLASHES
puts(buffer);
SLASHES EMPT
treeElem_t * tree = getOP();
ASSERT_OK(tree);
if (Lexems.data[cnt_lex].oper[0] != '\0')
{
printf("SYNTAX ERROR! RECOMPILE YOUR GOPNIK PROG!\n");
printf("cnt_lex = %d\n");
printf("(%s)\n", Lexems.data[cnt_lex].oper);
}
SLASHES printf("Amount of nodes - (%d)\n", node_amount);
FILE *output = openFile("commands.txt");
FILE *dump = openFile("dump.txt");
FILE *viewTree = openFile("tree.txt");
dumpTree(tree, NODEBUG, BEGIN, stdout);
dumpTree(tree, DEBUG, BEGIN, dump);
printNode(tree, output);
FinishWork(input, output, dump, viewTree, lex_dump, buffer, tree);
}
std::string MySQLRecognitionBase::dumpTree(pANTLR3_UINT8 *tokenNames, pANTLR3_BASE_TREE tree, const std::string &indentation)
{
std::string result;
ANTLR3_UINT32 char_pos = tree->getCharPositionInLine(tree);
ANTLR3_UINT32 line = tree->getLine(tree);
pANTLR3_STRING token_text = tree->getText(tree);
pANTLR3_COMMON_TOKEN token = tree->getToken(tree);
const char* utf8 = (const char*)token_text->chars;
if (token != NULL)
{
ANTLR3_UINT32 token_type = token->getType(token);
pANTLR3_UINT8 token_name;
if (token_type == EOF)
token_name = (pANTLR3_UINT8)"EOF";
else
token_name = tokenNames[token_type];
#ifdef ANTLR3_USE_64BIT
result = base::strfmt("%s(line: %i, offset: %i, length: %" PRId64 ", index: %" PRId64 ", %s[%i]) %s\n",
indentation.c_str(), line, char_pos, token->stop - token->start + 1, token->index, token_name,
token_type, utf8);
#else
result = base::strfmt("%s(line: %i, offset: %i, length: %i, index: %i, %s[%i]) %s\n",
indentation.c_str(), line, char_pos, token->stop - token->start + 1, token->index, token_name,
token_type, utf8);
#endif
}
else
{
result = base::strfmt("%s(line: %i, offset: %i, nil) %s\n", indentation.c_str(), line, char_pos, utf8);
}
for (ANTLR3_UINT32 index = 0; index < tree->getChildCount(tree); index++)
{
pANTLR3_BASE_TREE child = (pANTLR3_BASE_TREE)tree->getChild(tree, index);
std::string child_text = dumpTree(tokenNames, child, indentation + "\t");
result += child_text;
}
return result;
}
int dumpTree(struct countnode *n,int indent)
{
if (indent==0) fprintf(stderr,"dumpTree:\n");
int i;
for(i=0;i<CHARCOUNT;i++) {
if (getCount(n,i)) {
fprintf(stderr,"%s'%c' x%d\n",
&" "[40-indent],
chars[i],getCount(n,i));
}
if (getChild(n,i,0)&&*getChild(n,i,0)) {
fprintf(stderr,"%s'%c':\n",
&" "[40-indent],
chars[i]);
dumpTree(*getChild(n,i,0),indent+2);
}
}
return 0;
}
extern "C" float EXPORT_API LoadStageClip( const char *projectFolder, const char *clipName, const char *sheetResolution )
{
// Load a stage clip. Build clip data and spritesheets and register in manager.
// This bit must be called in the worker thread and is thread-safe with rendering thread
// that cannot create rendering objects on its own.
LOGI( "Loading Stage Clip ('%s':'%s')\n", projectFolder, clipName );
RD_ClipDataKey key(projectFolder, clipName);
RD_ClipDataPtr_t pClipData = RD_ClipDataManager::instance()->object(key);
if (pClipData.isValid())
{
return pClipData->totalDuration();
}
RD_ClipDataCore *clipDataCore = new RD_ClipDataCore;
// Try to load from binary file, fallback on xml format.
if ( BIN_ProjectLoader::loadStageClip( projectFolder, clipName, clipDataCore ) == false )
XML_ProjectLoader::loadStageClip( projectFolder, clipName, clipDataCore );
pClipData = new RD_ClipData(clipDataCore);
for ( unsigned i = 0, iEnd = (unsigned)clipDataCore->count() ; i<iEnd ; ++i )
{
TV_NodeTreeViewPtr_t nodeTreeView = clipDataCore->nodeTreeView(i);
dumpTree( nodeTreeView, "" );
// Load sprite sheets if necessary
STD_String spriteSheetName;
if (nodeTreeView->spriteSheet(spriteSheetName))
{
RD_SpriteSheetKey key(projectFolder, spriteSheetName, sheetResolution);
RD_SpriteSheet::createOrLoad( key );
}
}
RD_ClipDataManager::instance()->addObject( key, pClipData );
return pClipData->totalDuration();
}
template< typename Tnode> void dumpTree( ElementRef< Tnode>& elref)
{
oratext* name = elref.getNodeName();
if (name == NULL)
{
printf( " Node Name: NO Name\n");
return;
}
if (!strcmp((char *) name, "ACT"))
dumpPart< Tnode>( elref, FALSE);
else if (!strcmp((char *) name, "SCENE"))
dumpPart< Tnode>( elref, TRUE);
Tnode* np = NULL;
ElementRef< Tnode>* elemrp = NULL;
if (elref.hasChildNodes())
{
NodeList< Tnode>* lp = elref.getChildNodes();
NodeListRef< Tnode> lref( elref, lp);
ub4 len = lref.getLength();
for (int i = 0; i < len; i++)
{
np = lref.item( i);
if (i == 0)
elemrp = new ElementRef< Tnode>( elref, np);
else
elemrp->resetNode( np);
if (elemrp->getNodeType() == ELEMENT_NODE)
dumpTree( *elemrp);
}
if (len > 0)
delete elemrp;
}
}
bool TestBTree::testRandom()
{
typedef std::pair< Map::iterator, bool > MapInsertion;
typedef std::pair< Tree::iterator, bool > TreeInsertion;
status << "Running Test Random\n";
Map map;
Tree tree;
Vector vector( elements );
_init( vector );
for( unsigned int i = 0; i < iterations; ++i )
{
switch( random() % 3 )
{
case 0:
{
size_t index = random() % vector.size();
MapInsertion mapInsertion = map.insert(
std::make_pair( vector[ index ], i ) );
TreeInsertion treeInsertion = tree.insert(
std::make_pair( vector[ index ], i ) );
if( mapInsertion.second != treeInsertion.second )
{
status << "At index " << i << std::boolalpha
<< " map insertion "
<< mapInsertion.second
<< " did not match tree insertion "
<< treeInsertion.second << "\n";
dumpTree( tree, path );
return false;
}
if( mapInsertion.first->first
!= treeInsertion.first->first )
{
status << "At index " << i << " map key "
<< mapInsertion.first->first
<< " did not match tree key "
<< treeInsertion.first->first << "\n";
dumpTree( tree, path );
return false;
}
if( mapInsertion.first->second
!= treeInsertion.first->second )
{
status << "At index " << i << " map value "
<< mapInsertion.first->second
<< " did not match tree value "
<< treeInsertion.first->second << "\n";
dumpTree( tree, path );
return false;
}
break;
}
case 1:
{
size_t index = random() % vector.size();
Map::const_iterator mi = map.find( vector[ index ] );
Tree::const_iterator ti = tree.find( vector[ index ] );
bool mapEnd = mi == map.end();
bool treeEnd = ti == tree.end();
if( mapEnd || treeEnd )
{
if( mapEnd != treeEnd )
{
status << "At index " << i << std::boolalpha
<< " for key " << vector[ index ] << " map end "
<< mapEnd << " did not match tree end "
<< treeEnd << "\n";
dumpTree( tree, path );
return false;
}
}
else
{
if( mi->first != ti->first )
{
status << "At index " << i << " map key "
<< mi->first << " did not match tree key "
<< ti->first << "\n";
dumpTree( tree, path );
return false;
}
if( mi->second != ti->second )
{
status << "At index " << i << " map value "
<< mi->second << " did not match tree value "
<< ti->second << "\n";
dumpTree( tree, path );
return false;
}
}
}
case 2:
{
size_t index = random() % vector.size();
Map::iterator mi = map.find( vector[ index ] );
Tree::iterator ti = tree.find( vector[ index ] );
bool mapEnd = mi == map.end();
bool treeEnd = ti == tree.end();
if( mapEnd || treeEnd )
{
if( mapEnd != treeEnd )
{
status << "At index " << i << std::boolalpha
<< " for key " << vector[ index ] << " map end "
<< mapEnd << " did not match tree end "
<< treeEnd << "\n";
dumpTree( tree, path );
return false;
}
}
else
{
map.erase( mi );
tree.erase( ti );
}
}
}
}
status << "Test Random Passed\n";
return true;
}
// . return false if blocked, true otherwise
// . sets g_errno on error
bool RdbDump::set ( //char *coll ,
collnum_t collnum ,
BigFile *file ,
int32_t id2 , // in Rdb::m_files[] array
bool isTitledb ,
RdbBuckets *buckets , // optional buckets to dump
RdbTree *tree , // optional tree to dump
RdbMap *map ,
RdbCache *cache ,
int32_t maxBufSize ,
bool orderedDump , // dump in order of keys?
bool dedup , // 4 RdbCache::incorporateList()
int32_t niceness ,
void *state ,
void (* callback) ( void *state ) ,
bool useHalfKeys ,
int64_t startOffset ,
//key_t prevLastKey ,
char *prevLastKey ,
char keySize ,
//class DiskPageCache *pc ,
void *pc ,
int64_t maxFileSize ,
Rdb *rdb ) {
if ( ! orderedDump ) {
log(LOG_LOGIC,"db: RdbDump does not support non-ordered.");
char *xx = NULL; *xx = 0;
}
//if ( ! coll &&
//if ( ! coll && rdb->m_isCollectionLess )
// strcpy(m_coll,rdb->m_dbname);
m_collnum = collnum;
// use 0 for collectionless
if ( rdb && rdb->m_isCollectionLess ) m_collnum = 0;
// are we like catdb/statsdb etc.?
m_doCollCheck = true;
if ( rdb && rdb->m_isCollectionLess ) m_doCollCheck = false;
// RdbMerge also calls us but rdb is always set to NULL and it was
// causing a merge on catdb (collectionless) to screw up
if ( ! rdb ) m_doCollCheck = false;
/*
if ( ! coll && g_catdb.getRdb() == rdb )
strcpy(m_coll, "catdb");
else if ( ! coll && g_statsdb.getRdb() == rdb )
strcpy(m_coll, "statsdb");
else if ( ! coll && g_accessdb.getRdb() == rdb )
strcpy(m_coll, "accessdb");
*/
//else
// strcpy ( m_coll , coll );
m_file = file;
m_id2 = id2;
m_isTitledb = isTitledb;
m_buckets = buckets;
m_tree = tree;
m_map = map;
m_cache = cache;
m_orderedDump = orderedDump;
m_dedup = dedup;
m_state = state;
m_callback = callback;
m_list = NULL;
m_niceness = niceness;
m_tried = false;
m_isSuspended = false;
m_ks = keySize;
m_addToMap = true;
// reset this in case we run out of mem, it doesn't get set properly
// and needs to be NULL for RdbMem's call to getLastKeyinQueue()
m_lastKeyInQueue = NULL;
KEYMIN(m_firstKeyInQueue,m_ks);
m_isDumping = false;
m_writing = false;
m_buf = NULL;
m_verifyBuf = NULL;
m_maxBufSize = maxBufSize;
m_offset = startOffset ;
m_rolledOver = false; // true if m_nextKey rolls over back to 0
//m_nextKey = 0 ; // used in dumpTree()
KEYMIN(m_nextKey,m_ks);
m_nextNode = 0 ; // used in dumpTree()
// if we're dumping indexdb, allow half keys
m_useHalfKeys = useHalfKeys;
//m_prevLastKey = prevLastKey;
KEYSET(m_prevLastKey,prevLastKey,m_ks);
// for setting m_rdb->m_needsSave after deleting the dump list
m_rdb = rdb;
// . don't dump to a pre-existing file
// . seems like Rdb.cpp makes a new BigFile before calling this
// . now we can resume merges, so we can indeed dump to the END
// of a pre-exiting file, but not when dumping a tree!
//if ( m_file->doesExist() > 0 ) {
if ( (m_tree || m_buckets) && m_file->getFileSize() > 0 ) {
g_errno = EEXIST;
log("db: Could not dump to %s. File exists.",
m_file->getFilename());
return true;
}
// . NOTE: MAX_PART_SIZE in BigFile must be defined to be bigger than
// anything we actually dump since we only anticipate spanning 1 file
// and so only register the first file's fd for write callbacks
//if ( m_tree && m_tree->getMaxMem() > MAX_PART_SIZE )
//return log("RdbDump::dump: tree bigger than file part size");
// . open the file nonblocking, sync with disk, read/write
// . NOTE: O_SYNC doesn't work too well over NFS
// . we need O_SYNC when dumping trees only because we delete the
// nodes/records as we dump them
// . ensure this sets g_errno for us
// . TODO: open might not block! fix that!
int32_t flags = O_RDWR | O_CREAT ;
// a niceness bigger than 0 means to do non-blocking dumps
if ( niceness > 0 ) flags |= O_ASYNC | O_NONBLOCK ;
if ( ! m_file->open ( flags , pc , maxFileSize ) ) return true;
// . get the file descriptor of the first real file in BigFile
// . we should only dump to the first file in BigFile otherwise,
// we'd have to juggle fd registration
m_fd = m_file->getfd ( 0 , false /*for reading?*/ );
if ( m_fd < 0 ) {
log(LOG_LOGIC,"db: dump: Bad fd of first file in BigFile.") ;
return true;
}
// debug test
//char buf1[10*1024];
//int32_t n1 = m_file->write ( buf1 , 10*1024 , 0 );
//log("bytes written=%"INT32"\n",n1);
// we're now considered to be in dumping state
m_isDumping = true;
// . if no tree was provided to dump it must be RdbMerge calling us
// . he'll want to call dumpList() on his own
if ( ! m_tree && !m_buckets ) return true;
// how many recs in tree?
int32_t nr;
char *structureName;
if(m_tree) {
nr = m_tree->getNumUsedNodes();
structureName = "tree";
}
else if(m_buckets){
nr = m_buckets->getNumKeys();
structureName = "buckets";
}
// debug msg
log(LOG_INFO,"db: Dumping %"INT32" recs from %s to files.",
nr, structureName);
// nr , m_file->getFilename() );
// keep a total count for reporting when done
m_totalPosDumped = 0;
m_totalNegDumped = 0;
// we have our own flag here since m_dump::m_isDumping gets
// set to true between collection dumps, RdbMem.cpp needs
// a flag that doesn't do that... see RdbDump.cpp.
// this was in Rdb.cpp but when threads were turned off it was
// NEVER getting set and resulted in corruption in RdbMem.cpp.
m_rdb->m_inDumpLoop = true;
// . start dumping the tree
// . return false if it blocked
if ( ! dumpTree ( false ) ) return false;
// no longer dumping
doneDumping();
// return true since we didn't block
return true;
}
/// Dump DOM tree using XercesC handles
void dump_tree(Handle_t elt, ostream& os) {
dumpTree((DOMNode*)elt.ptr(),os);
}
/// Dump DOM tree using XercesC handles
void dump_doc(DOMDocument* doc, ostream& os) {
dumpTree(doc,os);
}
bool TestBTree::testInsert()
{
status << "Running Test Insert\n";
Map map;
Tree tree;
Vector vector( elements );
_init( vector );
for( unsigned int i = 0; i < iterations; ++i )
{
switch( random() % 2 )
{
case 0:
{
size_t index = random() % vector.size();
map.insert( std::make_pair( vector[ index ], i ) );
Tree::iterator fi =
tree.lower_bound( vector[ index ] );
fi = tree.insert( fi,
std::make_pair( vector[ index ], i ) );
if( fi->first != vector[ index ] )
{
status << "Insert failed, returned iterator with key "
<< fi->first << " does not match inserted value "
<< vector[ index ] << "\n";
dumpTree( tree, path );
return false;
}
break;
}
case 1:
{
size_t index = random() % vector.size();
Map::iterator mi = map.find( vector[ index ] );
Tree::iterator ti = tree.find( vector[ index ] );
if( mi != map.end() )
{
map.erase( mi );
tree.erase( ti );
}
break;
}
}
}
tree.clear();
tree.insert( map.begin(), map.end() );
{
Map::iterator mi = map.begin();
Tree::iterator ti = tree.begin();
for( ; mi != map.end() && ti != tree.end(); ++mi, ++ti )
{
if( mi->first != ti->first )
{
status << "Insert failed, map key " << mi->first
<< " does not match tree key " << ti->first << "\n";
dumpTree( tree, path );
return false;
}
if( mi->second != ti->second )
{
status << "Insert failed, map value "
<< mi->second
<< " does not match tree value " << ti->second
<< "\n";
dumpTree( tree, path );
return false;
}
}
}
status << " Test Insert Passed.\n";
return true;
}
bool TestBTree::testSwap()
{
status << "Running Test Swap\n";
Map map, map1;
Tree tree, tree1;
Vector vector( elements );
_init( vector );
for( unsigned int i = 0; i < iterations; ++i )
{
switch( random() % 2 )
{
case 0:
{
size_t index = random() % vector.size();
map.insert( std::make_pair( vector[ index ], i ) );
tree.insert( std::make_pair( vector[ index ], i ) );
break;
}
case 1:
{
size_t index = random() % vector.size();
Map::iterator mi = map.find( vector[ index ] );
Tree::iterator ti = tree.find( vector[ index ] );
if( mi != map.end() )
{
map.erase( mi );
tree.erase( ti );
}
break;
}
}
}
for( unsigned int i = 0; i < iterations; ++i )
{
switch( random() % 2 )
{
case 0:
{
size_t index = random() % vector.size();
map1.insert( std::make_pair( vector[ index ], i ) );
tree1.insert( std::make_pair( vector[ index ], i ) );
break;
}
case 1:
{
size_t index = random() % vector.size();
Map::iterator mi = map1.find( vector[ index ] );
Tree::iterator ti = tree1.find( vector[ index ] );
if( mi != map1.end() )
{
map1.erase( mi );
tree1.erase( ti );
}
break;
}
}
}
map.swap( map1 );
tree.swap( tree1 );
{
Map::iterator mi = map.begin();
Tree::iterator ti = tree.begin();
for( ; mi != map.end() && ti != tree.end(); ++mi, ++ti )
{
if( mi->first != ti->first )
{
status << "Swap failed, map key " << mi->first
<< " does not match tree key " << ti->first << "\n";
dumpTree( tree, path );
return false;
}
if( mi->second != ti->second )
{
status << "Swap failed, map value "
<< mi->second
<< " does not match tree value " << ti->second
<< "\n";
dumpTree( tree, path );
return false;
}
}
}
{
Map::iterator mi = map1.begin();
Tree::iterator ti = tree1.begin();
for( ; mi != map1.end() && ti != tree1.end(); ++mi, ++ti )
{
if( mi->first != ti->first )
{
status << "Swap failed, map key " << mi->first
<< " does not match tree key " << ti->first << "\n";
dumpTree( tree1, path );
return false;
}
if( mi->second != ti->second )
{
status << "Swap failed, map value "
<< mi->second
<< " does not match tree value " << ti->second
<< "\n";
dumpTree( tree1, path );
return false;
}
}
}
status << " Test Swap Passed.\n";
return true;
}
bool TestBTree::testSearching()
{
status << "Running Test Searching\n";
Map map, map1;
Tree tree, tree1;
Vector vector( elements );
_init( vector );
for( unsigned int i = 0; i < iterations; ++i )
{
switch( random() % 3 )
{
case 0:
{
size_t index = random() % vector.size();
map.insert( std::make_pair( vector[ index ], i ) );
tree.insert( std::make_pair( vector[ index ], i ) );
break;
}
case 1:
{
size_t index = random() % vector.size();
Map::iterator mi = map.find( vector[ index ] );
Tree::iterator ti = tree.find( vector[ index ] );
if( mi != map.end() )
{
map.erase( mi );
tree.erase( ti );
}
break;
}
case 2:
{
size_t index = random() % vector.size();
Map::iterator mi = map.find( vector[ index ] );
Tree::iterator ti = tree.find( vector[ index ] );
if( mi != map.end() )
{
if( ti == tree.end() )
{
status << "Map found key " << mi->first
<< ", but it was not found in the tree.\n";
dumpTree( tree, path );
return false;
}
if( mi->first != ti->first )
{
status << "Find failed, map key " << mi->first
<< " does not match tree key " << ti->first
<< "\n";
dumpTree( tree, path );
return false;
}
if( mi->second != ti->second )
{
status << "Find failed, map value " << mi->second
<< " does not match tree value " << ti->second
<< "\n";
dumpTree( tree, path );
return false;
}
}
mi = map.lower_bound( vector[ index ] );
ti = tree.lower_bound( vector[ index ] );
if( mi != map.end() )
{
if( ti == tree.end() )
{
status << "Map lower_bound found key " << mi->first
<< ", but it was not found in the tree.\n";
dumpTree( tree, path );
return false;
}
if( mi->first != ti->first )
{
status << "Lower_bound failed, map key "
<< mi->first
<< " does not match tree key " << ti->first
<< "\n";
dumpTree( tree, path );
return false;
}
if( mi->second != ti->second )
{
status << "Lower_bound failed, map value "
<< mi->second
<< " does not match tree value " << ti->second
<< "\n";
dumpTree( tree, path );
return false;
}
}
mi = map.upper_bound( vector[ index ] );
ti = tree.upper_bound( vector[ index ] );
if( mi != map.end() )
{
if( ti == tree.end() )
{
status << "Map upper_bound found key " << mi->first
<< ", but it was not found in the tree.\n";
dumpTree( tree, path );
return false;
}
if( mi->first != ti->first )
{
status << "Upper_bound failed, map key "
<< mi->first
<< " does not match tree key " << ti->first
<< "\n";
dumpTree( tree, path );
return false;
}
if( mi->second != ti->second )
{
status << "Upper_bound failed, map value "
<< mi->second
<< " does not match tree value " << ti->second
<< "\n";
dumpTree( tree, path );
return false;
}
}
std::pair< Map::iterator, Map::iterator >
mp = map.equal_range( vector[ index ] );
std::pair< Tree::iterator, Tree::iterator >
tp = tree.equal_range( vector[ index ] );
if( mp.first != map.end() )
{
if( tp.first == tree.end() )
{
status << "Map equal range lower key "
<< mp.first->first
<< ", but it was not found in the tree.\n";
dumpTree( tree, path );
return false;
}
if( mp.first->first != tp.first->first )
{
status << "Equal_range failed, lower map key "
<< mp.first->first
<< " does not match tree key "
<< tp.first->first
<< "\n";
dumpTree( tree, path );
return false;
}
if( mp.first->second != tp.first->second )
{
status << "Equal_range failed, lower map value "
<< mp.first->second
<< " does not match tree value "
<< tp.first->second << "\n";
dumpTree( tree, path );
return false;
}
}
if( mp.second != map.end() )
{
if( tp.second == tree.end() )
{ dumpTree( tree, path, "failed" );
status << "Map equal range upper key "
<< mp.second->first
<< ", but it was not found in the tree.\n";
dumpTree( tree, path );
return false;
}
if( mp.second->first != tp.second->first )
{
status << "Equal_range failed, upper map key "
<< mp.second->first
<< " does not match tree key "
<< tp.second->first
<< "\n";
dumpTree( tree, path );
return false;
}
if( mp.second->second != tp.second->second )
{
status << "Equal_range failed, upper map value "
<< mp.second->second
<< " does not match tree value "
<< tp.second->second << "\n";
dumpTree( tree, path );
return false;
}
}
break;
}
}
}
status << "Test Searching Passed.\n";
return true;
}
bool TestBTree::testIteration()
{
status << "Running Test Forward Iteration\n";
Map map;
Tree tree;
Vector vector( elements );
_init( vector );
for( unsigned int i = 0; i < iterations; ++i )
{
switch( random() % 2 )
{
case 0:
{
size_t index = random() % vector.size();
map.insert( std::make_pair( vector[ index ], i ) );
tree.insert( std::make_pair( vector[ index ], i ) );
break;
}
case 1:
{
size_t index = random() % vector.size();
Map::iterator mi = map.find( vector[ index ] );
Tree::iterator ti = tree.find( vector[ index ] );
if( mi != map.end() )
{
map.erase( mi );
tree.erase( ti );
}
break;
}
}
}
{
Map::iterator mi = map.begin();
Tree::iterator ti = tree.begin();
for( ; mi != map.end() && ti != tree.end(); ++mi, ++ti )
{
if( mi->first != ti->first )
{
status << "Forward iteration failed, map key " << mi->first
<< " does not match tree key " << ti->first << "\n";
dumpTree( tree, path );
return false;
}
if( mi->second != ti->second )
{
status << "Forward iteration failed, map value "
<< mi->second
<< " does not match tree value " << ti->second << "\n";
dumpTree( tree, path );
return false;
}
}
if( mi != map.end() )
{
status << "Forward iteration failed, map did not hit the end\n";
dumpTree( tree, path );
return false;
}
if( ti != tree.end() )
{
status << "Forward iteration failed, tree did not hit end\n";
dumpTree( tree, path );
return false;
}
}
{
Map::const_iterator mi = map.begin();
Tree::const_iterator ti = tree.begin();
for( ; mi != map.end() && ti != tree.end(); ++mi, ++ti )
{
if( mi->first != ti->first )
{
status << "Forward const iteration failed, map key "
<< mi->first
<< " does not match tree key " << ti->first << "\n";
dumpTree( tree, path );
return false;
}
if( mi->second != ti->second )
{
status << "Forward const iteration failed, map value "
<< mi->second
<< " does not match tree value " << ti->second << "\n";
dumpTree( tree, path );
return false;
}
}
if( mi != map.end() )
{
status << "Forward const iteration failed, map did "
<< "not hit the end\n";
dumpTree( tree, path );
return false;
}
if( ti != tree.end() )
{
status << "Forward const iteration failed, tree"
<< " did not hit end\n";
dumpTree( tree, path );
return false;
}
}
{
Map::reverse_iterator mi = map.rbegin();
Tree::reverse_iterator ti = tree.rbegin();
for( ; mi != map.rend() && ti != tree.rend(); ++mi, ++ti )
{
if( mi->first != ti->first )
{
status << "Reverse iteration failed, map key "
<< mi->first
<< " does not match tree key " << ti->first << "\n";
dumpTree( tree, path );
return false;
}
if( mi->second != ti->second )
{
status << "Reverse iteration failed, map value "
<< mi->second
<< " does not match tree value " << ti->second << "\n";
dumpTree( tree, path );
return false;
}
}
if( mi != map.rend() )
{
status << "Reverse iteration failed, map did "
<< "not hit the end\n";
dumpTree( tree, path );
return false;
}
if( ti != tree.rend() )
{
status << "Reverse iteration failed, tree"
<< " did not hit end\n";
dumpTree( tree, path );
return false;
}
}
{
Map::const_reverse_iterator mi = map.rbegin();
Tree::const_reverse_iterator ti = tree.rbegin();
for( ; mi != map.rend() && ti != tree.rend(); ++mi, ++ti )
{
if( mi->first != ti->first )
{
status << "Reverse const iteration failed, map key "
<< mi->first
<< " does not match tree key " << ti->first << "\n";
dumpTree( tree, path );
return false;
}
if( mi->second != ti->second )
{
status << "Reverse const iteration failed, map value "
<< mi->second
<< " does not match tree value " << ti->second << "\n";
dumpTree( tree, path );
return false;
}
}
if( mi != map.rend() )
{
status << "Reverse const iteration failed, map did "
<< "not hit the end\n";
dumpTree( tree, path );
return false;
}
if( ti != tree.rend() )
{
status << "Reverse const iteration failed, tree"
<< " did not hit end\n";
dumpTree( tree, path );
return false;
}
}
status << "Test Iteration Passed\n";
return true;
}
bool TestBTree::testClear()
{
status << "Running Test Clear\n";
Map map;
Tree tree;
Vector vector( elements );
_init( vector );
for( unsigned int i = 0; i < iterations; ++i )
{
switch( random() % 2 )
{
case 0:
{
size_t index = random() % vector.size();
map.insert( std::make_pair( vector[ index ], i ) );
tree.insert( std::make_pair( vector[ index ], i ) );
if( map.size() != tree.size() )
{
status << "Map size " << map.size()
<< " does not match tree size "
<< tree.size() << "\n";
dumpTree( tree, path );
return false;
}
break;
}
case 1:
{
size_t index = random() % vector.size();
Map::iterator mi = map.find( vector[ index ] );
Tree::iterator ti = tree.find( vector[ index ] );
if( mi != map.end() )
{
map.erase( mi );
tree.erase( ti );
if( map.size() != tree.size() )
{
status << "Map size " << map.size()
<< " does not match tree size "
<< tree.size() << "\n";
dumpTree( tree, path );
return false;
}
}
break;
}
}
}
map.clear();
tree.clear();
if( map.size() != tree.size() )
{
status << "Ater clear, map size " << map.size()
<< " does not match tree size "
<< tree.size() << "\n";
dumpTree( tree, path );
return false;
}
if( !tree.empty() )
{
status << "Ater clear, tree reported not empty\n";
dumpTree( tree, path );
return false;
}
for( unsigned int i = 0; i < iterations; ++i )
{
switch( random() % 2 )
{
case 0:
{
size_t index = random() % vector.size();
map.insert( std::make_pair( vector[ index ], i ) );
tree.insert( std::make_pair( vector[ index ], i ) );
if( map.size() != tree.size() )
{
status << "Map size " << map.size()
<< " does not match tree size "
<< tree.size() << "\n";
dumpTree( tree, path );
return false;
}
break;
}
case 1:
{
size_t index = random() % vector.size();
Map::iterator mi = map.find( vector[ index ] );
Tree::iterator ti = tree.find( vector[ index ] );
if( mi != map.end() )
{
map.erase( mi );
tree.erase( ti );
if( map.size() != tree.size() )
{
status << "Map size " << map.size()
<< " does not match tree size "
<< tree.size() << "\n";
dumpTree( tree, path );
return false;
}
}
break;
}
}
}
status << "Test Clear Passed\n";
return true;
}
bool TestBTree::testCopy()
{
status << "Running Test Copy\n";
Map map;
Tree tree;
Vector vector( elements );
_init( vector );
for( unsigned int i = 0; i < iterations; ++i )
{
switch( random() % 2 )
{
case 0:
{
size_t index = random() % vector.size();
map.insert( std::make_pair( vector[ index ], i ) );
tree.insert( std::make_pair( vector[ index ], i ) );
break;
}
case 1:
{
size_t index = random() % vector.size();
Map::iterator mi = map.find( vector[ index ] );
Tree::iterator ti = tree.find( vector[ index ] );
if( mi != map.end() )
{
map.erase( mi );
tree.erase( ti );
}
break;
}
}
}
Tree copy( tree );
{
Map::iterator mi = map.begin();
Tree::iterator ti = copy.begin();
for( ; mi != map.end() && ti != copy.end(); ++mi, ++ti )
{
if( mi->first != ti->first )
{
status << "Copy failed, map key " << mi->first
<< " does not match tree key " << ti->first
<< "\n";
dumpTree( copy, path );
return false;
}
if( mi->second != ti->second )
{
status << "Copy failed, map value "
<< mi->second
<< " does not match tree value " << ti->second
<< "\n";
dumpTree( copy, path );
return false;
}
}
}
copy.clear();
copy = tree;
{
Map::iterator mi = map.begin();
Tree::iterator ti = copy.begin();
for( ; mi != map.end() && ti != copy.end(); ++mi, ++ti )
{
if( mi->first != ti->first )
{
status << "Assign failed, map key " << mi->first
<< " does not match tree key " << ti->first << "\n";
dumpTree( copy, path );
return false;
}
if( mi->second != ti->second )
{
status << "Assign failed, map value "
<< mi->second
<< " does not match tree value " << ti->second << "\n";
dumpTree( copy, path );
return false;
}
}
}
status << " Test Copy Passed.\n";
return true;
}
bool TestBTree::testComparisons()
{
status << "Running Test Comparisons\n";
Map map, map1;
Tree tree, tree1;
Vector vector( elements );
_init( vector );
for( unsigned int i = 0; i < iterations; ++i )
{
switch( random() % 2 )
{
case 0:
{
size_t index = random() % vector.size();
map.insert( std::make_pair( vector[ index ], i ) );
tree.insert( std::make_pair( vector[ index ], i ) );
break;
}
case 1:
{
size_t index = random() % vector.size();
Map::iterator mi = map.find( vector[ index ] );
Tree::iterator ti = tree.find( vector[ index ] );
if( mi != map.end() )
{
map.erase( mi );
tree.erase( ti );
}
break;
}
}
}
for( unsigned int i = 0; i < iterations; ++i )
{
switch( random() % 2 )
{
case 0:
{
size_t index = random() % vector.size();
map1.insert( std::make_pair( vector[ index ], i ) );
tree1.insert( std::make_pair( vector[ index ], i ) );
break;
}
case 1:
{
size_t index = random() % vector.size();
Map::iterator mi = map1.find( vector[ index ] );
Tree::iterator ti = tree1.find( vector[ index ] );
if( mi != map1.end() )
{
map1.erase( mi );
tree1.erase( ti );
}
break;
}
}
}
bool mapResult;
bool treeResult;
mapResult = map == map1;
treeResult = tree == tree1;
if( mapResult != treeResult )
{
status << "For comparison ==, map result " << mapResult
<< " does not match tree result " << treeResult << "\n";
dumpTree( tree, path, "failed" );
dumpTree( tree1, path, "failed1" );
return false;
}
mapResult = map != map1;
treeResult = tree != tree1;
if( mapResult != treeResult )
{
status << "For comparison !=, map result " << mapResult
<< " does not match tree result " << treeResult << "\n";
dumpTree( tree, path, "failed" );
dumpTree( tree1, path, "failed1" );
return false;
}
mapResult = map < map1;
treeResult = tree < tree1;
if( mapResult != treeResult )
{
status << "For comparison <, map result " << mapResult
<< " does not match tree result " << treeResult << "\n";
dumpTree( tree, path, "failed" );
dumpTree( tree1, path, "failed1" );
return false;
}
mapResult = map <= map1;
treeResult = tree <= tree1;
if( mapResult != treeResult )
{
status << "For comparison <=, map result " << mapResult
<< " does not match tree result " << treeResult << "\n";
dumpTree( tree, path, "failed" );
dumpTree( tree1, path, "failed1" );
return false;
}
mapResult = map > map1;
treeResult = tree > tree1;
if( mapResult != treeResult )
{
status << "For comparison >, map result " << mapResult
<< " does not match tree result " << treeResult << "\n";
dumpTree( tree, path, "failed" );
dumpTree( tree1, path, "failed1" );
return false;
}
mapResult = map >= map1;
treeResult = tree >= tree1;
if( mapResult != treeResult )
{
status << "For comparison >=, map result " << mapResult
<< " does not match tree result " << treeResult << "\n";
dumpTree( tree, path, "failed" );
dumpTree( tree1, path, "failed1" );
return false;
}
status << "Test Comparison Passed\n";
return true;
}
// add extra axioms for equality, etc.
int
addextraaxioms()
{
// check phases to run
if (!phases[EXPANDFILE] || !phases[PARSEFILE] ||
!phases[ADDEXTRAAXIOMS])
{
cout << endl;
cout << "Skipping adding extra axioms." << endl;
return(OK);
}
// check if program uses equality
if (equality)
{
// verbose message
if (verbose)
{
cout << endl;
cout << "Equality found in program ..." << endl;
}
// check if paramodulation is in use
if (paramodulation)
{
// verbose message
if (verbose)
{
cout << endl;
cout << "Paramodulation is active ..." << endl;
}
// add functionally reflexive axioms
if (addreflexiveaxioms() != OK)
{
ERROR("add reflexive axioms failed.", errno);
return(NOTOK);
}
}
else
{
// verbose message
if (verbose)
{
cout << endl;
cout << "Axiomatizing equality ..." << endl;
}
// axiomatize equality
if (addequalityaxioms() != OK)
{
ERROR("add equality axioms failed.", errno);
return(NOTOK);
}
}
if (verbose)
{
cout << endl;
cout << "Dumping parse tree after adding extra axioms ..." << endl;
dumpTree();
}
}
// all done
return(OK);
}
