1 /*
2  *  Copyright (C) 2005-2018 Team Kodi
3  *  This file is part of Kodi - https://kodi.tv
4  *
5  *  SPDX-License-Identifier: GPL-2.0-or-later
6  *  See LICENSES/README.md for more information.
7  */
8 
9 #include "utils/StringUtils.h"
10 
11 #include <algorithm>
12 
13 #include <gtest/gtest.h>
14 enum class ECG
15 {
16   A,
17   B
18 };
19 
20 enum EG
21 {
22   C,
23   D
24 };
25 
26 namespace test_enum
27 {
28 enum class ECN
29 {
30   A = 1,
31   B
32 };
33 enum EN
34 {
35   C = 1,
36   D
37 };
38 }
TEST(TestStringUtils,Format)39 TEST(TestStringUtils, Format)
40 {
41   std::string refstr = "test 25 2.7 ff FF";
42 
43   std::string varstr =
44       StringUtils::Format("%s %d %.1f %x %02X", "test", 25, 2.743f, 0x00ff, 0x00ff);
45   EXPECT_STREQ(refstr.c_str(), varstr.c_str());
46 
47   varstr = StringUtils::Format("", "test", 25, 2.743f, 0x00ff, 0x00ff);
48   EXPECT_STREQ("", varstr.c_str());
49 }
50 
TEST(TestStringUtils,FormatEnum)51 TEST(TestStringUtils, FormatEnum)
52 {
53   const char* zero = "0";
54   const char* one = "1";
55 
56   std::string varstr = StringUtils::Format("{}", ECG::A);
57   EXPECT_STREQ(zero, varstr.c_str());
58 
59   varstr = StringUtils::Format("{}", EG::C);
60   EXPECT_STREQ(zero, varstr.c_str());
61 
62   varstr = StringUtils::Format("{}", test_enum::ECN::A);
63   EXPECT_STREQ(one, varstr.c_str());
64 
65   varstr = StringUtils::Format("{}", test_enum::EN::C);
66   EXPECT_STREQ(one, varstr.c_str());
67 }
68 
TEST(TestStringUtils,FormatEnumWidth)69 TEST(TestStringUtils, FormatEnumWidth)
70 {
71   const char* one = "01";
72 
73   std::string varstr = StringUtils::Format("{:02d}", ECG::B);
74   EXPECT_STREQ(one, varstr.c_str());
75 
76   varstr = StringUtils::Format("%02d", EG::D);
77   EXPECT_STREQ(one, varstr.c_str());
78 }
79 
TEST(TestStringUtils,ToUpper)80 TEST(TestStringUtils, ToUpper)
81 {
82   std::string refstr = "TEST";
83 
84   std::string varstr = "TeSt";
85   StringUtils::ToUpper(varstr);
86   EXPECT_STREQ(refstr.c_str(), varstr.c_str());
87 }
88 
TEST(TestStringUtils,ToLower)89 TEST(TestStringUtils, ToLower)
90 {
91   std::string refstr = "test";
92 
93   std::string varstr = "TeSt";
94   StringUtils::ToLower(varstr);
95   EXPECT_STREQ(refstr.c_str(), varstr.c_str());
96 }
97 
TEST(TestStringUtils,ToCapitalize)98 TEST(TestStringUtils, ToCapitalize)
99 {
100   std::string refstr = "Test";
101   std::string varstr = "test";
102   StringUtils::ToCapitalize(varstr);
103   EXPECT_STREQ(refstr.c_str(), varstr.c_str());
104 
105   refstr = "Just A Test";
106   varstr = "just a test";
107   StringUtils::ToCapitalize(varstr);
108   EXPECT_STREQ(refstr.c_str(), varstr.c_str());
109 
110   refstr = "Test -1;2:3, String For Case";
111   varstr = "test -1;2:3, string for Case";
112   StringUtils::ToCapitalize(varstr);
113   EXPECT_STREQ(refstr.c_str(), varstr.c_str());
114 
115   refstr = "  JuST Another\t\tTEst:\nWoRKs ";
116   varstr = "  juST another\t\ttEst:\nwoRKs ";
117   StringUtils::ToCapitalize(varstr);
118   EXPECT_STREQ(refstr.c_str(), varstr.c_str());
119 
120   refstr = "N.Y.P.D";
121   varstr = "n.y.p.d";
122   StringUtils::ToCapitalize(varstr);
123   EXPECT_STREQ(refstr.c_str(), varstr.c_str());
124 
125   refstr = "N-Y-P-D";
126   varstr = "n-y-p-d";
127   StringUtils::ToCapitalize(varstr);
128   EXPECT_STREQ(refstr.c_str(), varstr.c_str());
129 }
130 
TEST(TestStringUtils,EqualsNoCase)131 TEST(TestStringUtils, EqualsNoCase)
132 {
133   std::string refstr = "TeSt";
134 
135   EXPECT_TRUE(StringUtils::EqualsNoCase(refstr, "TeSt"));
136   EXPECT_TRUE(StringUtils::EqualsNoCase(refstr, "tEsT"));
137 }
138 
TEST(TestStringUtils,Left)139 TEST(TestStringUtils, Left)
140 {
141   std::string refstr, varstr;
142   std::string origstr = "test";
143 
144   refstr = "";
145   varstr = StringUtils::Left(origstr, 0);
146   EXPECT_STREQ(refstr.c_str(), varstr.c_str());
147 
148   refstr = "te";
149   varstr = StringUtils::Left(origstr, 2);
150   EXPECT_STREQ(refstr.c_str(), varstr.c_str());
151 
152   refstr = "test";
153   varstr = StringUtils::Left(origstr, 10);
154   EXPECT_STREQ(refstr.c_str(), varstr.c_str());
155 }
156 
TEST(TestStringUtils,Mid)157 TEST(TestStringUtils, Mid)
158 {
159   std::string refstr, varstr;
160   std::string origstr = "test";
161 
162   refstr = "";
163   varstr = StringUtils::Mid(origstr, 0, 0);
164   EXPECT_STREQ(refstr.c_str(), varstr.c_str());
165 
166   refstr = "te";
167   varstr = StringUtils::Mid(origstr, 0, 2);
168   EXPECT_STREQ(refstr.c_str(), varstr.c_str());
169 
170   refstr = "test";
171   varstr = StringUtils::Mid(origstr, 0, 10);
172   EXPECT_STREQ(refstr.c_str(), varstr.c_str());
173 
174   refstr = "st";
175   varstr = StringUtils::Mid(origstr, 2);
176   EXPECT_STREQ(refstr.c_str(), varstr.c_str());
177 
178   refstr = "st";
179   varstr = StringUtils::Mid(origstr, 2, 2);
180   EXPECT_STREQ(refstr.c_str(), varstr.c_str());
181 
182   refstr = "es";
183   varstr = StringUtils::Mid(origstr, 1, 2);
184   EXPECT_STREQ(refstr.c_str(), varstr.c_str());
185 }
186 
TEST(TestStringUtils,Right)187 TEST(TestStringUtils, Right)
188 {
189   std::string refstr, varstr;
190   std::string origstr = "test";
191 
192   refstr = "";
193   varstr = StringUtils::Right(origstr, 0);
194   EXPECT_STREQ(refstr.c_str(), varstr.c_str());
195 
196   refstr = "st";
197   varstr = StringUtils::Right(origstr, 2);
198   EXPECT_STREQ(refstr.c_str(), varstr.c_str());
199 
200   refstr = "test";
201   varstr = StringUtils::Right(origstr, 10);
202   EXPECT_STREQ(refstr.c_str(), varstr.c_str());
203 }
204 
TEST(TestStringUtils,Trim)205 TEST(TestStringUtils, Trim)
206 {
207   std::string refstr = "test test";
208 
209   std::string varstr = " test test   ";
210   StringUtils::Trim(varstr);
211   EXPECT_STREQ(refstr.c_str(), varstr.c_str());
212 }
213 
TEST(TestStringUtils,TrimLeft)214 TEST(TestStringUtils, TrimLeft)
215 {
216   std::string refstr = "test test   ";
217 
218   std::string varstr = " test test   ";
219   StringUtils::TrimLeft(varstr);
220   EXPECT_STREQ(refstr.c_str(), varstr.c_str());
221 }
222 
TEST(TestStringUtils,TrimRight)223 TEST(TestStringUtils, TrimRight)
224 {
225   std::string refstr = " test test";
226 
227   std::string varstr = " test test   ";
228   StringUtils::TrimRight(varstr);
229   EXPECT_STREQ(refstr.c_str(), varstr.c_str());
230 }
231 
TEST(TestStringUtils,Replace)232 TEST(TestStringUtils, Replace)
233 {
234   std::string refstr = "text text";
235 
236   std::string varstr = "test test";
237   EXPECT_EQ(StringUtils::Replace(varstr, 's', 'x'), 2);
238   EXPECT_STREQ(refstr.c_str(), varstr.c_str());
239 
240   EXPECT_EQ(StringUtils::Replace(varstr, 's', 'x'), 0);
241   EXPECT_STREQ(refstr.c_str(), varstr.c_str());
242 
243   varstr = "test test";
244   EXPECT_EQ(StringUtils::Replace(varstr, "s", "x"), 2);
245   EXPECT_STREQ(refstr.c_str(), varstr.c_str());
246 
247   EXPECT_EQ(StringUtils::Replace(varstr, "s", "x"), 0);
248   EXPECT_STREQ(refstr.c_str(), varstr.c_str());
249 }
250 
TEST(TestStringUtils,StartsWith)251 TEST(TestStringUtils, StartsWith)
252 {
253   std::string refstr = "test";
254 
255   EXPECT_FALSE(StringUtils::StartsWithNoCase(refstr, "x"));
256 
257   EXPECT_TRUE(StringUtils::StartsWith(refstr, "te"));
258   EXPECT_TRUE(StringUtils::StartsWith(refstr, "test"));
259   EXPECT_FALSE(StringUtils::StartsWith(refstr, "Te"));
260 
261   EXPECT_TRUE(StringUtils::StartsWithNoCase(refstr, "Te"));
262   EXPECT_TRUE(StringUtils::StartsWithNoCase(refstr, "TesT"));
263 }
264 
TEST(TestStringUtils,EndsWith)265 TEST(TestStringUtils, EndsWith)
266 {
267   std::string refstr = "test";
268 
269   EXPECT_FALSE(StringUtils::EndsWithNoCase(refstr, "x"));
270 
271   EXPECT_TRUE(StringUtils::EndsWith(refstr, "st"));
272   EXPECT_TRUE(StringUtils::EndsWith(refstr, "test"));
273   EXPECT_FALSE(StringUtils::EndsWith(refstr, "sT"));
274 
275   EXPECT_TRUE(StringUtils::EndsWithNoCase(refstr, "sT"));
276   EXPECT_TRUE(StringUtils::EndsWithNoCase(refstr, "TesT"));
277 }
278 
TEST(TestStringUtils,Join)279 TEST(TestStringUtils, Join)
280 {
281   std::string refstr, varstr;
282   std::vector<std::string> strarray;
283 
284   strarray.emplace_back("a");
285   strarray.emplace_back("b");
286   strarray.emplace_back("c");
287   strarray.emplace_back("de");
288   strarray.emplace_back(",");
289   strarray.emplace_back("fg");
290   strarray.emplace_back(",");
291   refstr = "a,b,c,de,,,fg,,";
292   varstr = StringUtils::Join(strarray, ",");
293   EXPECT_STREQ(refstr.c_str(), varstr.c_str());
294 }
295 
TEST(TestStringUtils,Split)296 TEST(TestStringUtils, Split)
297 {
298   std::vector<std::string> varresults;
299 
300   // test overload with string as delimiter
301   varresults = StringUtils::Split("g,h,ij,k,lm,,n", ",");
302   EXPECT_STREQ("g", varresults.at(0).c_str());
303   EXPECT_STREQ("h", varresults.at(1).c_str());
304   EXPECT_STREQ("ij", varresults.at(2).c_str());
305   EXPECT_STREQ("k", varresults.at(3).c_str());
306   EXPECT_STREQ("lm", varresults.at(4).c_str());
307   EXPECT_STREQ("", varresults.at(5).c_str());
308   EXPECT_STREQ("n", varresults.at(6).c_str());
309 
310   EXPECT_TRUE(StringUtils::Split("", "|").empty());
311 
312   EXPECT_EQ(4U, StringUtils::Split("a bc  d ef ghi ", " ", 4).size());
313   EXPECT_STREQ("d ef ghi ", StringUtils::Split("a bc  d ef ghi ", " ", 4).at(3).c_str()) << "Last part must include rest of the input string";
314   EXPECT_EQ(7U, StringUtils::Split("a bc  d ef ghi ", " ").size()) << "Result must be 7 strings including two empty strings";
315   EXPECT_STREQ("bc", StringUtils::Split("a bc  d ef ghi ", " ").at(1).c_str());
316   EXPECT_STREQ("", StringUtils::Split("a bc  d ef ghi ", " ").at(2).c_str());
317   EXPECT_STREQ("", StringUtils::Split("a bc  d ef ghi ", " ").at(6).c_str());
318 
319   EXPECT_EQ(2U, StringUtils::Split("a bc  d ef ghi ", "  ").size());
320   EXPECT_EQ(2U, StringUtils::Split("a bc  d ef ghi ", "  ", 10).size());
321   EXPECT_STREQ("a bc", StringUtils::Split("a bc  d ef ghi ", "  ", 10).at(0).c_str());
322 
323   EXPECT_EQ(1U, StringUtils::Split("a bc  d ef ghi ", " z").size());
324   EXPECT_STREQ("a bc  d ef ghi ", StringUtils::Split("a bc  d ef ghi ", " z").at(0).c_str());
325 
326   EXPECT_EQ(1U, StringUtils::Split("a bc  d ef ghi ", "").size());
327   EXPECT_STREQ("a bc  d ef ghi ", StringUtils::Split("a bc  d ef ghi ", "").at(0).c_str());
328 
329   // test overload with char as delimiter
330   EXPECT_EQ(4U, StringUtils::Split("a bc  d ef ghi ", ' ', 4).size());
331   EXPECT_STREQ("d ef ghi ", StringUtils::Split("a bc  d ef ghi ", ' ', 4).at(3).c_str());
332   EXPECT_EQ(7U, StringUtils::Split("a bc  d ef ghi ", ' ').size()) << "Result must be 7 strings including two empty strings";
333   EXPECT_STREQ("bc", StringUtils::Split("a bc  d ef ghi ", ' ').at(1).c_str());
334   EXPECT_STREQ("", StringUtils::Split("a bc  d ef ghi ", ' ').at(2).c_str());
335   EXPECT_STREQ("", StringUtils::Split("a bc  d ef ghi ", ' ').at(6).c_str());
336 
337   EXPECT_EQ(1U, StringUtils::Split("a bc  d ef ghi ", 'z').size());
338   EXPECT_STREQ("a bc  d ef ghi ", StringUtils::Split("a bc  d ef ghi ", 'z').at(0).c_str());
339 
340   EXPECT_EQ(1U, StringUtils::Split("a bc  d ef ghi ", "").size());
341   EXPECT_STREQ("a bc  d ef ghi ", StringUtils::Split("a bc  d ef ghi ", 'z').at(0).c_str());
342 }
343 
TEST(TestStringUtils,FindNumber)344 TEST(TestStringUtils, FindNumber)
345 {
346   EXPECT_EQ(3, StringUtils::FindNumber("aabcaadeaa", "aa"));
347   EXPECT_EQ(1, StringUtils::FindNumber("aabcaadeaa", "b"));
348 }
349 
TEST(TestStringUtils,AlphaNumericCompare)350 TEST(TestStringUtils, AlphaNumericCompare)
351 {
352   int64_t ref, var;
353 
354   ref = 0;
355   var = StringUtils::AlphaNumericCompare(L"123abc", L"abc123");
356   EXPECT_LT(var, ref);
357 }
358 
TEST(TestStringUtils,TimeStringToSeconds)359 TEST(TestStringUtils, TimeStringToSeconds)
360 {
361   EXPECT_EQ(77455, StringUtils::TimeStringToSeconds("21:30:55"));
362   EXPECT_EQ(7*60, StringUtils::TimeStringToSeconds("7 min"));
363   EXPECT_EQ(7*60, StringUtils::TimeStringToSeconds("7 min\t"));
364   EXPECT_EQ(154*60, StringUtils::TimeStringToSeconds("   154 min"));
365   EXPECT_EQ(1*60+1, StringUtils::TimeStringToSeconds("1:01"));
366   EXPECT_EQ(4*60+3, StringUtils::TimeStringToSeconds("4:03"));
367   EXPECT_EQ(2*3600+4*60+3, StringUtils::TimeStringToSeconds("2:04:03"));
368   EXPECT_EQ(2*3600+4*60+3, StringUtils::TimeStringToSeconds("   2:4:3"));
369   EXPECT_EQ(2*3600+4*60+3, StringUtils::TimeStringToSeconds("  \t\t 02:04:03 \n "));
370   EXPECT_EQ(1*3600+5*60+2, StringUtils::TimeStringToSeconds("01:05:02:04:03 \n "));
371   EXPECT_EQ(0, StringUtils::TimeStringToSeconds("blah"));
372   EXPECT_EQ(0, StringUtils::TimeStringToSeconds("ля-ля"));
373 }
374 
TEST(TestStringUtils,RemoveCRLF)375 TEST(TestStringUtils, RemoveCRLF)
376 {
377   std::string refstr, varstr;
378 
379   refstr = "test\r\nstring\nblah blah";
380   varstr = "test\r\nstring\nblah blah\n";
381   StringUtils::RemoveCRLF(varstr);
382   EXPECT_STREQ(refstr.c_str(), varstr.c_str());
383 }
384 
TEST(TestStringUtils,utf8_strlen)385 TEST(TestStringUtils, utf8_strlen)
386 {
387   size_t ref, var;
388 
389   ref = 9;
390   var = StringUtils::utf8_strlen("ｔｅｓｔ＿ＵＴＦ８");
391   EXPECT_EQ(ref, var);
392 }
393 
TEST(TestStringUtils,SecondsToTimeString)394 TEST(TestStringUtils, SecondsToTimeString)
395 {
396   std::string ref, var;
397 
398   ref = "21:30:55";
399   var = StringUtils::SecondsToTimeString(77455);
400   EXPECT_STREQ(ref.c_str(), var.c_str());
401 }
402 
TEST(TestStringUtils,IsNaturalNumber)403 TEST(TestStringUtils, IsNaturalNumber)
404 {
405   EXPECT_TRUE(StringUtils::IsNaturalNumber("10"));
406   EXPECT_TRUE(StringUtils::IsNaturalNumber(" 10"));
407   EXPECT_TRUE(StringUtils::IsNaturalNumber("0"));
408   EXPECT_FALSE(StringUtils::IsNaturalNumber(" 1 0"));
409   EXPECT_FALSE(StringUtils::IsNaturalNumber("1.0"));
410   EXPECT_FALSE(StringUtils::IsNaturalNumber("1.1"));
411   EXPECT_FALSE(StringUtils::IsNaturalNumber("0x1"));
412   EXPECT_FALSE(StringUtils::IsNaturalNumber("blah"));
413   EXPECT_FALSE(StringUtils::IsNaturalNumber("120 h"));
414   EXPECT_FALSE(StringUtils::IsNaturalNumber(" "));
415   EXPECT_FALSE(StringUtils::IsNaturalNumber(""));
416 }
417 
TEST(TestStringUtils,IsInteger)418 TEST(TestStringUtils, IsInteger)
419 {
420   EXPECT_TRUE(StringUtils::IsInteger("10"));
421   EXPECT_TRUE(StringUtils::IsInteger(" -10"));
422   EXPECT_TRUE(StringUtils::IsInteger("0"));
423   EXPECT_FALSE(StringUtils::IsInteger(" 1 0"));
424   EXPECT_FALSE(StringUtils::IsInteger("1.0"));
425   EXPECT_FALSE(StringUtils::IsInteger("1.1"));
426   EXPECT_FALSE(StringUtils::IsInteger("0x1"));
427   EXPECT_FALSE(StringUtils::IsInteger("blah"));
428   EXPECT_FALSE(StringUtils::IsInteger("120 h"));
429   EXPECT_FALSE(StringUtils::IsInteger(" "));
430   EXPECT_FALSE(StringUtils::IsInteger(""));
431 }
432 
TEST(TestStringUtils,SizeToString)433 TEST(TestStringUtils, SizeToString)
434 {
435   std::string ref, var;
436 
437   ref = "2.00 GB";
438   var = StringUtils::SizeToString(2147483647);
439   EXPECT_STREQ(ref.c_str(), var.c_str());
440 }
441 
TEST(TestStringUtils,EmptyString)442 TEST(TestStringUtils, EmptyString)
443 {
444   EXPECT_STREQ("", StringUtils::Empty.c_str());
445 }
446 
TEST(TestStringUtils,FindWords)447 TEST(TestStringUtils, FindWords)
448 {
449   size_t ref, var;
450 
451   ref = 5;
452   var = StringUtils::FindWords("test string", "string");
453   EXPECT_EQ(ref, var);
454   var = StringUtils::FindWords("12345string", "string");
455   EXPECT_EQ(ref, var);
456   var = StringUtils::FindWords("apple2012", "2012");
457   EXPECT_EQ(ref, var);
458   ref = -1;
459   var = StringUtils::FindWords("12345string", "ring");
460   EXPECT_EQ(ref, var);
461   var = StringUtils::FindWords("12345string", "345");
462   EXPECT_EQ(ref, var);
463   var = StringUtils::FindWords("apple2012", "e2012");
464   EXPECT_EQ(ref, var);
465   var = StringUtils::FindWords("apple2012", "12");
466   EXPECT_EQ(ref, var);
467 }
468 
TEST(TestStringUtils,FindWords_NonAscii)469 TEST(TestStringUtils, FindWords_NonAscii)
470 {
471   size_t ref, var;
472 
473   ref = 6;
474   var = StringUtils::FindWords("我的视频", "视频");
475   EXPECT_EQ(ref, var);
476   var = StringUtils::FindWords("我的视频", "视");
477   EXPECT_EQ(ref, var);
478   var = StringUtils::FindWords("Apple ple", "ple");
479   EXPECT_EQ(ref, var);
480   ref = 7;
481   var = StringUtils::FindWords("Äpfel.pfel", "pfel");
482   EXPECT_EQ(ref, var);
483 }
484 
TEST(TestStringUtils,FindEndBracket)485 TEST(TestStringUtils, FindEndBracket)
486 {
487   int ref, var;
488 
489   ref = 11;
490   var = StringUtils::FindEndBracket("atest testbb test", 'a', 'b');
491   EXPECT_EQ(ref, var);
492 }
493 
TEST(TestStringUtils,DateStringToYYYYMMDD)494 TEST(TestStringUtils, DateStringToYYYYMMDD)
495 {
496   int ref, var;
497 
498   ref = 20120706;
499   var = StringUtils::DateStringToYYYYMMDD("2012-07-06");
500   EXPECT_EQ(ref, var);
501 }
502 
TEST(TestStringUtils,WordToDigits)503 TEST(TestStringUtils, WordToDigits)
504 {
505   std::string ref, var;
506 
507   ref = "8378 787464";
508   var = "test string";
509   StringUtils::WordToDigits(var);
510   EXPECT_STREQ(ref.c_str(), var.c_str());
511 }
512 
TEST(TestStringUtils,CreateUUID)513 TEST(TestStringUtils, CreateUUID)
514 {
515   std::cout << "CreateUUID(): " << StringUtils::CreateUUID() << std::endl;
516 }
517 
TEST(TestStringUtils,ValidateUUID)518 TEST(TestStringUtils, ValidateUUID)
519 {
520   EXPECT_TRUE(StringUtils::ValidateUUID(StringUtils::CreateUUID()));
521 }
522 
TEST(TestStringUtils,CompareFuzzy)523 TEST(TestStringUtils, CompareFuzzy)
524 {
525   double ref, var;
526 
527   ref = 6.25f;
528   var = StringUtils::CompareFuzzy("test string", "string test");
529   EXPECT_EQ(ref, var);
530 }
531 
TEST(TestStringUtils,FindBestMatch)532 TEST(TestStringUtils, FindBestMatch)
533 {
534   double refdouble, vardouble;
535   int refint, varint;
536   std::vector<std::string> strarray;
537 
538   refint = 3;
539   refdouble = 0.5625f;
540   strarray.emplace_back("");
541   strarray.emplace_back("a");
542   strarray.emplace_back("e");
543   strarray.emplace_back("es");
544   strarray.emplace_back("t");
545   varint = StringUtils::FindBestMatch("test", strarray, vardouble);
546   EXPECT_EQ(refint, varint);
547   EXPECT_EQ(refdouble, vardouble);
548 }
549 
TEST(TestStringUtils,Paramify)550 TEST(TestStringUtils, Paramify)
551 {
552   const char *input = "some, very \\ odd \"string\"";
553   const char *ref   = "\"some, very \\\\ odd \\\"string\\\"\"";
554 
555   std::string result = StringUtils::Paramify(input);
556   EXPECT_STREQ(ref, result.c_str());
557 }
558 
TEST(TestStringUtils,sortstringbyname)559 TEST(TestStringUtils, sortstringbyname)
560 {
561   std::vector<std::string> strarray;
562   strarray.emplace_back("B");
563   strarray.emplace_back("c");
564   strarray.emplace_back("a");
565   std::sort(strarray.begin(), strarray.end(), sortstringbyname());
566 
567   EXPECT_STREQ("a", strarray[0].c_str());
568   EXPECT_STREQ("B", strarray[1].c_str());
569   EXPECT_STREQ("c", strarray[2].c_str());
570 }
571 
TEST(TestStringUtils,FileSizeFormat)572 TEST(TestStringUtils, FileSizeFormat)
573 {
574   EXPECT_STREQ("0B", StringUtils::FormatFileSize(0).c_str());
575 
576   EXPECT_STREQ("999B", StringUtils::FormatFileSize(999).c_str());
577   EXPECT_STREQ("0.98kB", StringUtils::FormatFileSize(1000).c_str());
578 
579   EXPECT_STREQ("1.00kB", StringUtils::FormatFileSize(1024).c_str());
580   EXPECT_STREQ("9.99kB", StringUtils::FormatFileSize(10229).c_str());
581 
582   EXPECT_STREQ("10.1kB", StringUtils::FormatFileSize(10387).c_str());
583   EXPECT_STREQ("99.9kB", StringUtils::FormatFileSize(102297).c_str());
584 
585   EXPECT_STREQ("100kB", StringUtils::FormatFileSize(102400).c_str());
586   EXPECT_STREQ("999kB", StringUtils::FormatFileSize(1023431).c_str());
587 
588   EXPECT_STREQ("0.98MB", StringUtils::FormatFileSize(1023897).c_str());
589   EXPECT_STREQ("0.98MB", StringUtils::FormatFileSize(1024000).c_str());
590 
591   //Last unit should overflow the 3 digit limit
592   EXPECT_STREQ("5432PB", StringUtils::FormatFileSize(6115888293969133568).c_str());
593 }
594 
TEST(TestStringUtils,ToHexadecimal)595 TEST(TestStringUtils, ToHexadecimal)
596 {
597   EXPECT_STREQ("", StringUtils::ToHexadecimal("").c_str());
598   EXPECT_STREQ("616263", StringUtils::ToHexadecimal("abc").c_str());
599   std::string a{"a\0b\n", 4};
600   EXPECT_STREQ("6100620a", StringUtils::ToHexadecimal(a).c_str());
601   std::string nul{"\0", 1};
602   EXPECT_STREQ("00", StringUtils::ToHexadecimal(nul).c_str());
603   std::string ff{"\xFF", 1};
604   EXPECT_STREQ("ff", StringUtils::ToHexadecimal(ff).c_str());
605 }
606