1 #include "util-inl.h"
2 #include "debug_utils-inl.h"
3 #include "env-inl.h"
4 #include "gtest/gtest.h"
5
TEST(UtilTest,ListHead)6 TEST(UtilTest, ListHead) {
7 struct Item { node::ListNode<Item> node_; };
8 typedef node::ListHead<Item, &Item::node_> List;
9
10 List list;
11 EXPECT_TRUE(list.IsEmpty());
12
13 Item one;
14 EXPECT_TRUE(one.node_.IsEmpty());
15
16 list.PushBack(&one);
17 EXPECT_FALSE(list.IsEmpty());
18 EXPECT_FALSE(one.node_.IsEmpty());
19
20 {
21 List::Iterator it = list.begin();
22 EXPECT_NE(list.end(), it);
23 EXPECT_EQ(&one, *it);
24 ++it;
25 EXPECT_FALSE(it != list.end()); // Iterator only implements != operator.
26 }
27
28 Item two;
29 list.PushBack(&two);
30
31 {
32 List::Iterator it = list.begin();
33 EXPECT_NE(list.end(), it);
34 EXPECT_EQ(&one, *it);
35 ++it;
36 EXPECT_NE(list.end(), it);
37 EXPECT_EQ(&two, *it);
38 ++it;
39 EXPECT_FALSE(it != list.end()); // Iterator only implements != operator.
40 }
41
42 EXPECT_EQ(&one, list.PopFront());
43 EXPECT_TRUE(one.node_.IsEmpty());
44 EXPECT_FALSE(list.IsEmpty());
45
46 {
47 List::Iterator it = list.begin();
48 EXPECT_NE(list.end(), it);
49 EXPECT_EQ(&two, *it);
50 ++it;
51 EXPECT_FALSE(it != list.end()); // Iterator only implements != operator.
52 }
53
54 EXPECT_EQ(&two, list.PopFront());
55 EXPECT_TRUE(two.node_.IsEmpty());
56 EXPECT_TRUE(list.IsEmpty());
57 EXPECT_FALSE(list.begin() != list.end());
58 }
59
TEST(UtilTest,StringEqualNoCase)60 TEST(UtilTest, StringEqualNoCase) {
61 using node::StringEqualNoCase;
62 EXPECT_FALSE(StringEqualNoCase("a", "b"));
63 EXPECT_TRUE(StringEqualNoCase("", ""));
64 EXPECT_TRUE(StringEqualNoCase("equal", "equal"));
65 EXPECT_TRUE(StringEqualNoCase("equal", "EQUAL"));
66 EXPECT_TRUE(StringEqualNoCase("EQUAL", "EQUAL"));
67 EXPECT_FALSE(StringEqualNoCase("equal", "equals"));
68 EXPECT_FALSE(StringEqualNoCase("equals", "equal"));
69 }
70
TEST(UtilTest,StringEqualNoCaseN)71 TEST(UtilTest, StringEqualNoCaseN) {
72 using node::StringEqualNoCaseN;
73 EXPECT_FALSE(StringEqualNoCaseN("a", "b", strlen("a")));
74 EXPECT_TRUE(StringEqualNoCaseN("", "", strlen("")));
75 EXPECT_TRUE(StringEqualNoCaseN("equal", "equal", strlen("equal")));
76 EXPECT_TRUE(StringEqualNoCaseN("equal", "EQUAL", strlen("equal")));
77 EXPECT_TRUE(StringEqualNoCaseN("EQUAL", "EQUAL", strlen("equal")));
78 EXPECT_TRUE(StringEqualNoCaseN("equal", "equals", strlen("equal")));
79 EXPECT_FALSE(StringEqualNoCaseN("equal", "equals", strlen("equals")));
80 EXPECT_TRUE(StringEqualNoCaseN("equals", "equal", strlen("equal")));
81 EXPECT_FALSE(StringEqualNoCaseN("equals", "equal", strlen("equals")));
82 EXPECT_TRUE(StringEqualNoCaseN("abc\0abc", "abc\0efg", strlen("abcdefgh")));
83 EXPECT_FALSE(StringEqualNoCaseN("abc\0abc", "abcd\0efg", strlen("abcdefgh")));
84 }
85
TEST(UtilTest,ToLower)86 TEST(UtilTest, ToLower) {
87 using node::ToLower;
88 EXPECT_EQ('0', ToLower('0'));
89 EXPECT_EQ('a', ToLower('a'));
90 EXPECT_EQ('a', ToLower('A'));
91 }
92
93 #define TEST_AND_FREE(expression) \
94 do { \
95 auto pointer = expression; \
96 EXPECT_NE(nullptr, pointer); \
97 free(pointer); \
98 } while (0)
99
TEST(UtilTest,Malloc)100 TEST(UtilTest, Malloc) {
101 using node::Malloc;
102 TEST_AND_FREE(Malloc<char>(0));
103 TEST_AND_FREE(Malloc<char>(1));
104 TEST_AND_FREE(Malloc(0));
105 TEST_AND_FREE(Malloc(1));
106 }
107
TEST(UtilTest,Calloc)108 TEST(UtilTest, Calloc) {
109 using node::Calloc;
110 TEST_AND_FREE(Calloc<char>(0));
111 TEST_AND_FREE(Calloc<char>(1));
112 TEST_AND_FREE(Calloc(0));
113 TEST_AND_FREE(Calloc(1));
114 }
115
TEST(UtilTest,UncheckedMalloc)116 TEST(UtilTest, UncheckedMalloc) {
117 using node::UncheckedMalloc;
118 TEST_AND_FREE(UncheckedMalloc<char>(0));
119 TEST_AND_FREE(UncheckedMalloc<char>(1));
120 TEST_AND_FREE(UncheckedMalloc(0));
121 TEST_AND_FREE(UncheckedMalloc(1));
122 }
123
TEST(UtilTest,UncheckedCalloc)124 TEST(UtilTest, UncheckedCalloc) {
125 using node::UncheckedCalloc;
126 TEST_AND_FREE(UncheckedCalloc<char>(0));
127 TEST_AND_FREE(UncheckedCalloc<char>(1));
128 TEST_AND_FREE(UncheckedCalloc(0));
129 TEST_AND_FREE(UncheckedCalloc(1));
130 }
131
132 template <typename T>
MaybeStackBufferBasic()133 static void MaybeStackBufferBasic() {
134 using node::MaybeStackBuffer;
135
136 MaybeStackBuffer<T> buf;
137 size_t old_length;
138 size_t old_capacity;
139
140 /* Default constructor */
141 EXPECT_EQ(0U, buf.length());
142 EXPECT_FALSE(buf.IsAllocated());
143 EXPECT_GT(buf.capacity(), buf.length());
144
145 /* SetLength() expansion */
146 buf.SetLength(buf.capacity());
147 EXPECT_EQ(buf.capacity(), buf.length());
148 EXPECT_FALSE(buf.IsAllocated());
149
150 /* Means of accessing raw buffer */
151 EXPECT_EQ(buf.out(), *buf);
152 EXPECT_EQ(&buf[0], *buf);
153
154 /* Basic I/O */
155 for (size_t i = 0; i < buf.length(); i++)
156 buf[i] = static_cast<T>(i);
157 for (size_t i = 0; i < buf.length(); i++)
158 EXPECT_EQ(static_cast<T>(i), buf[i]);
159
160 /* SetLengthAndZeroTerminate() */
161 buf.SetLengthAndZeroTerminate(buf.capacity() - 1);
162 EXPECT_EQ(buf.capacity() - 1, buf.length());
163 for (size_t i = 0; i < buf.length(); i++)
164 EXPECT_EQ(static_cast<T>(i), buf[i]);
165 buf.SetLength(buf.capacity());
166 EXPECT_EQ(0, buf[buf.length() - 1]);
167
168 /* Initial Realloc */
169 old_length = buf.length() - 1;
170 old_capacity = buf.capacity();
171 buf.AllocateSufficientStorage(buf.capacity() * 2);
172 EXPECT_EQ(buf.capacity(), buf.length());
173 EXPECT_TRUE(buf.IsAllocated());
174 for (size_t i = 0; i < old_length; i++)
175 EXPECT_EQ(static_cast<T>(i), buf[i]);
176 EXPECT_EQ(0, buf[old_length]);
177
178 /* SetLength() reduction and expansion */
179 for (size_t i = 0; i < buf.length(); i++)
180 buf[i] = static_cast<T>(i);
181 buf.SetLength(10);
182 for (size_t i = 0; i < buf.length(); i++)
183 EXPECT_EQ(static_cast<T>(i), buf[i]);
184 buf.SetLength(buf.capacity());
185 for (size_t i = 0; i < buf.length(); i++)
186 EXPECT_EQ(static_cast<T>(i), buf[i]);
187
188 /* Subsequent Realloc */
189 old_length = buf.length();
190 old_capacity = buf.capacity();
191 buf.AllocateSufficientStorage(old_capacity * 1.5);
192 EXPECT_EQ(buf.capacity(), buf.length());
193 EXPECT_EQ(static_cast<size_t>(old_capacity * 1.5), buf.length());
194 EXPECT_TRUE(buf.IsAllocated());
195 for (size_t i = 0; i < old_length; i++)
196 EXPECT_EQ(static_cast<T>(i), buf[i]);
197
198 /* Basic I/O on Realloc'd buffer */
199 for (size_t i = 0; i < buf.length(); i++)
200 buf[i] = static_cast<T>(i);
201 for (size_t i = 0; i < buf.length(); i++)
202 EXPECT_EQ(static_cast<T>(i), buf[i]);
203
204 /* Release() */
205 T* rawbuf = buf.out();
206 buf.Release();
207 EXPECT_EQ(0U, buf.length());
208 EXPECT_FALSE(buf.IsAllocated());
209 EXPECT_GT(buf.capacity(), buf.length());
210 free(rawbuf);
211 }
212
TEST(UtilTest,MaybeStackBuffer)213 TEST(UtilTest, MaybeStackBuffer) {
214 using node::MaybeStackBuffer;
215
216 MaybeStackBufferBasic<uint8_t>();
217 MaybeStackBufferBasic<uint16_t>();
218
219 // Constructor with size parameter
220 {
221 MaybeStackBuffer<unsigned char> buf(100);
222 EXPECT_EQ(100U, buf.length());
223 EXPECT_FALSE(buf.IsAllocated());
224 EXPECT_GT(buf.capacity(), buf.length());
225 buf.SetLength(buf.capacity());
226 EXPECT_EQ(buf.capacity(), buf.length());
227 EXPECT_FALSE(buf.IsAllocated());
228 for (size_t i = 0; i < buf.length(); i++)
229 buf[i] = static_cast<unsigned char>(i);
230 for (size_t i = 0; i < buf.length(); i++)
231 EXPECT_EQ(static_cast<unsigned char>(i), buf[i]);
232
233 MaybeStackBuffer<unsigned char> bigbuf(10000);
234 EXPECT_EQ(10000U, bigbuf.length());
235 EXPECT_TRUE(bigbuf.IsAllocated());
236 EXPECT_EQ(bigbuf.length(), bigbuf.capacity());
237 for (size_t i = 0; i < bigbuf.length(); i++)
238 bigbuf[i] = static_cast<unsigned char>(i);
239 for (size_t i = 0; i < bigbuf.length(); i++)
240 EXPECT_EQ(static_cast<unsigned char>(i), bigbuf[i]);
241 }
242
243 // Invalidated buffer
244 {
245 MaybeStackBuffer<char> buf;
246 buf.Invalidate();
247 EXPECT_TRUE(buf.IsInvalidated());
248 EXPECT_FALSE(buf.IsAllocated());
249 EXPECT_EQ(0U, buf.length());
250 EXPECT_EQ(0U, buf.capacity());
251 buf.Invalidate();
252 EXPECT_TRUE(buf.IsInvalidated());
253 }
254 }
255
TEST(UtilTest,SPrintF)256 TEST(UtilTest, SPrintF) {
257 using node::SPrintF;
258
259 // %d, %u and %s all do the same thing. The actual C++ type is used to infer
260 // the right representation.
261 EXPECT_EQ(SPrintF("%s", false), "false");
262 EXPECT_EQ(SPrintF("%s", true), "true");
263 EXPECT_EQ(SPrintF("%d", true), "true");
264 EXPECT_EQ(SPrintF("%u", true), "true");
265 EXPECT_EQ(SPrintF("%d", 10000000000LL), "10000000000");
266 EXPECT_EQ(SPrintF("%d", -10000000000LL), "-10000000000");
267 EXPECT_EQ(SPrintF("%u", 10000000000LL), "10000000000");
268 EXPECT_EQ(SPrintF("%u", -10000000000LL), "-10000000000");
269 EXPECT_EQ(SPrintF("%i", 10), "10");
270 EXPECT_EQ(SPrintF("%d", 10), "10");
271 EXPECT_EQ(SPrintF("%x", 15), "f");
272 EXPECT_EQ(SPrintF("%x", 16), "10");
273 EXPECT_EQ(SPrintF("%X", 15), "F");
274 EXPECT_EQ(SPrintF("%X", 16), "10");
275 EXPECT_EQ(SPrintF("%o", 7), "7");
276 EXPECT_EQ(SPrintF("%o", 8), "10");
277
278 EXPECT_EQ(atof(SPrintF("%s", 0.5).c_str()), 0.5);
279 EXPECT_EQ(atof(SPrintF("%s", -0.5).c_str()), -0.5);
280
281 void (*fn)() = []() {};
282 void* p = reinterpret_cast<void*>(&fn);
283 EXPECT_GE(SPrintF("%p", fn).size(), 4u);
284 EXPECT_GE(SPrintF("%p", p).size(), 4u);
285
286 const std::string foo = "foo";
287 const char* bar = "bar";
288 EXPECT_EQ(SPrintF("%s %s", foo, "bar"), "foo bar");
289 EXPECT_EQ(SPrintF("%s %s", foo, bar), "foo bar");
290 EXPECT_EQ(SPrintF("%s", nullptr), "(null)");
291
292 EXPECT_EQ(SPrintF("[%% %s %%]", foo), "[% foo %]");
293
294 struct HasToString {
295 std::string ToString() const {
296 return "meow";
297 }
298 };
299 EXPECT_EQ(SPrintF("%s", HasToString{}), "meow");
300
301 const std::string with_zero = std::string("a") + '\0' + 'b';
302 EXPECT_EQ(SPrintF("%s", with_zero), with_zero);
303 }
304