FreeCAD

1
// SPDX-License-Identifier: LGPL-2.1-or-later
2

3
#include "gtest/gtest.h"
4

5
#include "App/ComplexGeoData.h"
6
#include "App/MappedName.h"
7

8
#include <string>
9

10
// NOLINTBEGIN(readability-magic-numbers)
11

12
TEST(MappedName, defaultConstruction)
13
{
14
    // Act
15
    Data::MappedName mappedName;
16

17
    // Assert
18
    EXPECT_EQ(mappedName.isRaw(), false);
19
    EXPECT_EQ(mappedName.empty(), true);
20
    EXPECT_EQ(mappedName.size(), 0);
21
    EXPECT_EQ(mappedName.dataBytes(), QByteArray());
22
    EXPECT_EQ(mappedName.postfixBytes(), QByteArray());
23
}
24

25
TEST(MappedName, namedConstruction)
26
{
27
    // Act
28
    Data::MappedName mappedName("TEST");
29

30
    // Assert
31
    EXPECT_EQ(mappedName.isRaw(), false);
32
    EXPECT_EQ(mappedName.empty(), false);
33
    EXPECT_EQ(mappedName.size(), 4);
34
    EXPECT_EQ(mappedName.dataBytes(), QByteArray("TEST"));
35
    EXPECT_EQ(mappedName.postfixBytes(), QByteArray());
36
}
37

38
TEST(MappedName, namedConstructionWithMaxSize)
39
{
40
    // Act
41
    Data::MappedName mappedName("TEST", 2);
42

43
    // Assert
44
    EXPECT_EQ(mappedName.isRaw(), false);
45
    EXPECT_EQ(mappedName.empty(), false);
46
    EXPECT_EQ(mappedName.size(), 2);
47
    EXPECT_EQ(mappedName.dataBytes(), QByteArray("TE"));
48
    EXPECT_EQ(mappedName.postfixBytes(), QByteArray());
49
}
50

51
TEST(MappedName, namedConstructionDiscardPrefix)
52
{
53
    // Arrange
54
    std::string name = std::string(Data::ELEMENT_MAP_PREFIX) + "TEST";
55

56
    // Act
57
    Data::MappedName mappedName(name.c_str());
58

59
    // Assert
60
    EXPECT_EQ(mappedName.isRaw(), false);
61
    EXPECT_EQ(mappedName.empty(), false);
62
    EXPECT_EQ(mappedName.size(), 4);
63
    EXPECT_EQ(mappedName.dataBytes(), QByteArray("TEST"));
64
    EXPECT_EQ(mappedName.postfixBytes(), QByteArray());
65
}
66

67
TEST(MappedName, stringNamedConstruction)
68
{
69
    // Act
70
    Data::MappedName mappedName(std::string("TEST"));
71

72
    // Assert
73
    EXPECT_EQ(mappedName.isRaw(), false);
74
    EXPECT_EQ(mappedName.empty(), false);
75
    EXPECT_EQ(mappedName.size(), 4);
76
    EXPECT_EQ(mappedName.dataBytes(), QByteArray("TEST"));
77
    EXPECT_EQ(mappedName.postfixBytes(), QByteArray());
78
}
79

80
TEST(MappedName, stringNamedConstructionDiscardPrefix)
81
{
82
    // Arrange
83
    std::string name = std::string(Data::ELEMENT_MAP_PREFIX) + "TEST";
84

85
    // Act
86
    Data::MappedName mappedName(name);
87

88
    // Assert
89
    EXPECT_EQ(mappedName.isRaw(), false);
90
    EXPECT_EQ(mappedName.empty(), false);
91
    EXPECT_EQ(mappedName.size(), 4);
92
    EXPECT_EQ(mappedName.dataBytes(), QByteArray("TEST"));
93
    EXPECT_EQ(mappedName.postfixBytes(), QByteArray());
94
}
95

96
TEST(MappedName, constructFromIndexedNameNoIndex)
97
{
98
    // Arrange
99
    Data::IndexedName indexedName {"INDEXED_NAME"};
100

101
    // Act
102
    Data::MappedName mappedName {indexedName};
103

104
    // Assert
105
    EXPECT_EQ(mappedName.dataBytes().constData(), indexedName.getType());  // shared memory
106
    EXPECT_EQ(mappedName.isRaw(), true);
107
}
108

109
TEST(MappedName, constructFromIndexedNameWithIndex)
110
{
111
    // Arrange
112
    Data::IndexedName indexedName {"INDEXED_NAME", 1};
113

114
    // Act
115
    Data::MappedName mappedName {indexedName};
116

117
    // Assert
118
    EXPECT_NE(mappedName.dataBytes().constData(), indexedName.getType());  // NOT shared memory
119
    EXPECT_EQ(mappedName.isRaw(), false);
120
    EXPECT_EQ(mappedName.toString(), indexedName.toString());
121
}
122

123
TEST(MappedName, copyConstructor)
124
{
125
    // Arrange
126
    Data::MappedName temp("TEST");
127

128
    // Act
129
    Data::MappedName mappedName(temp);
130

131
    // Assert
132
    EXPECT_EQ(mappedName.isRaw(), false);
133
    EXPECT_EQ(mappedName.empty(), false);
134
    EXPECT_EQ(mappedName.size(), 4);
135
    EXPECT_EQ(mappedName.dataBytes(), QByteArray("TEST"));
136
    EXPECT_EQ(mappedName.postfixBytes(), QByteArray());
137
}
138

139
TEST(MappedName, copyConstructorWithPostfix)
140
{
141
    // Arrange
142
    Data::MappedName temp("TEST");
143

144
    // Act
145
    Data::MappedName mappedName(temp, "POSTFIXTEST");
146

147
    // Assert
148
    EXPECT_EQ(mappedName.isRaw(), false);
149
    EXPECT_EQ(mappedName.empty(), false);
150
    EXPECT_EQ(mappedName.size(), 15);
151
    EXPECT_EQ(mappedName.dataBytes(), QByteArray("TEST"));
152
    EXPECT_EQ(mappedName.postfixBytes(), QByteArray("POSTFIXTEST"));
153

154
    // Act
155
    Data::MappedName mappedName2(mappedName, "ANOTHERPOSTFIX");
156

157
    // Assert
158
    EXPECT_EQ(mappedName2.isRaw(), false);
159
    EXPECT_EQ(mappedName2.empty(), false);
160
    EXPECT_EQ(mappedName2.size(), 29);
161
    EXPECT_EQ(mappedName2.dataBytes(), QByteArray("TESTPOSTFIXTEST"));
162
    EXPECT_EQ(mappedName2.postfixBytes(), QByteArray("ANOTHERPOSTFIX"));
163
}
164

165
TEST(MappedName, copyConstructorStartpos)
166
{
167
    // Arrange
168
    Data::MappedName temp(Data::MappedName("TEST"), "POSTFIXTEST");
169

170
    // Act
171
    Data::MappedName mappedName(temp, 2, -1);
172

173
    // Assert
174
    EXPECT_EQ(mappedName.isRaw(), false);
175
    EXPECT_EQ(mappedName.empty(), false);
176
    EXPECT_EQ(mappedName.size(), 13);
177
    EXPECT_EQ(mappedName.dataBytes(), QByteArray("ST"));
178
    EXPECT_EQ(mappedName.postfixBytes(), QByteArray("POSTFIXTEST"));
179
}
180

181
TEST(MappedName, copyConstructorStartposAndSize)
182
{
183
    // Arrange
184
    Data::MappedName temp(Data::MappedName("TEST"), "POSTFIXTEST");
185

186
    // Act
187
    Data::MappedName mappedName(temp, 2, 6);
188

189
    // Assert
190
    EXPECT_EQ(mappedName.isRaw(), false);
191
    EXPECT_EQ(mappedName.empty(), false);
192
    EXPECT_EQ(mappedName.size(), 6);
193
    EXPECT_EQ(mappedName.dataBytes(), QByteArray("ST"));
194
    EXPECT_EQ(mappedName.postfixBytes(), QByteArray("POST"));
195
}
196

197
TEST(MappedName, moveConstructor)
198
{
199
    // Arrange
200
    Data::MappedName temp(Data::MappedName("TEST"), "POSTFIXTEST");
201

202
    // Act
203
    Data::MappedName mappedName(std::move(temp));
204

205
    // Assert
206
    EXPECT_EQ(mappedName.isRaw(), false);
207
    EXPECT_EQ(mappedName.empty(), false);
208
    EXPECT_EQ(mappedName.size(), 15);
209
    EXPECT_EQ(mappedName.dataBytes(), QByteArray("TEST"));
210
    EXPECT_EQ(mappedName.postfixBytes(), QByteArray("POSTFIXTEST"));
211
}
212

213
TEST(MappedName, fromRawData)
214
{
215
    // Act
216
    Data::MappedName mappedName = Data::MappedName::fromRawData("TESTTEST", 8);
217

218
    // Assert
219
    EXPECT_EQ(mappedName.isRaw(), true);
220
    EXPECT_EQ(mappedName.empty(), false);
221
    EXPECT_EQ(mappedName.size(), 8);
222
    EXPECT_EQ(mappedName.dataBytes(), QByteArray("TESTTEST", 8));
223
    EXPECT_EQ(mappedName.postfixBytes(), QByteArray());
224
}
225

226
TEST(MappedName, fromRawDataQByteArray)
227
{
228
    // Arrange
229
    QByteArray testByteArray("TESTTEST", 8);
230

231
    // Act
232
    Data::MappedName mappedName = Data::MappedName::fromRawData(testByteArray);
233

234
    // Assert
235
    EXPECT_EQ(mappedName.isRaw(), true);
236
    EXPECT_EQ(mappedName.empty(), false);
237
    EXPECT_EQ(mappedName.size(), 8);
238
    EXPECT_EQ(mappedName.dataBytes(), QByteArray("TESTTEST", 8));
239
    EXPECT_EQ(mappedName.postfixBytes(), QByteArray());
240
}
241

242
TEST(MappedName, fromRawDataCopy)
243
{
244
    // Arrange
245
    QByteArray testByteArray("TESTTEST", 8);
246
    Data::MappedName temp = Data::MappedName::fromRawData(testByteArray);
247
    temp.append("TESTPOSTFIX");
248
    temp.compact();  // Always call compact before accessing data!
249

250
    // Act
251
    Data::MappedName mappedName = Data::MappedName::fromRawData(temp, 0);
252

253
    // Assert
254
    EXPECT_EQ(mappedName.isRaw(), true);
255
    EXPECT_EQ(mappedName.empty(), false);
256
    EXPECT_EQ(mappedName.size(), 19);
257
    EXPECT_EQ(mappedName.dataBytes(), QByteArray("TESTTEST", 8));
258
    EXPECT_EQ(mappedName.postfixBytes(), QByteArray("TESTPOSTFIX"));
259
}
260

261
TEST(MappedName, fromRawDataCopyStartposAndSize)
262
{
263
    // Arrange
264
    QByteArray testByteArray("TESTTEST", 8);
265
    Data::MappedName temp = Data::MappedName::fromRawData(testByteArray);
266
    temp.append("ABCDEFGHIJKLM");  // postfix
267
    temp.compact();                // Always call compact before accessing data!
268

269
    // Act
270
    Data::MappedName mappedName = Data::MappedName::fromRawData(temp, 2, 13);
271

272
    // Assert
273
    EXPECT_EQ(mappedName.isRaw(), true);
274
    EXPECT_EQ(mappedName.empty(), false);
275
    EXPECT_EQ(mappedName.size(), 13);
276
    EXPECT_EQ(mappedName.dataBytes(), QByteArray("STTEST", 6));
277
    EXPECT_EQ(mappedName.postfixBytes(), QByteArray("ABCDEFG"));
278
}
279

280
TEST(MappedName, assignmentOperator)
281
{
282
    // Arrange
283
    Data::MappedName temp(Data::MappedName("TEST"), "POSTFIXTEST");
284

285
    // Act
286
    Data::MappedName mappedName = temp;
287

288
    // Assert
289
    EXPECT_EQ(mappedName.isRaw(), false);
290
    EXPECT_EQ(mappedName.empty(), false);
291
    EXPECT_EQ(mappedName.size(), 15);
292
    EXPECT_EQ(mappedName.dataBytes(), QByteArray("TEST"));
293
    EXPECT_EQ(mappedName.postfixBytes(), QByteArray("POSTFIXTEST"));
294
}
295

296
TEST(MappedName, assignmentOperatorString)
297
{
298
    // Arrange
299
    Data::MappedName mappedName;
300

301
    // Act
302
    mappedName = std::string("TEST");
303

304
    // Assert
305
    EXPECT_EQ(mappedName.isRaw(), false);
306
    EXPECT_EQ(mappedName.empty(), false);
307
    EXPECT_EQ(mappedName.size(), 4);
308
    EXPECT_EQ(mappedName.dataBytes(), QByteArray("TEST"));
309
    EXPECT_EQ(mappedName.postfixBytes(), QByteArray());
310
}
311

312
TEST(MappedName, assignmentOperatorConstCharPtr)
313
{
314
    // Arrange
315
    Data::MappedName mappedName;
316

317
    // Act
318
    mappedName = "TEST";
319

320
    // Assert
321
    EXPECT_EQ(mappedName.isRaw(), false);
322
    EXPECT_EQ(mappedName.empty(), false);
323
    EXPECT_EQ(mappedName.size(), 4);
324
    EXPECT_EQ(mappedName.dataBytes(), QByteArray("TEST"));
325
    EXPECT_EQ(mappedName.postfixBytes(), QByteArray());
326
}
327

328
TEST(MappedName, assignmentOperatorMove)
329
{
330
    // Arrange
331
    Data::MappedName temp(Data::MappedName("TEST"), "POSTFIXTEST");
332

333
    // Act
334
    Data::MappedName mappedName = std::move(temp);
335

336
    // Assert
337
    EXPECT_EQ(mappedName.isRaw(), false);
338
    EXPECT_EQ(mappedName.empty(), false);
339
    EXPECT_EQ(mappedName.size(), 15);
340
    EXPECT_EQ(mappedName.dataBytes(), QByteArray("TEST"));
341
    EXPECT_EQ(mappedName.postfixBytes(), QByteArray("POSTFIXTEST"));
342
}
343

344
TEST(MappedName, streamInsertionOperator)
345
{
346
    // Arrange
347
    Data::MappedName mappedName(Data::MappedName("TEST"), "POSTFIXTEST");
348
    std::stringstream ss;
349

350
    // Act
351
    ss << mappedName;
352

353
    // Assert
354
    EXPECT_EQ(ss.str(), std::string("TESTPOSTFIXTEST"));
355
}
356

357
TEST(MappedName, comparisonOperators)
358
{
359
    // Arrange
360
    Data::MappedName mappedName1(Data::MappedName("TEST"), "POSTFIXTEST");
361
    Data::MappedName mappedName2(Data::MappedName("TEST"), "POSTFIXTEST");
362
    Data::MappedName mappedName3(Data::MappedName("TESTPOST"), "FIXTEST");
363
    Data::MappedName mappedName4(Data::MappedName("THIS"), "ISDIFFERENT");
364

365
    // Act & Assert
366
    EXPECT_EQ(mappedName1 == mappedName1, true);
367
    EXPECT_EQ(mappedName1 == mappedName2, true);
368
    EXPECT_EQ(mappedName1 == mappedName3, true);
369
    EXPECT_EQ(mappedName1 == mappedName4, false);
370

371
    EXPECT_EQ(mappedName1 != mappedName1, false);
372
    EXPECT_EQ(mappedName1 != mappedName2, false);
373
    EXPECT_EQ(mappedName1 != mappedName3, false);
374
    EXPECT_EQ(mappedName1 != mappedName4, true);
375
}
376

377
TEST(MappedName, additionOperators)
378
{
379
    // Arrange
380
    Data::MappedName mappedName(Data::MappedName("TEST"), "POSTFIXTEST");
381
    QByteArray post3("POST3");
382

383
    // Act
384
    mappedName += "POST1";
385
    mappedName += std::string("POST2");
386
    mappedName += post3;
387
    mappedName += Data::MappedName("POST4");
388

389
    // Assert
390
    EXPECT_EQ(mappedName.isRaw(), false);
391
    EXPECT_EQ(mappedName.empty(), false);
392
    EXPECT_EQ(mappedName.size(), 35);
393
    EXPECT_EQ(mappedName.dataBytes(), QByteArray("TEST"));
394
    EXPECT_EQ(mappedName.postfixBytes(), QByteArray("POSTFIXTESTPOST1POST2POST3POST4"));
395

396
    // Arrange
397
    mappedName = Data::MappedName(Data::MappedName("TEST"), "POSTFIXTEST");
398
    QByteArray post8("POST8");
399

400
    // Act
401
    mappedName = mappedName + Data::MappedName("POST5");
402
    mappedName = mappedName + "POST6";
403
    mappedName = mappedName + std::string("POST7");
404
    mappedName = mappedName + post8;
405

406
    // Assert
407
    EXPECT_EQ(mappedName.isRaw(), false);
408
    EXPECT_EQ(mappedName.empty(), false);
409
    EXPECT_EQ(mappedName.size(), 35);
410
    EXPECT_EQ(mappedName.dataBytes(), QByteArray("TEST"));
411
    EXPECT_EQ(mappedName.postfixBytes(), QByteArray("POSTFIXTESTPOST5POST6POST7POST8"));
412
}
413

414
TEST(MappedName, append)
415
{
416
    // Arrange
417
    Data::MappedName mappedName;
418

419
    // Act
420
    mappedName.append("TEST");
421

422
    // Assert
423
    EXPECT_EQ(mappedName.isRaw(), false);
424
    EXPECT_EQ(mappedName.empty(), false);
425
    EXPECT_EQ(mappedName.size(), 4);
426
    EXPECT_EQ(mappedName.dataBytes(), QByteArray("TEST"));
427
    EXPECT_EQ(mappedName.postfixBytes(), QByteArray(""));
428

429
    // Act
430
    mappedName.append("POSTFIX");
431

432
    // Assert
433
    EXPECT_EQ(mappedName.isRaw(), false);
434
    EXPECT_EQ(mappedName.empty(), false);
435
    EXPECT_EQ(mappedName.size(), 11);
436
    EXPECT_EQ(mappedName.dataBytes(), QByteArray("TEST"));
437
    EXPECT_EQ(mappedName.postfixBytes(), QByteArray("POSTFIX"));
438

439
    // Act
440
    mappedName.append("ANOTHERPOSTFIX", 5);
441

442
    // Assert
443
    EXPECT_EQ(mappedName.isRaw(), false);
444
    EXPECT_EQ(mappedName.empty(), false);
445
    EXPECT_EQ(mappedName.size(), 16);
446
    EXPECT_EQ(mappedName.dataBytes(), QByteArray("TEST"));
447
    EXPECT_EQ(mappedName.postfixBytes(), QByteArray("POSTFIXANOTH"));
448
}
449

450
TEST(MappedName, appendMappedNameObj)
451
{
452
    // Arrange
453
    Data::MappedName mappedName;
454
    Data::MappedName temp(Data::MappedName("TEST"), "POSTFIXTEST");
455

456
    // Act
457
    mappedName.append(temp);
458

459
    // Assert
460
    EXPECT_EQ(mappedName.isRaw(), false);
461
    EXPECT_EQ(mappedName.empty(), false);
462
    EXPECT_EQ(mappedName.size(), 15);
463
    EXPECT_EQ(mappedName.dataBytes(), QByteArray("TEST"));
464
    EXPECT_EQ(mappedName.postfixBytes(), QByteArray("POSTFIXTEST"));
465

466
    // Act
467
    mappedName.append(temp, 2, 7);
468

469
    // Assert
470
    EXPECT_EQ(mappedName.isRaw(), false);
471
    EXPECT_EQ(mappedName.empty(), false);
472
    EXPECT_EQ(mappedName.size(), 22);
473
    EXPECT_EQ(mappedName.dataBytes(), QByteArray("TEST"));
474
    EXPECT_EQ(mappedName.postfixBytes(), QByteArray("POSTFIXTESTSTPOSTF"));
475
}
476

477
TEST(MappedName, toString)
478
{
479
    // Arrange
480
    Data::MappedName mappedName(Data::MappedName("TEST"), "POSTFIXTEST");
481

482
    // Act & Assert
483
    EXPECT_EQ(mappedName.toString(0), "TESTPOSTFIXTEST");
484
    EXPECT_EQ(mappedName.toString(0), std::string("TESTPOSTFIXTEST"));
485
    EXPECT_EQ(mappedName.toString(2, 8), "STPOSTFI");
486
    EXPECT_EQ(mappedName.toString(2, 8), std::string("STPOSTFI"));
487
}
488

489
TEST(MappedName, toConstString)
490
{
491
    // Arrange
492
    Data::MappedName mappedName(Data::MappedName("TEST"), "POSTFIXTEST");
493
    int size {0};
494

495
    // Act
496
    const char* temp = mappedName.toConstString(0, size);
497

498
    // Assert
499
    EXPECT_EQ(QByteArray(temp, size), QByteArray("TEST"));
500
    EXPECT_EQ(size, 4);
501

502
    // Act
503
    const char* temp2 = mappedName.toConstString(7, size);
504

505
    // Assert
506
    EXPECT_EQ(QByteArray(temp2, size), QByteArray("TFIXTEST"));
507
    EXPECT_EQ(size, 8);
508
}
509

510
TEST(MappedName, toRawBytes)
511
{
512
    // Arrange
513
    Data::MappedName mappedName(Data::MappedName("TEST"), "POSTFIXTEST");
514

515
    // Act & Assert
516
    EXPECT_EQ(mappedName.toRawBytes(), QByteArray("TESTPOSTFIXTEST"));
517
    EXPECT_EQ(mappedName.toRawBytes(3), QByteArray("TPOSTFIXTEST"));
518
    EXPECT_EQ(mappedName.toRawBytes(7, 3), QByteArray("TFI"));
519
    EXPECT_EQ(mappedName.toRawBytes(502, 5), QByteArray());
520
}
521

522
TEST(MappedName, toIndexedNameASCIIOnly)
523
{
524
    // Arrange
525
    Data::MappedName mappedName {"MAPPED_NAME"};
526

527
    // Act
528
    auto indexedName = mappedName.toIndexedName();
529

530
    // Assert
531
    EXPECT_FALSE(indexedName.isNull());
532
}
533

534
TEST(MappedName, toIndexedNameInvalid)
535
{
536
    // Arrange
537
    Data::MappedName mappedName {"MAPPED-NAME"};
538

539
    // Act
540
    auto indexedName = mappedName.toIndexedName();
541

542
    // Assert
543
    EXPECT_TRUE(indexedName.isNull());
544
}
545

546
TEST(MappedName, appendToBuffer)
547
{
548
    // Arrange
549
    Data::MappedName mappedName(Data::MappedName("TEST"), "POSTFIXTEST");
550
    std::string buffer("STUFF");
551

552
    // Act
553
    mappedName.appendToBuffer(buffer);
554

555
    // Assert
556
    EXPECT_EQ(buffer, std::string("STUFFTESTPOSTFIXTEST"));
557

558
    // Act
559
    mappedName.appendToBuffer(buffer, 2, 7);
560

561
    // Assert
562
    EXPECT_EQ(buffer, std::string("STUFFTESTPOSTFIXTESTSTPOSTF"));
563
}
564

565
TEST(MappedName, appendToBufferWithPrefix)
566
{
567
    // Arrange
568
    Data::MappedName mappedName(Data::MappedName("TEST"), "POSTFIXTEST");
569
    std::string buffer("STUFF");
570
    std::string elemMapPrefix = Data::ELEMENT_MAP_PREFIX;
571

572
    // Act
573
    mappedName.appendToBufferWithPrefix(buffer);
574

575
    // Assert
576
    EXPECT_EQ(buffer, std::string("STUFF") + elemMapPrefix + std::string("TESTPOSTFIXTEST"));
577

578
    // Arrange
579
    Data::MappedName mappedName2("TEST");  // If mappedName does not have a postfix and is a valid
580
                                           // indexedName: prefix is not added
581

582
    // Act
583
    mappedName2.appendToBufferWithPrefix(buffer);
584

585
    // Assert
586
    EXPECT_EQ(buffer,
587
              std::string("STUFF") + elemMapPrefix + std::string("TESTPOSTFIXTEST")
588
                  + /*missing prefix*/ std::string("TEST"));
589
}
590

591
TEST(MappedName, toPrefixedString)
592
{
593
    // Arrange
594
    Data::MappedName mappedName(Data::MappedName("TEST"), "POSTFIXTEST");
595
    std::string buffer("STUFF");
596
    std::string elemMapPrefix = Data::ELEMENT_MAP_PREFIX;
597

598
    // Act
599
    buffer += mappedName.toPrefixedString();
600

601
    // Assert
602
    EXPECT_EQ(buffer, std::string("STUFF") + elemMapPrefix + std::string("TESTPOSTFIXTEST"));
603

604
    // Arrange
605
    Data::MappedName mappedName2("TEST");  // If mappedName does not have a postfix and is a valid
606
                                           // indexedName: prefix is not added
607

608
    // Act
609
    buffer += mappedName2.toPrefixedString();
610

611
    // Assert
612
    EXPECT_EQ(buffer,
613
              std::string("STUFF") + elemMapPrefix + std::string("TESTPOSTFIXTEST")
614
                  + /*missing prefix*/ std::string("TEST"));
615
}
616

617
TEST(MappedName, toBytes)
618
{
619
    // Arrange
620
    Data::MappedName mappedName(Data::MappedName("TEST"), "POSTFIXTEST");
621

622
    // Act & Assert
623
    EXPECT_EQ(mappedName.toBytes(), QByteArray("TESTPOSTFIXTEST"));
624
}
625

626
TEST(MappedName, compare)
627
{
628
    // Arrange
629
    Data::MappedName mappedName1(Data::MappedName("TEST"), "POSTFIXTEST");
630
    Data::MappedName mappedName2(Data::MappedName("TEST"), "POSTFIXTEST");
631
    Data::MappedName mappedName3(Data::MappedName("TESTPOST"), "FIXTEST");
632
    Data::MappedName mappedName4(Data::MappedName("THIS"), "ISDIFFERENT");
633
    Data::MappedName mappedName5(Data::MappedName("SH"), "ORTHER");
634
    Data::MappedName mappedName6(Data::MappedName("VERYVERYVERY"), "VERYMUCHLONGER");
635

636
    // Act & Assert
637
    EXPECT_EQ(mappedName1.compare(mappedName1), 0);
638
    EXPECT_EQ(mappedName1.compare(mappedName2), 0);
639
    EXPECT_EQ(mappedName1.compare(mappedName3), 0);
640
    EXPECT_EQ(mappedName1.compare(mappedName4), -1);
641
    EXPECT_EQ(mappedName1.compare(mappedName5), 1);
642
    EXPECT_EQ(mappedName1.compare(mappedName6), -1);
643

644
    EXPECT_EQ(mappedName1 < mappedName1, false);
645
    EXPECT_EQ(mappedName1 < mappedName2, false);
646
    EXPECT_EQ(mappedName1 < mappedName3, false);
647
    EXPECT_EQ(mappedName1 < mappedName4, true);
648
    EXPECT_EQ(mappedName1 < mappedName5, false);
649
    EXPECT_EQ(mappedName1 < mappedName6, true);
650
}
651

652
TEST(MappedName, subscriptOperator)
653
{
654
    // Arrange
655
    Data::MappedName mappedName(Data::MappedName("TEST"), "POSTFIXTEST");
656

657
    // Act & Assert
658
    EXPECT_EQ(mappedName[0], 'T');
659
    EXPECT_EQ(mappedName[1], 'E');
660
    EXPECT_EQ(mappedName[2], 'S');
661
    EXPECT_EQ(mappedName[3], 'T');
662
    EXPECT_EQ(mappedName[4], 'P');
663
    EXPECT_EQ(mappedName[5], 'O');
664
    EXPECT_EQ(mappedName[6], 'S');
665
    EXPECT_EQ(mappedName[7], 'T');
666
    EXPECT_EQ(mappedName[8], 'F');
667
    EXPECT_EQ(mappedName[9], 'I');
668
}
669

670
TEST(MappedName, copy)
671
{
672
    // Arrange
673
    Data::MappedName mappedName(Data::MappedName("TEST"), "POSTFIXTEST");
674

675
    // Act
676
    Data::MappedName mappedName2 = mappedName.copy();
677

678
    // Assert
679
    EXPECT_EQ(mappedName, mappedName2);
680
}
681

682
TEST(MappedName, compact)
683
{
684
    // Arrange
685
    Data::MappedName mappedName = Data::MappedName::fromRawData("TESTTEST", 8);
686

687
    // Act
688
    mappedName.compact();
689

690
    // Assert
691
    EXPECT_EQ(mappedName.isRaw(), false);
692
    EXPECT_EQ(mappedName.empty(), false);
693
    EXPECT_EQ(mappedName.size(), 8);
694
    EXPECT_EQ(mappedName.dataBytes(), QByteArray("TESTTEST", 8));
695
    EXPECT_EQ(mappedName.postfixBytes(), QByteArray());
696
}
697

698
TEST(MappedName, boolOperator)
699
{
700
    // Arrange
701
    Data::MappedName mappedName;
702

703
    // Act & Assert
704
    EXPECT_EQ((bool)mappedName, false);
705

706
    // Arrange
707
    mappedName.append("TEST");
708

709
    // Act & Assert
710
    EXPECT_EQ((bool)mappedName, true);
711
}
712

713
TEST(MappedName, clear)
714
{
715
    // Arrange
716
    Data::MappedName mappedName(Data::MappedName("TEST"), "POSTFIXTEST");
717

718
    // Act
719
    mappedName.clear();
720

721
    // Assert
722
    EXPECT_EQ(mappedName.empty(), true);
723
}
724

725
TEST(MappedName, find)
726
{
727
    // Arrange
728
    Data::MappedName mappedName(Data::MappedName("TEST"), "POSTFIXTEST");
729

730
    // Act & Assert
731
    EXPECT_EQ(mappedName.find(nullptr), -1);
732
    EXPECT_EQ(mappedName.find(""), 0);
733
    EXPECT_EQ(mappedName.find(std::string("")), 0);
734
    EXPECT_EQ(mappedName.find("TEST"), 0);
735
    EXPECT_EQ(mappedName.find("STPO"), -1);  // sentence must be fully contained in data or postfix
736
    EXPECT_EQ(mappedName.find("POST"), 4);
737
    EXPECT_EQ(mappedName.find("POST", 4), 4);
738
    EXPECT_EQ(mappedName.find("POST", 5), -1);
739

740
    EXPECT_EQ(mappedName.rfind("ST"), 13);
741
    EXPECT_EQ(mappedName.rfind("ST", 15), 13);
742
    EXPECT_EQ(mappedName.rfind("ST", 14), 13);
743
    EXPECT_EQ(mappedName.rfind("ST", 13), 13);
744
    EXPECT_EQ(mappedName.rfind("ST", 12), 6);
745
    EXPECT_EQ(mappedName.rfind("ST", 11), 6);
746
    EXPECT_EQ(mappedName.rfind("ST", 10), 6);
747
    EXPECT_EQ(mappedName.rfind("ST", 9), 6);
748
    EXPECT_EQ(mappedName.rfind("ST", 8), 6);
749
    EXPECT_EQ(mappedName.rfind("ST", 7), 6);
750
    EXPECT_EQ(mappedName.rfind("ST", 6), 6);
751
    EXPECT_EQ(mappedName.rfind("ST", 5), 2);
752
    EXPECT_EQ(mappedName.rfind("ST", 4), 2);
753
    EXPECT_EQ(mappedName.rfind("ST", 3), 2);
754
    EXPECT_EQ(mappedName.rfind("ST", 2), 2);
755
    EXPECT_EQ(mappedName.rfind("ST", 1), -1);
756
    EXPECT_EQ(mappedName.rfind("ST", 0), -1);
757
}
758

759
TEST(MappedName, rfind)
760
{
761
    // Arrange
762
    Data::MappedName mappedName(Data::MappedName("TEST"), "POSTFIXTEST");
763

764
    // Act & Assert
765
    EXPECT_EQ(mappedName.rfind(nullptr), -1);
766
    EXPECT_EQ(mappedName.rfind(""), mappedName.size());
767
    EXPECT_EQ(mappedName.rfind(std::string("")), mappedName.size());
768
    EXPECT_EQ(mappedName.rfind("TEST"), 11);
769
    EXPECT_EQ(mappedName.rfind("STPO"), -1);  // sentence must be fully contained in data or postfix
770
    EXPECT_EQ(mappedName.rfind("POST"), 4);
771
    EXPECT_EQ(mappedName.rfind("POST", 4), 4);
772
    EXPECT_EQ(mappedName.rfind("POST", 3), -1);
773

774
    EXPECT_EQ(mappedName.rfind("ST"), 13);
775
    EXPECT_EQ(mappedName.rfind("ST", 0), -1);
776
    EXPECT_EQ(mappedName.rfind("ST", 1), -1);
777
    EXPECT_EQ(mappedName.rfind("ST", 2), 2);
778
    EXPECT_EQ(mappedName.rfind("ST", 3), 2);
779
    EXPECT_EQ(mappedName.rfind("ST", 4), 2);
780
    EXPECT_EQ(mappedName.rfind("ST", 5), 2);
781
    EXPECT_EQ(mappedName.rfind("ST", 6), 6);
782
    EXPECT_EQ(mappedName.rfind("ST", 7), 6);
783
    EXPECT_EQ(mappedName.rfind("ST", 8), 6);
784
    EXPECT_EQ(mappedName.rfind("ST", 9), 6);
785
    EXPECT_EQ(mappedName.rfind("ST", 10), 6);
786
    EXPECT_EQ(mappedName.rfind("ST", 11), 6);
787
    EXPECT_EQ(mappedName.rfind("ST", 12), 6);
788
    EXPECT_EQ(mappedName.rfind("ST", 13), 13);
789
    EXPECT_EQ(mappedName.rfind("ST", 14), 13);
790
    EXPECT_EQ(mappedName.rfind("ST", 15), 13);
791
}
792

793
TEST(MappedName, endswith)
794
{
795
    // Arrange
796
    Data::MappedName mappedName("TEST");
797

798
    // Act & Assert
799
    EXPECT_EQ(mappedName.endsWith(nullptr), false);
800
    EXPECT_EQ(mappedName.endsWith("TEST"), true);
801
    EXPECT_EQ(mappedName.endsWith(std::string("TEST")), true);
802
    EXPECT_EQ(mappedName.endsWith("WASD"), false);
803

804
    // Arrange
805
    mappedName.append("POSTFIX");
806

807
    // Act & Assert
808
    EXPECT_EQ(mappedName.endsWith(nullptr), false);
809
    EXPECT_EQ(mappedName.endsWith("TEST"), false);
810
    EXPECT_EQ(mappedName.endsWith("FIX"), true);
811
}
812

813
TEST(MappedName, startsWith)
814
{
815
    // Arrange
816
    Data::MappedName mappedName;
817

818
    // Act & Assert
819
    EXPECT_EQ(mappedName.startsWith(nullptr), false);
820
    EXPECT_EQ(mappedName.startsWith(QByteArray()), true);
821
    EXPECT_EQ(mappedName.startsWith(""), true);
822
    EXPECT_EQ(mappedName.startsWith(std::string("")), true);
823
    EXPECT_EQ(mappedName.startsWith("WASD"), false);
824

825
    // Arrange
826
    mappedName.append("TEST");
827

828
    // Act & Assert
829
    EXPECT_EQ(mappedName.startsWith(nullptr), false);
830
    EXPECT_EQ(mappedName.startsWith(QByteArray()), true);
831
    EXPECT_EQ(mappedName.startsWith("TEST"), true);
832
    EXPECT_EQ(mappedName.startsWith(std::string("TEST")), true);
833
    EXPECT_EQ(mappedName.startsWith("WASD"), false);
834
}
835

836
TEST(MappedName, findTagInElementNameHexPositiveIndexNonrecursive)
837
{
838
    // The non-recursive version will find just the last tag, prefixed by the POSTFIX_TAG (";:H").
839
    // It consists of a tag (stored in hexadecimal) and a length (also stored in hex), separated by
840
    // a colon. In this example, we expect the get ;:H1b:10,F as our element, which is a tag of
841
    // 0x1b and an indicated length of 0x10 (16 bytes). So the output length is the position of the
842
    // tag (36) minus the indicated length, giving 20.
843

844
    // Arrange
845
    Data::MappedName mappedName("#94;:G0;XTR;:H19:8,F;:H1a,F;BND:-1:0;:H1b:10,F");
846
    long tagOutput {0};
847
    int lenOutput {0};
848
    std::string postfix;
849
    char type {0};
850

851
    // Act
852
    int result =
853
        mappedName.findTagInElementName(&tagOutput, &lenOutput, &postfix, &type, false, false);
854

855
    // Assert
856
    EXPECT_EQ(result, 36);       // The location of the tag
857
    EXPECT_EQ(tagOutput, 0x1b);  // The tag
858
    EXPECT_EQ(lenOutput, 20);    // The calculated length based on the tag's length parameter
859
    EXPECT_EQ(postfix, ";:H1b:10,F");
860
    EXPECT_EQ(type, 'F');  // F=Face
861
}
862

863
TEST(MappedName, findTagInElementNameDecPositiveIndexNonrecursive)
864
{
865
    // Test backwards compatibility with the older style decimal tag storage.
866

867
    // Arrange
868
    Data::MappedName mappedName("#94;:G0;XTR;:T19:8,F;:T26,F;BND:-1:0;:T27:16,F");
869
    long tagOutput {0};
870
    int lenOutput {0};
871
    std::string postfix;
872
    char type {0};
873

874
    // Act
875
    int result =
876
        mappedName.findTagInElementName(&tagOutput, &lenOutput, &postfix, &type, false, false);
877

878
    // Assert
879
    EXPECT_EQ(result, 36);     // The location of the tag
880
    EXPECT_EQ(tagOutput, 27);  // The tag
881
    EXPECT_EQ(lenOutput, 16);  // The specified length
882
    EXPECT_EQ(postfix, ";:T27:16,F");
883
    EXPECT_EQ(type, 'F');  // F=Face
884
}
885

886
TEST(MappedName, findTagInElementNameHexNegativeIndexNonrecursive)
887
{
888
    // Test handling a negative index that is flipped to positive
889

890
    // Arrange
891
    Data::MappedName mappedName("#94;:G0;XTR;:H19:8,F;:H1a,F;BND:-1:0;:H-1b:10,F");
892
    long tagOutput {0};
893
    int lenOutput {0};
894
    std::string postfix;
895
    char type {0};
896

897
    // Act
898
    int result =
899
        mappedName.findTagInElementName(&tagOutput, &lenOutput, &postfix, &type, false, false);
900

901
    // Assert
902
    EXPECT_EQ(result, 36);       // The location of the tag
903
    EXPECT_EQ(tagOutput, 0x1b);  // The tag is returned positive, even though it was input negative
904
    EXPECT_EQ(lenOutput, 20);    // The calculated length based on the tag's length parameter
905
    EXPECT_EQ(postfix, ";:H-1b:10,F");
906
    EXPECT_EQ(type, 'F');  // F=Face
907
}
908

909
TEST(MappedName, findTagInElementNameHexExpectedNegativeIndexNonrecursive)
910
{
911
    // Test handling an untransformed negative index
912

913
    // Arrange
914
    Data::MappedName mappedName("#94;:G0;XTR;:H19:8,F;:H1a,F;BND:-1:0;:H-1b:10,F");
915
    long tagOutput {0};
916
    int lenOutput {0};
917
    std::string postfix;
918
    char type {0};
919

920
    // Act
921
    int result =
922
        mappedName.findTagInElementName(&tagOutput, &lenOutput, &postfix, &type, true, false);
923

924
    // Assert
925
    EXPECT_EQ(result, 36);        // The location of the tag
926
    EXPECT_EQ(tagOutput, -0x1b);  // The tag is returned negative
927
    EXPECT_EQ(lenOutput, 20);     // The calculated length based on the tag's length parameter
928
    EXPECT_EQ(postfix, ";:H-1b:10,F");
929
    EXPECT_EQ(type, 'F');  // F=Face
930
}
931

932
TEST(MappedName, findTagInElementNameRecursive)
933
{
934
    // Test the recursive resolution of the name
935

936
    // Arrange
937
    Data::MappedName mappedName("#94;:G0;XTR;:H19:8,F;:H1a,F;BND:-1:0;:H1b:10,F");
938
    long tagOutput {0};
939
    int lenOutput {0};
940
    std::string postfix;
941
    char type {0};
942

943
    // Act
944
    int result =
945
        mappedName.findTagInElementName(&tagOutput, &lenOutput, &postfix, &type, false, true);
946

947
    // Assert
948
    EXPECT_EQ(result, 36);       // The location of the tag
949
    EXPECT_EQ(tagOutput, 0x1b);  // The tag
950
    EXPECT_EQ(lenOutput, 27);    // Now includes the next tag, from the recursive search
951
    EXPECT_EQ(postfix, ";:H1b:10,F");
952
    EXPECT_EQ(type, 'F');  // F=Face
953
}
954

955
TEST(MappedName, hash)
956
{
957
    // Arrange
958
    Data::MappedName mappedName(Data::MappedName("TEST"), "POSTFIXTEST");
959

960
    // Act & Assert
961
    EXPECT_EQ(mappedName.hash(), qHash(QByteArray("TEST"), qHash(QByteArray("POSTFIXTEST"))));
962
}
963

964
// NOLINTEND(readability-magic-numbers)
965