#define BOOST_TEST_MODULE  StackTest 
#include <boost/test/unit_test.hpp>
#include <boost/test/included/unit_test.hpp>

#include "StackT.h"

using namespace std;

char RandLetter() {
   int offset = rand() % 26;
   char letter = static_cast<char>('A'+offset);
   if (rand()%2 == 0) {
       letter = static_cast<char>(tolower(letter));
   } 

   return letter;
}

BOOST_AUTO_TEST_SUITE(NON_COPY_CONSTRUCTOR_BASED)

BOOST_AUTO_TEST_CASE(Constructor_Test){
    StackT s;

    BOOST_TEST(s.Size() == 0);
    BOOST_TEST(s.IsEmpty());
}

BOOST_AUTO_TEST_CASE(Push_Test_1) {
    StackT s;

    s.Push('A');
    BOOST_TEST(s.Top() == 'A');
    BOOST_TEST(s.Size() == 1);
    BOOST_TEST(not s.IsEmpty());

    s.Pop();
    BOOST_TEST(s.Size() == 0);
    BOOST_TEST(s.IsEmpty());

}

BOOST_AUTO_TEST_CASE(Push_Test_2) {
    StackT s;

    s.Push('A');
    s.Push('B');
    BOOST_TEST(s.Top() == 'B');
    BOOST_TEST(s.Size() == 2);
    BOOST_TEST(not s.IsEmpty());

    s.Pop();
    BOOST_TEST(s.Top() == 'A');
    BOOST_TEST(s.Size() == 1);
    BOOST_TEST(not s.IsEmpty());

    s.Pop();
    BOOST_TEST(s.Size() == 0);
    BOOST_TEST(s.IsEmpty());
}

BOOST_AUTO_TEST_SUITE_END()

BOOST_AUTO_TEST_SUITE(COPY_CONSTRUCTOR_BASED)

void CheckStack(StackT stack,  vector<char> standard ) {

    BOOST_TEST_REQUIRE(stack.Size() ==  standard.size());

    while (stack.Size() > 0) {
       BOOST_TEST(stack.Top() == standard.back());
       stack.Pop();
       standard.pop_back();
    }

    BOOST_TEST(stack.Size() == 0);
    BOOST_TEST(stack.IsEmpty());
}

BOOST_AUTO_TEST_CASE(STATIC_TEST) {
    int i,j;

    for(i =0; i <= 10; i ++) {
       cout << "I = " << i << endl;
       StackT s, t;
       vector<char> v;

       for (j = 0; j<i ; j++) {
          s.Push(static_cast<char>(j+'A'));
          v.push_back(static_cast<char>(j+'A'));
       }
       CheckStack(s,v);
       BOOST_TEST(s.Size() == i);

       t = s;
       CheckStack(s,v);
       CheckStack(t,v);
       BOOST_TEST(s.Size() == i);

       s = s;
       CheckStack(s,v);
       BOOST_TEST(s.Size() == i);

       StackT u(s);
       CheckStack(s,v);
       CheckStack(u,v);

    }
}

const int MAX_TESTS = 100;

BOOST_AUTO_TEST_CASE(RANDOM_TEST) {
     int testCount;
     int i;
     int action;

     char letter;
     int size;

     for (testCount = 0; testCount < MAX_TESTS; testCount++) {
        StackT s;
        vector<char> v;

        size = rand() % 500;

        for(i = 0; i < size; i++) {
            action = rand() % 2;
            switch(action) {
               case 0: // push an item
                  letter = RandLetter();
                  v.push_back(letter);
                  s.Push( letter);
                  break;
               case 1: // pop an item
                  if (s.Size() > 0) {
                     v.pop_back();
                     s.Pop();
                  }
            }
            CheckStack(s,v);
        }
     }
}

BOOST_AUTO_TEST_SUITE_END()