Structures

1
#include <QtTest>
2
#include <QCoreApplication>
3

4
#include "../../src/stack.hpp"
5

6
using namespace stt;
7

8
class TestStack : public QObject
9
{
10
    Q_OBJECT
11
    Stack<double> d_stack;
12
    Stack<int> i_stack;
13
    Stack<char> c_stack;
14

15
    QVector<double> d_case;
16
    QVector<int> i_case;
17
    QVector<char> c_case;
18

19
public:
20
    TestStack();
21
    ~TestStack();
22

23
private slots:
24
    void initTestCase();
25
    void cleanupTestCase();
26
    void testCaseConstructors();
27
    void testCasePushItem();
28
    void testCaseFrontBackItem();
29
    void testCaseFlip();
30
    void testCasePopItem();
31
    void testCaseOperatorPlusEqual();
32
};
33

34
TestStack::TestStack()
35
{
36

37
}
38

39
TestStack::~TestStack() {}
40

41
void TestStack::initTestCase()
42
{
43
    d_case = {9.0, 10.0, 13.0, 14.4, 15.6};
44
    i_case = {9, 10, 13, 14, 15};
45
    c_case = {'A', 'B', 'C', 'D', 'F'};
46
}
47

48
void TestStack::testCaseConstructors()
49
{
50
    Stack<double> d2_stack(9.0, 10.0, 13.0, 14.4, 15.6);
51
    foreach(auto d, d_case)
52
        QCOMPARE(d2_stack.pop(), d);
53
}
54

55
void TestStack::testCasePushItem()
56
{
57
    foreach(auto d, d_case)
58
        d_stack.push(d);
59
    foreach(auto i, i_case)
60
        i_stack.push(i);
61
    foreach(auto c, c_case)
62
        c_stack.push(c);
63
}
64

65
void TestStack::testCaseFrontBackItem()
66
{
67
    QCOMPARE(d_stack.front(), d_case.last());
68
    QCOMPARE(d_stack.back(), d_case.first());
69
    QCOMPARE(i_stack.front(), i_case.last());
70
    QCOMPARE(i_stack.back(), i_case.first());
71
    QCOMPARE(c_stack.front(), c_case.last());
72
    QCOMPARE(c_stack.back(), c_case.first());
73
}
74

75
void TestStack::testCaseFlip()
76
{
77
    Stack<double> d2_stack = d_stack;
78
    d2_stack.flip();
79
    foreach(auto d, d_case)
80
        QCOMPARE(d2_stack.pop(), d);
81
}
82

83
void TestStack::testCasePopItem()
84
{
85
    for(int i = d_case.size() - 1; i >= 0; i--)
86
        QCOMPARE(d_stack.pop(), d_case[i]);
87
    for(int i = i_case.size() - 1; i >= 0; i--)
88
        QCOMPARE(i_stack.pop(), i_case[i]);
89
    for(int i = c_case.size() - 1; i >= 0; i--)
90
        QCOMPARE(c_stack.pop(), c_case[i]);
91
}
92

93
void TestStack::testCaseOperatorPlusEqual()
94
{
95
    d_stack.push(9.0);
96
    d_stack.push(1.0);
97
    d_stack = d_stack + d_stack;
98
    QCOMPARE(d_stack.pop(), 1.0);
99
    QCOMPARE(d_stack.pop(), 9.0);
100
    QCOMPARE(d_stack.pop(), 1.0);
101
    QCOMPARE(d_stack.pop(), 9.0);
102

103
    d_stack.push(9.0);
104
    d_stack.push(1.0);
105
    d_stack += d_stack;
106
    QCOMPARE(d_stack.pop(), 1.0);
107
    QCOMPARE(d_stack.pop(), 9.0);
108
    QCOMPARE(d_stack.pop(), 1.0);
109
    QCOMPARE(d_stack.pop(), 9.0);
110
}
111

112

113
void TestStack::cleanupTestCase()
114
{
115
    d_stack.clear();
116
    i_stack.clear();
117
    c_stack.clear();
118
    QCOMPARE(d_stack.empty(), true);
119
    QCOMPARE(i_stack.empty(), true);
120
    QCOMPARE(c_stack.empty(), true);
121
}
122

123
QTEST_APPLESS_MAIN(TestStack)
124

125
#include "tst_teststack.moc"
126