UtilTest.cc 31 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980
  1. #include "util.h"
  2. #include <cstring>
  3. #include <string>
  4. #include <iostream>
  5. #include <cppunit/extensions/HelperMacros.h>
  6. #include "FixedNumberRandomizer.h"
  7. #include "DlAbortEx.h"
  8. #include "BitfieldMan.h"
  9. #include "ByteArrayDiskWriter.h"
  10. #include "FileEntry.h"
  11. #include "File.h"
  12. #include "array_fun.h"
  13. namespace aria2 {
  14. class UtilTest:public CppUnit::TestFixture {
  15. CPPUNIT_TEST_SUITE(UtilTest);
  16. CPPUNIT_TEST(testTrim);
  17. CPPUNIT_TEST(testSplit);
  18. CPPUNIT_TEST(testSplit_many);
  19. CPPUNIT_TEST(testEndsWith);
  20. CPPUNIT_TEST(testReplace);
  21. CPPUNIT_TEST(testStartsWith);
  22. // may be moved to other helper class in the future.
  23. CPPUNIT_TEST(testGetContentDispositionFilename);
  24. CPPUNIT_TEST(testRandomAlpha);
  25. CPPUNIT_TEST(testToUpper);
  26. CPPUNIT_TEST(testToLower);
  27. CPPUNIT_TEST(testUrldecode);
  28. CPPUNIT_TEST(testGetRealSize);
  29. CPPUNIT_TEST(testAbbrevSize);
  30. CPPUNIT_TEST(testToStream);
  31. CPPUNIT_TEST(testIsNumber);
  32. CPPUNIT_TEST(testIsLowercase);
  33. CPPUNIT_TEST(testIsUppercase);
  34. CPPUNIT_TEST(testAlphaToNum);
  35. CPPUNIT_TEST(testMkdirs);
  36. CPPUNIT_TEST(testConvertBitfield);
  37. CPPUNIT_TEST(testParseIntRange);
  38. CPPUNIT_TEST(testParseIntRange_invalidRange);
  39. CPPUNIT_TEST(testParseInt);
  40. CPPUNIT_TEST(testParseUInt);
  41. CPPUNIT_TEST(testParseLLInt);
  42. CPPUNIT_TEST(testParseULLInt);
  43. CPPUNIT_TEST(testToString_binaryStream);
  44. CPPUNIT_TEST(testItos);
  45. CPPUNIT_TEST(testUitos);
  46. CPPUNIT_TEST(testNtoh64);
  47. CPPUNIT_TEST(testUrlencode);
  48. CPPUNIT_TEST(testHtmlEscape);
  49. CPPUNIT_TEST(testJoinPath);
  50. CPPUNIT_TEST(testParseIndexPath);
  51. CPPUNIT_TEST(testCreateIndexPathMap);
  52. CPPUNIT_TEST(testGenerateRandomData);
  53. CPPUNIT_TEST(testFromHex);
  54. CPPUNIT_TEST(testParsePrioritizePieceRange);
  55. CPPUNIT_TEST(testApplyDir);
  56. CPPUNIT_TEST(testFixTaintedBasename);
  57. CPPUNIT_TEST(testIsNumericHost);
  58. CPPUNIT_TEST_SUITE_END();
  59. private:
  60. public:
  61. void setUp() {
  62. }
  63. void testTrim();
  64. void testSplit();
  65. void testSplit_many();
  66. void testEndsWith();
  67. void testReplace();
  68. void testStartsWith();
  69. // may be moved to other helper class in the future.
  70. void testGetContentDispositionFilename();
  71. void testRandomAlpha();
  72. void testToUpper();
  73. void testToLower();
  74. void testUrldecode();
  75. void testGetRealSize();
  76. void testAbbrevSize();
  77. void testToStream();
  78. void testIsNumber();
  79. void testIsLowercase();
  80. void testIsUppercase();
  81. void testAlphaToNum();
  82. void testMkdirs();
  83. void testConvertBitfield();
  84. void testParseIntRange();
  85. void testParseIntRange_invalidRange();
  86. void testParseInt();
  87. void testParseUInt();
  88. void testParseLLInt();
  89. void testParseULLInt();
  90. void testToString_binaryStream();
  91. void testItos();
  92. void testUitos();
  93. void testNtoh64();
  94. void testUrlencode();
  95. void testHtmlEscape();
  96. void testJoinPath();
  97. void testParseIndexPath();
  98. void testCreateIndexPathMap();
  99. void testGenerateRandomData();
  100. void testFromHex();
  101. void testParsePrioritizePieceRange();
  102. void testApplyDir();
  103. void testFixTaintedBasename();
  104. void testIsNumericHost();
  105. };
  106. CPPUNIT_TEST_SUITE_REGISTRATION( UtilTest );
  107. void UtilTest::testTrim() {
  108. std::string str1 = "aria2";
  109. CPPUNIT_ASSERT_EQUAL(str1, util::trim("aria2"));
  110. CPPUNIT_ASSERT_EQUAL(str1, util::trim(" aria2"));
  111. CPPUNIT_ASSERT_EQUAL(str1, util::trim(" aria2 "));
  112. CPPUNIT_ASSERT_EQUAL(str1, util::trim(" aria2 "));
  113. std::string str2 = "aria2 debut";
  114. CPPUNIT_ASSERT_EQUAL(str2, util::trim("aria2 debut"));
  115. CPPUNIT_ASSERT_EQUAL(str2, util::trim(" aria2 debut "));
  116. std::string str3 = "";
  117. CPPUNIT_ASSERT_EQUAL(str3, util::trim(""));
  118. CPPUNIT_ASSERT_EQUAL(str3, util::trim(" "));
  119. CPPUNIT_ASSERT_EQUAL(str3, util::trim(" "));
  120. std::string str4 = "A";
  121. CPPUNIT_ASSERT_EQUAL(str4, util::trim("A"));
  122. CPPUNIT_ASSERT_EQUAL(str4, util::trim(" A "));
  123. CPPUNIT_ASSERT_EQUAL(str4, util::trim(" A "));
  124. }
  125. void UtilTest::testSplit() {
  126. std::pair<std::string, std::string> p1;
  127. util::split(p1, "name=value", '=');
  128. CPPUNIT_ASSERT_EQUAL(std::string("name"), p1.first);
  129. CPPUNIT_ASSERT_EQUAL(std::string("value"), p1.second);
  130. util::split(p1, " name = value ", '=');
  131. CPPUNIT_ASSERT_EQUAL(std::string("name"), p1.first);
  132. CPPUNIT_ASSERT_EQUAL(std::string("value"), p1.second);
  133. util::split(p1, "=value", '=');
  134. CPPUNIT_ASSERT_EQUAL(std::string(""), p1.first);
  135. CPPUNIT_ASSERT_EQUAL(std::string("value"), p1.second);
  136. util::split(p1, "name=", '=');
  137. CPPUNIT_ASSERT_EQUAL(std::string("name"), p1.first);
  138. CPPUNIT_ASSERT_EQUAL(std::string(""), p1.second);
  139. util::split(p1, "name", '=');
  140. CPPUNIT_ASSERT_EQUAL(std::string("name"), p1.first);
  141. CPPUNIT_ASSERT_EQUAL(std::string(""), p1.second);
  142. }
  143. void UtilTest::testSplit_many() {
  144. std::vector<std::string> v1;
  145. util::split("name1=value1; name2=value2; name3=value3",std::back_inserter(v1),
  146. ";", true);
  147. CPPUNIT_ASSERT_EQUAL((size_t)3, v1.size());
  148. std::vector<std::string>::iterator itr = v1.begin();
  149. CPPUNIT_ASSERT_EQUAL(std::string("name1=value1"), *itr++);
  150. CPPUNIT_ASSERT_EQUAL(std::string("name2=value2"), *itr++);
  151. CPPUNIT_ASSERT_EQUAL(std::string("name3=value3"), *itr++);
  152. v1.clear();
  153. util::split("name1=value1; name2=value2; name3=value3",std::back_inserter(v1),
  154. ";", false);
  155. CPPUNIT_ASSERT_EQUAL((size_t)3, v1.size());
  156. itr = v1.begin();
  157. CPPUNIT_ASSERT_EQUAL(std::string("name1=value1"), *itr++);
  158. CPPUNIT_ASSERT_EQUAL(std::string(" name2=value2"), *itr++);
  159. CPPUNIT_ASSERT_EQUAL(std::string(" name3=value3"), *itr++);
  160. v1.clear();
  161. util::split("k=v", std::back_inserter(v1), ";", false, true);
  162. CPPUNIT_ASSERT_EQUAL((size_t)1, v1.size());
  163. CPPUNIT_ASSERT_EQUAL(std::string("k=v"), v1[0]);
  164. v1.clear();
  165. util::split(" ", std::back_inserter(v1), ";", true, true);
  166. CPPUNIT_ASSERT_EQUAL((size_t)1, v1.size());
  167. CPPUNIT_ASSERT_EQUAL(std::string(""), v1[0]);
  168. v1.clear();
  169. util::split(" ", std::back_inserter(v1), ";", true);
  170. CPPUNIT_ASSERT_EQUAL((size_t)0, v1.size());
  171. }
  172. void UtilTest::testEndsWith() {
  173. std::string target = "abcdefg";
  174. std::string part = "fg";
  175. CPPUNIT_ASSERT(util::endsWith(target, part));
  176. target = "abdefg";
  177. part = "g";
  178. CPPUNIT_ASSERT(util::endsWith(target, part));
  179. target = "abdefg";
  180. part = "eg";
  181. CPPUNIT_ASSERT(!util::endsWith(target, part));
  182. target = "g";
  183. part = "eg";
  184. CPPUNIT_ASSERT(!util::endsWith(target, part));
  185. target = "g";
  186. part = "g";
  187. CPPUNIT_ASSERT(util::endsWith(target, part));
  188. target = "g";
  189. part = "";
  190. CPPUNIT_ASSERT(util::endsWith(target, part));
  191. target = "";
  192. part = "";
  193. CPPUNIT_ASSERT(util::endsWith(target, part));
  194. target = "";
  195. part = "g";
  196. CPPUNIT_ASSERT(!util::endsWith(target, part));
  197. }
  198. void UtilTest::testReplace() {
  199. CPPUNIT_ASSERT_EQUAL(std::string("abc\n"), util::replace("abc\r\n", "\r", ""));
  200. CPPUNIT_ASSERT_EQUAL(std::string("abc"), util::replace("abc\r\n", "\r\n", ""));
  201. CPPUNIT_ASSERT_EQUAL(std::string(""), util::replace("", "\r\n", ""));
  202. CPPUNIT_ASSERT_EQUAL(std::string("abc"), util::replace("abc", "", "a"));
  203. CPPUNIT_ASSERT_EQUAL(std::string("xbc"), util::replace("abc", "a", "x"));
  204. }
  205. void UtilTest::testStartsWith() {
  206. std::string target;
  207. std::string part;
  208. target = "abcdefg";
  209. part = "abc";
  210. CPPUNIT_ASSERT(util::startsWith(target, part));
  211. target = "abcdefg";
  212. part = "abx";
  213. CPPUNIT_ASSERT(!util::startsWith(target, part));
  214. target = "abcdefg";
  215. part = "bcd";
  216. CPPUNIT_ASSERT(!util::startsWith(target, part));
  217. target = "";
  218. part = "a";
  219. CPPUNIT_ASSERT(!util::startsWith(target, part));
  220. target = "";
  221. part = "";
  222. CPPUNIT_ASSERT(util::startsWith(target, part));
  223. target = "a";
  224. part = "";
  225. CPPUNIT_ASSERT(util::startsWith(target, part));
  226. target = "a";
  227. part = "a";
  228. CPPUNIT_ASSERT(util::startsWith(target, part));
  229. }
  230. void UtilTest::testGetContentDispositionFilename() {
  231. std::string h1 = "attachment; filename=\"aria2.tar.bz2\"";
  232. CPPUNIT_ASSERT_EQUAL(std::string("aria2.tar.bz2"), util::getContentDispositionFilename(h1));
  233. std::string h2 = "attachment; filename=\"\"";
  234. CPPUNIT_ASSERT_EQUAL(std::string(""), util::getContentDispositionFilename(h2));
  235. std::string h3 = "attachment; filename=\"";
  236. CPPUNIT_ASSERT_EQUAL(std::string(""), util::getContentDispositionFilename(h3));
  237. std::string h4 = "attachment;";
  238. CPPUNIT_ASSERT_EQUAL(std::string(""), util::getContentDispositionFilename(h4));
  239. std::string h5 = "attachment; filename=aria2.tar.bz2";
  240. CPPUNIT_ASSERT_EQUAL(std::string("aria2.tar.bz2"), util::getContentDispositionFilename(h5));
  241. std::string h6 = "attachment; filename='aria2.tar.bz2'";
  242. CPPUNIT_ASSERT_EQUAL(std::string("aria2.tar.bz2"), util::getContentDispositionFilename(h6));
  243. std::string h7 = "attachment; filename='aria2.tar.bz2";
  244. CPPUNIT_ASSERT_EQUAL(std::string("aria2.tar.bz2"), util::getContentDispositionFilename(h7));
  245. std::string h8 = "attachment; filename=aria2.tar.bz2; creation-date=20 Jun 2007 00:00:00 GMT";
  246. CPPUNIT_ASSERT_EQUAL(std::string("aria2.tar.bz2"), util::getContentDispositionFilename(h8));
  247. std::string h9 = "attachment; filename=\"aria2.tar.bz2; creation-date=20 Jun 2007 00:00:00 GMT\"";
  248. CPPUNIT_ASSERT_EQUAL(std::string("aria2.tar.bz2"),
  249. util::getContentDispositionFilename(h9));
  250. std::string h10 = "attachment; filename=";
  251. CPPUNIT_ASSERT_EQUAL(std::string(""), util::getContentDispositionFilename(h10));
  252. std::string h11 = "attachment; filename=;";
  253. CPPUNIT_ASSERT_EQUAL(std::string(""), util::getContentDispositionFilename(h11));
  254. std::string filenameWithDir = "attachment; filename=dir/file";
  255. CPPUNIT_ASSERT_EQUAL(std::string("file"),
  256. util::getContentDispositionFilename(filenameWithDir));
  257. std::string parentDir = "attachment; filename=..";
  258. CPPUNIT_ASSERT_EQUAL(std::string(),
  259. util::getContentDispositionFilename(parentDir));
  260. std::string currentDir = "attachment; filename=.";
  261. CPPUNIT_ASSERT_EQUAL(std::string(),
  262. util::getContentDispositionFilename(currentDir));
  263. // RFC2231 Section4
  264. std::string extparam1 = "attachment; filename * = UTF-8'ja'filename";
  265. CPPUNIT_ASSERT_EQUAL(std::string("filename"),
  266. util::getContentDispositionFilename(extparam1));
  267. std::string extparam2 = "filename*=''aria2";
  268. CPPUNIT_ASSERT_EQUAL(std::string("aria2"),
  269. util::getContentDispositionFilename(extparam2));
  270. std::string extparam3 = "filename*='''";
  271. CPPUNIT_ASSERT_EQUAL(std::string(""),
  272. util::getContentDispositionFilename(extparam3));
  273. std::string extparam4 = "filename*='aria2";
  274. CPPUNIT_ASSERT_EQUAL(std::string(""),
  275. util::getContentDispositionFilename(extparam4));
  276. std::string extparam5 = "filename*='''aria2";
  277. CPPUNIT_ASSERT_EQUAL(std::string(""),
  278. util::getContentDispositionFilename(extparam5));
  279. std::string extparam6 = "filename*";
  280. CPPUNIT_ASSERT_EQUAL(std::string(""),
  281. util::getContentDispositionFilename(extparam6));
  282. std::string extparam7 = "filename*=UTF-8''aria2;filename=hello%20world";
  283. CPPUNIT_ASSERT_EQUAL(std::string("aria2"),
  284. util::getContentDispositionFilename(extparam7));
  285. std::string extparam8 = "filename=aria2;filename*=UTF-8''hello%20world";
  286. CPPUNIT_ASSERT_EQUAL(std::string("hello world"),
  287. util::getContentDispositionFilename(extparam8));
  288. std::string extparam9 = "filename*=iso-8859-1''%A3";
  289. std::string extparam9ans;
  290. extparam9ans += 0xc2;
  291. extparam9ans += 0xa3;
  292. CPPUNIT_ASSERT_EQUAL(extparam9ans,
  293. util::getContentDispositionFilename(extparam9));
  294. }
  295. class Printer {
  296. public:
  297. template<class T>
  298. void operator()(T t) {
  299. std::cerr << t << ", ";
  300. }
  301. };
  302. void UtilTest::testRandomAlpha() {
  303. SharedHandle<Randomizer> rand(new FixedNumberRandomizer());
  304. std::string s = util::randomAlpha(8, rand);
  305. CPPUNIT_ASSERT_EQUAL(std::string("AAAAAAAA"), s);
  306. }
  307. void UtilTest::testToUpper() {
  308. std::string src = "608cabc0f2fa18c260cafd974516865c772363d5";
  309. std::string upp = "608CABC0F2FA18C260CAFD974516865C772363D5";
  310. CPPUNIT_ASSERT_EQUAL(upp, util::toUpper(src));
  311. }
  312. void UtilTest::testToLower() {
  313. std::string src = "608CABC0F2FA18C260CAFD974516865C772363D5";
  314. std::string upp = "608cabc0f2fa18c260cafd974516865c772363d5";
  315. CPPUNIT_ASSERT_EQUAL(upp, util::toLower(src));
  316. }
  317. void UtilTest::testUrldecode() {
  318. std::string src = "http://aria2.sourceforge.net/aria2%200.7.0%20docs.html";
  319. CPPUNIT_ASSERT_EQUAL(std::string("http://aria2.sourceforge.net/aria2 0.7.0 docs.html"),
  320. util::urldecode(src));
  321. std::string src2 = "aria2+aria2";
  322. CPPUNIT_ASSERT_EQUAL(std::string("aria2+aria2"), util::urldecode(src2));
  323. std::string src3 = "%5t%20";
  324. CPPUNIT_ASSERT_EQUAL(std::string("%5t "), util::urldecode(src3));
  325. std::string src4 = "%";
  326. CPPUNIT_ASSERT_EQUAL(std::string("%"), util::urldecode(src4));
  327. std::string src5 = "%3";
  328. CPPUNIT_ASSERT_EQUAL(std::string("%3"), util::urldecode(src5));
  329. std::string src6 = "%2f";
  330. CPPUNIT_ASSERT_EQUAL(std::string("/"), util::urldecode(src6));
  331. }
  332. void UtilTest::testGetRealSize()
  333. {
  334. CPPUNIT_ASSERT_EQUAL((int64_t)4294967296LL, util::getRealSize("4096M"));
  335. CPPUNIT_ASSERT_EQUAL((int64_t)1024, util::getRealSize("1K"));
  336. try {
  337. util::getRealSize("");
  338. CPPUNIT_FAIL("exception must be thrown.");
  339. } catch(Exception& e) {
  340. std::cerr << e.stackTrace();
  341. }
  342. try {
  343. util::getRealSize("foo");
  344. CPPUNIT_FAIL("exception must be thrown.");
  345. } catch(Exception& e) {
  346. std::cerr << e.stackTrace();
  347. }
  348. try {
  349. util::getRealSize("-1");
  350. CPPUNIT_FAIL("exception must be thrown.");
  351. } catch(Exception& e) {
  352. std::cerr << e.stackTrace();
  353. }
  354. try {
  355. util::getRealSize("9223372036854775807K");
  356. CPPUNIT_FAIL("exception must be thrown.");
  357. } catch(Exception& e) {
  358. std::cerr << e.stackTrace();
  359. }
  360. try {
  361. util::getRealSize("9223372036854775807M");
  362. CPPUNIT_FAIL("exception must be thrown.");
  363. } catch(Exception& e) {
  364. std::cerr << e.stackTrace();
  365. }
  366. }
  367. void UtilTest::testAbbrevSize()
  368. {
  369. CPPUNIT_ASSERT_EQUAL(std::string("4,096.0Mi"), util::abbrevSize(4294967296LL));
  370. CPPUNIT_ASSERT_EQUAL(std::string("1.0Ki"), util::abbrevSize(1024));
  371. CPPUNIT_ASSERT_EQUAL(std::string("1,023"), util::abbrevSize(1023));
  372. CPPUNIT_ASSERT_EQUAL(std::string("0"), util::abbrevSize(0));
  373. CPPUNIT_ASSERT_EQUAL(std::string("1.1Ki"), util::abbrevSize(1127));
  374. CPPUNIT_ASSERT_EQUAL(std::string("1.5Mi"), util::abbrevSize(1572864));
  375. }
  376. void UtilTest::testToStream()
  377. {
  378. std::ostringstream os;
  379. SharedHandle<FileEntry> f1(new FileEntry("aria2.tar.bz2", 12300, 0));
  380. SharedHandle<FileEntry> f2(new FileEntry("aria2.txt", 556, 0));
  381. std::deque<SharedHandle<FileEntry> > entries;
  382. entries.push_back(f1);
  383. entries.push_back(f2);
  384. util::toStream(entries.begin(), entries.end(), os);
  385. CPPUNIT_ASSERT_EQUAL(
  386. std::string("Files:\n"
  387. "idx|path/length\n"
  388. "===+===========================================================================\n"
  389. " 1|aria2.tar.bz2\n"
  390. " |12.0KiB (12,300)\n"
  391. "---+---------------------------------------------------------------------------\n"
  392. " 2|aria2.txt\n"
  393. " |556B (556)\n"
  394. "---+---------------------------------------------------------------------------\n"),
  395. os.str());
  396. }
  397. void UtilTest::testIsNumber()
  398. {
  399. CPPUNIT_ASSERT_EQUAL(true, util::isNumber("000"));
  400. CPPUNIT_ASSERT_EQUAL(false, util::isNumber("a"));
  401. CPPUNIT_ASSERT_EQUAL(false, util::isNumber("0a"));
  402. CPPUNIT_ASSERT_EQUAL(false, util::isNumber(""));
  403. CPPUNIT_ASSERT_EQUAL(false, util::isNumber(" "));
  404. }
  405. void UtilTest::testIsLowercase()
  406. {
  407. CPPUNIT_ASSERT_EQUAL(true, util::isLowercase("alpha"));
  408. CPPUNIT_ASSERT_EQUAL(false, util::isLowercase("Alpha"));
  409. CPPUNIT_ASSERT_EQUAL(false, util::isLowercase("1alpha"));
  410. CPPUNIT_ASSERT_EQUAL(false, util::isLowercase(""));
  411. CPPUNIT_ASSERT_EQUAL(false, util::isLowercase(" "));
  412. }
  413. void UtilTest::testIsUppercase()
  414. {
  415. CPPUNIT_ASSERT_EQUAL(true, util::isUppercase("ALPHA"));
  416. CPPUNIT_ASSERT_EQUAL(false, util::isUppercase("Alpha"));
  417. CPPUNIT_ASSERT_EQUAL(false, util::isUppercase("1ALPHA"));
  418. CPPUNIT_ASSERT_EQUAL(false, util::isUppercase(""));
  419. CPPUNIT_ASSERT_EQUAL(false, util::isUppercase(" "));
  420. }
  421. void UtilTest::testAlphaToNum()
  422. {
  423. CPPUNIT_ASSERT_EQUAL(0U, util::alphaToNum("a"));
  424. CPPUNIT_ASSERT_EQUAL(0U, util::alphaToNum("aa"));
  425. CPPUNIT_ASSERT_EQUAL(1U, util::alphaToNum("b"));
  426. CPPUNIT_ASSERT_EQUAL(675U, util::alphaToNum("zz")); // 25*26+25
  427. CPPUNIT_ASSERT_EQUAL(675U, util::alphaToNum("ZZ")); // 25*26+25
  428. CPPUNIT_ASSERT_EQUAL(0U, util::alphaToNum(""));
  429. CPPUNIT_ASSERT_EQUAL(4294967295U, util::alphaToNum("NXMRLXV"));
  430. CPPUNIT_ASSERT_EQUAL(0U, util::alphaToNum("NXMRLXW")); // uint32_t overflow
  431. }
  432. void UtilTest::testMkdirs()
  433. {
  434. std::string dir = "/tmp/aria2-UtilTest-testMkdirs";
  435. File d(dir);
  436. if(d.exists()) {
  437. CPPUNIT_ASSERT(d.remove());
  438. }
  439. CPPUNIT_ASSERT(!d.exists());
  440. util::mkdirs(dir);
  441. CPPUNIT_ASSERT(d.isDir());
  442. std::string file = "./UtilTest.cc";
  443. File f(file);
  444. CPPUNIT_ASSERT(f.isFile());
  445. try {
  446. util::mkdirs(file);
  447. CPPUNIT_FAIL("exception must be thrown.");
  448. } catch(DlAbortEx& ex) {
  449. std::cerr << ex.stackTrace() << std::endl;
  450. }
  451. }
  452. void UtilTest::testConvertBitfield()
  453. {
  454. BitfieldMan srcBitfield(384*1024, 256*1024*256+1);
  455. BitfieldMan destBitfield(512*1024, srcBitfield.getTotalLength());
  456. srcBitfield.setAllBit();
  457. srcBitfield.unsetBit(2);// <- range [768, 1152)
  458. // which corresponds to the index [1,2] in destBitfield
  459. util::convertBitfield(&destBitfield, &srcBitfield);
  460. CPPUNIT_ASSERT_EQUAL(std::string("9fffffffffffffffffffffffffffffff80"),
  461. util::toHex(destBitfield.getBitfield(),
  462. destBitfield.getBitfieldLength()));
  463. }
  464. void UtilTest::testParseIntRange()
  465. {
  466. IntSequence seq = util::parseIntRange("1,3-8,10");
  467. CPPUNIT_ASSERT(seq.hasNext());
  468. CPPUNIT_ASSERT_EQUAL((int32_t)1, seq.next());
  469. CPPUNIT_ASSERT(seq.hasNext());
  470. CPPUNIT_ASSERT_EQUAL((int32_t)3, seq.next());
  471. CPPUNIT_ASSERT(seq.hasNext());
  472. CPPUNIT_ASSERT_EQUAL((int32_t)4, seq.next());
  473. CPPUNIT_ASSERT(seq.hasNext());
  474. CPPUNIT_ASSERT_EQUAL((int32_t)5, seq.next());
  475. CPPUNIT_ASSERT(seq.hasNext());
  476. CPPUNIT_ASSERT_EQUAL((int32_t)6, seq.next());
  477. CPPUNIT_ASSERT(seq.hasNext());
  478. CPPUNIT_ASSERT_EQUAL((int32_t)7, seq.next());
  479. CPPUNIT_ASSERT(seq.hasNext());
  480. CPPUNIT_ASSERT_EQUAL((int32_t)8, seq.next());
  481. CPPUNIT_ASSERT(seq.hasNext());
  482. CPPUNIT_ASSERT_EQUAL((int32_t)10, seq.next());
  483. CPPUNIT_ASSERT(!seq.hasNext());
  484. CPPUNIT_ASSERT_EQUAL((int32_t)0, seq.next());
  485. }
  486. void UtilTest::testParseIntRange_invalidRange()
  487. {
  488. try {
  489. IntSequence seq = util::parseIntRange("-1");
  490. CPPUNIT_FAIL("exception must be thrown.");
  491. } catch(Exception& e) {
  492. std::cerr << e.stackTrace();
  493. }
  494. try {
  495. IntSequence seq = util::parseIntRange("2147483648");
  496. CPPUNIT_FAIL("exception must be thrown.");
  497. } catch(Exception& e) {
  498. std::cerr << e.stackTrace();
  499. }
  500. try {
  501. IntSequence seq = util::parseIntRange("2147483647-2147483648");
  502. CPPUNIT_FAIL("exception must be thrown.");
  503. } catch(Exception& e) {
  504. std::cerr << e.stackTrace();
  505. }
  506. try {
  507. IntSequence seq = util::parseIntRange("1-2x");
  508. CPPUNIT_FAIL("exception must be thrown.");
  509. } catch(Exception& e) {
  510. std::cerr << e.stackTrace();
  511. }
  512. try {
  513. IntSequence seq = util::parseIntRange("3x-4");
  514. CPPUNIT_FAIL("exception must be thrown.");
  515. } catch(Exception& e) {
  516. std::cerr << e.stackTrace();
  517. }
  518. }
  519. void UtilTest::testParseInt()
  520. {
  521. CPPUNIT_ASSERT_EQUAL(-1, util::parseInt(" -1 "));
  522. CPPUNIT_ASSERT_EQUAL(2147483647, util::parseInt("2147483647"));
  523. try {
  524. util::parseInt("2147483648");
  525. CPPUNIT_FAIL("exception must be thrown.");
  526. } catch(Exception& e) {
  527. std::cerr << e.stackTrace();
  528. }
  529. try {
  530. util::parseInt("-2147483649");
  531. CPPUNIT_FAIL("exception must be thrown.");
  532. } catch(Exception& e) {
  533. std::cerr << e.stackTrace();
  534. }
  535. try {
  536. util::parseInt("12x");
  537. CPPUNIT_FAIL("exception must be thrown.");
  538. } catch(Exception& e) {
  539. std::cerr << e.stackTrace();
  540. }
  541. try {
  542. util::parseInt("");
  543. CPPUNIT_FAIL("exception must be thrown.");
  544. } catch(Exception& e) {
  545. std::cerr << e.stackTrace();
  546. }
  547. }
  548. void UtilTest::testParseUInt()
  549. {
  550. CPPUNIT_ASSERT_EQUAL(4294967295U, util::parseUInt(" 4294967295 "));
  551. try {
  552. util::parseUInt("-1");
  553. CPPUNIT_FAIL("exception must be thrown.");
  554. } catch(Exception& e) {
  555. std::cerr << e.stackTrace();
  556. }
  557. try {
  558. util::parseUInt("4294967296");
  559. CPPUNIT_FAIL("exception must be thrown.");
  560. } catch(Exception& e) {
  561. std::cerr << e.stackTrace();
  562. }
  563. }
  564. void UtilTest::testParseLLInt()
  565. {
  566. CPPUNIT_ASSERT_EQUAL((int64_t)-1LL, util::parseLLInt(" -1 "));
  567. CPPUNIT_ASSERT_EQUAL((int64_t)9223372036854775807LL,
  568. util::parseLLInt("9223372036854775807"));
  569. try {
  570. util::parseLLInt("9223372036854775808");
  571. CPPUNIT_FAIL("exception must be thrown.");
  572. } catch(Exception& e) {
  573. std::cerr << e.stackTrace();
  574. }
  575. try {
  576. util::parseLLInt("-9223372036854775809");
  577. CPPUNIT_FAIL("exception must be thrown.");
  578. } catch(Exception& e) {
  579. std::cerr << e.stackTrace();
  580. }
  581. try {
  582. util::parseLLInt("12x");
  583. CPPUNIT_FAIL("exception must be thrown.");
  584. } catch(Exception& e) {
  585. std::cerr << e.stackTrace();
  586. }
  587. try {
  588. util::parseLLInt("");
  589. CPPUNIT_FAIL("exception must be thrown.");
  590. } catch(Exception& e) {
  591. std::cerr << e.stackTrace();
  592. }
  593. }
  594. void UtilTest::testParseULLInt()
  595. {
  596. CPPUNIT_ASSERT_EQUAL((uint64_t)18446744073709551615ULL,
  597. util::parseULLInt("18446744073709551615"));
  598. try {
  599. util::parseUInt("-1");
  600. CPPUNIT_FAIL("exception must be thrown.");
  601. } catch(Exception& e) {
  602. std::cerr << e.stackTrace();
  603. }
  604. try {
  605. util::parseLLInt("18446744073709551616");
  606. CPPUNIT_FAIL("exception must be thrown.");
  607. } catch(Exception& e) {
  608. std::cerr << e.stackTrace();
  609. }
  610. }
  611. void UtilTest::testToString_binaryStream()
  612. {
  613. SharedHandle<DiskWriter> dw(new ByteArrayDiskWriter());
  614. std::string data(16*1024+256, 'a');
  615. dw->initAndOpenFile();
  616. dw->writeData((const unsigned char*)data.c_str(), data.size(), 0);
  617. std::string readData = util::toString(dw);
  618. CPPUNIT_ASSERT_EQUAL(data, readData);
  619. }
  620. void UtilTest::testItos()
  621. {
  622. {
  623. int i = 0;
  624. CPPUNIT_ASSERT_EQUAL(std::string("0"), util::itos(i));
  625. }
  626. {
  627. int i = 100;
  628. CPPUNIT_ASSERT_EQUAL(std::string("100"), util::itos(i, true));
  629. }
  630. {
  631. int i = 100;
  632. CPPUNIT_ASSERT_EQUAL(std::string("100"), util::itos(i));
  633. }
  634. {
  635. int i = 12345;
  636. CPPUNIT_ASSERT_EQUAL(std::string("12,345"), util::itos(i, true));
  637. }
  638. {
  639. int i = 12345;
  640. CPPUNIT_ASSERT_EQUAL(std::string("12345"), util::itos(i));
  641. }
  642. {
  643. int i = -12345;
  644. CPPUNIT_ASSERT_EQUAL(std::string("-12,345"), util::itos(i, true));
  645. }
  646. {
  647. int64_t i = INT64_MAX;
  648. CPPUNIT_ASSERT_EQUAL(std::string("9,223,372,036,854,775,807"), util::itos(i, true));
  649. }
  650. }
  651. void UtilTest::testUitos()
  652. {
  653. {
  654. uint16_t i = 12345;
  655. CPPUNIT_ASSERT_EQUAL(std::string("12345"), util::uitos(i));
  656. }
  657. {
  658. int16_t i = -12345;
  659. CPPUNIT_ASSERT_EQUAL(std::string("/.-,+"), util::uitos(i));
  660. }
  661. }
  662. void UtilTest::testNtoh64()
  663. {
  664. uint64_t x = 0xff00ff00ee00ee00LL;
  665. #ifdef WORDS_BIGENDIAN
  666. CPPUNIT_ASSERT_EQUAL(x, ntoh64(x));
  667. CPPUNIT_ASSERT_EQUAL(x, hton64(x));
  668. #else // !WORDS_BIGENDIAN
  669. uint64_t y = 0x00ee00ee00ff00ffLL;
  670. CPPUNIT_ASSERT_EQUAL(y, ntoh64(x));
  671. CPPUNIT_ASSERT_EQUAL(x, hton64(y));
  672. #endif // !WORDS_BIGENDIAN
  673. }
  674. void UtilTest::testUrlencode()
  675. {
  676. CPPUNIT_ASSERT_EQUAL
  677. (std::string("%3A%2F%3F%23%5B%5D%40%21%25%26%27%28%29%2A%2B%2C%3B%3D"),
  678. util::urlencode(":/?#[]@!%&'()*+,;="));
  679. std::string unreserved =
  680. "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  681. "abcdefghijklmnopqrstuvwxyz"
  682. "0123456789"
  683. "-._~";
  684. CPPUNIT_ASSERT_EQUAL(unreserved, util::urlencode(unreserved));
  685. CPPUNIT_ASSERT_EQUAL(std::string("1%5EA%20"), util::urlencode("1^A "));
  686. }
  687. void UtilTest::testHtmlEscape()
  688. {
  689. CPPUNIT_ASSERT_EQUAL(std::string("aria2&lt;&gt;&quot;&#39;util"),
  690. util::htmlEscape("aria2<>\"'util"));
  691. }
  692. void UtilTest::testJoinPath()
  693. {
  694. const std::string dir1dir2file[] = { "dir1", "dir2", "file" };
  695. CPPUNIT_ASSERT_EQUAL
  696. (std::string("dir1/dir2/file"),
  697. util::joinPath(&dir1dir2file[0],
  698. &dir1dir2file[arrayLength(dir1dir2file)]));
  699. const std::string dirparentfile[] = { "dir", "..", "file" };
  700. CPPUNIT_ASSERT_EQUAL
  701. (std::string("file"),
  702. util::joinPath(&dirparentfile[0],
  703. &dirparentfile[arrayLength(dirparentfile)]));
  704. const std::string dirparentparentfile[] = { "dir", "..", "..", "file" };
  705. CPPUNIT_ASSERT_EQUAL
  706. (std::string("file"),
  707. util::joinPath(&dirparentparentfile[0],
  708. &dirparentparentfile[arrayLength(dirparentparentfile)]));
  709. const std::string dirdotfile[] = { "dir", ".", "file" };
  710. CPPUNIT_ASSERT_EQUAL(std::string("dir/file"),
  711. util::joinPath(&dirdotfile[0],
  712. &dirdotfile[arrayLength(dirdotfile)]));
  713. const std::string empty[] = {};
  714. CPPUNIT_ASSERT_EQUAL(std::string(""), util::joinPath(&empty[0], &empty[0]));
  715. const std::string parentdot[] = { "..", "." };
  716. CPPUNIT_ASSERT_EQUAL(std::string(""),
  717. util::joinPath(&parentdot[0],
  718. &parentdot[arrayLength(parentdot)]));
  719. }
  720. void UtilTest::testParseIndexPath()
  721. {
  722. std::map<size_t, std::string>::value_type p = util::parseIndexPath("1=foo");
  723. CPPUNIT_ASSERT_EQUAL((size_t)1, p.first);
  724. CPPUNIT_ASSERT_EQUAL(std::string("foo"), p.second);
  725. try {
  726. util::parseIndexPath("1X=foo");
  727. CPPUNIT_FAIL("exception must be thrown.");
  728. } catch(Exception& e) {
  729. // success
  730. }
  731. try {
  732. util::parseIndexPath("1=");
  733. CPPUNIT_FAIL("exception must be thrown.");
  734. } catch(Exception& e) {
  735. // success
  736. }
  737. }
  738. void UtilTest::testCreateIndexPathMap()
  739. {
  740. std::stringstream in
  741. ("1=/tmp/myfile\n"
  742. "100=/myhome/mypicture.png\n");
  743. std::map<size_t, std::string> m = util::createIndexPathMap(in);
  744. CPPUNIT_ASSERT_EQUAL((size_t)2, m.size());
  745. CPPUNIT_ASSERT(m.find(1) != m.end());
  746. CPPUNIT_ASSERT_EQUAL(std::string("/tmp/myfile"), m[1]);
  747. CPPUNIT_ASSERT(m.find(100) != m.end());
  748. CPPUNIT_ASSERT_EQUAL(std::string("/myhome/mypicture.png"), m[100]);
  749. }
  750. void UtilTest::testGenerateRandomData()
  751. {
  752. unsigned char data1[20];
  753. util::generateRandomData(data1, sizeof(data1));
  754. unsigned char data2[20];
  755. util::generateRandomData(data2, sizeof(data2));
  756. CPPUNIT_ASSERT(memcmp(data1, data2, sizeof(data1)) != 0);
  757. }
  758. void UtilTest::testFromHex()
  759. {
  760. std::string src;
  761. std::string dest;
  762. src = "0011fF";
  763. dest = util::fromHex(src);
  764. CPPUNIT_ASSERT_EQUAL((size_t)3, dest.size());
  765. CPPUNIT_ASSERT_EQUAL((char)0x00, dest[0]);
  766. CPPUNIT_ASSERT_EQUAL((char)0x11, dest[1]);
  767. CPPUNIT_ASSERT_EQUAL((char)0xff, dest[2]);
  768. src = "0011f";
  769. CPPUNIT_ASSERT(util::fromHex(src).empty());
  770. src = "001g";
  771. CPPUNIT_ASSERT(util::fromHex(src).empty());
  772. }
  773. void UtilTest::testParsePrioritizePieceRange()
  774. {
  775. // piece index
  776. // 0 1 2 3 4 5 6 7
  777. // | | | |
  778. // file1 | | |
  779. // | | |
  780. // file2 | |
  781. // file3 |
  782. // | |
  783. // file4 |
  784. size_t pieceLength = 1024;
  785. std::vector<SharedHandle<FileEntry> > entries(4, SharedHandle<FileEntry>());
  786. entries[0].reset(new FileEntry("file1", 1024, 0));
  787. entries[1].reset(new FileEntry("file2",2560,entries[0]->getLastOffset()));
  788. entries[2].reset(new FileEntry("file3",0,entries[1]->getLastOffset()));
  789. entries[3].reset(new FileEntry("file4",3584,entries[2]->getLastOffset()));
  790. std::vector<size_t> result;
  791. util::parsePrioritizePieceRange(result, "head=1", entries, pieceLength);
  792. CPPUNIT_ASSERT_EQUAL((size_t)3, result.size());
  793. CPPUNIT_ASSERT_EQUAL((size_t)0, result[0]);
  794. CPPUNIT_ASSERT_EQUAL((size_t)1, result[1]);
  795. CPPUNIT_ASSERT_EQUAL((size_t)3, result[2]);
  796. result.clear();
  797. util::parsePrioritizePieceRange(result, "tail=1", entries, pieceLength);
  798. CPPUNIT_ASSERT_EQUAL((size_t)3, result.size());
  799. CPPUNIT_ASSERT_EQUAL((size_t)0, result[0]);
  800. CPPUNIT_ASSERT_EQUAL((size_t)3, result[1]);
  801. CPPUNIT_ASSERT_EQUAL((size_t)6, result[2]);
  802. result.clear();
  803. util::parsePrioritizePieceRange(result, "head=1K", entries, pieceLength);
  804. CPPUNIT_ASSERT_EQUAL((size_t)4, result.size());
  805. CPPUNIT_ASSERT_EQUAL((size_t)0, result[0]);
  806. CPPUNIT_ASSERT_EQUAL((size_t)1, result[1]);
  807. CPPUNIT_ASSERT_EQUAL((size_t)3, result[2]);
  808. CPPUNIT_ASSERT_EQUAL((size_t)4, result[3]);
  809. result.clear();
  810. util::parsePrioritizePieceRange(result, "head", entries, pieceLength, 1024);
  811. CPPUNIT_ASSERT_EQUAL((size_t)4, result.size());
  812. CPPUNIT_ASSERT_EQUAL((size_t)0, result[0]);
  813. CPPUNIT_ASSERT_EQUAL((size_t)1, result[1]);
  814. CPPUNIT_ASSERT_EQUAL((size_t)3, result[2]);
  815. CPPUNIT_ASSERT_EQUAL((size_t)4, result[3]);
  816. result.clear();
  817. util::parsePrioritizePieceRange(result, "tail=1K", entries, pieceLength);
  818. CPPUNIT_ASSERT_EQUAL((size_t)4, result.size());
  819. CPPUNIT_ASSERT_EQUAL((size_t)0, result[0]);
  820. CPPUNIT_ASSERT_EQUAL((size_t)2, result[1]);
  821. CPPUNIT_ASSERT_EQUAL((size_t)3, result[2]);
  822. CPPUNIT_ASSERT_EQUAL((size_t)6, result[3]);
  823. result.clear();
  824. util::parsePrioritizePieceRange(result, "tail", entries, pieceLength, 1024);
  825. CPPUNIT_ASSERT_EQUAL((size_t)4, result.size());
  826. CPPUNIT_ASSERT_EQUAL((size_t)0, result[0]);
  827. CPPUNIT_ASSERT_EQUAL((size_t)2, result[1]);
  828. CPPUNIT_ASSERT_EQUAL((size_t)3, result[2]);
  829. CPPUNIT_ASSERT_EQUAL((size_t)6, result[3]);
  830. result.clear();
  831. util::parsePrioritizePieceRange(result, "head=1,tail=1", entries, pieceLength);
  832. CPPUNIT_ASSERT_EQUAL((size_t)4, result.size());
  833. CPPUNIT_ASSERT_EQUAL((size_t)0, result[0]);
  834. CPPUNIT_ASSERT_EQUAL((size_t)1, result[1]);
  835. CPPUNIT_ASSERT_EQUAL((size_t)3, result[2]);
  836. CPPUNIT_ASSERT_EQUAL((size_t)6, result[3]);
  837. result.clear();
  838. util::parsePrioritizePieceRange(result, "head=300M,tail=300M",
  839. entries, pieceLength);
  840. CPPUNIT_ASSERT_EQUAL((size_t)7, result.size());
  841. for(size_t i = 0; i < 7; ++i) {
  842. CPPUNIT_ASSERT_EQUAL(i, result[i]);
  843. }
  844. result.clear();
  845. util::parsePrioritizePieceRange(result, "", entries, pieceLength);
  846. CPPUNIT_ASSERT(result.empty());
  847. }
  848. void UtilTest::testApplyDir()
  849. {
  850. CPPUNIT_ASSERT_EQUAL(std::string("./pred"), util::applyDir("", "pred"));
  851. CPPUNIT_ASSERT_EQUAL(std::string("/pred"), util::applyDir("/", "pred"));
  852. CPPUNIT_ASSERT_EQUAL(std::string("./pred"), util::applyDir(".", "pred"));
  853. CPPUNIT_ASSERT_EQUAL(std::string("/dl/pred"), util::applyDir("/dl", "pred"));
  854. }
  855. void UtilTest::testFixTaintedBasename()
  856. {
  857. CPPUNIT_ASSERT_EQUAL(std::string("a_b"), util::fixTaintedBasename("a/b"));
  858. CPPUNIT_ASSERT_EQUAL(std::string("a_b"), util::fixTaintedBasename("a\\b"));
  859. CPPUNIT_ASSERT_EQUAL(std::string("a__b"), util::fixTaintedBasename("a\\/b"));
  860. }
  861. void UtilTest::testIsNumericHost()
  862. {
  863. CPPUNIT_ASSERT(util::isNumericHost("192.168.0.1"));
  864. CPPUNIT_ASSERT(!util::isNumericHost("aria2.sf.net"));
  865. CPPUNIT_ASSERT(util::isNumericHost("::1"));
  866. }
  867. } // namespace aria2