PageRenderTime 182ms CodeModel.GetById 70ms RepoModel.GetById 0ms app.codeStats 0ms

/mordor/tests/buffer.cpp

http://github.com/mozy/mordor
C++ | 840 lines | 737 code | 95 blank | 8 comment | 52 complexity | b8f9b1e326ae510e0e680c84a6117497 MD5 | raw file
Possible License(s): BSD-3-Clause
  1. // Copyright (c) 2009 - Mozy, Inc.
  2. #include <boost/bind.hpp>
  3. #include "mordor/streams/buffer.h"
  4. #include "mordor/test/test.h"
  5. using namespace Mordor;
  6. using namespace Mordor::Test;
  7. MORDOR_UNITTEST(Buffer, copyInString)
  8. {
  9. Buffer b;
  10. b.copyIn("hello");
  11. MORDOR_TEST_ASSERT_EQUAL(b.readAvailable(), 5u);
  12. MORDOR_TEST_ASSERT_EQUAL(b.writeAvailable(), 0u);
  13. MORDOR_TEST_ASSERT_EQUAL(b.segments(), 1u);
  14. MORDOR_TEST_ASSERT(b == "hello");
  15. }
  16. MORDOR_UNITTEST(Buffer, copyInStdString)
  17. {
  18. Buffer b;
  19. std::string str("abc\0def", 7);
  20. b.copyIn(str);
  21. MORDOR_TEST_ASSERT_EQUAL(b.readAvailable(), 7u);
  22. MORDOR_TEST_ASSERT_EQUAL(b.writeAvailable(), 0u);
  23. MORDOR_TEST_ASSERT_EQUAL(b.segments(), 1u);
  24. MORDOR_TEST_ASSERT(b == str);
  25. }
  26. MORDOR_UNITTEST(Buffer, copyInStdString2)
  27. {
  28. Buffer b;
  29. std::ostringstream os;
  30. os << "hello" << '\0' << "world" << '\0' << '\x0a';
  31. b.copyIn(os.str());
  32. MORDOR_TEST_ASSERT_EQUAL(b.readAvailable(), 13u);
  33. MORDOR_TEST_ASSERT_EQUAL(b.writeAvailable(), 0u);
  34. MORDOR_TEST_ASSERT_EQUAL(b.segments(), 1u);
  35. MORDOR_TEST_ASSERT(b == os.str());
  36. }
  37. MORDOR_UNITTEST(Buffer, copyInOtherBuffer)
  38. {
  39. Buffer b1, b2("hello");
  40. b1.copyIn(b2);
  41. MORDOR_TEST_ASSERT_EQUAL(b1.readAvailable(), 5u);
  42. MORDOR_TEST_ASSERT_EQUAL(b1.writeAvailable(), 0u);
  43. MORDOR_TEST_ASSERT_EQUAL(b1.segments(), 1u);
  44. MORDOR_TEST_ASSERT(b1 == "hello");
  45. }
  46. MORDOR_UNITTEST(Buffer, copyInPartial)
  47. {
  48. Buffer b1, b2("hello");
  49. b1.copyIn(b2, 3);
  50. MORDOR_TEST_ASSERT_EQUAL(b1.readAvailable(), 3u);
  51. MORDOR_TEST_ASSERT_EQUAL(b1.writeAvailable(), 0u);
  52. MORDOR_TEST_ASSERT_EQUAL(b1.segments(), 1u);
  53. MORDOR_TEST_ASSERT(b1 == "hel");
  54. }
  55. MORDOR_UNITTEST(Buffer, copyInOffset)
  56. {
  57. Buffer b1, b2("hello world");
  58. b1.copyIn(b2, 7, 2);
  59. MORDOR_TEST_ASSERT_EQUAL(b1.readAvailable(), 7u);
  60. MORDOR_TEST_ASSERT_EQUAL(b1.writeAvailable(), 0u);
  61. MORDOR_TEST_ASSERT_EQUAL(b1.segments(), 1u);
  62. MORDOR_TEST_ASSERT(b1 == "llo wor");
  63. }
  64. MORDOR_UNITTEST(Buffer, copyInOffsetMultiSegments)
  65. {
  66. Buffer b1, b2;
  67. b2.copyIn("hello\n");
  68. b2.copyIn("foo\n");
  69. b2.copyIn("bar\n");
  70. MORDOR_TEST_ASSERT_EQUAL(b2.segments(), 3u);
  71. b1.copyIn(b2, 5, 7);
  72. MORDOR_TEST_ASSERT_EQUAL(b1.readAvailable(), 5u);
  73. MORDOR_TEST_ASSERT_EQUAL(b1.writeAvailable(), 0u);
  74. MORDOR_TEST_ASSERT_EQUAL(b1.segments(), 2u);
  75. MORDOR_TEST_ASSERT(b1 == "oo\nba");
  76. }
  77. MORDOR_UNITTEST(Buffer, copyInStringToReserved)
  78. {
  79. Buffer b;
  80. b.reserve(5);
  81. b.copyIn("hello");
  82. MORDOR_TEST_ASSERT_EQUAL(b.readAvailable(), 5u);
  83. MORDOR_TEST_ASSERT_EQUAL(b.segments(), 1u);
  84. MORDOR_TEST_ASSERT(b == "hello");
  85. }
  86. MORDOR_UNITTEST(Buffer, copyInStringAfterAnotherSegment)
  87. {
  88. Buffer b("hello");
  89. b.copyIn("world");
  90. MORDOR_TEST_ASSERT_EQUAL(b.readAvailable(), 10u);
  91. MORDOR_TEST_ASSERT_EQUAL(b.writeAvailable(), 0u);
  92. MORDOR_TEST_ASSERT_EQUAL(b.segments(), 2u);
  93. MORDOR_TEST_ASSERT(b == "helloworld");
  94. }
  95. MORDOR_UNITTEST(Buffer, copyInStringToReservedAfterAnotherSegment)
  96. {
  97. Buffer b("hello");
  98. b.reserve(5);
  99. b.copyIn("world");
  100. MORDOR_TEST_ASSERT_EQUAL(b.readAvailable(), 10u);
  101. MORDOR_TEST_ASSERT_EQUAL(b.segments(), 2u);
  102. MORDOR_TEST_ASSERT(b == "helloworld");
  103. }
  104. MORDOR_UNITTEST(Buffer, copyInStringToSplitSegment)
  105. {
  106. Buffer b;
  107. b.reserve(10);
  108. b.copyIn("hello");
  109. MORDOR_TEST_ASSERT_EQUAL(b.readAvailable(), 5u);
  110. MORDOR_TEST_ASSERT_GREATER_THAN_OR_EQUAL(b.writeAvailable(), 5u);
  111. MORDOR_TEST_ASSERT_EQUAL(b.segments(), 1u);
  112. b.copyIn("world");
  113. MORDOR_TEST_ASSERT_EQUAL(b.readAvailable(), 10u);
  114. MORDOR_TEST_ASSERT_EQUAL(b.segments(), 1u);
  115. MORDOR_TEST_ASSERT(b == "helloworld");
  116. }
  117. MORDOR_UNITTEST(Buffer, copyInWithReserve)
  118. {
  119. Buffer b1, b2("hello");
  120. b1.reserve(10);
  121. MORDOR_TEST_ASSERT_GREATER_THAN_OR_EQUAL(b1.writeAvailable(), 10u);
  122. MORDOR_TEST_ASSERT_EQUAL(b1.segments(), 1u);
  123. size_t writeAvailable = b1.writeAvailable();
  124. b1.copyIn(b2);
  125. MORDOR_TEST_ASSERT_EQUAL(b1.readAvailable(), 5u);
  126. // Shouldn't have eaten any
  127. MORDOR_TEST_ASSERT_EQUAL(b1.writeAvailable(), writeAvailable);
  128. MORDOR_TEST_ASSERT_EQUAL(b1.segments(), 2u);
  129. MORDOR_TEST_ASSERT(b1 == "hello");
  130. }
  131. MORDOR_UNITTEST(Buffer, copyInToSplitSegment)
  132. {
  133. Buffer b1, b2("world");
  134. b1.reserve(10);
  135. b1.copyIn("hello");
  136. MORDOR_TEST_ASSERT_EQUAL(b1.readAvailable(), 5u);
  137. MORDOR_TEST_ASSERT_GREATER_THAN_OR_EQUAL(b1.writeAvailable(), 5u);
  138. MORDOR_TEST_ASSERT_EQUAL(b1.segments(), 1u);
  139. size_t writeAvailable = b1.writeAvailable();
  140. b1.copyIn(b2, 5);
  141. MORDOR_TEST_ASSERT_EQUAL(b1.readAvailable(), 10u);
  142. // Shouldn't have eaten any
  143. MORDOR_TEST_ASSERT_EQUAL(b1.writeAvailable(), writeAvailable);
  144. MORDOR_TEST_ASSERT_EQUAL(b1.segments(), 3u);
  145. MORDOR_TEST_ASSERT(b1 == "helloworld");
  146. }
  147. #ifndef NDEBUG
  148. MORDOR_UNITTEST(Buffer, copyInMoreThanThereIs)
  149. {
  150. Buffer b1, b2;
  151. MORDOR_TEST_ASSERT_ASSERTED(b1.copyIn(b2, 1));
  152. b2.copyIn("hello");
  153. MORDOR_TEST_ASSERT_ASSERTED(b1.copyIn(b2, 6));
  154. }
  155. #endif
  156. MORDOR_UNITTEST(Buffer, copyInMerge)
  157. {
  158. Buffer b1, b2("hello");
  159. b1.copyIn(b2, 2);
  160. b2.consume(2);
  161. b1.copyIn(b2, 3);
  162. MORDOR_TEST_ASSERT_EQUAL(b1.readAvailable(), 5u);
  163. MORDOR_TEST_ASSERT_EQUAL(b1.segments(), 1u);
  164. MORDOR_TEST_ASSERT(b1 == "hello");
  165. }
  166. MORDOR_UNITTEST(Buffer, copyInMergePlus)
  167. {
  168. Buffer b1, b2("hello");
  169. b2.copyIn("world");
  170. MORDOR_TEST_ASSERT_EQUAL(b2.segments(), 2u);
  171. b1.copyIn(b2, 2);
  172. b2.consume(2);
  173. b1.copyIn(b2, 4);
  174. MORDOR_TEST_ASSERT_EQUAL(b1.readAvailable(), 6u);
  175. MORDOR_TEST_ASSERT_EQUAL(b1.segments(), 2u);
  176. MORDOR_TEST_ASSERT(b1 == "hellow");
  177. }
  178. MORDOR_UNITTEST(Buffer, copyOutOffset)
  179. {
  180. Buffer b("hello world");
  181. std::string out;
  182. out.resize(7);
  183. b.copyOut(&out[0], 7, 2);
  184. MORDOR_TEST_ASSERT(out == "llo wor");
  185. }
  186. MORDOR_UNITTEST(Buffer, noSplitOnTruncate)
  187. {
  188. Buffer b1;
  189. b1.reserve(10);
  190. b1.copyIn("hello");
  191. b1.truncate(5);
  192. MORDOR_TEST_ASSERT_GREATER_THAN_OR_EQUAL(b1.writeAvailable(), 5u);
  193. b1.copyIn("world");
  194. MORDOR_TEST_ASSERT_EQUAL(b1.segments(), 1u);
  195. MORDOR_TEST_ASSERT(b1 == "helloworld");
  196. }
  197. MORDOR_UNITTEST(Buffer, copyConstructor)
  198. {
  199. Buffer buf1;
  200. buf1.copyIn("hello");
  201. Buffer buf2(buf1);
  202. MORDOR_TEST_ASSERT(buf1 == "hello");
  203. MORDOR_TEST_ASSERT(buf2 == "hello");
  204. MORDOR_TEST_ASSERT_EQUAL(buf1.writeAvailable(), 0u);
  205. MORDOR_TEST_ASSERT_EQUAL(buf2.writeAvailable(), 0u);
  206. }
  207. MORDOR_UNITTEST(Buffer, copyConstructorImmutability)
  208. {
  209. Buffer buf1;
  210. buf1.reserve(10);
  211. Buffer buf2(buf1);
  212. buf1.copyIn("hello");
  213. buf2.copyIn("tommy");
  214. MORDOR_TEST_ASSERT_EQUAL(buf1.readAvailable(), 5u);
  215. MORDOR_TEST_ASSERT_GREATER_THAN_OR_EQUAL(buf1.writeAvailable(), 5u);
  216. MORDOR_TEST_ASSERT_EQUAL(buf2.readAvailable(), 5u);
  217. MORDOR_TEST_ASSERT_EQUAL(buf2.writeAvailable(), 0u);
  218. MORDOR_TEST_ASSERT(buf1 == "hello");
  219. MORDOR_TEST_ASSERT(buf2 == "tommy");
  220. }
  221. MORDOR_UNITTEST(Buffer, truncate)
  222. {
  223. Buffer buf("hello");
  224. buf.truncate(3);
  225. MORDOR_TEST_ASSERT(buf == "hel");
  226. }
  227. MORDOR_UNITTEST(Buffer, truncateMultipleSegments1)
  228. {
  229. Buffer buf("hello");
  230. buf.copyIn("world");
  231. buf.truncate(3);
  232. MORDOR_TEST_ASSERT(buf == "hel");
  233. }
  234. MORDOR_UNITTEST(Buffer, truncateMultipleSegments2)
  235. {
  236. Buffer buf("hello");
  237. buf.copyIn("world");
  238. buf.truncate(8);
  239. MORDOR_TEST_ASSERT(buf == "hellowor");
  240. }
  241. MORDOR_UNITTEST(Buffer, truncateBeforeWriteSegments)
  242. {
  243. Buffer buf("hello");
  244. buf.reserve(5);
  245. buf.truncate(3);
  246. MORDOR_TEST_ASSERT(buf == "hel");
  247. MORDOR_TEST_ASSERT_GREATER_THAN_OR_EQUAL(buf.writeAvailable(), 5u);
  248. }
  249. MORDOR_UNITTEST(Buffer, truncateAtWriteSegments)
  250. {
  251. Buffer buf("hello");
  252. buf.reserve(10);
  253. buf.copyIn("world");
  254. buf.truncate(8);
  255. MORDOR_TEST_ASSERT(buf == "hellowor");
  256. MORDOR_TEST_ASSERT_GREATER_THAN_OR_EQUAL(buf.writeAvailable(), 10u);
  257. }
  258. MORDOR_UNITTEST(Buffer, compareEmpty)
  259. {
  260. Buffer buf1, buf2;
  261. MORDOR_TEST_ASSERT(buf1 == buf2);
  262. MORDOR_TEST_ASSERT(!(buf1 != buf2));
  263. }
  264. MORDOR_UNITTEST(Buffer, compareSimpleInequality)
  265. {
  266. Buffer buf1, buf2("h");
  267. MORDOR_TEST_ASSERT(buf1 != buf2);
  268. MORDOR_TEST_ASSERT(!(buf1 == buf2));
  269. }
  270. MORDOR_UNITTEST(Buffer, compareIdentical)
  271. {
  272. Buffer buf1("hello"), buf2("hello");
  273. MORDOR_TEST_ASSERT(buf1 == buf2);
  274. MORDOR_TEST_ASSERT(!(buf1 != buf2));
  275. }
  276. MORDOR_UNITTEST(Buffer, compareLotsOfSegmentsOnTheLeft)
  277. {
  278. Buffer buf1, buf2("hello world!");
  279. buf1.copyIn("he");
  280. buf1.copyIn("l");
  281. buf1.copyIn("l");
  282. buf1.copyIn("o wor");
  283. buf1.copyIn("ld!");
  284. MORDOR_TEST_ASSERT(buf1 == buf2);
  285. MORDOR_TEST_ASSERT(!(buf1 != buf2));
  286. }
  287. MORDOR_UNITTEST(Buffer, compareLotOfSegmentsOnTheRight)
  288. {
  289. Buffer buf1("hello world!"), buf2;
  290. buf2.copyIn("he");
  291. buf2.copyIn("l");
  292. buf2.copyIn("l");
  293. buf2.copyIn("o wor");
  294. buf2.copyIn("ld!");
  295. MORDOR_TEST_ASSERT(buf1 == buf2);
  296. MORDOR_TEST_ASSERT(!(buf1 != buf2));
  297. }
  298. MORDOR_UNITTEST(Buffer, compareLotsOfSegments)
  299. {
  300. Buffer buf1, buf2;
  301. buf1.copyIn("he");
  302. buf1.copyIn("l");
  303. buf1.copyIn("l");
  304. buf1.copyIn("o wor");
  305. buf1.copyIn("ld!");
  306. buf2.copyIn("he");
  307. buf2.copyIn("l");
  308. buf2.copyIn("l");
  309. buf2.copyIn("o wor");
  310. buf2.copyIn("ld!");
  311. MORDOR_TEST_ASSERT(buf1 == buf2);
  312. MORDOR_TEST_ASSERT(!(buf1 != buf2));
  313. }
  314. MORDOR_UNITTEST(Buffer, compareLotsOfMismatchedSegments)
  315. {
  316. Buffer buf1, buf2;
  317. buf1.copyIn("hel");
  318. buf1.copyIn("lo ");
  319. buf1.copyIn("wo");
  320. buf1.copyIn("rld!");
  321. buf2.copyIn("he");
  322. buf2.copyIn("l");
  323. buf2.copyIn("l");
  324. buf2.copyIn("o wor");
  325. buf2.copyIn("ld!");
  326. MORDOR_TEST_ASSERT(buf1 == buf2);
  327. MORDOR_TEST_ASSERT(!(buf1 != buf2));
  328. }
  329. MORDOR_UNITTEST(Buffer, compareLotsOfSegmentsOnTheLeftInequality)
  330. {
  331. Buffer buf1, buf2("hello world!");
  332. buf1.copyIn("he");
  333. buf1.copyIn("l");
  334. buf1.copyIn("l");
  335. buf1.copyIn("o wor");
  336. buf1.copyIn("ld! ");
  337. MORDOR_TEST_ASSERT(buf1 != buf2);
  338. MORDOR_TEST_ASSERT(!(buf1 == buf2));
  339. }
  340. MORDOR_UNITTEST(Buffer, compareLotOfSegmentsOnTheRightInequality)
  341. {
  342. Buffer buf1("hello world!"), buf2;
  343. buf2.copyIn("he");
  344. buf2.copyIn("l");
  345. buf2.copyIn("l");
  346. buf2.copyIn("o wor");
  347. buf2.copyIn("ld! ");
  348. MORDOR_TEST_ASSERT(buf1 != buf2);
  349. MORDOR_TEST_ASSERT(!(buf1 == buf2));
  350. }
  351. MORDOR_UNITTEST(Buffer, compareLotsOfSegmentsInequality)
  352. {
  353. Buffer buf1, buf2;
  354. buf1.copyIn("he");
  355. buf1.copyIn("l");
  356. buf1.copyIn("l");
  357. buf1.copyIn("o wor");
  358. buf1.copyIn("ld!");
  359. buf2.copyIn("he");
  360. buf2.copyIn("l");
  361. buf2.copyIn("l");
  362. buf2.copyIn("o wor");
  363. buf2.copyIn("ld! ");
  364. MORDOR_TEST_ASSERT(buf1 != buf2);
  365. MORDOR_TEST_ASSERT(!(buf1 == buf2));
  366. }
  367. MORDOR_UNITTEST(Buffer, compareLotsOfMismatchedSegmentsInequality)
  368. {
  369. Buffer buf1, buf2;
  370. buf1.copyIn("hel");
  371. buf1.copyIn("lo ");
  372. buf1.copyIn("wo");
  373. buf1.copyIn("rld!");
  374. buf2.copyIn("he");
  375. buf2.copyIn("l");
  376. buf2.copyIn("l");
  377. buf2.copyIn("o wor");
  378. buf2.copyIn("ld! ");
  379. MORDOR_TEST_ASSERT(buf1 != buf2);
  380. MORDOR_TEST_ASSERT(!(buf1 == buf2));
  381. }
  382. MORDOR_UNITTEST(Buffer, reserveWithReadAvailable)
  383. {
  384. Buffer buf1("hello");
  385. buf1.reserve(10);
  386. MORDOR_TEST_ASSERT_EQUAL(buf1.readAvailable(), 5u);
  387. MORDOR_TEST_ASSERT_GREATER_THAN_OR_EQUAL(buf1.writeAvailable(), 10u);
  388. }
  389. MORDOR_UNITTEST(Buffer, reserveWithWriteAvailable)
  390. {
  391. Buffer buf1;
  392. buf1.reserve(5);
  393. // Internal knowledge that reserve doubles the reservation
  394. MORDOR_TEST_ASSERT_EQUAL(buf1.writeAvailable(), 10u);
  395. buf1.reserve(11);
  396. MORDOR_TEST_ASSERT_EQUAL(buf1.writeAvailable(), 22u);
  397. }
  398. MORDOR_UNITTEST(Buffer, reserveWithReadAndWriteAvailable)
  399. {
  400. Buffer buf1("hello");
  401. buf1.reserve(5);
  402. // Internal knowledge that reserve doubles the reservation
  403. MORDOR_TEST_ASSERT_EQUAL(buf1.readAvailable(), 5u);
  404. MORDOR_TEST_ASSERT_EQUAL(buf1.writeAvailable(), 10u);
  405. buf1.reserve(11);
  406. MORDOR_TEST_ASSERT_EQUAL(buf1.readAvailable(), 5u);
  407. MORDOR_TEST_ASSERT_EQUAL(buf1.writeAvailable(), 22u);
  408. }
  409. static void
  410. visitor1(const void *b, size_t len)
  411. {
  412. MORDOR_NOTREACHED();
  413. }
  414. MORDOR_UNITTEST(Buffer, visitEmpty)
  415. {
  416. Buffer b;
  417. b.visit(&visitor1);
  418. }
  419. MORDOR_UNITTEST(Buffer, visitNonEmpty0)
  420. {
  421. Buffer b("hello");
  422. b.visit(&visitor1, 0);
  423. }
  424. static void
  425. visitor2(const void *b, size_t len, int &sequence)
  426. {
  427. MORDOR_TEST_ASSERT_EQUAL(++sequence, 1);
  428. MORDOR_TEST_ASSERT_EQUAL(len, 5u);
  429. MORDOR_TEST_ASSERT(memcmp(b, "hello", 5) == 0);
  430. }
  431. MORDOR_UNITTEST(Buffer, visitSingleSegment)
  432. {
  433. Buffer b("hello");
  434. int sequence = 0;
  435. b.visit(boost::bind(&visitor2, _1, _2, boost::ref(sequence)));
  436. MORDOR_TEST_ASSERT_EQUAL(++sequence, 2);
  437. }
  438. static void
  439. visitor3(const void *b, size_t len, int &sequence)
  440. {
  441. switch (len) {
  442. case 1:
  443. MORDOR_TEST_ASSERT_EQUAL(++sequence, 1);
  444. MORDOR_TEST_ASSERT(memcmp(b, "a", 1) == 0);
  445. break;
  446. case 2:
  447. MORDOR_TEST_ASSERT_EQUAL(++sequence, 2);
  448. MORDOR_TEST_ASSERT(memcmp(b, "bc", 2) == 0);
  449. break;
  450. default:
  451. MORDOR_NOTREACHED();
  452. }
  453. }
  454. MORDOR_UNITTEST(Buffer, visitMultipleSegments)
  455. {
  456. Buffer b;
  457. int sequence = 0;
  458. b.copyIn("a");
  459. b.copyIn("bc");
  460. b.visit(boost::bind(&visitor3, _1, _2, boost::ref(sequence)));
  461. MORDOR_TEST_ASSERT_EQUAL(++sequence, 3);
  462. }
  463. MORDOR_UNITTEST(Buffer, visitMultipleSegmentsPartial)
  464. {
  465. Buffer b;
  466. int sequence = 0;
  467. b.copyIn("a");
  468. b.copyIn("bcd");
  469. b.visit(boost::bind(&visitor3, _1, _2, boost::ref(sequence)), 3);
  470. MORDOR_TEST_ASSERT_EQUAL(++sequence, 3);
  471. }
  472. MORDOR_UNITTEST(Buffer, visitWithWriteSegment)
  473. {
  474. Buffer b("hello");
  475. b.reserve(5);
  476. int sequence = 0;
  477. b.visit(boost::bind(&visitor2, _1, _2, boost::ref(sequence)));
  478. MORDOR_TEST_ASSERT_EQUAL(++sequence, 2);
  479. }
  480. MORDOR_UNITTEST(Buffer, visitWithMixedSegment)
  481. {
  482. Buffer b;
  483. b.reserve(10);
  484. b.copyIn("hello");
  485. int sequence = 0;
  486. b.visit(boost::bind(&visitor2, _1, _2, boost::ref(sequence)));
  487. MORDOR_TEST_ASSERT_EQUAL(++sequence, 2);
  488. }
  489. #ifndef NDEBUG
  490. MORDOR_UNITTEST(Buffer, visitMoreThanThereIs)
  491. {
  492. Buffer b;
  493. MORDOR_TEST_ASSERT_ASSERTED(b.visit(&visitor1, 1));
  494. }
  495. #endif
  496. MORDOR_UNITTEST(Buffer, findCharEmpty)
  497. {
  498. Buffer b;
  499. MORDOR_TEST_ASSERT_EQUAL(b.segments(), 0u);
  500. MORDOR_TEST_ASSERT_EQUAL(b.find('\n'), -1);
  501. MORDOR_TEST_ASSERT_EQUAL(b.find('\n', 0), -1);
  502. #ifndef NDEBUG
  503. MORDOR_TEST_ASSERT_ASSERTED(b.find('\n', 1));
  504. #endif
  505. // Put a write segment on the end
  506. b.reserve(10);
  507. MORDOR_TEST_ASSERT_EQUAL(b.segments(), 1u);
  508. MORDOR_TEST_ASSERT_EQUAL(b.find('\n'), -1);
  509. #ifndef NDEBUG
  510. MORDOR_TEST_ASSERT_ASSERTED(b.find('\n', 1));
  511. #endif
  512. }
  513. MORDOR_UNITTEST(Buffer, findCharSimple)
  514. {
  515. Buffer b("\nhello");
  516. MORDOR_TEST_ASSERT_EQUAL(b.segments(), 1u);
  517. MORDOR_TEST_ASSERT_EQUAL(b.find('\r'), -1);
  518. MORDOR_TEST_ASSERT_EQUAL(b.find('\n'), 0);
  519. MORDOR_TEST_ASSERT_EQUAL(b.find('h'), 1);
  520. MORDOR_TEST_ASSERT_EQUAL(b.find('e'), 2);
  521. MORDOR_TEST_ASSERT_EQUAL(b.find('l'), 3);
  522. MORDOR_TEST_ASSERT_EQUAL(b.find('o'), 5);
  523. MORDOR_TEST_ASSERT_EQUAL(b.find('\r', 2), -1);
  524. MORDOR_TEST_ASSERT_EQUAL(b.find('\n', 2), 0);
  525. MORDOR_TEST_ASSERT_EQUAL(b.find('h', 2), 1);
  526. MORDOR_TEST_ASSERT_EQUAL(b.find('e', 2), -1);
  527. MORDOR_TEST_ASSERT_EQUAL(b.find('l', 2), -1);
  528. MORDOR_TEST_ASSERT_EQUAL(b.find('o', 2), -1);
  529. MORDOR_TEST_ASSERT_EQUAL(b.find('\n', 0), -1);
  530. }
  531. MORDOR_UNITTEST(Buffer, findCharTwoSegments)
  532. {
  533. Buffer b("\nhe");
  534. b.copyIn("llo");
  535. MORDOR_TEST_ASSERT_EQUAL(b.segments(), 2u);
  536. MORDOR_TEST_ASSERT_EQUAL(b.find('\r'), -1);
  537. MORDOR_TEST_ASSERT_EQUAL(b.find('\n'), 0);
  538. MORDOR_TEST_ASSERT_EQUAL(b.find('h'), 1);
  539. MORDOR_TEST_ASSERT_EQUAL(b.find('e'), 2);
  540. MORDOR_TEST_ASSERT_EQUAL(b.find('l'), 3);
  541. MORDOR_TEST_ASSERT_EQUAL(b.find('o'), 5);
  542. MORDOR_TEST_ASSERT_EQUAL(b.find('\r', 2), -1);
  543. MORDOR_TEST_ASSERT_EQUAL(b.find('\n', 2), 0);
  544. MORDOR_TEST_ASSERT_EQUAL(b.find('h', 2), 1);
  545. MORDOR_TEST_ASSERT_EQUAL(b.find('e', 2), -1);
  546. MORDOR_TEST_ASSERT_EQUAL(b.find('l', 2), -1);
  547. MORDOR_TEST_ASSERT_EQUAL(b.find('o', 2), -1);
  548. MORDOR_TEST_ASSERT_EQUAL(b.find('\r', 4), -1);
  549. MORDOR_TEST_ASSERT_EQUAL(b.find('\n', 4), 0);
  550. MORDOR_TEST_ASSERT_EQUAL(b.find('h', 4), 1);
  551. MORDOR_TEST_ASSERT_EQUAL(b.find('e', 4), 2);
  552. MORDOR_TEST_ASSERT_EQUAL(b.find('l', 4), 3);
  553. MORDOR_TEST_ASSERT_EQUAL(b.find('o', 4), -1);
  554. // Put a write segment on the end
  555. b.reserve(10);
  556. MORDOR_TEST_ASSERT_EQUAL(b.segments(), 3u);
  557. MORDOR_TEST_ASSERT_EQUAL(b.find('\r'), -1);
  558. MORDOR_TEST_ASSERT_EQUAL(b.find('\n'), 0);
  559. MORDOR_TEST_ASSERT_EQUAL(b.find('h'), 1);
  560. MORDOR_TEST_ASSERT_EQUAL(b.find('e'), 2);
  561. MORDOR_TEST_ASSERT_EQUAL(b.find('l'), 3);
  562. MORDOR_TEST_ASSERT_EQUAL(b.find('o'), 5);
  563. MORDOR_TEST_ASSERT_EQUAL(b.find('\r', 2), -1);
  564. MORDOR_TEST_ASSERT_EQUAL(b.find('\n', 2), 0);
  565. MORDOR_TEST_ASSERT_EQUAL(b.find('h', 2), 1);
  566. MORDOR_TEST_ASSERT_EQUAL(b.find('e', 2), -1);
  567. MORDOR_TEST_ASSERT_EQUAL(b.find('l', 2), -1);
  568. MORDOR_TEST_ASSERT_EQUAL(b.find('o', 2), -1);
  569. MORDOR_TEST_ASSERT_EQUAL(b.find('\r', 4), -1);
  570. MORDOR_TEST_ASSERT_EQUAL(b.find('\n', 4), 0);
  571. MORDOR_TEST_ASSERT_EQUAL(b.find('h', 4), 1);
  572. MORDOR_TEST_ASSERT_EQUAL(b.find('e', 4), 2);
  573. MORDOR_TEST_ASSERT_EQUAL(b.find('l', 4), 3);
  574. MORDOR_TEST_ASSERT_EQUAL(b.find('o', 4), -1);
  575. }
  576. MORDOR_UNITTEST(Buffer, findCharMixedSegment)
  577. {
  578. Buffer b("\nhe");
  579. b.reserve(10);
  580. b.copyIn("llo");
  581. MORDOR_TEST_ASSERT_EQUAL(b.segments(), 2u);
  582. MORDOR_TEST_ASSERT_EQUAL(b.find('\r'), -1);
  583. MORDOR_TEST_ASSERT_EQUAL(b.find('\n'), 0);
  584. MORDOR_TEST_ASSERT_EQUAL(b.find('h'), 1);
  585. MORDOR_TEST_ASSERT_EQUAL(b.find('e'), 2);
  586. MORDOR_TEST_ASSERT_EQUAL(b.find('l'), 3);
  587. MORDOR_TEST_ASSERT_EQUAL(b.find('o'), 5);
  588. MORDOR_TEST_ASSERT_EQUAL(b.find('\r', 2), -1);
  589. MORDOR_TEST_ASSERT_EQUAL(b.find('\n', 2), 0);
  590. MORDOR_TEST_ASSERT_EQUAL(b.find('h', 2), 1);
  591. MORDOR_TEST_ASSERT_EQUAL(b.find('e', 2), -1);
  592. MORDOR_TEST_ASSERT_EQUAL(b.find('l', 2), -1);
  593. MORDOR_TEST_ASSERT_EQUAL(b.find('o', 2), -1);
  594. MORDOR_TEST_ASSERT_EQUAL(b.find('\r', 4), -1);
  595. MORDOR_TEST_ASSERT_EQUAL(b.find('\n', 4), 0);
  596. MORDOR_TEST_ASSERT_EQUAL(b.find('h', 4), 1);
  597. MORDOR_TEST_ASSERT_EQUAL(b.find('e', 4), 2);
  598. MORDOR_TEST_ASSERT_EQUAL(b.find('l', 4), 3);
  599. MORDOR_TEST_ASSERT_EQUAL(b.find('o', 4), -1);
  600. }
  601. MORDOR_UNITTEST(Buffer, findStringEmpty)
  602. {
  603. Buffer b;
  604. MORDOR_TEST_ASSERT_EQUAL(b.find("h"), -1);
  605. MORDOR_TEST_ASSERT_EQUAL(b.find("h", 0), -1);
  606. #ifndef NDEBUG
  607. MORDOR_TEST_ASSERT_ASSERTED(b.find(""));
  608. MORDOR_TEST_ASSERT_ASSERTED(b.find("h", 1));
  609. #endif
  610. // Put a write segment on the end
  611. b.reserve(10);
  612. MORDOR_TEST_ASSERT_EQUAL(b.segments(), 1u);
  613. MORDOR_TEST_ASSERT_EQUAL(b.find("h"), -1);
  614. MORDOR_TEST_ASSERT_EQUAL(b.find("h", 0), -1);
  615. #ifndef NDEBUG
  616. MORDOR_TEST_ASSERT_ASSERTED(b.find(""));
  617. MORDOR_TEST_ASSERT_ASSERTED(b.find("h", 1));
  618. #endif
  619. }
  620. MORDOR_UNITTEST(Buffer, findStringSimple)
  621. {
  622. Buffer b("helloworld");
  623. MORDOR_TEST_ASSERT_EQUAL(b.segments(), 1u);
  624. MORDOR_TEST_ASSERT_EQUAL(b.find("abc"), -1);
  625. MORDOR_TEST_ASSERT_EQUAL(b.find("helloworld"), 0);
  626. MORDOR_TEST_ASSERT_EQUAL(b.find("helloworld2"), -1);
  627. MORDOR_TEST_ASSERT_EQUAL(b.find("elloworld"), 1);
  628. MORDOR_TEST_ASSERT_EQUAL(b.find("helloworl"), 0);
  629. MORDOR_TEST_ASSERT_EQUAL(b.find("h"), 0);
  630. MORDOR_TEST_ASSERT_EQUAL(b.find("l"), 2);
  631. MORDOR_TEST_ASSERT_EQUAL(b.find("o"), 4);
  632. MORDOR_TEST_ASSERT_EQUAL(b.find("lo"), 3);
  633. MORDOR_TEST_ASSERT_EQUAL(b.find("d"), 9);
  634. MORDOR_TEST_ASSERT_EQUAL(b.find("abc", 5), -1);
  635. MORDOR_TEST_ASSERT_EQUAL(b.find("helloworld", 5), -1);
  636. MORDOR_TEST_ASSERT_EQUAL(b.find("hello", 5), 0);
  637. MORDOR_TEST_ASSERT_EQUAL(b.find("ello", 5), 1);
  638. MORDOR_TEST_ASSERT_EQUAL(b.find("helloworld2", 5), -1);
  639. MORDOR_TEST_ASSERT_EQUAL(b.find("elloworld", 5), -1);
  640. MORDOR_TEST_ASSERT_EQUAL(b.find("hell", 5), 0);
  641. MORDOR_TEST_ASSERT_EQUAL(b.find("h", 5), 0);
  642. MORDOR_TEST_ASSERT_EQUAL(b.find("l", 5), 2);
  643. MORDOR_TEST_ASSERT_EQUAL(b.find("o", 5), 4);
  644. MORDOR_TEST_ASSERT_EQUAL(b.find("lo", 5), 3);
  645. MORDOR_TEST_ASSERT_EQUAL(b.find("ow", 5), -1);
  646. MORDOR_TEST_ASSERT_EQUAL(b.find("h", 0), -1);
  647. }
  648. MORDOR_UNITTEST(Buffer, findStringTwoSegments)
  649. {
  650. Buffer b("hello");
  651. b.copyIn("world");
  652. MORDOR_TEST_ASSERT_EQUAL(b.segments(), 2u);
  653. MORDOR_TEST_ASSERT_EQUAL(b.find("abc"), -1);
  654. MORDOR_TEST_ASSERT_EQUAL(b.find("helloworld"), 0);
  655. MORDOR_TEST_ASSERT_EQUAL(b.find("helloworld2"), -1);
  656. MORDOR_TEST_ASSERT_EQUAL(b.find("elloworld"), 1);
  657. MORDOR_TEST_ASSERT_EQUAL(b.find("helloworl"), 0);
  658. MORDOR_TEST_ASSERT_EQUAL(b.find("h"), 0);
  659. MORDOR_TEST_ASSERT_EQUAL(b.find("l"), 2);
  660. MORDOR_TEST_ASSERT_EQUAL(b.find("o"), 4);
  661. MORDOR_TEST_ASSERT_EQUAL(b.find("lo"), 3);
  662. MORDOR_TEST_ASSERT_EQUAL(b.find("d"), 9);
  663. MORDOR_TEST_ASSERT_EQUAL(b.find("abc", 7), -1);
  664. MORDOR_TEST_ASSERT_EQUAL(b.find("helloworld", 7), -1);
  665. MORDOR_TEST_ASSERT_EQUAL(b.find("hellowo", 7), 0);
  666. MORDOR_TEST_ASSERT_EQUAL(b.find("ellowo", 7), 1);
  667. MORDOR_TEST_ASSERT_EQUAL(b.find("helloworld2", 7), -1);
  668. MORDOR_TEST_ASSERT_EQUAL(b.find("elloworld", 7), -1);
  669. MORDOR_TEST_ASSERT_EQUAL(b.find("hellow", 7), 0);
  670. MORDOR_TEST_ASSERT_EQUAL(b.find("h", 7), 0);
  671. MORDOR_TEST_ASSERT_EQUAL(b.find("l", 7), 2);
  672. MORDOR_TEST_ASSERT_EQUAL(b.find("o", 7), 4);
  673. MORDOR_TEST_ASSERT_EQUAL(b.find("lo", 7), 3);
  674. MORDOR_TEST_ASSERT_EQUAL(b.find("or", 7), -1);
  675. MORDOR_TEST_ASSERT_EQUAL(b.find("h", 0), -1);
  676. }
  677. MORDOR_UNITTEST(Buffer, findStringAcrossMultipleSegments)
  678. {
  679. Buffer b("hello");
  680. b.copyIn("world");
  681. b.copyIn("foo");
  682. MORDOR_TEST_ASSERT_EQUAL(b.segments(), 3u);
  683. MORDOR_TEST_ASSERT_EQUAL(b.find("lloworldfo"), 2);
  684. }
  685. MORDOR_UNITTEST(Buffer, findStringLongFalsePositive)
  686. {
  687. Buffer b("100000011");
  688. MORDOR_TEST_ASSERT_EQUAL(b.find("000011"), 3);
  689. }
  690. MORDOR_UNITTEST(Buffer, findStringFalsePositiveAcrossMultipleSegments)
  691. {
  692. Buffer b("10");
  693. b.copyIn("00");
  694. b.copyIn("00");
  695. b.copyIn("00");
  696. b.copyIn("11");
  697. MORDOR_TEST_ASSERT_EQUAL(b.segments(), 5u);
  698. MORDOR_TEST_ASSERT_EQUAL(b.find("000011"), 4);
  699. }
  700. MORDOR_UNITTEST(Buffer, toString)
  701. {
  702. Buffer b;
  703. MORDOR_TEST_ASSERT(b.toString().empty());
  704. b.copyIn("hello");
  705. MORDOR_TEST_ASSERT_EQUAL(b.toString(), "hello");
  706. b.copyIn("world");
  707. MORDOR_TEST_ASSERT_EQUAL(b.toString(), "helloworld");
  708. b.consume(3);
  709. MORDOR_TEST_ASSERT_EQUAL(b.toString(), "loworld");
  710. }
  711. MORDOR_UNITTEST(Buffer, reserve0)
  712. {
  713. Buffer b;
  714. b.reserve(0);
  715. MORDOR_TEST_ASSERT_EQUAL(b.segments(), 0u);
  716. }
  717. MORDOR_UNITTEST(Buffer, writeBuffer0)
  718. {
  719. Buffer b;
  720. iovec iov = b.writeBuffer(0, true);
  721. MORDOR_TEST_ASSERT_EQUAL(iov.iov_len, 0u);
  722. MORDOR_TEST_ASSERT_EQUAL(b.segments(), 0u);
  723. }
  724. MORDOR_UNITTEST(Buffer, clearReadPortionOnly)
  725. {
  726. Buffer b;
  727. MORDOR_TEST_ASSERT_EQUAL(b.readAvailable(), 0u);
  728. MORDOR_TEST_ASSERT_EQUAL(b.writeAvailable(), 0u);
  729. b.clear(false);
  730. MORDOR_TEST_ASSERT_EQUAL(b.readAvailable(), 0u);
  731. MORDOR_TEST_ASSERT_EQUAL(b.writeAvailable(), 0u);
  732. b.copyIn("hello");
  733. b.clear(false);
  734. MORDOR_TEST_ASSERT_EQUAL(b.readAvailable(), 0u);
  735. MORDOR_TEST_ASSERT_EQUAL(b.writeAvailable(), 0u);
  736. b.copyIn("hello");
  737. b.reserve(10);
  738. b.clear(false);
  739. MORDOR_TEST_ASSERT_EQUAL(b.readAvailable(), 0u);
  740. MORDOR_TEST_ASSERT_GREATER_THAN_OR_EQUAL(b.writeAvailable(), 10u);
  741. b.copyIn("world");
  742. b.clear(false);
  743. MORDOR_TEST_ASSERT_EQUAL(b.readAvailable(), 0u);
  744. MORDOR_TEST_ASSERT_GREATER_THAN_OR_EQUAL(b.writeAvailable(), 5u);
  745. }