// A unit test for the Midterm #1 Langara CPSC 2150 fall 2018
// Author: Gladys Monagan
// version: October 12, 2018
/* thanks to the following link for helping me catch exceptions:
https://stackoverflow.com/questions/47583352/how-to-catch-segmentation-fault-with-google-test
*/

#define HAS_SEGMENTATION_FAULTS

#include "deque.h"
#include "gtest/gtest.h"
#include <string.h>

using std::string;

const int PILES = 100; // 10000;


// helper function to print custom error message
string COUT_ERROR(string e) {
  return "[    ERROR ] " + e;
}

TEST(constructorTest, DefaultConstructor) {
   Deque deque;
   EXPECT_EQ("[]", deque.stringFrontToBack()) <<
      COUT_ERROR("the constructor should have made an empty deque");
}

// empty tests
TEST(isEmptyTest, NewDeque) {
   Deque deque;
   EXPECT_TRUE(deque.isEmpty()) <<
      COUT_ERROR("A new deque should be empty");
}
TEST(isEmptyTest, WithOneElementAddedAndRemovedFF) {
   Deque deque;
   deque.pushFront('a');
   deque.popFront();
   EXPECT_TRUE(deque.isEmpty()) <<
      COUT_ERROR("after one pushFront and one popFront deque should be empty");
}

TEST(isEmptyTest, WithOneElementAddedAndRemovedFB) {
   Deque deque;
   deque.pushFront('a');
   deque.popBack();
   EXPECT_TRUE(deque.isEmpty()) <<
      COUT_ERROR("after one pushFront and one popBack deque should be empty");
}
TEST(isEmptyTest, WithOneElementAddedAndRemovedBB) {
   Deque deque;
   deque.pushBack('a');
   deque.popBack();
   EXPECT_TRUE(deque.isEmpty()) <<
      COUT_ERROR("after one pushBack and one popBack deque should be empty");
}

TEST(isEmptyTest, WithOneElementAddedAndRemovedBF) {
   Deque deque;
   deque.pushBack('a');
   deque.popFront();
   EXPECT_TRUE(deque.isEmpty()) <<
      COUT_ERROR("after one pushBack and one popFront deque should be empty");
}

TEST(isEmptyTest, SeveralElementAddedAndRemovedFFFF) {
   Deque deque;
   deque.pushFront('a');
   deque.pushFront('b');
   deque.popFront();
   deque.popFront();
   deque.pushFront('c');
   deque.popFront();
   deque.pushFront('d');
   deque.popFront();
   EXPECT_TRUE(deque.isEmpty()) <<
      COUT_ERROR("after 4  pushFronts and 4 popFronts,the queue should be empty");
}
TEST(isEmptyTest, SeveralElementAddedAndRemovedBBBB) {
   Deque deque;
   deque.pushBack('a');
   deque.popBack();
   deque.pushBack('b');
   deque.popBack();
   deque.pushBack('c');
   deque.popBack();
   EXPECT_TRUE(deque.isEmpty()) <<
      COUT_ERROR("after 3 pushBacks and 3 popBacks, the queue should be empty");
}
TEST(pushFrontTest, OneElement) {
   Deque deque;
   deque.pushFront('x');
   EXPECT_EQ("[x]", deque.stringFrontToBack()) <<
      COUT_ERROR("'x' was pushFronted onto an empty deque");
}
TEST(pushFrontTest, TwoElements) {
   Deque deque;
   deque.pushFront('z');
   deque.pushFront('y');
   EXPECT_EQ("[yz]", deque.stringFrontToBack()) <<
      COUT_ERROR("'z' and 'y' were pushFronted onto an empty deque");
}
TEST(pushFrontTest, ThreeElements) {
   Deque deque;
   deque.pushFront('z');
   deque.pushFront('y');
   deque.pushFront('x');
   EXPECT_EQ("[xyz]", deque.stringFrontToBack()) <<
      COUT_ERROR("'z', 'y', 'x' were pushFronted onto an empty deque");
}
TEST(pushFrontTest, PilesOfElements) {
   Deque deque;
   for (int i = 0; i < PILES; i++)
      deque.pushFront('x');
   while (!deque.isEmpty()) {
      //ASSERT_EXIT((deque.popFront(),exit(0)),::testing::ExitedWithCode(0),".*");
      deque.popFront();
   }
}
TEST(pushBackTest, OneElement) {
   Deque deque;
   deque.pushBack('a');
   EXPECT_EQ("[a]", deque.stringFrontToBack()) <<
      COUT_ERROR("'a' was pushBacked onto an empty deque");
}
TEST(pushBackTest, TwoElements) {
   Deque deque;
   deque.pushBack('a');
   deque.pushBack('b');
   EXPECT_EQ("[ab]", deque.stringFrontToBack()) <<
      COUT_ERROR("'a' and 'b' were pushBacked onto an empty deque");
}
TEST(pushBackTest, ThreeElements) {
   Deque deque;
   deque.pushBack('a');
   deque.pushBack('b');
   deque.pushBack('c');
   EXPECT_EQ("[abc]", deque.stringFrontToBack()) <<
      COUT_ERROR("'a', 'b', 'c' were pushBacked onto an empty deque");
}
TEST(pushBackTest, PilesOfElements) {
   Deque deque;
   for (int i = 0; i < PILES; i++)
      deque.pushBack('x');
   while (!deque.isEmpty()) {
      //ASSERT_EXIT((deque.popBack(),exit(0)),::testing::ExitedWithCode(0),".*");
      deque.popBack();
   }
}

TEST(pushFrontTest, PilesOfElementsFBF) {
   Deque deque;
   for (int i = 0; i < PILES; i++) {
      deque.pushFront('x');
      deque.pushBack('a');
   }
   while (!deque.isEmpty()) {
      //ASSERT_EXIT((deque.popFront(),exit(0)),::testing::ExitedWithCode(0),".*");
      deque.popFront();
   }
}
TEST(pushFrontTest, PilesOfElementsFBFB) {
   Deque deque;
   for (int i = 0; i < PILES; i++) {
      deque.pushFront('x');
      deque.pushBack('a');
   }
   while (!deque.isEmpty()) {
      //ASSERT_EXIT((deque.popFront(),exit(0)),::testing::ExitedWithCode(0),".*");
      deque.popFront();
      deque.popBack();
   }
}
TEST(pushFrontTest, PilesOfElementsBFB) {
   Deque deque;
   for (int i = 0; i < PILES; i++) {
      deque.pushBack('a');
   }
   for (int i = 0; i < PILES; i++) {
      deque.pushFront('a');
   }
   while (!deque.isEmpty()) {
      //ASSERT_EXIT((deque.popFront(),exit(0)),::testing::ExitedWithCode(0),".*");
      deque.popBack();
   }
}

TEST(pushFrontBackTest, LeaveOneElementFront) {
   Deque deque;
   deque.pushFront('b');
   deque.pushFront('a');
   ASSERT_EQ("[ab]", deque.stringFrontToBack()) <<
      COUT_ERROR("pushFront('b') pushFront('a')");
   EXPECT_EQ('a', deque.popFront())  <<
      COUT_ERROR("pushFront('b') pushFront('a') popFront()");
   EXPECT_EQ('b', deque.popFront())   <<
      COUT_ERROR("pushFront('b') pushFront('a') popFront() popFront()");
   EXPECT_EQ("[]", deque.stringFrontToBack()) <<
      COUT_ERROR("pushFront('b') pushFront('a') popFront() popFront()");
   deque.pushBack('x');
   EXPECT_EQ("[x]", deque.stringFrontToBack()) <<
      COUT_ERROR("pushFront('b') pushFront('a') popFront() popFront() pushBack('x')");
   EXPECT_EQ('x', deque.popFront())   <<
      COUT_ERROR("last element of queue");
}
TEST(pushFrontBackTest, LeaveOneElementBack) {
   Deque deque;
   deque.pushBack('b');
   deque.pushFront('a');
   ASSERT_EQ("[ab]", deque.stringFrontToBack()) <<
      COUT_ERROR("pushBack('b') pushFront('a')");
   EXPECT_EQ('b', deque.popBack())  <<
      COUT_ERROR("pushBack('b') pushFront('a') popBack()");
   EXPECT_EQ('a', deque.popBack())   <<
      COUT_ERROR("pushBack('b') pushFront('a') popBack() popBack()");
   EXPECT_EQ("[]", deque.stringFrontToBack()) <<
      COUT_ERROR("pushBack('b') pushFront('a') popBack() popBack()");
   deque.pushFront('x');
   EXPECT_EQ("[x]", deque.stringFrontToBack()) <<
      COUT_ERROR("pushFront('b') pushFront('a') popBack() popBack() pushBack('x')");
   EXPECT_EQ('x', deque.popFront())   <<
      COUT_ERROR("last element of queue");
}
TEST(pushFrontBackTest, ThreeElementsFBF) {
   Deque deque;
   deque.pushFront('b');
   deque.pushBack('c');
   deque.pushFront('a');
   EXPECT_EQ("[abc]", deque.stringFrontToBack()) <<
      COUT_ERROR("pushF('b') pushB('c') pushF('a')");
}
TEST(pushFrontBackTest, ThreeElementsBBF) {
   Deque deque;
   deque.pushBack('b');
   deque.pushBack('c');
   deque.pushFront('a');
   EXPECT_EQ("[abc]", deque.stringFrontToBack()) <<
      COUT_ERROR("pushB('b') pushB('c') pushF('a')");
}
TEST(pushFrontBackTest, ThreeElementsFFB) {
   Deque deque;
   deque.pushFront('b');
   deque.pushFront('a');
   deque.pushBack('c');
   EXPECT_EQ("[abc]", deque.stringFrontToBack()) <<
      COUT_ERROR("pushF('b') pushF('a') pushB('c')");
}
TEST(pushFrontBackTest, SeveralElementsFFBFB) {
   Deque deque;
   deque.pushFront('c');
   deque.pushFront('b');
   deque.pushBack('d');
   deque.pushFront('a');
   deque.pushBack('e');
   EXPECT_EQ("[abcde]", deque.stringFrontToBack()) <<
      COUT_ERROR("pushF('c') pushF('b') pushB('d') pushF('a') pushB('e')");
}
TEST(pushFrontBackTest, SeveralElementsBFBFB) {
   Deque deque;
   deque.pushBack('c');
   deque.pushFront('b');
   deque.pushBack('d');
   deque.pushFront('a');
   deque.pushBack('e');
   EXPECT_EQ("[abcde]", deque.stringFrontToBack()) <<
      COUT_ERROR("pushB('c') pushF('b') pushB('d') pushF('a') pushB('e')");
}
TEST(pushFrontBackTest, SeveralElementsBFFBF) {
   Deque deque;
   deque.pushBack('d');
   deque.pushFront('c');
   deque.pushFront('b');
   deque.pushBack('e');
   deque.pushFront('a');
   EXPECT_EQ("[abcde]", deque.stringFrontToBack()) <<
      COUT_ERROR("pushB('d') pushF('c') pushF('b') pushB('e') pushF('a')");
}

TEST(popFrontTest, OneElementF) {
   Deque deque;
   deque.pushFront('x');
   EXPECT_EQ('x', deque.popFront())  <<
      COUT_ERROR("pushFront('x') and then popFront()");
}
TEST(popFrontTest, OneElementB) {
   Deque deque;
   deque.pushBack('a');
   EXPECT_EQ('a', deque.popFront())  <<
      COUT_ERROR("pushBack('x') and then popFront()");
}
TEST(popFrontTest, ManyElementsBF) {
   Deque deque;
   for (char ch = 'A'; ch <= 'Z'; ch++) {
      deque.pushBack(ch);
   }
   for (char ch = 'A'; ch <= 'Z'; ch++) {
      EXPECT_EQ(ch, deque.popFront())  <<
         COUT_ERROR("after pushBack of the letter popFront() failed");
   }
}
TEST(popFrontTest, ManyElementsFF) {
   Deque deque;
   for (char ch = 'A'; ch <= 'Z'; ch++) {
      deque.pushFront(ch);
   }
   for (char ch = 'Z'; ch <= 'A'; ch--) {
      EXPECT_EQ(ch, deque.popFront())  <<
         COUT_ERROR("after pushBack of the letter popFront() failed");
   }
}

TEST(popBackTest, OneElementFB) {
   Deque deque;
   deque.pushFront('x');
   EXPECT_EQ('x', deque.popBack())  <<
      COUT_ERROR("pushFront('x') and then popBack()");
}
TEST(popBackTest, OneElementBB) {
   Deque deque1;
   deque1.pushBack('a');
   EXPECT_EQ('a', deque1.popBack())  <<
      COUT_ERROR("pushBack('x') and then popBack()");
}
TEST(popBackTest, ManyElementsBB) {
   Deque deque;
   for (char ch = 'A'; ch <= 'Z'; ch++) {
      deque.pushBack(ch);
   }
   for (char ch = 'Z'; ch <= 'A'; ch--) {
      EXPECT_EQ(ch, deque.popBack())  <<
         COUT_ERROR("after pushBack of the letter popBack() failed");
   }
}
TEST(popBackTest, ManyElementsFB) {
   Deque deque;
   for (char ch = 'A'; ch <= 'Z'; ch++) {
      deque.pushFront(ch);
   }
   for (char ch = 'A'; ch <= 'Z'; ch++) {
      EXPECT_EQ(ch, deque.popBack())  <<
         COUT_ERROR("after pushBack of the letter popBack() failed");
   }
}

TEST(copyConstructorTest, EmptyDeque) {
   Deque deque;
   Deque otherDeque = deque;
   EXPECT_EQ(
      deque.stringFrontToBack(),
      otherDeque.stringFrontToBack()) <<
         COUT_ERROR("failed to copy an empty deque properly");
}
TEST(copyConstructorTest, DequeWithElements) {
   Deque deque;
   deque.pushFront('d');
   deque.pushFront('c');
   deque.pushFront('b');
   deque.pushFront('a');
   ASSERT_EQ("[abcd]", deque.stringFrontToBack()) <<
      COUT_ERROR("deque was not constructed properly");
   Deque copiedDeque = deque;
   EXPECT_EQ(
      deque.stringFrontToBack(),
      copiedDeque.stringFrontToBack()) <<
         COUT_ERROR("failed to copy construct the deque properly");
   // modify original deque which should then be different from copiedDeque's
   deque.popBack();
   deque.popBack();
   deque.popBack();
   deque.popBack();
   deque.pushBack('x');
   EXPECT_NE(
      deque.stringFrontToBack(),
      copiedDeque.stringFrontToBack()) <<
         COUT_ERROR("copy constructor of deque was not done properly");
   copiedDeque.popBack();
   copiedDeque.popBack();
   copiedDeque.popBack();
   copiedDeque.popBack();
   copiedDeque.pushFront('x');
   EXPECT_EQ(
      deque.stringFrontToBack(),
      copiedDeque.stringFrontToBack()) <<
         COUT_ERROR("after copy constructor deques constructed properly");
}

TEST(copyConstructorTest, DequesWithDifferentScopes) {
   Deque deque;
   deque.pushBack('a');
   deque.pushBack('b');
   deque.pushBack('c');
   deque.pushBack('d');
   ASSERT_EQ("[abcd]", deque.stringFrontToBack()) <<
      COUT_ERROR("deque was not constructed properly");
   {
      Deque innerDeque(deque);
      EXPECT_EQ(
         deque.stringFrontToBack(),
         innerDeque.stringFrontToBack()) <<
            COUT_ERROR("after assignment, the deques have the same values");
      // presumably the destructor is called here, innerDeque goes out of scope
   }
   EXPECT_EQ("[abcd]", deque.stringFrontToBack()) <<
      COUT_ERROR("error after the deque it was copied from goes out of scope");
}

TEST(overloadedAssignmentOperatorTest, EmptyDeque) {
   Deque deque;
   Deque otherDeque;
   deque = otherDeque;
   EXPECT_EQ(
      deque.stringFrontToBack(),
      otherDeque.stringFrontToBack()) <<
         COUT_ERROR("failed to assign an empty deque properly");
}
TEST(overloadedAssignmentOperatorTest, DequeWithOneElement) {
   Deque deque;
   deque.pushFront('j');
   ASSERT_EQ("[j]", deque.stringFrontToBack()) <<
      COUT_ERROR("original deque was not constructed properly");

   Deque rtSideDeque;
   rtSideDeque.pushFront('a');
   ASSERT_EQ("[a]", rtSideDeque.stringFrontToBack()) <<
      COUT_ERROR("rtSideDeque was not constructed properly");

   ASSERT_NE(deque.stringFrontToBack(), rtSideDeque.stringFrontToBack()) <<
      COUT_ERROR("both deques should be different before the overloaded assignment");

   deque = rtSideDeque;
   EXPECT_EQ(deque.stringFrontToBack(), rtSideDeque.stringFrontToBack()) <<
      COUT_ERROR("both deques should have the same values");
   EXPECT_EQ('a', rtSideDeque.popFront()) <<
      COUT_ERROR("a should have popped from the rtSide");
   ASSERT_NE(deque.stringFrontToBack(), rtSideDeque.stringFrontToBack()) <<
      COUT_ERROR("both deques should be different after popping from rtSide deque");
}

TEST(overloadedAssignmentOperatorTest, DequeWithElements) {
   Deque deque;
   deque.pushFront('j');
   deque.pushBack('k');
   ASSERT_EQ("[jk]", deque.stringFrontToBack()) <<
      COUT_ERROR("original deque was not constructed properly");

   Deque rtSideDeque;
   rtSideDeque.pushFront('a');
   rtSideDeque.pushBack('b');
   rtSideDeque.pushBack('c');
   rtSideDeque.pushBack('d');
   ASSERT_EQ("[abcd]", rtSideDeque.stringFrontToBack()) <<
      COUT_ERROR("rtSideDeque was not constructed properly");

   ASSERT_NE(deque.stringFrontToBack(), rtSideDeque.stringFrontToBack()) <<
      COUT_ERROR("both deques should be different before the overloaded assignment");

   deque = rtSideDeque;
   EXPECT_EQ("[abcd]", rtSideDeque.stringFrontToBack()) <<
      COUT_ERROR("in deque = rtSideDeque both deques should have stayed the same values");
   EXPECT_EQ("[abcd]", deque.stringFrontToBack()) <<
      COUT_ERROR("deque = rtSideDeque failed");
   EXPECT_EQ(deque.stringFrontToBack(), rtSideDeque.stringFrontToBack()) <<
      COUT_ERROR("both deques should have the same values");
   // modify deques one at a time
   rtSideDeque.popFront();
   rtSideDeque.popFront();
   EXPECT_NE(deque.stringFrontToBack(), rtSideDeque.stringFrontToBack()) <<
      COUT_ERROR("both deques should be different from poping from one deque");
   deque.popFront();
   deque.popFront();
   EXPECT_EQ(deque.stringFrontToBack(), rtSideDeque.stringFrontToBack()) <<
      COUT_ERROR("both deques should have the same values");
}

TEST(overloadedAssignmentOperatorTest, DequesWithDifferentScopes) {
   Deque deque;
   deque.pushFront('d');
   deque.pushFront('c');
   deque.pushFront('b');
   deque.pushFront('a');
   ASSERT_EQ("[abcd]", deque.stringFrontToBack()) <<
      COUT_ERROR("deque was not constructed properly");
   {
      Deque innerDeque;
      innerDeque.pushFront('z');
      innerDeque.pushFront('y');
      innerDeque.pushFront('x');
      ASSERT_EQ("[xyz]", innerDeque.stringFrontToBack()) <<
         COUT_ERROR("deque was not constructed properly");
      deque = innerDeque;
      EXPECT_EQ(
         deque.stringFrontToBack(),
         innerDeque.stringFrontToBack()) <<
            COUT_ERROR("after assignment, the deques have the same values");
      // presumably the destructor is called here, innerDeque goes out of scope
   }
   EXPECT_EQ("[xyz]", deque.stringFrontToBack()) <<
      COUT_ERROR("a deep copy seems to not have occurred");
}


TEST(destructorTest, EmptyDeque) {
   {
      Deque deque;
      ASSERT_TRUE(deque.isEmpty()) <<
         COUT_ERROR("should be empty => destructor test aborted");
      // ~Deque called
   }
   Deque deque;
   EXPECT_TRUE(deque.isEmpty()) <<
      COUT_ERROR("the destructor should have returned the memory");
}

TEST(destructorTest, DequeWithElements) {
   {
      Deque deque;
      deque.pushFront('c');
      deque.pushFront('b');
      deque.pushFront('a');
      ASSERT_FALSE(deque.isEmpty()) <<
         COUT_ERROR("should be [ a b c ] => destructor test aborted");
      // ~Deque called
   }
   Deque deque;
   EXPECT_TRUE(deque.isEmpty()) <<
      COUT_ERROR("the destructor should have returned the memory");
}

TEST(destructorTest, WithPointer) {
   Deque* p = new Deque;
   ASSERT_TRUE(p->isEmpty())  <<
      COUT_ERROR("deque pointed to should be empty => destructor test aborted");
   p->pushFront('s');
   p->pushFront('r');
   p->pushFront('q');
   p->pushFront('p');
   p->pushFront('o');
   delete p;
   p = new Deque;
   EXPECT_TRUE(p->isEmpty())  <<
      COUT_ERROR("deque pointed to should be empty");
   delete p;
}

#ifdef HAS_SEGMENTATION_FAULTS
TEST(popFrontThrowsTest, ThrowExceptionWhenEmpty) {
   Deque deque;
   ASSERT_EXIT((deque.popFront(),exit(0)),::testing::ExitedWithCode(0),".*");
}

TEST(popBackThrowsTest, ThrowExceptionWhenEmpty) {
   Deque deque;
   ASSERT_EXIT((deque.popBack(),exit(0)),::testing::ExitedWithCode(0),".*");
}

TEST(popBackThrowsTest, OneElementPoppedF) {
   Deque deque;
   deque.pushFront('x');
   EXPECT_EQ('x', deque.popBack())  <<
      COUT_ERROR("pushFront('x') and then popBack()");
   ASSERT_EXIT((deque.popBack(), exit(0)),::testing::ExitedWithCode(0),".*");
}

TEST(popBackThrowsTest, OneElementPoppedB) {
   Deque deque;
   deque.pushBack('x');
   EXPECT_EQ('x', deque.popBack())  <<
      COUT_ERROR("pushFront('x') and then popBack()");
   ASSERT_EXIT((deque.popBack(), exit(0)),::testing::ExitedWithCode(0),".*");
}

TEST(popFrontThrowsTest, OneElementPoppedF) {
   Deque deque;
   deque.pushFront('x');
   EXPECT_EQ('x', deque.popFront())  <<
      COUT_ERROR("pushFront('x') and then popFront()");
   ASSERT_EXIT((deque.popFront(),exit(0)),::testing::ExitedWithCode(0),".*le");
}

TEST(popFrontThrowsTest, OneElementPoppedB) {
   Deque deque;
   deque.pushBack('x');
   EXPECT_EQ('x', deque.popFront())  <<
      COUT_ERROR("pushFront('x') and then popFront()");
   ASSERT_EXIT((deque.popFront(),exit(0)),::testing::ExitedWithCode(0),".*le");
}

#else
TEST(popFrontThrowsTest, ThrowExceptionWhenEmpty) {
   Deque deque;
   EXPECT_THROW(deque.popFront(), DequeException) <<
      COUT_ERROR("the deque is empty so popFront is not possible");
}
TEST(popBackThrowsTest, ThrowExceptionWhenEmpty) {
   Deque deque;
   EXPECT_THROW(deque.popBack(), DequeException) <<
      COUT_ERROR("the deque is empty so popBack is not possible");
}

TEST(popBackThrowsTest, ThrowExceptionAfterPoppingSinceEmptyF) {
   Deque deque;
   deque.pushFront('x');
   EXPECT_EQ('x', deque.popBack())  <<
      COUT_ERROR("pushFront('x') and then popBack()");
   EXPECT_THROW(deque.popBack(), DequeException) <<
      COUT_ERROR("the deque is empty so popBack is not possible");
}

TEST(popBackThrowsTest, ThrowExceptionAfterPoppingSinceEmptyB) {
   Deque deque;
   deque.pushBack('x');
   EXPECT_EQ('x', deque.popBack())  <<
      COUT_ERROR("pushFront('x') and then popBack()");
   EXPECT_THROW(deque.popBack(), DequeException) <<
      COUT_ERROR("the deque is empty so popBack is not possible");
}

TEST(popFrontThrowsTest, ThrowExceptionAfterPoppingSinceEmptyF) {
   Deque deque;
   deque.pushFront('x');
   EXPECT_EQ('x', deque.popFront())  <<
      COUT_ERROR("pushFront('x') and then popFront()");
   EXPECT_THROW(deque.popFront(), DequeException) <<
      COUT_ERROR("the deque is empty so popFront is not possible");
}

TEST(popFrontThrowsTest, ThrowExceptionAfterPoppingSinceEmptyB) {
   Deque deque;
   deque.pushBack('x');
   EXPECT_EQ('x', deque.popFront())  <<
      COUT_ERROR("pushFront('x') and then popFront()");
   EXPECT_THROW(deque.popFront(), DequeException) <<
      COUT_ERROR("the deque is empty so popFront is not possible");
}

#endif

// causes a segmentation fault if not done properly
// but test does not fail