src/testcases/PoolTest.cpp

#include "PoolTest.h"

#include <iostream>

#define ELEMENTS 100

CPPUNIT_TEST_SUITE_REGISTRATION(PoolTest);

using namespace std;

// Note:
// we have to declare all those variables which we want to use for all
// tests within this test suite static because there are side effects which
// occur on transition to the next test which would change the values of our
// variables
static Pool<int>*   pPool = NULL;
static RTList<int>* pList = NULL;

// some data structure we use as template type
struct foo_t {
    int bar;
};


// PoolTest

void PoolTest::printTestSuiteName() {
    cout << "\b \nRunning Pool Tests: " << flush;
}

void PoolTest::testAllocPool() {
    //cout << "testAllocPool()" << flush;
    pPool = new Pool<int>(ELEMENTS);
    CPPUNIT_ASSERT(pPool != NULL);
    CPPUNIT_ASSERT(pPool->isEmpty());
    CPPUNIT_ASSERT(pPool->first() == pPool->end());
    CPPUNIT_ASSERT(pPool->last()  == pPool->begin());
    CPPUNIT_ASSERT(!pPool->poolIsEmpty());
}

void PoolTest::testAllocAppendElements() {
    //cout << "testAllocAppendElements()" << flush;
    // allocate elements and assign a value to it
    for (int i = 0; i < ELEMENTS; i++) {
        Pool<int>::Iterator iter = pPool->allocAppend();
        CPPUNIT_ASSERT(iter != pPool->begin());
        CPPUNIT_ASSERT(iter != pPool->end());
        CPPUNIT_ASSERT(iter == pPool->last());
        *iter = i;
    }
    CPPUNIT_ASSERT(!pPool->isEmpty());
    CPPUNIT_ASSERT(pPool->first() != pPool->end());
    CPPUNIT_ASSERT(pPool->last()  != pPool->begin());
    CPPUNIT_ASSERT(pPool->poolIsEmpty());
}

void PoolTest::testIterateForward() {
    //cout << "testIterateForward()" << flush;
    // iterate forward through the allocated elements and check their values
    Pool<int>::Iterator iter = pPool->first();
    for (int i = 0; i < ELEMENTS; i++) {
        CPPUNIT_ASSERT(*iter == i);
        CPPUNIT_ASSERT(iter != pPool->begin());
        CPPUNIT_ASSERT(iter != pPool->end());
        iter++;
    }
    CPPUNIT_ASSERT(iter == pPool->end());
}

void PoolTest::testIterateBackward() {
    //cout << "testIterateBackward()" << flush;
    // iterate backward through the allocated elements and check their values
    Pool<int>::Iterator iter = pPool->last();
    for (int i = ELEMENTS - 1; i >= 0; i--) {
        CPPUNIT_ASSERT(*iter == i);
        CPPUNIT_ASSERT(iter != pPool->begin());
        CPPUNIT_ASSERT(iter != pPool->end());
        --iter;
    }
    CPPUNIT_ASSERT(iter == pPool->begin());
}

void PoolTest::testFreeElements() {
    //cout << "testFreeElements()" << flush;
    // free all elements
    Pool<int>::Iterator iter = pPool->first();
    for (int i = 0; i < ELEMENTS; i++) {
        pPool->free(iter);
        iter++;
    }
    CPPUNIT_ASSERT(pPool->isEmpty());
    CPPUNIT_ASSERT(pPool->first() == pPool->end());
    CPPUNIT_ASSERT(pPool->last()  == pPool->begin());
    CPPUNIT_ASSERT(!pPool->poolIsEmpty());
}

void PoolTest::testAllocPrependElements() {
    //cout << "testAllocPrependElements()" << flush;
    for (int i = ELEMENTS - 1; i >= 0; i--) {
        Pool<int>::Iterator iter = pPool->allocPrepend();
        CPPUNIT_ASSERT(iter != pPool->begin());
        CPPUNIT_ASSERT(iter != pPool->end());
        CPPUNIT_ASSERT(iter == pPool->first());
        *iter = i;
    }
    CPPUNIT_ASSERT(!pPool->isEmpty());
    CPPUNIT_ASSERT(pPool->first() != pPool->end());
    CPPUNIT_ASSERT(pPool->last()  != pPool->begin());
    CPPUNIT_ASSERT(pPool->poolIsEmpty());
}

void PoolTest::testClear() {
    //cout << "testClear()" << flush;
    pPool->clear();
    CPPUNIT_ASSERT(pPool->isEmpty());
    CPPUNIT_ASSERT(pPool->first() == pPool->end());
    CPPUNIT_ASSERT(pPool->last()  == pPool->begin());
    CPPUNIT_ASSERT(!pPool->poolIsEmpty());
}

void PoolTest::testAllocList() {
    //cout << "testAllocList()" << flush;
    pList = new RTList<int>(pPool);
    CPPUNIT_ASSERT(pList != NULL);
    CPPUNIT_ASSERT(pList->isEmpty());
    CPPUNIT_ASSERT(pList->first() == pList->end());
    CPPUNIT_ASSERT(pList->last()  == pList->begin());
    CPPUNIT_ASSERT(!pPool->poolIsEmpty());
}

void PoolTest::testAllocElementsOnList() {
    //cout << "testAllocElementsOnList()" << flush;
    // allocate elements and assign a value to it
    for (int i = 0; i < ELEMENTS; i++) {
        Pool<int>::Iterator iter = pList->allocAppend();
        CPPUNIT_ASSERT(iter != pList->begin());
        CPPUNIT_ASSERT(iter != pList->end());
        CPPUNIT_ASSERT(iter == pList->last());
        *iter = i;
    }
    CPPUNIT_ASSERT(!pList->isEmpty());
    CPPUNIT_ASSERT(pList->first() != pList->end());
    CPPUNIT_ASSERT(pList->last()  != pList->begin());
    CPPUNIT_ASSERT(pPool->poolIsEmpty());
}

void PoolTest::testIterateForwardOnList() {
    //cout << "testIterateForwardOnList()" << flush;
    // iterate forward through the allocated elements and check their values
    RTList<int>::Iterator iter = pList->first();
    for (int i = 0; i < ELEMENTS; i++) {
        CPPUNIT_ASSERT(*iter == i);
        CPPUNIT_ASSERT(iter != pList->begin());
        CPPUNIT_ASSERT(iter != pList->end());
        iter++;
    }
    CPPUNIT_ASSERT(iter == pList->end());
}

void PoolTest::testIterateBackwardOnList() {
    //cout << "testIterateBackwardOnList()" << flush;
    // iterate backward through the allocated elements and check their values
    RTList<int>::Iterator iter = pList->last();
    for (int i = ELEMENTS - 1; i >= 0; i--) {
        CPPUNIT_ASSERT(*iter == i);
        CPPUNIT_ASSERT(iter != pList->begin());
        CPPUNIT_ASSERT(iter != pList->end());
        --iter;
    }
    CPPUNIT_ASSERT(iter == pList->begin());
}

void PoolTest::testClearList() {
    //cout << "testClearList()" << flush;
    pList->clear();
    CPPUNIT_ASSERT(pList->isEmpty());
    CPPUNIT_ASSERT(pList->first() == pList->end());
    CPPUNIT_ASSERT(pList->last()  == pList->begin());
    CPPUNIT_ASSERT(!pPool->poolIsEmpty());
}

void PoolTest::testMoveToEnd() {
    testAllocElementsOnList();
    CPPUNIT_ASSERT(!pList->isEmpty());
    CPPUNIT_ASSERT(pPool->poolIsEmpty());

    //cout << "testMoveToEnd()" << flush;
    RTList<int> _2ndList(pPool);

    {
        RTList<int>::Iterator iter = pList->first();
        for (int i = 0; i < ELEMENTS; i++) {
            *iter = i;
            RTList<int>::Iterator iterOn2ndList = iter.moveToEndOf(&_2ndList);
            CPPUNIT_ASSERT(*iterOn2ndList == i);
            CPPUNIT_ASSERT(iterOn2ndList == _2ndList.last());
            iter++;
        }
        CPPUNIT_ASSERT(iter == pList->end());
        CPPUNIT_ASSERT(pList->isEmpty());
        CPPUNIT_ASSERT(!_2ndList.isEmpty());
    }

    {
        RTList<int>::Iterator iter = _2ndList.first();
        for (int i = 0; i < ELEMENTS; i++) {
            CPPUNIT_ASSERT(*iter == i);
            CPPUNIT_ASSERT(iter != _2ndList.begin());
            CPPUNIT_ASSERT(iter != _2ndList.end());
            iter++;
        }
        CPPUNIT_ASSERT(iter == _2ndList.end());
    }

    _2ndList.clear();
    CPPUNIT_ASSERT(_2ndList.isEmpty());
    CPPUNIT_ASSERT(!pPool->poolIsEmpty());
}

void PoolTest::testMoveToBegin() {
    testAllocElementsOnList();
    CPPUNIT_ASSERT(!pList->isEmpty());
    CPPUNIT_ASSERT(pPool->poolIsEmpty());

    //cout << "testMoveToBegin()" << flush;
    RTList<int> _2ndList(pPool);

    {
        RTList<int>::Iterator iter = pList->first();
        for (int i = 0; i < ELEMENTS; i++) {
            *iter = i;
            RTList<int>::Iterator iterOn2ndList = iter.moveToBeginOf(&_2ndList);
            CPPUNIT_ASSERT(*iterOn2ndList == i);
            CPPUNIT_ASSERT(iterOn2ndList == _2ndList.first());
            iter++;
        }
        CPPUNIT_ASSERT(iter == pList->end());
        CPPUNIT_ASSERT(pList->isEmpty());
        CPPUNIT_ASSERT(!_2ndList.isEmpty());
    }

    {
        RTList<int>::Iterator iter = _2ndList.first();
        for (int i = ELEMENTS - 1; i >= 0; i--) {
            CPPUNIT_ASSERT(*iter == i);
            CPPUNIT_ASSERT(iter != _2ndList.begin());
            CPPUNIT_ASSERT(iter != _2ndList.end());
            iter++;
        }
        CPPUNIT_ASSERT(iter == _2ndList.end());
    }

    _2ndList.clear();
    CPPUNIT_ASSERT(_2ndList.isEmpty());
    CPPUNIT_ASSERT(!pPool->poolIsEmpty());
}

void PoolTest::testFreeList() {
    //cout << "testFreeList()" << flush;
    if (pList) delete pList;
}

void PoolTest::testFreePool() {
    //cout << "testFreePool()" << flush;
    if (pPool) delete pPool;
}

void PoolTest::testAccessElements() {
    Pool<foo_t> pool(100);
    CPPUNIT_ASSERT(!pool.poolIsEmpty());
    CPPUNIT_ASSERT(pool.isEmpty());

    for (int i = 0; i < 100; i++) pool.allocAppend();
    CPPUNIT_ASSERT(pool.poolIsEmpty());
    CPPUNIT_ASSERT(!pool.isEmpty());

    Pool<foo_t>::Iterator it = pool.first();
    for (int i = 0; i < 100; i++) {
        it->bar = i;
        ++it;
    }

    it = pool.last();
    for (int i = 99; i >= 0; i--) {
        CPPUNIT_ASSERT(it->bar == i);
        --it;
    }

    pool.clear();
    CPPUNIT_ASSERT(!pool.poolIsEmpty());
    CPPUNIT_ASSERT(pool.isEmpty());
}

void PoolTest::testInvalidIterators() {
    RTList<foo_t>::Iterator itNothing;
    bool passed = (itNothing) ? false : true;
    CPPUNIT_ASSERT(passed);
    CPPUNIT_ASSERT(itNothing != true);
    CPPUNIT_ASSERT(!itNothing);

    Pool<foo_t> pool(10);
    passed = (pool.begin()) ? false : true;
    CPPUNIT_ASSERT(passed);
    CPPUNIT_ASSERT(pool.begin() != true);
    CPPUNIT_ASSERT(!pool.begin());
    passed = (pool.end()) ? false : true;
    CPPUNIT_ASSERT(passed);
    CPPUNIT_ASSERT(pool.end() != true);
    CPPUNIT_ASSERT(!pool.end());
}
1	#include "PoolTest.h"
2
3	#include <iostream>
4
5	#define ELEMENTS 100
6
7	CPPUNIT_TEST_SUITE_REGISTRATION(PoolTest);
8
9	using namespace std;
10
11	// Note:
12	// we have to declare all those variables which we want to use for all
13	// tests within this test suite static because there are side effects which
14	// occur on transition to the next test which would change the values of our
15	// variables
16	static Pool<int>* pPool = NULL;
17	static RTList<int>* pList = NULL;
18
19	// some data structure we use as template type
20	struct foo_t {
21	int bar;
22	};
23
24
25	// PoolTest
26
27	void PoolTest::printTestSuiteName() {
28	cout << "\b \nRunning Pool Tests: " << flush;
29	}
30
31	void PoolTest::testAllocPool() {
32	//cout << "testAllocPool()" << flush;
33	pPool = new Pool<int>(ELEMENTS);
34	CPPUNIT_ASSERT(pPool != NULL);
35	CPPUNIT_ASSERT(pPool->isEmpty());
36	CPPUNIT_ASSERT(pPool->first() == pPool->end());
37	CPPUNIT_ASSERT(pPool->last() == pPool->begin());
38	CPPUNIT_ASSERT(!pPool->poolIsEmpty());
39	}
40
41	void PoolTest::testAllocAppendElements() {
42	//cout << "testAllocAppendElements()" << flush;
43	// allocate elements and assign a value to it
44	for (int i = 0; i < ELEMENTS; i++) {
45	Pool<int>::Iterator iter = pPool->allocAppend();
46	CPPUNIT_ASSERT(iter != pPool->begin());
47	CPPUNIT_ASSERT(iter != pPool->end());
48	CPPUNIT_ASSERT(iter == pPool->last());
49	*iter = i;
50	}
51	CPPUNIT_ASSERT(!pPool->isEmpty());
52	CPPUNIT_ASSERT(pPool->first() != pPool->end());
53	CPPUNIT_ASSERT(pPool->last() != pPool->begin());
54	CPPUNIT_ASSERT(pPool->poolIsEmpty());
55	}
56
57	void PoolTest::testIterateForward() {
58	//cout << "testIterateForward()" << flush;
59	// iterate forward through the allocated elements and check their values
60	Pool<int>::Iterator iter = pPool->first();
61	for (int i = 0; i < ELEMENTS; i++) {
62	CPPUNIT_ASSERT(*iter == i);
63	CPPUNIT_ASSERT(iter != pPool->begin());
64	CPPUNIT_ASSERT(iter != pPool->end());
65	iter++;
66	}
67	CPPUNIT_ASSERT(iter == pPool->end());
68	}
69
70	void PoolTest::testIterateBackward() {
71	//cout << "testIterateBackward()" << flush;
72	// iterate backward through the allocated elements and check their values
73	Pool<int>::Iterator iter = pPool->last();
74	for (int i = ELEMENTS - 1; i >= 0; i--) {
75	CPPUNIT_ASSERT(*iter == i);
76	CPPUNIT_ASSERT(iter != pPool->begin());
77	CPPUNIT_ASSERT(iter != pPool->end());
78	--iter;
79	}
80	CPPUNIT_ASSERT(iter == pPool->begin());
81	}
82
83	void PoolTest::testFreeElements() {
84	//cout << "testFreeElements()" << flush;
85	// free all elements
86	Pool<int>::Iterator iter = pPool->first();
87	for (int i = 0; i < ELEMENTS; i++) {
88	pPool->free(iter);
89	iter++;
90	}
91	CPPUNIT_ASSERT(pPool->isEmpty());
92	CPPUNIT_ASSERT(pPool->first() == pPool->end());
93	CPPUNIT_ASSERT(pPool->last() == pPool->begin());
94	CPPUNIT_ASSERT(!pPool->poolIsEmpty());
95	}
96
97	void PoolTest::testAllocPrependElements() {
98	//cout << "testAllocPrependElements()" << flush;
99	for (int i = ELEMENTS - 1; i >= 0; i--) {
100	Pool<int>::Iterator iter = pPool->allocPrepend();
101	CPPUNIT_ASSERT(iter != pPool->begin());
102	CPPUNIT_ASSERT(iter != pPool->end());
103	CPPUNIT_ASSERT(iter == pPool->first());
104	*iter = i;
105	}
106	CPPUNIT_ASSERT(!pPool->isEmpty());
107	CPPUNIT_ASSERT(pPool->first() != pPool->end());
108	CPPUNIT_ASSERT(pPool->last() != pPool->begin());
109	CPPUNIT_ASSERT(pPool->poolIsEmpty());
110	}
111
112	void PoolTest::testClear() {
113	//cout << "testClear()" << flush;
114	pPool->clear();
115	CPPUNIT_ASSERT(pPool->isEmpty());
116	CPPUNIT_ASSERT(pPool->first() == pPool->end());
117	CPPUNIT_ASSERT(pPool->last() == pPool->begin());
118	CPPUNIT_ASSERT(!pPool->poolIsEmpty());
119	}
120
121	void PoolTest::testAllocList() {
122	//cout << "testAllocList()" << flush;
123	pList = new RTList<int>(pPool);
124	CPPUNIT_ASSERT(pList != NULL);
125	CPPUNIT_ASSERT(pList->isEmpty());
126	CPPUNIT_ASSERT(pList->first() == pList->end());
127	CPPUNIT_ASSERT(pList->last() == pList->begin());
128	CPPUNIT_ASSERT(!pPool->poolIsEmpty());
129	}
130
131	void PoolTest::testAllocElementsOnList() {
132	//cout << "testAllocElementsOnList()" << flush;
133	// allocate elements and assign a value to it
134	for (int i = 0; i < ELEMENTS; i++) {
135	Pool<int>::Iterator iter = pList->allocAppend();
136	CPPUNIT_ASSERT(iter != pList->begin());
137	CPPUNIT_ASSERT(iter != pList->end());
138	CPPUNIT_ASSERT(iter == pList->last());
139	*iter = i;
140	}
141	CPPUNIT_ASSERT(!pList->isEmpty());
142	CPPUNIT_ASSERT(pList->first() != pList->end());
143	CPPUNIT_ASSERT(pList->last() != pList->begin());
144	CPPUNIT_ASSERT(pPool->poolIsEmpty());
145	}
146
147	void PoolTest::testIterateForwardOnList() {
148	//cout << "testIterateForwardOnList()" << flush;
149	// iterate forward through the allocated elements and check their values
150	RTList<int>::Iterator iter = pList->first();
151	for (int i = 0; i < ELEMENTS; i++) {
152	CPPUNIT_ASSERT(*iter == i);
153	CPPUNIT_ASSERT(iter != pList->begin());
154	CPPUNIT_ASSERT(iter != pList->end());
155	iter++;
156	}
157	CPPUNIT_ASSERT(iter == pList->end());
158	}
159
160	void PoolTest::testIterateBackwardOnList() {
161	//cout << "testIterateBackwardOnList()" << flush;
162	// iterate backward through the allocated elements and check their values
163	RTList<int>::Iterator iter = pList->last();
164	for (int i = ELEMENTS - 1; i >= 0; i--) {
165	CPPUNIT_ASSERT(*iter == i);
166	CPPUNIT_ASSERT(iter != pList->begin());
167	CPPUNIT_ASSERT(iter != pList->end());
168	--iter;
169	}
170	CPPUNIT_ASSERT(iter == pList->begin());
171	}
172
173	void PoolTest::testClearList() {
174	//cout << "testClearList()" << flush;
175	pList->clear();
176	CPPUNIT_ASSERT(pList->isEmpty());
177	CPPUNIT_ASSERT(pList->first() == pList->end());
178	CPPUNIT_ASSERT(pList->last() == pList->begin());
179	CPPUNIT_ASSERT(!pPool->poolIsEmpty());
180	}
181
182	void PoolTest::testMoveToEnd() {
183	testAllocElementsOnList();
184	CPPUNIT_ASSERT(!pList->isEmpty());
185	CPPUNIT_ASSERT(pPool->poolIsEmpty());
186
187	//cout << "testMoveToEnd()" << flush;
188	RTList<int> _2ndList(pPool);
189
190	{
191	RTList<int>::Iterator iter = pList->first();
192	for (int i = 0; i < ELEMENTS; i++) {
193	*iter = i;
194	RTList<int>::Iterator iterOn2ndList = iter.moveToEndOf(&_2ndList);
195	CPPUNIT_ASSERT(*iterOn2ndList == i);
196	CPPUNIT_ASSERT(iterOn2ndList == _2ndList.last());
197	iter++;
198	}
199	CPPUNIT_ASSERT(iter == pList->end());
200	CPPUNIT_ASSERT(pList->isEmpty());
201	CPPUNIT_ASSERT(!_2ndList.isEmpty());
202	}
203
204	{
205	RTList<int>::Iterator iter = _2ndList.first();
206	for (int i = 0; i < ELEMENTS; i++) {
207	CPPUNIT_ASSERT(*iter == i);
208	CPPUNIT_ASSERT(iter != _2ndList.begin());
209	CPPUNIT_ASSERT(iter != _2ndList.end());
210	iter++;
211	}
212	CPPUNIT_ASSERT(iter == _2ndList.end());
213	}
214
215	_2ndList.clear();
216	CPPUNIT_ASSERT(_2ndList.isEmpty());
217	CPPUNIT_ASSERT(!pPool->poolIsEmpty());
218	}
219
220	void PoolTest::testMoveToBegin() {
221	testAllocElementsOnList();
222	CPPUNIT_ASSERT(!pList->isEmpty());
223	CPPUNIT_ASSERT(pPool->poolIsEmpty());
224
225	//cout << "testMoveToBegin()" << flush;
226	RTList<int> _2ndList(pPool);
227
228	{
229	RTList<int>::Iterator iter = pList->first();
230	for (int i = 0; i < ELEMENTS; i++) {
231	*iter = i;
232	RTList<int>::Iterator iterOn2ndList = iter.moveToBeginOf(&_2ndList);
233	CPPUNIT_ASSERT(*iterOn2ndList == i);
234	CPPUNIT_ASSERT(iterOn2ndList == _2ndList.first());
235	iter++;
236	}
237	CPPUNIT_ASSERT(iter == pList->end());
238	CPPUNIT_ASSERT(pList->isEmpty());
239	CPPUNIT_ASSERT(!_2ndList.isEmpty());
240	}
241
242	{
243	RTList<int>::Iterator iter = _2ndList.first();
244	for (int i = ELEMENTS - 1; i >= 0; i--) {
245	CPPUNIT_ASSERT(*iter == i);
246	CPPUNIT_ASSERT(iter != _2ndList.begin());
247	CPPUNIT_ASSERT(iter != _2ndList.end());
248	iter++;
249	}
250	CPPUNIT_ASSERT(iter == _2ndList.end());
251	}
252
253	_2ndList.clear();
254	CPPUNIT_ASSERT(_2ndList.isEmpty());
255	CPPUNIT_ASSERT(!pPool->poolIsEmpty());
256	}
257
258	void PoolTest::testFreeList() {
259	//cout << "testFreeList()" << flush;
260	if (pList) delete pList;
261	}
262
263	void PoolTest::testFreePool() {
264	//cout << "testFreePool()" << flush;
265	if (pPool) delete pPool;
266	}
267
268	void PoolTest::testAccessElements() {
269	Pool<foo_t> pool(100);
270	CPPUNIT_ASSERT(!pool.poolIsEmpty());
271	CPPUNIT_ASSERT(pool.isEmpty());
272
273	for (int i = 0; i < 100; i++) pool.allocAppend();
274	CPPUNIT_ASSERT(pool.poolIsEmpty());
275	CPPUNIT_ASSERT(!pool.isEmpty());
276
277	Pool<foo_t>::Iterator it = pool.first();
278	for (int i = 0; i < 100; i++) {
279	it->bar = i;
280	++it;
281	}
282
283	it = pool.last();
284	for (int i = 99; i >= 0; i--) {
285	CPPUNIT_ASSERT(it->bar == i);
286	--it;
287	}
288
289	pool.clear();
290	CPPUNIT_ASSERT(!pool.poolIsEmpty());
291	CPPUNIT_ASSERT(pool.isEmpty());
292	}
293
294	void PoolTest::testInvalidIterators() {
295	RTList<foo_t>::Iterator itNothing;
296	bool passed = (itNothing) ? false : true;
297	CPPUNIT_ASSERT(passed);
298	CPPUNIT_ASSERT(itNothing != true);
299	CPPUNIT_ASSERT(!itNothing);
300
301	Pool<foo_t> pool(10);
302	passed = (pool.begin()) ? false : true;
303	CPPUNIT_ASSERT(passed);
304	CPPUNIT_ASSERT(pool.begin() != true);
305	CPPUNIT_ASSERT(!pool.begin());
306	passed = (pool.end()) ? false : true;
307	CPPUNIT_ASSERT(passed);
308	CPPUNIT_ASSERT(pool.end() != true);
309	CPPUNIT_ASSERT(!pool.end());
310	}