1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
#include "simdjson.h"
#include "test_macros.h"
#include <cstdlib>
// this test is needed, because memcpy may be invoked on a null pointer
// otherwise
static bool testNullString() {
TEST_START();
std::string_view empty;
simdjson::padded_string blah(empty);
TEST_SUCCEED();
}
static bool testPaddedStringBuilder() {
TEST_START();
// Test empty builder
{
simdjson::padded_string_builder builder;
ASSERT_EQUAL(builder.length(), 0);
auto result = builder.build();
ASSERT_EQUAL(result.length(), 0);
ASSERT_EQUAL(std::string_view(result), "");
}
// Test appending data
{
simdjson::padded_string_builder builder;
const char* data = "Hello";
bool success = builder.append(data, 5);
ASSERT_TRUE(success);
ASSERT_EQUAL(builder.length(), 5);
auto result = builder.build();
ASSERT_EQUAL(result.length(), 5);
ASSERT_EQUAL(std::string_view(result), "Hello");
// Builder should still have content
ASSERT_EQUAL(builder.length(), 5);
}
// Test appending string_view
{
simdjson::padded_string_builder builder;
std::string_view sv = " World";
bool success = builder.append(sv);
ASSERT_TRUE(success);
ASSERT_EQUAL(builder.length(), 6);
auto result = builder.build();
ASSERT_EQUAL(result.size(), 6);
ASSERT_EQUAL(std::string_view(result), " World");
}
// Test multiple appends
{
simdjson::padded_string_builder builder;
ASSERT_TRUE(builder.append("Hello", 5));
ASSERT_TRUE(builder.append(" ", 1));
ASSERT_TRUE(builder.append("World", 5));
ASSERT_EQUAL(builder.length(), 11);
auto result = builder.build();
ASSERT_EQUAL(result.size(), 11);
ASSERT_EQUAL(std::string_view(result), "Hello World");
}
// Test convert (move)
{
simdjson::padded_string_builder builder;
ASSERT_TRUE(builder.append("Convert", 7));
ASSERT_EQUAL(builder.length(), 7);
auto result = builder.convert();
ASSERT_EQUAL(result.size(), 7);
ASSERT_EQUAL(std::string_view(result), "Convert");
// Builder should be empty after convert
ASSERT_EQUAL(builder.length(), 0);
// Building again should give empty string
auto empty_result = builder.build();
ASSERT_EQUAL(empty_result.size(), 0);
}
// Test initial capacity
{
simdjson::padded_string_builder builder(100);
ASSERT_EQUAL(builder.length(), 0);
// Capacity is internal, but we can test appending large data
std::string large_data(50, 'A');
bool success = builder.append(large_data.data(), large_data.size());
ASSERT_TRUE(success);
ASSERT_EQUAL(builder.length(), 50);
}
// Test move constructor
{
simdjson::padded_string_builder builder1;
ASSERT_TRUE(builder1.append("Move", 4));
simdjson::padded_string_builder builder2(std::move(builder1));
ASSERT_EQUAL(builder2.length(), 4);
ASSERT_EQUAL(builder1.length(), 0); // moved from
auto result = builder2.build();
ASSERT_EQUAL(std::string_view(result), "Move");
}
// Test move assignment
{
simdjson::padded_string_builder builder1;
ASSERT_TRUE(builder1.append("Assign", 6));
simdjson::padded_string_builder builder2;
builder2 = std::move(builder1);
ASSERT_EQUAL(builder2.length(), 6);
ASSERT_EQUAL(builder1.length(), 0); // moved from
auto result = builder2.convert();
ASSERT_EQUAL(std::string_view(result), "Assign");
}
TEST_SUCCEED();
}
int main() {
if (!testNullString()) {
return EXIT_FAILURE;
}
if (!testPaddedStringBuilder()) {
return EXIT_FAILURE;
}
std::cout << "All tests passed!" << std::endl;
return EXIT_SUCCESS;
}
|
