test_stack.cpp

#include <cassert>    
#include <iostream>   
#include <stdexcept>  
#include <vector>     
 
#include "./stack.hpp"
 
template <typename T>
void testConstructedStackIsEmpty() {
    const stack<T> curStack;
    assert(curStack.isEmptyStack());
}
 
void testPush() {
    using valueType = int;
    stack<valueType> curStack;
    curStack.push(10);
    curStack.push(20);
    curStack.push(30);
    curStack.push(40);
    const auto expectedData = std::vector<valueType>({40, 30, 20, 10});
    assert(curStack.toVector() == expectedData);
}
 
void testTop() {
    using valueType = unsigned;
    stack<valueType> curStack;
    curStack.push(1);
    curStack.push(2);
    curStack.push(3);
    curStack.push(4);
    assert(curStack.top() == static_cast<valueType>(4));
}
 
void testPop() {
    using valueType = int;
    stack<valueType> curStack;
    curStack.push(100);
    curStack.push(200);
    curStack.push(300);
 
    assert(curStack.top() == static_cast<valueType>(300));
    curStack.pop();
    assert(curStack.top() == static_cast<valueType>(200));
    curStack.pop();
    assert(curStack.top() == static_cast<valueType>(100));
    curStack.pop();
    assert(curStack.isEmptyStack());
}
 
void testClear() {
    stack<int> curStack;
    curStack.push(1000);
    curStack.push(2000);
    curStack.clear();
    assert(curStack.isEmptyStack());
}
 
void testCopyOfStackHasSameData() {
    stack<int> stackA;
    stackA.push(10);
    stackA.push(200);
    stackA.push(3000);
    const auto stackB(stackA);
    assert(stackA.toVector() == stackB.toVector());
}
 
void testPushingToCopyDoesNotChangeOriginal() {
    using valueType = int;
    stack<valueType> stackA;
    stackA.push(10);
    stackA.push(20);
    stackA.push(30);
    auto stackB(stackA);
    stackB.push(40);
 
    const auto expectedDataA = std::vector<valueType>({30, 20, 10});
    const auto expectedDataB = std::vector<valueType>({40, 30, 20, 10});
 
    assert(stackA.toVector() == expectedDataA);
    assert(stackB.toVector() == expectedDataB);
}
 
void testPoppingFromCopyDoesNotChangeOriginal() {
    using valueType = int;
    stack<valueType> stackA;
    stackA.push(10);
    stackA.push(20);
    stackA.push(30);
    auto stackB(stackA);
    stackB.pop();
 
    const auto expectedDataA = std::vector<valueType>({30, 20, 10});
    const auto expectedDataB = std::vector<valueType>({20, 10});
 
    assert(stackA.toVector() == expectedDataA);
    assert(stackB.toVector() == expectedDataB);
}
 
void testPushingToOrginalDoesNotChangeCopy() {
    using valueType = int;
    stack<valueType> stackA;
    stackA.push(10);
    stackA.push(20);
    stackA.push(30);
    const auto stackB(stackA);
    stackA.push(40);
 
    const auto expectedDataA = std::vector<valueType>({40, 30, 20, 10});
    const auto expectedDataB = std::vector<valueType>({30, 20, 10});
 
    assert(stackA.toVector() == expectedDataA);
    assert(stackB.toVector() == expectedDataB);
}
 
void testPoppingFromOrginalDoesNotChangeCopy() {
    using valueType = int;
    stack<valueType> stackA;
    stackA.push(10);
    stackA.push(20);
    stackA.push(30);
    const auto stackB(stackA);
    stackA.pop();
 
    const auto expectedDataA = std::vector<valueType>({20, 10});
    const auto expectedDataB = std::vector<valueType>({30, 20, 10});
 
    assert(stackA.toVector() == expectedDataA);
    assert(stackB.toVector() == expectedDataB);
}
 
void testAssign() {
    using valueType = int;
    stack<valueType> stackA;
    stackA.push(10);
    stackA.push(20);
    stackA.push(30);
    stack<valueType> stackB = stackA;
    stackA.pop();
    stackB.push(40);
 
    const auto expectedDataA = std::vector<valueType>({20, 10});
    const auto expectedDataB = std::vector<valueType>({40, 30, 20, 10});
 
    assert(stackA.toVector() == expectedDataA);
    assert(stackB.toVector() == expectedDataB);
 
    stackB = stackA;
    stackA.pop();
    stackB.push(5);
    stackB.push(6);
 
    const auto otherExpectedDataA = std::vector<valueType>({10});
    const auto otherExpectedDataB = std::vector<valueType>({6, 5, 20, 10});
 
    assert(stackA.toVector() == otherExpectedDataA);
    assert(stackB.toVector() == otherExpectedDataB);
}
 
void testTopThrowsAnInvalidArgumentWhenStackEmpty() {
    const stack<long double> curStack;
    bool wasException = false;
    try {
        curStack.top();
    } catch (const std::invalid_argument&) {
        wasException = true;
    }
    assert(wasException);
}
 
void testPopThrowsAnInvalidArgumentWhenStackEmpty() {
    stack<bool> curStack;
    bool wasException = false;
    try {
        curStack.pop();
    } catch (const std::invalid_argument&) {
        wasException = true;
    }
    assert(wasException);
}
 
int main() {
    testConstructedStackIsEmpty<int>();
    testConstructedStackIsEmpty<char>();
 
    testPush();
    testPop();
    testClear();
 
    testCopyOfStackHasSameData();
    testPushingToCopyDoesNotChangeOriginal();
    testPoppingFromCopyDoesNotChangeOriginal();
    testPushingToOrginalDoesNotChangeCopy();
    testPoppingFromOrginalDoesNotChangeCopy();
 
    testAssign();
 
    testTopThrowsAnInvalidArgumentWhenStackEmpty();
    testPopThrowsAnInvalidArgumentWhenStackEmpty();
 
    std::cout << "All tests pass!\n";
    return 0;
}