CoCalc -- test

GitHub Repository: godotengine/godot
Path: blob/master/tests/core/templates/test_vector.h
¹⁰²⁷⁸ views
1
/**************************************************************************/
2
/*  test_vector.h                                                         */
3
/**************************************************************************/
4
/*                         This file is part of:                          */
5
/*                             GODOT ENGINE                               */
6
/*                        https://godotengine.org                         */
7
/**************************************************************************/
8
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
9
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
10
/*                                                                        */
11
/* Permission is hereby granted, free of charge, to any person obtaining  */
12
/* a copy of this software and associated documentation files (the        */
13
/* "Software"), to deal in the Software without restriction, including    */
14
/* without limitation the rights to use, copy, modify, merge, publish,    */
15
/* distribute, sublicense, and/or sell copies of the Software, and to     */
16
/* permit persons to whom the Software is furnished to do so, subject to  */
17
/* the following conditions:                                              */
18
/*                                                                        */
19
/* The above copyright notice and this permission notice shall be         */
20
/* included in all copies or substantial portions of the Software.        */
21
/*                                                                        */
22
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
23
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
24
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
25
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
26
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
27
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
28
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
29
/**************************************************************************/
30

31
#pragma once
32

33
#include "core/templates/vector.h"
34

35
#include "tests/test_macros.h"
36

37
namespace TestVector {
38

39
TEST_CASE("[Vector] List initialization") {
40
	Vector<int> vector{ 0, 1, 2, 3, 4 };
41

42
	CHECK(vector.size() == 5);
43
	CHECK(vector[0] == 0);
44
	CHECK(vector[1] == 1);
45
	CHECK(vector[2] == 2);
46
	CHECK(vector[3] == 3);
47
	CHECK(vector[4] == 4);
48
}
49

50
TEST_CASE("[Vector] Push back and append") {
51
	Vector<int> vector;
52
	vector.push_back(0);
53
	vector.push_back(1);
54
	vector.push_back(2);
55
	vector.push_back(3);
56
	// Alias for `push_back`.
57
	vector.append(4);
58

59
	CHECK(vector[0] == 0);
60
	CHECK(vector[1] == 1);
61
	CHECK(vector[2] == 2);
62
	CHECK(vector[3] == 3);
63
	CHECK(vector[4] == 4);
64
}
65

66
TEST_CASE("[Vector] Append array") {
67
	Vector<int> vector;
68
	vector.push_back(1);
69
	vector.push_back(2);
70

71
	Vector<int> vector_other;
72
	vector_other.push_back(128);
73
	vector_other.push_back(129);
74
	vector.append_array(vector_other);
75

76
	CHECK(vector.size() == 4);
77
	CHECK(vector[0] == 1);
78
	CHECK(vector[1] == 2);
79
	CHECK(vector[2] == 128);
80
	CHECK(vector[3] == 129);
81
}
82

83
TEST_CASE("[Vector] Insert") {
84
	Vector<int> vector;
85
	vector.insert(0, 2);
86
	vector.insert(0, 8);
87
	vector.insert(2, 5);
88
	vector.insert(1, 5);
89
	vector.insert(0, -2);
90

91
	CHECK(vector.size() == 5);
92
	CHECK(vector[0] == -2);
93
	CHECK(vector[1] == 8);
94
	CHECK(vector[2] == 5);
95
	CHECK(vector[3] == 2);
96
	CHECK(vector[4] == 5);
97
}
98

99
TEST_CASE("[Vector] Ordered insert") {
100
	Vector<int> vector;
101
	vector.ordered_insert(2);
102
	vector.ordered_insert(8);
103
	vector.ordered_insert(5);
104
	vector.ordered_insert(5);
105
	vector.ordered_insert(-2);
106

107
	CHECK(vector.size() == 5);
108
	CHECK(vector[0] == -2);
109
	CHECK(vector[1] == 2);
110
	CHECK(vector[2] == 5);
111
	CHECK(vector[3] == 5);
112
	CHECK(vector[4] == 8);
113
}
114

115
TEST_CASE("[Vector] Insert + Ordered insert") {
116
	Vector<int> vector;
117
	vector.ordered_insert(2);
118
	vector.ordered_insert(8);
119
	vector.insert(0, 5);
120
	vector.ordered_insert(5);
121
	vector.insert(1, -2);
122

123
	CHECK(vector.size() == 5);
124
	CHECK(vector[0] == 5);
125
	CHECK(vector[1] == -2);
126
	CHECK(vector[2] == 2);
127
	CHECK(vector[3] == 5);
128
	CHECK(vector[4] == 8);
129
}
130

131
TEST_CASE("[Vector] Fill large array and modify it") {
132
	Vector<int> vector;
133
	vector.resize(1'000'000);
134
	vector.fill(0x60d07);
135

136
	vector.write[200] = 0;
137
	CHECK(vector.size() == 1'000'000);
138
	CHECK(vector[0] == 0x60d07);
139
	CHECK(vector[200] == 0);
140
	CHECK(vector[499'999] == 0x60d07);
141
	CHECK(vector[999'999] == 0x60d07);
142
	vector.remove_at(200);
143
	CHECK(vector[200] == 0x60d07);
144

145
	vector.clear();
146
	CHECK(vector.size() == 0);
147
}
148

149
TEST_CASE("[Vector] Copy creation") {
150
	Vector<int> vector;
151
	vector.push_back(0);
152
	vector.push_back(1);
153
	vector.push_back(2);
154
	vector.push_back(3);
155
	vector.push_back(4);
156

157
	Vector<int> vector_other = Vector<int>(vector);
158
	vector_other.remove_at(0);
159
	CHECK(vector_other[0] == 1);
160
	CHECK(vector_other[1] == 2);
161
	CHECK(vector_other[2] == 3);
162
	CHECK(vector_other[3] == 4);
163

164
	// Make sure the original vector isn't modified.
165
	CHECK(vector[0] == 0);
166
	CHECK(vector[1] == 1);
167
	CHECK(vector[2] == 2);
168
	CHECK(vector[3] == 3);
169
	CHECK(vector[4] == 4);
170
}
171

172
TEST_CASE("[Vector] Duplicate") {
173
	Vector<int> vector;
174
	vector.push_back(0);
175
	vector.push_back(1);
176
	vector.push_back(2);
177
	vector.push_back(3);
178
	vector.push_back(4);
179

180
	Vector<int> vector_other = vector.duplicate();
181
	vector_other.remove_at(0);
182
	CHECK(vector_other[0] == 1);
183
	CHECK(vector_other[1] == 2);
184
	CHECK(vector_other[2] == 3);
185
	CHECK(vector_other[3] == 4);
186

187
	// Make sure the original vector isn't modified.
188
	CHECK(vector[0] == 0);
189
	CHECK(vector[1] == 1);
190
	CHECK(vector[2] == 2);
191
	CHECK(vector[3] == 3);
192
	CHECK(vector[4] == 4);
193
}
194

195
TEST_CASE("[Vector] Get, set") {
196
	Vector<int> vector;
197
	vector.push_back(0);
198
	vector.push_back(1);
199
	vector.push_back(2);
200
	vector.push_back(3);
201
	vector.push_back(4);
202

203
	CHECK(vector.get(0) == 0);
204
	CHECK(vector.get(1) == 1);
205
	vector.set(2, 256);
206
	CHECK(vector.get(2) == 256);
207
	CHECK(vector.get(3) == 3);
208

209
	ERR_PRINT_OFF;
210
	// Invalid (but should not crash): setting out of bounds.
211
	vector.set(6, 500);
212
	ERR_PRINT_ON;
213

214
	CHECK(vector.get(4) == 4);
215
}
216

217
TEST_CASE("[Vector] To byte array (variant call)") {
218
	// PackedInt32Array.
219
	{
220
		PackedInt32Array vector[] = { { 0, -1, 2008 }, {} };
221
		PackedByteArray out[] = { { /* 0 */ 0x00, 0x00, 0x00, 0x00, /* -1 */ 0xFF, 0xFF, 0xFF, 0xFF, /* 2008 */ 0xD8, 0x07, 0x00, 0x00 }, {} };
222

223
		for (size_t i = 0; i < std::size(vector); i++) {
224
			Callable::CallError err;
225
			Variant v_ret;
226
			Variant v_vector = vector[i];
227
			v_vector.callp("to_byte_array", nullptr, 0, v_ret, err);
228
			CHECK(v_ret.get_type() == Variant::PACKED_BYTE_ARRAY);
229
			CHECK(v_ret.operator PackedByteArray() == out[i]);
230
		}
231
	}
232

233
	// PackedInt64Array.
234
	{
235
		PackedInt64Array vector[] = { { 0, -1, 2008 }, {} };
236
		PackedByteArray out[] = { { /* 0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* -1 */ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, /* 2008 */ 0xD8, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, {} };
237

238
		for (size_t i = 0; i < std::size(vector); i++) {
239
			Callable::CallError err;
240
			Variant v_ret;
241
			Variant v_vector = vector[i];
242
			v_vector.callp("to_byte_array", nullptr, 0, v_ret, err);
243
			CHECK(v_ret.get_type() == Variant::PACKED_BYTE_ARRAY);
244
			CHECK(v_ret.operator PackedByteArray() == out[i]);
245
		}
246
	}
247

248
	// PackedFloat32Array.
249
	{
250
		PackedFloat32Array vector[] = { { 0.0, -1.0, 200e24 }, {} };
251
		PackedByteArray out[] = { { /* 0.0 */ 0x00, 0x00, 0x00, 0x00, /* -1.0 */ 0x00, 0x00, 0x80, 0xBF, /* 200e24 */ 0xA6, 0x6F, 0x25, 0x6B }, {} };
252

253
		for (size_t i = 0; i < std::size(vector); i++) {
254
			Callable::CallError err;
255
			Variant v_ret;
256
			Variant v_vector = vector[i];
257
			v_vector.callp("to_byte_array", nullptr, 0, v_ret, err);
258
			CHECK(v_ret.get_type() == Variant::PACKED_BYTE_ARRAY);
259
			CHECK(v_ret.operator PackedByteArray() == out[i]);
260
		}
261
	}
262
	// PackedFloat64Array.
263
	{
264
		PackedFloat64Array vector[] = { { 0.0, -1.0, 200e24 }, {} };
265
		PackedByteArray out[] = { { /* 0.0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* -1.0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xBF, /* 200e24 */ 0x35, 0x03, 0x32, 0xB7, 0xF4, 0xAD, 0x64, 0x45 }, {} };
266

267
		for (size_t i = 0; i < std::size(vector); i++) {
268
			Callable::CallError err;
269
			Variant v_ret;
270
			Variant v_vector = vector[i];
271
			v_vector.callp("to_byte_array", nullptr, 0, v_ret, err);
272
			CHECK(v_ret.get_type() == Variant::PACKED_BYTE_ARRAY);
273
			CHECK(v_ret.operator PackedByteArray() == out[i]);
274
		}
275
	}
276

277
	// PackedStringArray.
278
	{
279
		PackedStringArray vector[] = { { "test", "string" }, {}, { "", "test" } };
280
		PackedByteArray out[] = { { /* test */ 0x74, 0x65, 0x73, 0x74, /* null */ 0x00, /* string */ 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, /* null */ 0x00 }, {}, { /* null */ 0x00, /* test */ 0x74, 0x65, 0x73, 0x74, /* null */ 0x00 } };
281

282
		for (size_t i = 0; i < std::size(vector); i++) {
283
			Callable::CallError err;
284
			Variant v_ret;
285
			Variant v_vector = vector[i];
286
			v_vector.callp("to_byte_array", nullptr, 0, v_ret, err);
287
			CHECK(v_ret.get_type() == Variant::PACKED_BYTE_ARRAY);
288
			CHECK(v_ret.operator PackedByteArray() == out[i]);
289
		}
290
	}
291

292
	// PackedVector2Array.
293
	{
294
		PackedVector2Array vector[] = { { Vector2(), Vector2(1, -1) }, {} };
295
#ifdef REAL_T_IS_DOUBLE
296
		PackedByteArray out[] = { { /* X=0.0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* Y=0.0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* X=1.0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x3F, /* Y=-1.0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xBF }, {} };
297
#else
298
		PackedByteArray out[] = { { /* X=0.0 */ 0x00, 0x00, 0x00, 0x00, /* Y=0.0 */ 0x00, 0x00, 0x00, 0x00, /* X=1.0 */ 0x00, 0x00, 0x80, 0x3F, /* Y=-1.0 */ 0x00, 0x00, 0x80, 0xBF }, {} };
299
#endif
300

301
		for (size_t i = 0; i < std::size(vector); i++) {
302
			Callable::CallError err;
303
			Variant v_ret;
304
			Variant v_vector = vector[i];
305
			v_vector.callp("to_byte_array", nullptr, 0, v_ret, err);
306
			CHECK(v_ret.get_type() == Variant::PACKED_BYTE_ARRAY);
307
			CHECK(v_ret.operator PackedByteArray() == out[i]);
308
		}
309
	}
310

311
	// PackedVector3Array.
312
	{
313
		PackedVector3Array vector[] = { { Vector3(), Vector3(1, 1, -1) }, {} };
314
#ifdef REAL_T_IS_DOUBLE
315
		PackedByteArray out[] = { { /* X=0.0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* Y=0.0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* Z=0.0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* X=1.0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x3F, /* Y=1.0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x3F, /* Z=-1.0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xBF }, {} };
316
#else
317
		PackedByteArray out[] = { { /* X=0.0 */ 0x00, 0x00, 0x00, 0x00, /* Y=0.0 */ 0x00, 0x00, 0x00, 0x00, /* Z=0.0 */ 0x00, 0x00, 0x00, 0x00, /* X=1.0 */ 0x00, 0x00, 0x80, 0x3F, /* Y=1.0 */ 0x00, 0x00, 0x80, 0x3F, /* Z=-1.0 */ 0x00, 0x00, 0x80, 0xBF }, {} };
318
#endif
319

320
		for (size_t i = 0; i < std::size(vector); i++) {
321
			Callable::CallError err;
322
			Variant v_ret;
323
			Variant v_vector = vector[i];
324
			v_vector.callp("to_byte_array", nullptr, 0, v_ret, err);
325
			CHECK(v_ret.get_type() == Variant::PACKED_BYTE_ARRAY);
326
			CHECK(v_ret.operator PackedByteArray() == out[i]);
327
		}
328
	}
329

330
	// PackedColorArray.
331
	{
332
		PackedColorArray vector[] = { { Color(), Color(1, 1, 1) }, {} };
333
		PackedByteArray out[] = { { /* R=0.0 */ 0x00, 0x00, 0x00, 0x00, /* G=0.0 */ 0x00, 0x00, 0x00, 0x00, /* B=0.0 */ 0x00, 0x00, 0x00, 0x00, /* A=1.0 */ 0x00, 0x00, 0x80, 0x3F, /* R=1.0 */ 0x00, 0x00, 0x80, 0x3F, /* G=1.0 */ 0x00, 0x00, 0x80, 0x3F, /* B=1.0 */ 0x00, 0x00, 0x80, 0x3F, /* A=1.0 */ 0x00, 0x00, 0x80, 0x3F }, {} };
334

335
		for (size_t i = 0; i < std::size(vector); i++) {
336
			Callable::CallError err;
337
			Variant v_ret;
338
			Variant v_vector = vector[i];
339
			v_vector.callp("to_byte_array", nullptr, 0, v_ret, err);
340
			CHECK(v_ret.get_type() == Variant::PACKED_BYTE_ARRAY);
341
			CHECK(v_ret.operator PackedByteArray() == out[i]);
342
		}
343
	}
344

345
	// PackedVector4Array.
346
	{
347
		PackedVector4Array vector[] = { { Vector4(), Vector4(1, -1, 1, -1) }, {} };
348
#ifdef REAL_T_IS_DOUBLE
349
		PackedByteArray out[] = { { /* X=0.0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* Y=0.0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* Z 0.0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* W=0.0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* X=1.0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x3F, /* Y=-1.0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xBF, /* Z=1.0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x3F, /* W=-1.0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xBF }, {} };
350
#else
351
		PackedByteArray out[] = { { /* X=0.0 */ 0x00, 0x00, 0x00, 0x00, /* Y=0.0 */ 0x00, 0x00, 0x00, 0x00, /* Z=0.0 */ 0x00, 0x00, 0x00, 0x00, /* W 0.0 */ 0x00, 0x00, 0x00, 0x00, /* X 1.0 */ 0x00, 0x00, 0x80, 0x3F, /* Y=-1.0 */ 0x00, 0x00, 0x80, 0xBF, /* Z=1.0 */ 0x00, 0x00, 0x80, 0x3F, /* W=-1.0 */ 0x00, 0x00, 0x80, 0xBF }, {} };
352
#endif
353

354
		for (size_t i = 0; i < std::size(vector); i++) {
355
			Callable::CallError err;
356
			Variant v_ret;
357
			Variant v_vector = vector[i];
358
			v_vector.callp("to_byte_array", nullptr, 0, v_ret, err);
359
			CHECK(v_ret.get_type() == Variant::PACKED_BYTE_ARRAY);
360
			CHECK(v_ret.operator PackedByteArray() == out[i]);
361
		}
362
	}
363
}
364

365
TEST_CASE("[Vector] To byte array") {
366
	Vector<int> vector;
367
	vector.push_back(0);
368
	vector.push_back(-1);
369
	vector.push_back(2008);
370
	vector.push_back(999999999);
371

372
	Vector<uint8_t> byte_array = vector.to_byte_array();
373
	CHECK(byte_array.size() == 16);
374
	// vector[0]
375
	CHECK(byte_array[0] == 0);
376
	CHECK(byte_array[1] == 0);
377
	CHECK(byte_array[2] == 0);
378
	CHECK(byte_array[3] == 0);
379

380
	// vector[1]
381
	CHECK(byte_array[4] == 255);
382
	CHECK(byte_array[5] == 255);
383
	CHECK(byte_array[6] == 255);
384
	CHECK(byte_array[7] == 255);
385

386
	// vector[2]
387
	CHECK(byte_array[8] == 216);
388
	CHECK(byte_array[9] == 7);
389
	CHECK(byte_array[10] == 0);
390
	CHECK(byte_array[11] == 0);
391

392
	// vector[3]
393
	CHECK(byte_array[12] == 255);
394
	CHECK(byte_array[13] == 201);
395
	CHECK(byte_array[14] == 154);
396
	CHECK(byte_array[15] == 59);
397
}
398

399
TEST_CASE("[Vector] Slice") {
400
	Vector<int> vector;
401
	vector.push_back(0);
402
	vector.push_back(1);
403
	vector.push_back(2);
404
	vector.push_back(3);
405
	vector.push_back(4);
406

407
	Vector<int> slice0 = vector.slice(0, 0);
408
	CHECK(slice0.size() == 0);
409

410
	Vector<int> slice1 = vector.slice(1, 3);
411
	CHECK(slice1.size() == 2);
412
	CHECK(slice1[0] == 1);
413
	CHECK(slice1[1] == 2);
414

415
	Vector<int> slice2 = vector.slice(1, -1);
416
	CHECK(slice2.size() == 3);
417
	CHECK(slice2[0] == 1);
418
	CHECK(slice2[1] == 2);
419
	CHECK(slice2[2] == 3);
420

421
	Vector<int> slice3 = vector.slice(3);
422
	CHECK(slice3.size() == 2);
423
	CHECK(slice3[0] == 3);
424
	CHECK(slice3[1] == 4);
425

426
	Vector<int> slice4 = vector.slice(2, -2);
427
	CHECK(slice4.size() == 1);
428
	CHECK(slice4[0] == 2);
429

430
	Vector<int> slice5 = vector.slice(-2);
431
	CHECK(slice5.size() == 2);
432
	CHECK(slice5[0] == 3);
433
	CHECK(slice5[1] == 4);
434

435
	Vector<int> slice6 = vector.slice(2, 42);
436
	CHECK(slice6.size() == 3);
437
	CHECK(slice6[0] == 2);
438
	CHECK(slice6[1] == 3);
439
	CHECK(slice6[2] == 4);
440

441
	ERR_PRINT_OFF;
442
	Vector<int> slice7 = vector.slice(5, 1);
443
	CHECK(slice7.size() == 0); // Expected to fail.
444
	ERR_PRINT_ON;
445
}
446

447
TEST_CASE("[Vector] Find, has") {
448
	Vector<int> vector;
449
	vector.push_back(3);
450
	vector.push_back(1);
451
	vector.push_back(4);
452
	vector.push_back(0);
453
	vector.push_back(2);
454

455
	CHECK(vector[0] == 3);
456
	CHECK(vector[1] == 1);
457
	CHECK(vector[2] == 4);
458
	CHECK(vector[3] == 0);
459
	CHECK(vector[4] == 2);
460

461
	CHECK(vector.find(0) == 3);
462
	CHECK(vector.find(1) == 1);
463
	CHECK(vector.find(2) == 4);
464
	CHECK(vector.find(3) == 0);
465
	CHECK(vector.find(4) == 2);
466

467
	CHECK(vector.find(-1) == -1);
468
	CHECK(vector.find(5) == -1);
469

470
	CHECK(vector.has(0));
471
	CHECK(vector.has(1));
472
	CHECK(vector.has(2));
473
	CHECK(vector.has(3));
474
	CHECK(vector.has(4));
475

476
	CHECK(!vector.has(-1));
477
	CHECK(!vector.has(5));
478
}
479

480
TEST_CASE("[Vector] Remove at") {
481
	Vector<int> vector;
482
	vector.push_back(0);
483
	vector.push_back(1);
484
	vector.push_back(2);
485
	vector.push_back(3);
486
	vector.push_back(4);
487

488
	vector.remove_at(0);
489

490
	CHECK(vector[0] == 1);
491
	CHECK(vector[1] == 2);
492
	CHECK(vector[2] == 3);
493
	CHECK(vector[3] == 4);
494

495
	vector.remove_at(2);
496

497
	CHECK(vector[0] == 1);
498
	CHECK(vector[1] == 2);
499
	CHECK(vector[2] == 4);
500

501
	vector.remove_at(1);
502

503
	CHECK(vector[0] == 1);
504
	CHECK(vector[1] == 4);
505

506
	vector.remove_at(0);
507

508
	CHECK(vector[0] == 4);
509
}
510

511
TEST_CASE("[Vector] Remove at and find") {
512
	Vector<int> vector;
513
	vector.push_back(0);
514
	vector.push_back(1);
515
	vector.push_back(2);
516
	vector.push_back(3);
517
	vector.push_back(4);
518

519
	CHECK(vector.size() == 5);
520

521
	vector.remove_at(0);
522

523
	CHECK(vector.size() == 4);
524

525
	CHECK(vector.find(0) == -1);
526
	CHECK(vector.find(1) != -1);
527
	CHECK(vector.find(2) != -1);
528
	CHECK(vector.find(3) != -1);
529
	CHECK(vector.find(4) != -1);
530

531
	vector.remove_at(vector.find(3));
532

533
	CHECK(vector.size() == 3);
534

535
	CHECK(vector.find(3) == -1);
536
	CHECK(vector.find(1) != -1);
537
	CHECK(vector.find(2) != -1);
538
	CHECK(vector.find(4) != -1);
539

540
	vector.remove_at(vector.find(2));
541

542
	CHECK(vector.size() == 2);
543

544
	CHECK(vector.find(2) == -1);
545
	CHECK(vector.find(1) != -1);
546
	CHECK(vector.find(4) != -1);
547

548
	vector.remove_at(vector.find(4));
549

550
	CHECK(vector.size() == 1);
551

552
	CHECK(vector.find(4) == -1);
553
	CHECK(vector.find(1) != -1);
554

555
	vector.remove_at(0);
556

557
	CHECK(vector.is_empty());
558
	CHECK(vector.size() == 0);
559
}
560

561
TEST_CASE("[Vector] Erase") {
562
	Vector<int> vector;
563
	vector.push_back(1);
564
	vector.push_back(3);
565
	vector.push_back(0);
566
	vector.push_back(2);
567
	vector.push_back(4);
568

569
	CHECK(vector.find(2) == 3);
570

571
	vector.erase(2);
572

573
	CHECK(vector.find(2) == -1);
574
	CHECK(vector.size() == 4);
575
}
576

577
TEST_CASE("[Vector] Size, resize, reserve") {
578
	Vector<int> vector;
579
	CHECK(vector.is_empty());
580
	CHECK(vector.size() == 0);
581

582
	vector.resize(10);
583

584
	CHECK(vector.size() == 10);
585

586
	vector.resize(5);
587

588
	CHECK(vector.size() == 5);
589

590
	vector.remove_at(0);
591
	vector.remove_at(0);
592
	vector.remove_at(0);
593

594
	CHECK(vector.size() == 2);
595

596
	vector.clear();
597

598
	CHECK(vector.size() == 0);
599
	CHECK(vector.is_empty());
600

601
	vector.push_back(0);
602
	vector.push_back(0);
603
	vector.push_back(0);
604

605
	CHECK(vector.size() == 3);
606

607
	vector.push_back(0);
608

609
	CHECK(vector.size() == 4);
610
}
611

612
TEST_CASE("[Vector] Sort") {
613
	Vector<int> vector;
614
	vector.push_back(2);
615
	vector.push_back(8);
616
	vector.push_back(-4);
617
	vector.push_back(5);
618
	vector.sort();
619

620
	CHECK(vector.size() == 4);
621
	CHECK(vector[0] == -4);
622
	CHECK(vector[1] == 2);
623
	CHECK(vector[2] == 5);
624
	CHECK(vector[3] == 8);
625
}
626

627
TEST_CASE("[Vector] Sort custom") {
628
	Vector<String> vector;
629
	vector.push_back("world");
630
	vector.push_back("World");
631
	vector.push_back("Hello");
632
	vector.push_back("10Hello");
633
	vector.push_back("12Hello");
634
	vector.push_back("01Hello");
635
	vector.push_back("1Hello");
636
	vector.push_back(".Hello");
637
	vector.sort_custom<NaturalNoCaseComparator>();
638

639
	CHECK(vector.size() == 8);
640
	CHECK(vector[0] == ".Hello");
641
	CHECK(vector[1] == "01Hello");
642
	CHECK(vector[2] == "1Hello");
643
	CHECK(vector[3] == "10Hello");
644
	CHECK(vector[4] == "12Hello");
645
	CHECK(vector[5] == "Hello");
646
	CHECK(vector[6] == "world");
647
	CHECK(vector[7] == "World");
648
}
649

650
TEST_CASE("[Vector] Search") {
651
	Vector<int> vector;
652
	vector.push_back(1);
653
	vector.push_back(2);
654
	vector.push_back(3);
655
	vector.push_back(5);
656
	vector.push_back(8);
657
	CHECK(vector.bsearch(2, true) == 1);
658
	CHECK(vector.bsearch(2, false) == 2);
659
	CHECK(vector.bsearch(5, true) == 3);
660
	CHECK(vector.bsearch(5, false) == 4);
661
}
662

663
TEST_CASE("[Vector] Operators") {
664
	Vector<int> vector;
665
	vector.push_back(2);
666
	vector.push_back(8);
667
	vector.push_back(-4);
668
	vector.push_back(5);
669

670
	Vector<int> vector_other;
671
	vector_other.push_back(2);
672
	vector_other.push_back(8);
673
	vector_other.push_back(-4);
674
	vector_other.push_back(5);
675

676
	CHECK(vector == vector_other);
677

678
	vector_other.push_back(10);
679
	CHECK(vector != vector_other);
680
}
681

682
struct CyclicVectorHolder {
683
	Vector<CyclicVectorHolder> *vector = nullptr;
684
	bool is_destructing = false;
685

686
	~CyclicVectorHolder() {
687
		if (is_destructing) {
688
			// The vector must exist and not expose its backing array at this point.
689
			CHECK_NE(vector, nullptr);
690
			CHECK_EQ(vector->ptr(), nullptr);
691
		}
692
	}
693
};
694

695
TEST_CASE("[Vector] Cyclic Reference") {
696
	// Create a stack-space vector.
697
	Vector<CyclicVectorHolder> vector;
698
	// Add a new (empty) element.
699
	vector.resize(1);
700
	// Expose the vector to its element through CyclicVectorHolder.
701
	// This is questionable behavior, but should still behave graciously.
702
	vector.ptrw()[0] = CyclicVectorHolder{ &vector };
703
	vector.ptrw()[0].is_destructing = true;
704
	// The vector goes out of scope and destructs, calling CyclicVectorHolder's destructor.
705
}
706

707
} // namespace TestVector
708

709
Product

Resources

Company
