test.cpp 9.24 KB
Newer Older
Karsa Zoltán István committed
1 2 3
/**
 * \file test.cpp
 *
4
 * StrinPool nevű szorgalmi feladat tesztjei gtest_lite eszközeivel megvalósítva 
Karsa Zoltán István committed
5 6 7
 * A szorgalmi feladat megoldásához ezt az állományt nem kell beadni (feltölteni).
 *
 * A ELKESZULT makró vezérli az egyes tesztesetek fordítását, ezzel lehetővé válik
8
 * hogy kisebb lépésekben teszteljünk és inkrementálisan készüljön el a program.
Karsa Zoltán István committed
9 10 11 12 13 14 15 16 17 18
 *
 */

#include <iostream>

#include "gtest_lite.h"
#include "memtrace.h"
#include "rstring.h"
#include "pool.h"

19
#define ELKESZULT 0
Karsa Zoltán István committed
20 21

/* ELKESZULT makró:
22
    <= 4: RString tesztjei
23
    >= 14: Összes teszt
Karsa Zoltán István committed
24 25 26 27 28 29 30 31
*/

int main() {
    GTINIT(std::cin);
    #if ELKESZULT > 0
        TEST(RString, konstruktorok) {
            RString a(100);
            EXPECT_STREQ("", a);
Karsa Zoltán István committed
32 33
            EXPECT_EQ(100u, a.capacity());
            EXPECT_EQ(0u, a.size());
Karsa Zoltán István committed
34 35 36
            
            RString b("alma");
            EXPECT_STREQ("alma", b);
Karsa Zoltán István committed
37 38
            EXPECT_EQ(5u, b.capacity());
            EXPECT_EQ(4u, b.size());
Karsa Zoltán István committed
39 40 41

            RString c("alma", 10);
            EXPECT_STREQ("alma", b);
Karsa Zoltán István committed
42 43
            EXPECT_EQ(10u, c.capacity());
            EXPECT_EQ(4u, c.size());
Karsa Zoltán István committed
44 45 46
        } END
    #endif

47 48 49 50
    #if ELKESZULT > 1
        TEST(RString, konstruktor kivetel) {
            RString a("alma", 5);
            EXPECT_STREQ("alma", a);
Karsa Zoltán István committed
51 52
            EXPECT_EQ(5u, a.capacity());
            EXPECT_EQ(4u, a.size());
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68

            try {
                EXPECT_THROW_THROW(RString b("alma", 4), const char* p);
            } catch (const char *p) {
            #ifdef CPORTA
                EXPECT_ENVCASEEQ("ORG_ID", p);
            #endif
            }
        } END
    #endif

    #if ELKESZULT > 2
        TEST(RString, ertekado_str) {
            RString a("alma", 20);
            a = "korte";
            EXPECT_STREQ("korte", a);
Karsa Zoltán István committed
69 70
            EXPECT_EQ(20u, a.capacity());
            EXPECT_EQ(5u, a.size());
71 72
            a = "fa";
            EXPECT_STREQ("fa", a);
Karsa Zoltán István committed
73 74
            EXPECT_EQ(20u, a.capacity());
            EXPECT_EQ(2u, a.size());
75 76 77 78 79 80 81 82 83
        } END
    #endif

    #if ELKESZULT > 3
        TEST(RString, cast) {
            RString a("alma", 20);
            char* str = a;
            strcpy(&str[4], "fa");
            EXPECT_STREQ("almafa", a);
Karsa Zoltán István committed
84 85
            EXPECT_EQ(20u, a.capacity());
            EXPECT_EQ(6u, a.size());
86 87 88 89 90 91 92
        } END
    #endif


    #if ELKESZULT > 4
        TEST(StringPool, init) {
            StringPool pool(10, 20);
Karsa Zoltán István committed
93 94
            EXPECT_EQ(10u, pool.size());
            EXPECT_EQ(10u, pool.free_size());
95
            RString& ref = pool.acquire(15);
Karsa Zoltán István committed
96
            EXPECT_EQ(20u, ref.capacity());
97
            EXPECT_STREQ("", ref);
98 99
            RString& ref2 = pool.acquire("almafa");
            EXPECT_STREQ("almafa", ref2);
100 101 102 103 104 105 106
        } END
    #endif


    #if ELKESZULT > 5
        TEST(StringPool, free_size) {
            StringPool pool(2, 20);
Karsa Zoltán István committed
107
            EXPECT_EQ(2u, pool.free_size());
108
            RString& ref1 = pool.acquire(15);
Karsa Zoltán István committed
109
            EXPECT_EQ(1u, pool.free_size());
110
            RString& ref2 = pool.acquire(20);
Karsa Zoltán István committed
111 112 113
            EXPECT_EQ(0u, pool.free_size());
            EXPECT_EQ(20u, ref1.capacity());
            EXPECT_EQ(20u, ref2.capacity());
114 115 116 117 118 119 120
        } END
    #endif

    #if ELKESZULT > 6
        TEST(StringPool, create_new_obj) {
            StringPool pool(1, 20);
            RString& ref = pool.acquire(15);
Karsa Zoltán István committed
121 122
            EXPECT_EQ(20u, ref.capacity());
            EXPECT_EQ(0u, pool.free_size());
123
            RString& newobj = pool.acquire(10);
Karsa Zoltán István committed
124 125 126
            EXPECT_EQ(0u, pool.free_size());
            EXPECT_EQ(2u, pool.size());
            EXPECT_EQ(10u, newobj.capacity());
127 128 129 130 131 132 133
        } END
    #endif

    #if ELKESZULT > 7
        TEST(StringPool, release) {
            StringPool pool(1, 20);
            RString& ref = pool.acquire(15);
Karsa Zoltán István committed
134 135
            EXPECT_EQ(1u, pool.size());
            EXPECT_EQ(0u, pool.free_size());
136
            EXPECT_FALSE(pool.acquireable(ref));
137
            ref = "alma";
138
            EXPECT_STREQ("alma", ref);
139
            pool.release(ref);
140
            EXPECT_TRUE(pool.acquireable(ref));
Karsa Zoltán István committed
141 142
            EXPECT_EQ(1u, pool.free_size());
            EXPECT_EQ(1u, pool.size());
143 144
            ref = pool.acquire(15);
            EXPECT_STREQ("", ref);
145 146 147
        } END
    #endif

148 149 150 151
    #if ELKESZULT > 8
        TEST(StringPool, release_new) {
            StringPool pool(2, 15);
            RString& ref = pool.acquire(30);
Karsa Zoltán István committed
152 153 154
            EXPECT_EQ(3u, pool.size());
            EXPECT_EQ(30u, ref.capacity());
            EXPECT_EQ(2u, pool.free_size());
155 156
            ref = "alma";
            RString& ref2 = pool.acquire(15);
Karsa Zoltán István committed
157 158 159
            EXPECT_EQ(3u, pool.size());
            EXPECT_EQ(15u, ref2.capacity());
            EXPECT_EQ(1u, pool.free_size());
160 161
            pool.release(ref);
            pool.release(ref2);
Karsa Zoltán István committed
162 163
            EXPECT_EQ(3u, pool.free_size());
            EXPECT_EQ(3u, pool.size());
164
            pool.release(ref2);
Karsa Zoltán István committed
165 166
            EXPECT_EQ(3u, pool.free_size());
            EXPECT_EQ(3u, pool.size());
167 168 169 170 171 172 173 174
        } END
    #endif


    #if ELKESZULT > 9
        TEST(StringPool, release_complex) {
            StringPool pool(3, 15);
            RString& ref1 = pool.acquire(15);
Karsa Zoltán István committed
175 176 177
            EXPECT_EQ(3u, pool.size());
            EXPECT_EQ(15u, ref1.capacity());
            EXPECT_EQ(2u, pool.free_size());
178
            RString& ref2 = pool.acquire(30);
Karsa Zoltán István committed
179 180 181
            EXPECT_EQ(4u, pool.size());
            EXPECT_EQ(30u, ref2.capacity());
            EXPECT_EQ(2u, pool.free_size());
182
            pool.release(ref2);
Karsa Zoltán István committed
183 184
            EXPECT_EQ(3u, pool.free_size());
            EXPECT_EQ(4u, pool.size());
185
            RString& ref3 = pool.acquire(25);
Karsa Zoltán István committed
186 187 188
            EXPECT_EQ(4u, pool.size());
            EXPECT_EQ(30u, ref2.capacity());
            EXPECT_EQ(2u, pool.free_size());
189
            pool.release(ref3);
Karsa Zoltán István committed
190 191
            EXPECT_EQ(3u, pool.free_size());
            EXPECT_EQ(4u, pool.size());
192 193
        } END
    #endif
194

195
    #if ELKESZULT > 10
196 197 198
        TEST(StringPool, max_capacity_check) {
            StringPool pool(1, 10);
            pool.release(pool.acquire(5));
Karsa Zoltán István committed
199 200
            EXPECT_EQ(1u, pool.free_size());
            EXPECT_EQ(1u, pool.size());
Karsa Zoltán István committed
201
            RString& tmp = pool.acquire(15);
202 203
            pool.release(pool.acquire(20));
            pool.release(pool.acquire(25));
Karsa Zoltán István committed
204
            pool.release(tmp);
Karsa Zoltán István committed
205 206
            EXPECT_EQ(4u, pool.free_size());
            EXPECT_EQ(4u, pool.size());
207
            RString& ref = pool.acquire(15);
Karsa Zoltán István committed
208 209 210
            EXPECT_EQ(3u, pool.free_size());
            EXPECT_EQ(4u, pool.size());
            EXPECT_EQ(15u, ref.capacity());
211
            RString& ref1 = pool.acquire(15);
Karsa Zoltán István committed
212 213 214
            EXPECT_EQ(2u, pool.free_size());
            EXPECT_EQ(4u, pool.size());
            EXPECT_EQ(20u, ref1.capacity());
215
            RString& ref2 = pool.acquire(15);
Karsa Zoltán István committed
216 217 218
            EXPECT_EQ(1u, pool.free_size());
            EXPECT_EQ(4u, pool.size());
            EXPECT_EQ(25u, ref2.capacity());
219
            RString& ref3 = pool.acquire(15);
Karsa Zoltán István committed
220 221 222
            EXPECT_EQ(1u, pool.free_size());
            EXPECT_EQ(5u, pool.size());
            EXPECT_EQ(15u, ref3.capacity());
223 224 225
            pool.release(ref1);
            pool.release(ref2);
            RString& ref4 = pool.acquire(15);
Karsa Zoltán István committed
226 227 228
            EXPECT_EQ(2u, pool.free_size());
            EXPECT_EQ(5u, pool.size());
            EXPECT_EQ(20u, ref4.capacity());
229 230 231 232
        } END
    #endif

    #if ELKESZULT > 11
233 234
        TEST(StringPool, append) {
            StringPool pool(3, 15);
235
            RString& alma = pool.acquire("alma");
236
            const RString& fa = pool.acquire("fa");
237
            RString& almafa = pool.append(alma, fa);
Karsa Zoltán István committed
238 239
            EXPECT_EQ(3u, pool.size());
            EXPECT_EQ(1u, pool.free_size());
240
            EXPECT_EQ(&almafa, &alma);
241
            EXPECT_STREQ("almafa", almafa);
242 243 244
        } END
    #endif

245
    #if ELKESZULT > 12
246 247 248 249 250
        TEST(StringPool, append_complex) {
            StringPool pool(3, 15);
            RString& arvizturo = pool.acquire("arvizturo");
            RString& tukorfurogep = pool.acquire("tukorfurogep");
            RString& egyben = pool.append(arvizturo, tukorfurogep);
Karsa Zoltán István committed
251 252
            EXPECT_EQ(4u, pool.size());
            EXPECT_EQ(1u, pool.free_size());
253
            EXPECT_NE(&arvizturo, &egyben);
254
            EXPECT_STREQ("arvizturotukorfurogep", egyben);
255 256 257
        } END
    #endif

258 259 260


    #if ELKESZULT > 13
261 262 263 264 265
        TEST(StringPool, append_kivetel) {
            try {
                StringPool pool(3, 15);
                RString& arvizturo = pool.acquire("arvizturo");
                RString& tukorfurogep = pool.acquire("tukorfurogep");
266 267
                pool.release(arvizturo);
                EXPECT_THROW_THROW(pool.append(arvizturo, tukorfurogep), const char* p);
268 269 270 271 272 273 274 275 276 277 278
            } catch (const char *p) {
            #ifdef CPORTA
                EXPECT_ENVCASEEQ("ORG_ID", p);
            #endif
            }

            try {
                StringPool pool(3, 15);
                RString& arvizturo = pool.acquire("arvizturo");
                RString& tukorfurogep = pool.acquire("tukorfurogep");
                pool.release(tukorfurogep);
279
                EXPECT_THROW_THROW(pool.append(arvizturo, tukorfurogep), const char* p);
280 281 282 283 284
            } catch (const char *p) {
            #ifdef CPORTA
                EXPECT_ENVCASEEQ("ORG_ID", p);
            #endif
            }
285 286
        } END
    #endif
Karsa Zoltán István committed
287

288
    if (ELKESZULT < 14)
Karsa Zoltán István committed
289 290 291 292 293
      ADD_FAILURE() << "\nNem futott minden teszteset!" << std::endl;

    GTEND(std::cerr);
    return 0;
}