/
konstantin.chizhov
/
Mcucpp
GigaCode
beta
ОбзорЦентр заботыВойти

Mcucpp

Форк
0
Ветки: 6Коммиты: 303Теги: 0
Mcucpp
/tests
/UnitTests
/
containers.cpp 
419 строк · 10.1 Кб
1
#include <iostream>
2


3
#define DEBUG 1
4


5
#include <ring_buffer.h>
6
#include <stack.h>
7
#include <array.h>
8


9
#include <gtest/gtest.h>
10


11
using namespace Mcucpp;
12
using namespace  Containers;
13


14
TEST(Containers, RingBuffer1)
15
{
16
	RingBufferPO2<16, int> buf1;
17
	const RingBufferPO2<16, int> &cref = buf1;
18


19
	EXPECT_TRUE(buf1.empty());
20
	EXPECT_TRUE(buf1.push_back(100));
21
	EXPECT_FALSE(buf1.empty());
22
	EXPECT_EQ(buf1.front(), 100);
23
	EXPECT_TRUE(buf1.pop_front());
24
	EXPECT_TRUE(buf1.empty());
25
	EXPECT_FALSE(buf1.pop_front());
26


27
	EXPECT_TRUE(buf1.push_back(200));
28
	EXPECT_TRUE(buf1.push_back(300));
29


30
	EXPECT_EQ(buf1.front(), 200);
31
	EXPECT_EQ(buf1.back(), 300);
32
	EXPECT_EQ(buf1.size(), 2);
33


34
	EXPECT_EQ(cref.front(), 200);
35
	EXPECT_EQ(cref.back(), 300);
36
	EXPECT_EQ(cref.size(), 2);
37
	buf1.clear();
38
	EXPECT_EQ(buf1.size(), 0);
39
	EXPECT_TRUE(buf1.empty());
40


41
	for(unsigned i=0; i < buf1.capacity(); i++)
42
		EXPECT_TRUE(buf1.push_back(i));
43
	EXPECT_FALSE(buf1.push_back(-1));
44
	EXPECT_TRUE(buf1.full());
45
	EXPECT_TRUE(cref.full());
46


47
	for(unsigned i=0; i < buf1.capacity(); i++)
48
	{
49
		EXPECT_EQ(buf1[i], int(i));
50
		EXPECT_EQ(cref[i], int(i));
51
	}
52


53
	for(unsigned i=0; i < buf1.capacity(); i++)
54
	{
55
		EXPECT_EQ(buf1.front(), int(i));
56
		EXPECT_EQ(cref.front(), int(i));
57
		EXPECT_TRUE(buf1.pop_front());
58
	}
59
}
60


61
TEST(Containers, RingBufferPO2FullCondition)
62
{
63
	RingBufferPO2<16, int> buf1;
64
	
65
	for(unsigned i=0; i < buf1.capacity(); i++)
66
		EXPECT_TRUE(buf1.push_back(i));
67
	ASSERT_EQ(16, buf1.size());
68
	EXPECT_TRUE(buf1.full());
69
	
70
	for(unsigned i=0; i < 0xffff; i++)
71
	{
72
		ASSERT_TRUE(buf1.pop_front());
73
		ASSERT_TRUE(buf1.push_back(i));
74
		ASSERT_EQ(16, buf1.size());
75
	}
76
}
77


78
TEST(Containers, RingBufferFullCondition)
79
{
80
	RingBuffer<16, int> buf1;
81


82
	for(unsigned i=0; i < buf1.capacity(); i++)
83
		EXPECT_TRUE(buf1.push_back(i));
84
	ASSERT_EQ(16, buf1.size());
85
	EXPECT_TRUE(buf1.full());
86
	
87
	for(unsigned i=0; i < 0xffff; i++)
88
	{
89
		ASSERT_TRUE(buf1.pop_front());
90
		ASSERT_TRUE(buf1.push_back(i));
91
		ASSERT_EQ(16, buf1.size());
92
	}
93
}
94


95
size_t RoundToWordBoundary(size_t size)
96
{
97
	return (size + sizeof(unsigned) - 1) & ~(sizeof(unsigned) - 1);
98
}
99


100
TEST(Containers, RingBufferPO2StorageSize)
101
{
102
	EXPECT_EQ(sizeof(uint_fast8_t), sizeof(RingBufferPO2<16, uint8_t>::size_type));
103
	EXPECT_EQ(RoundToWordBoundary(16 + 2 * sizeof(uint_fast8_t)), sizeof(RingBufferPO2<16, uint8_t>));
104
	
105
	EXPECT_EQ(sizeof(uint_fast16_t), sizeof(RingBufferPO2<256, uint8_t>::size_type));
106
	EXPECT_EQ(RoundToWordBoundary(256 + 2 * sizeof(uint_fast16_t)), sizeof(RingBufferPO2<256, uint8_t>));
107
	
108
	EXPECT_EQ(sizeof(uint_fast8_t), sizeof(RingBufferPO2<16, uint16_t>::size_type));
109
	EXPECT_EQ(RoundToWordBoundary(16 * 2 + 2 * sizeof(uint_fast8_t)), sizeof(RingBufferPO2<16, uint16_t>));
110
	
111
	EXPECT_EQ(sizeof(uint_fast16_t), sizeof(RingBufferPO2<256, uint16_t>::size_type));
112
	EXPECT_EQ(RoundToWordBoundary(256 * 2 + 2 * sizeof(uint_fast16_t)), sizeof(RingBufferPO2<256, uint16_t>));
113
	
114
	EXPECT_EQ(sizeof(uint_fast8_t), sizeof(RingBufferPO2<16, uint16_t>::size_type));
115
	EXPECT_EQ(RoundToWordBoundary(16 * 4 + 2 * sizeof(uint_fast8_t)), sizeof(RingBufferPO2<16, uint32_t>));
116
	
117
	EXPECT_EQ(sizeof(uint_fast16_t), sizeof(RingBufferPO2<256, uint32_t>::size_type));
118
	EXPECT_EQ(RoundToWordBoundary(256 * 4 + 2 * sizeof(uint_fast16_t)), sizeof(RingBufferPO2<256, uint32_t>));
119
}
120


121
TEST(Containers, RingBuffer2)
122
{
123
	RingBuffer<20, int> buf1;
124
	const RingBuffer<20, int> &cref = buf1;
125


126
	EXPECT_TRUE(buf1.empty());
127
	EXPECT_TRUE(buf1.push_back(100));
128
	EXPECT_FALSE(buf1.empty());
129
	EXPECT_EQ(buf1.front(), 100);
130
	EXPECT_TRUE(buf1.push_back());
131
	EXPECT_EQ(buf1.back(), 0);
132
	EXPECT_TRUE(buf1.pop_front());
133
	EXPECT_TRUE(buf1.pop_front());
134
	EXPECT_TRUE(buf1.empty());
135
	EXPECT_FALSE(buf1.pop_front());
136


137
	EXPECT_TRUE(buf1.push_back(200));
138
	EXPECT_TRUE(buf1.push_back(300));
139


140
	EXPECT_EQ(buf1.front(), 200);
141
	EXPECT_EQ(buf1.back(), 300);
142
	EXPECT_EQ(buf1.size(), 2);
143


144
	EXPECT_EQ(cref.front(), 200);
145
	EXPECT_EQ(cref.back(), 300);
146
	EXPECT_EQ(cref.size(), 2);
147
	buf1.clear();
148
	EXPECT_EQ(buf1.size(), 0);
149
	EXPECT_TRUE(buf1.empty());
150


151
	for(unsigned i=0; i< buf1.capacity(); i++)
152
		EXPECT_TRUE(buf1.push_back(i));
153
	EXPECT_FALSE(buf1.push_back(-1));
154
	EXPECT_TRUE(buf1.full());
155
	EXPECT_TRUE(cref.full());
156


157
	for(unsigned i=0; i < buf1.capacity(); i++)
158
	{
159
		EXPECT_EQ(buf1[i], int(i));
160
		EXPECT_EQ(cref[i], int(i));
161
	}
162


163
	for(unsigned i=0; i < buf1.capacity(); i++)
164
	{
165
		EXPECT_EQ(buf1.front(), int(i));
166
		EXPECT_EQ(cref.front(), int(i));
167
		EXPECT_TRUE(buf1.pop_front());
168
	}
169
}
170


171


172
TEST(Containers, Stack)
173
{
174
	FixedStack<20, int> stack;
175
	FixedStack<20, int> &cref = stack;
176


177
	EXPECT_TRUE(stack.empty());
178
	EXPECT_TRUE(cref.empty());
179
	EXPECT_EQ(stack.size(), 0);
180
	EXPECT_EQ(cref.size(), 0);
181
	EXPECT_TRUE(stack.push_front(100));
182
	EXPECT_FALSE(stack.empty());
183
	EXPECT_FALSE(cref.empty());
184
	EXPECT_EQ(stack.front(), 100);
185
	EXPECT_EQ(cref.front(), 100);
186
	EXPECT_TRUE(stack.pop_front());
187
	EXPECT_FALSE(stack.pop_front());
188
	EXPECT_TRUE(stack.empty());
189
	EXPECT_TRUE(cref.empty());
190


191
	EXPECT_TRUE(stack.push_front(200));
192
	EXPECT_TRUE(stack.push_front(300));
193
	EXPECT_EQ(stack.front(), 300);
194
	EXPECT_EQ(cref.front(), 300);
195
	EXPECT_EQ(stack.back(), 200);
196
	EXPECT_EQ(cref.back(), 200);
197
	EXPECT_EQ(stack.size(), 2);
198
	EXPECT_EQ(cref.size(), 2);
199


200
	stack.clear();
201
	EXPECT_EQ(stack.size(), 0);
202
	EXPECT_TRUE(stack.empty());
203


204
	for(unsigned i=0; i< stack.capacity(); i++)
205
		EXPECT_TRUE(stack.push_front(i));
206
	EXPECT_FALSE(stack.push_front(-1));
207


208
	for(unsigned i=0; i < stack.capacity(); i++)
209
	{
210
		EXPECT_EQ(stack[i], int(stack.capacity() - 1 - i));
211
		EXPECT_EQ(cref[i], int(cref.capacity() - 1 - i));
212
	}
213


214
	for(unsigned i=0; i < stack.capacity(); i++)
215
	{
216
		EXPECT_EQ(stack.front(), int(stack.capacity() - 1 - i));
217
		EXPECT_EQ(cref.front(), int(cref.capacity() - 1 - i));
218
		EXPECT_TRUE(stack.pop_front());
219
	}
220
}
221


222


223
TEST(Containers, Array)
224
{
225
	FixedArray<20, int> array;
226
	FixedArray<20, int> &cref = array;
227


228
	EXPECT_TRUE(array.empty());
229
	EXPECT_TRUE(cref.empty());
230
	EXPECT_EQ(array.size(), 0);
231
	EXPECT_EQ(cref.size(), 0);
232


233
	EXPECT_TRUE(array.push_back(100));
234
	EXPECT_FALSE(array.empty());
235
	EXPECT_FALSE(cref.empty());
236
	EXPECT_EQ(array.front(), 100);
237
	EXPECT_EQ(cref.front(), 100);
238
	EXPECT_TRUE(array.pop_back());
239
	EXPECT_FALSE(array.pop_back());
240
	EXPECT_TRUE(array.empty());
241
	EXPECT_TRUE(cref.empty());
242


243
	EXPECT_TRUE(array.push_back(200));
244
	EXPECT_TRUE(array.push_back(300));
245
	EXPECT_EQ(array.front(), 200);
246
	EXPECT_EQ(cref.front(), 200);
247
	EXPECT_EQ(array.back(), 300);
248
	EXPECT_EQ(cref.back(), 300);
249
	EXPECT_EQ(array.size(), 2);
250
	EXPECT_EQ(cref.size(), 2);
251


252
	array.clear();
253
	EXPECT_EQ(array.size(), 0);
254
	EXPECT_TRUE(array.empty());
255


256
	for(unsigned i=0; i< array.capacity(); i++)
257
		EXPECT_TRUE(array.push_back(i));
258
	EXPECT_FALSE(array.push_back(-1));
259


260
	for(unsigned i=0; i < array.capacity(); i++)
261
	{
262
		EXPECT_EQ(array[i], int(i));
263
		EXPECT_EQ(cref[i], int(i));
264
	}
265


266
	for(unsigned i=0; i < array.capacity(); i++)
267
	{
268
		EXPECT_EQ(array.back(), int(array.capacity() - 1 - i));
269
		EXPECT_EQ(cref.back(), int(cref.capacity() - 1 - i));
270
		EXPECT_TRUE(array.pop_back());
271
	}
272
}
273


274


275
TEST(Containers, ArrayBool)
276
{
277
	FixedArray<20, bool> array;
278
	FixedArray<20, bool> &cref = array;
279


280
	EXPECT_TRUE(array.empty());
281
	EXPECT_TRUE(cref.empty());
282
	EXPECT_EQ(array.size(), 0);
283
	EXPECT_EQ(cref.size(), 0);
284


285
	EXPECT_TRUE(array.push_back(true));
286
	EXPECT_FALSE(array.empty());
287
	EXPECT_FALSE(cref.empty());
288
	EXPECT_EQ(array.front(), true);
289
	EXPECT_EQ(cref.front(), true);
290
	EXPECT_TRUE(array.pop_back());
291
	EXPECT_FALSE(array.pop_back());
292
	EXPECT_TRUE(array.empty());
293
	EXPECT_TRUE(cref.empty());
294


295
	EXPECT_TRUE(array.push_back(false));
296
	EXPECT_TRUE(array.push_back(true));
297
	EXPECT_EQ(array.front(), false);
298
	EXPECT_EQ(cref.front(), false);
299
	EXPECT_EQ(array.back(), true);
300
	EXPECT_EQ(cref.back(), true);
301
	EXPECT_EQ(array.size(), 2);
302
	EXPECT_EQ(cref.size(), 2);
303


304
	array.clear();
305
	EXPECT_EQ(array.size(), 0);
306
	EXPECT_TRUE(array.empty());
307


308
	for(unsigned i=0; i< array.capacity(); i++)
309
		EXPECT_TRUE(array.push_back(bool(i & 1)));
310
	EXPECT_FALSE(array.push_back(false)!=0);
311


312
	for(unsigned i=0; i < array.capacity(); i++)
313
	{
314
		EXPECT_EQ(array[i], bool(i & 1));
315
		EXPECT_EQ(cref[i], bool(i & 1));
316
	}
317


318
	for(unsigned i=0; i < array.capacity(); i++)
319
	{
320
		EXPECT_EQ(array.back(), bool(int(array.capacity() - 1 - i) & 1) );
321
		EXPECT_EQ(cref.back(), bool(int(cref.capacity() - 1 - i) & 1) );
322
		EXPECT_TRUE(array.pop_back());
323
	}
324
}
325


326
class ArrayBoolInitClass
327
{
328
	public:
329
	FixedArray<20, bool> array;
330
	ArrayBoolInitClass();
331
};
332


333


334
ArrayBoolInitClass::ArrayBoolInitClass()
335
		:array()
336
{
337
	array.push_back(false);
338
}
339


340
TEST(Containers, ArrayBoolInit)
341
{
342
	ArrayBoolInitClass foo;
343


344
	EXPECT_EQ(foo.array.size(), 1);
345
	ArrayBoolInitClass *pfoo = new ArrayBoolInitClass();
346
	EXPECT_EQ(pfoo->array.size(), 1);
347
	delete pfoo;
348
}
349


350
class ConstructionTest
351
{
352
	static int _count;
353
	int _data;
354
public:
355
	ConstructionTest()
356
		:_data(_count)
357
	{
358
		_count ++;
359
	}
360
	static void Reset()
361
	{
362
		_count = 0;
363
	}
364


365
	static int Count()
366
	{
367
		return _count;
368
	}
369
};
370


371
int ConstructionTest::_count = 0;
372


373
TEST(Array, ConstructionTest)
374
{
375
	ConstructionTest::Reset();
376
	FixedArray<20, ConstructionTest> array;
377
	EXPECT_EQ(0, ConstructionTest::Count());
378
	for(int i = 0; i<10; i++)
379
	{
380
		array.push_back( );
381
		EXPECT_EQ(i+1, ConstructionTest::Count());
382
	}
383
}
384


385
TEST(RingBufferPO2, ConstructionTest)
386
{
387
	ConstructionTest::Reset();
388
	RingBufferPO2<16, ConstructionTest> array;
389
	EXPECT_EQ(0, ConstructionTest::Count());
390
	for(int i = 0; i<10; i++)
391
	{
392
		array.push_back( );
393
		EXPECT_EQ(i+1, ConstructionTest::Count());
394
	}
395
}
396


397
TEST(RingBuffer, ConstructionTest)
398
{
399
	ConstructionTest::Reset();
400
	RingBuffer<22, ConstructionTest> array;
401
	EXPECT_EQ(0, ConstructionTest::Count());
402
	for(int i = 0; i<10; i++)
403
	{
404
		array.push_back( );
405
		EXPECT_EQ(i+1, ConstructionTest::Count());
406
	}
407
}
408


409
TEST(FixedStack, ConstructionTest)
410
{
411
	ConstructionTest::Reset();
412
	FixedStack<22, ConstructionTest> array;
413
	EXPECT_EQ(0, ConstructionTest::Count());
414
	for(int i = 0; i<10; i++)
415
	{
416
		array.push_front(ConstructionTest() );
417
		EXPECT_EQ(i+1, ConstructionTest::Count());
418
	}
419
}

Использование cookies

Мы используем файлы cookie в соответствии с Политикой конфиденциальности и Политикой использования cookies.

Нажимая кнопку «Принимаю», Вы даете АО «СберТех» согласие на обработку Ваших персональных данных в целях совершенствования нашего веб-сайта и Сервиса GitVerse, а также повышения удобства их использования.

Запретить использование cookies Вы можете самостоятельно в настройках Вашего браузера.