///////////////////////////////////////////////////////////////
//  TestMTQwNP.cpp -test mtqueue with node pool              //
//  ver 1.0                                                  //
//  Language:       Visual C++, ver 6.0                      //
//  Platform:       Micron Dual Pentium Pro 200, Win NT 4.0  //
//  Application:    Demo for CSE691, Pr#3, Fall 98           //
//  Author:         Jim Fawcett, CST 2-187, Syracuse Univ.   //
//                  (315) 443-3948, fawcett@ecs.syr.edu      //
///////////////////////////////////////////////////////////////
//  Operations:                                              //
///////////////////////////////////////////////////////////////
//  This program enqueues a large number of values, then     //
//  dequeues them, which should put all the dequeued nodes   //
//  in the node pool.  Then all values are queued back up    //
//  which should remove all the nodes from the node pool     //
//  and put them back on the queue.                          //
//                                                           //
///////////////////////////////////////////////////////////////
//  Build Process                                            //
///////////////////////////////////////////////////////////////
//  Files Required:                                          //
//    TestNTQwNP.cpp, nodePool.h, mtqueue.h                  //
//                                                           //
//  Compiler Command:                                        //
//    cl /GX /D "_X86_" TestMTQwNP.cpp                       //
//                                                           //
///////////////////////////////////////////////////////////////

#include <iostream>
#include "mtqueue.h"
#include "timer.h"
using namespace std;

//

void main() {

  cout << "\n  Testing mtqueue with node pool "
       << "\n ================================\n";


  cout << "\n  Testing queued values "
       << "\n -----------------------\n";

  mtqueue<int> mtq;

  int i, numQs = 7;
  cout << "\n  ";
  for(i=0; i<numQs-2; i++) {
    cout << "enQing " << i;
    mtq.enQ(i);
    if(i != numQs-3)
      cout << ", ";
  }

  cout << "\n  " << "deQing " << mtq.deQ() << ", ";
  cout << "deQing " << mtq.deQ() << ", ";
  cout << "deQing " << mtq.deQ();
  
  cout << "\n  " << "enQing " << numQs-2 << ", ";
  mtq.enQ(numQs-2); 
  cout << "enQing " << numQs-1;
  mtq.enQ(numQs-1);

  cout << "\n  head of queue has value = " << mtq.peekHead();
  cout << "\n  tail of queue has value = " << mtq.peekTail();
  cout << "\n  ";

  while(mtq.length() > 0) {
    cout << "deQing " << mtq.deQ();
    if(mtq.length() > 0)
      cout << ", ";
  }
  cout << endl;

//

  cout << "\n  Testing node pool stores and retrieves "
       << "\n ----------------------------------------\n";

  timer t;
  const int NumTimes = 500000;

  cout << "\n ---------------------------------------------"
       << "\n  enQueuing a large number of items "
       << "\n  should fill queue but leave node pool empty"
       << "\n ---------------------------------------------\n";

  t.start();
  for(i=0; i<NumTimes; i++)
    mtq.enQ(i);
  t.stop();

  cout << "\n  size of queue          = " << mtq.length();
  cout << "\n  size of free node pool = " << mtq.freeLength();
  cout << "\n  elapsed time           = " << t.elapsed();
  cout << "\n\n";

  cout << "\n --------------------------------------------"
       << "\n  deQueuing until queue is empty "
       << "\n  should fill node pool while emptying queue"
       << "\n --------------------------------------------\n";

  t.start();
  for(i=0; i<NumTimes; i++)
    mtq.deQ();
  t.stop();

  cout << "\n  size of queue          = " << mtq.length();
  cout << "\n  size of free node pool = " << mtq.freeLength();
  cout << "\n  elapsed time           = " << t.elapsed();
  cout << "\n\n";

  cout << "\n --------------------------------------------"
       << "\n  enQueuing a large number of items "
       << "\n  should fill queue while emptying node pool "
       << "\n --------------------------------------------\n";

  t.start();
  for(i=0; i<NumTimes; i++)
    mtq.enQ(i);
  t.stop();

  cout << "\n  size of queue          = " << mtq.length();
  cout << "\n  size of free node pool = " << mtq.freeLength();
  cout << "\n  elapsed time           = " << t.elapsed();
  cout << "\n\n";

//

  cout << "\n --------------------------------------------"
       << "\n  deQueuing half of previous items "
       << "\n  should leave queue and pool with same size"
       << "\n --------------------------------------------\n";

  t.start();
  for(i=0; i<NumTimes/2; i++)
    mtq.deQ();
  t.stop();

  cout << "\n  size of queue          = " << mtq.length();
  cout << "\n  size of free node pool = " << mtq.freeLength();
  cout << "\n  count()                = " << mtq.nodeCount();
  cout << "\n  elapsed time           = " << t.elapsed();
  cout << "\n\n";

  cout << "\n --------------------------------------------"
       << "\n  flushing the node pool"
       << "\n --------------------------------------------\n";

  mtq.flushNP();
  cout << "\n  size of queue          = " << mtq.length();
  cout << "\n  size of free node pool = " << mtq.freeLength();
  cout << "\n  count()                = " << mtq.nodeCount();
  cout << "\n\n";

  cout << "\n --------------------------------------------"
       << "\n  flushing the queue"
       << "\n --------------------------------------------\n";

  mtq.flush();
  cout << "\n  size of queue          = " << mtq.length();
  cout << "\n  size of free node pool = " << mtq.freeLength();
  cout << "\n  count()                = " << mtq.nodeCount();
  cout << "\n\n";

  cout << "\n --------------------------------------------"
       << "\n  flushing the node pool again"
       << "\n --------------------------------------------\n";

  mtq.flushNP();
  cout << "\n  size of queue          = " << mtq.length();
  cout << "\n  size of free node pool = " << mtq.freeLength();
  cout << "\n  count()                = " << mtq.nodeCount();
  cout << "\n\n";

}