/thirdparty/breakpad/common/test_assembler_unittest.cc

http://github.com/tomahawk-player/tomahawk · C++ · 1662 lines · 1398 code · 190 blank · 74 comment · 6 complexity · b82908334574f9c3113ba95343fcb0f4 MD5 · raw file

  1. // Copyright (c) 2010, Google Inc.
  2. // All rights reserved.
  3. //
  4. // Redistribution and use in source and binary forms, with or without
  5. // modification, are permitted provided that the following conditions are
  6. // met:
  7. //
  8. // * Redistributions of source code must retain the above copyright
  9. // notice, this list of conditions and the following disclaimer.
  10. // * Redistributions in binary form must reproduce the above
  11. // copyright notice, this list of conditions and the following disclaimer
  12. // in the documentation and/or other materials provided with the
  13. // distribution.
  14. // * Neither the name of Google Inc. nor the names of its
  15. // contributors may be used to endorse or promote products derived from
  16. // this software without specific prior written permission.
  17. //
  18. // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19. // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20. // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21. // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22. // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23. // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24. // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25. // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26. // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27. // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28. // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29. // Original author: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com>
  30. // test_assembler_unittest.cc: Unit tests for google_breakpad::TestAssembler.
  31. #include <string>
  32. #include <string.h>
  33. #include "breakpad_googletest_includes.h"
  34. #include "common/test_assembler.h"
  35. using google_breakpad::test_assembler::Label;
  36. using google_breakpad::test_assembler::Section;
  37. using google_breakpad::test_assembler::kBigEndian;
  38. using google_breakpad::test_assembler::kLittleEndian;
  39. using std::string;
  40. using testing::Test;
  41. TEST(ConstructLabel, Simple) {
  42. Label l;
  43. }
  44. TEST(ConstructLabel, Undefined) {
  45. Label l;
  46. EXPECT_FALSE(l.IsKnownConstant());
  47. }
  48. TEST(ConstructLabelDeathTest, Undefined) {
  49. Label l;
  50. ASSERT_DEATH(l.Value(), "IsKnownConstant\\(&v\\)");
  51. }
  52. TEST(ConstructLabel, Constant) {
  53. Label l(0x060b9f974eaf301eULL);
  54. u_int64_t v;
  55. EXPECT_TRUE(l.IsKnownConstant(&v));
  56. EXPECT_EQ(v, 0x060b9f974eaf301eULL);
  57. EXPECT_EQ(l.Value(), 0x060b9f974eaf301eULL);
  58. }
  59. TEST(ConstructLabel, Copy) {
  60. Label l;
  61. Label m(l);
  62. u_int64_t v;
  63. EXPECT_TRUE(l.IsKnownOffsetFrom(m, &v));
  64. EXPECT_EQ(0U, v);
  65. }
  66. // The left-hand-side of a label assignment can be either
  67. // unconstrained, related, or known. The right-hand-side can be any of
  68. // those, or an integer.
  69. TEST(Assignment, UnconstrainedToUnconstrained) {
  70. Label l, m;
  71. l = m;
  72. EXPECT_EQ(0U, l-m);
  73. EXPECT_TRUE(l.IsKnownOffsetFrom(m));
  74. u_int64_t d;
  75. EXPECT_TRUE(l.IsKnownOffsetFrom(m, &d));
  76. EXPECT_EQ(0U, d);
  77. EXPECT_FALSE(l.IsKnownConstant());
  78. }
  79. TEST(Assignment, UnconstrainedToRelated) {
  80. Label l, m, n;
  81. l = n;
  82. l = m;
  83. EXPECT_EQ(0U, l-m);
  84. EXPECT_TRUE(l.IsKnownOffsetFrom(m));
  85. u_int64_t d;
  86. EXPECT_TRUE(l.IsKnownOffsetFrom(m, &d));
  87. EXPECT_EQ(0U, d);
  88. EXPECT_FALSE(l.IsKnownConstant());
  89. }
  90. TEST(Assignment, UnconstrainedToKnown) {
  91. Label l, m;
  92. l = 0x8fd16e55b20a39c1ULL;
  93. l = m;
  94. EXPECT_EQ(0U, l-m);
  95. EXPECT_TRUE(l.IsKnownOffsetFrom(m));
  96. u_int64_t d;
  97. EXPECT_TRUE(l.IsKnownOffsetFrom(m, &d));
  98. EXPECT_EQ(0U, d);
  99. EXPECT_TRUE(m.IsKnownConstant());
  100. EXPECT_EQ(0x8fd16e55b20a39c1ULL, m.Value());
  101. }
  102. TEST(Assignment, RelatedToUnconstrained) {
  103. Label l, m, n;
  104. m = n;
  105. l = m;
  106. EXPECT_EQ(0U, l-n);
  107. EXPECT_TRUE(l.IsKnownOffsetFrom(n));
  108. u_int64_t d;
  109. EXPECT_TRUE(l.IsKnownOffsetFrom(n, &d));
  110. EXPECT_EQ(0U, d);
  111. EXPECT_FALSE(l.IsKnownConstant());
  112. }
  113. TEST(Assignment, RelatedToRelated) {
  114. Label l, m, n, o;
  115. l = n;
  116. m = o;
  117. l = m;
  118. EXPECT_EQ(0U, n-o);
  119. EXPECT_TRUE(n.IsKnownOffsetFrom(o));
  120. u_int64_t d;
  121. EXPECT_TRUE(n.IsKnownOffsetFrom(o, &d));
  122. EXPECT_EQ(0U, d);
  123. EXPECT_FALSE(l.IsKnownConstant());
  124. }
  125. TEST(Assignment, RelatedToKnown) {
  126. Label l, m, n;
  127. m = n;
  128. l = 0xd2011f8c82ad56f2ULL;
  129. l = m;
  130. EXPECT_TRUE(l.IsKnownConstant());
  131. EXPECT_EQ(0xd2011f8c82ad56f2ULL, l.Value());
  132. EXPECT_TRUE(m.IsKnownConstant());
  133. EXPECT_EQ(0xd2011f8c82ad56f2ULL, m.Value());
  134. EXPECT_TRUE(n.IsKnownConstant());
  135. EXPECT_EQ(0xd2011f8c82ad56f2ULL, n.Value());
  136. }
  137. TEST(Assignment, KnownToUnconstrained) {
  138. Label l, m;
  139. m = 0x50b024c0d6073887ULL;
  140. l = m;
  141. EXPECT_TRUE(l.IsKnownConstant());
  142. EXPECT_EQ(0x50b024c0d6073887ULL, l.Value());
  143. EXPECT_TRUE(m.IsKnownConstant());
  144. EXPECT_EQ(0x50b024c0d6073887ULL, m.Value());
  145. }
  146. TEST(Assignment, KnownToRelated) {
  147. Label l, m, n;
  148. l = n;
  149. m = 0x5348883655c727e5ULL;
  150. l = m;
  151. EXPECT_TRUE(l.IsKnownConstant());
  152. EXPECT_EQ(0x5348883655c727e5ULL, l.Value());
  153. EXPECT_TRUE(m.IsKnownConstant());
  154. EXPECT_EQ(0x5348883655c727e5ULL, m.Value());
  155. EXPECT_TRUE(n.IsKnownConstant());
  156. EXPECT_EQ(0x5348883655c727e5ULL, n.Value());
  157. }
  158. TEST(Assignment, KnownToKnown) {
  159. Label l, m;
  160. l = 0x36c209c20987564eULL;
  161. m = 0x36c209c20987564eULL;
  162. l = m;
  163. EXPECT_TRUE(l.IsKnownConstant());
  164. EXPECT_EQ(0x36c209c20987564eULL, l.Value());
  165. EXPECT_TRUE(m.IsKnownConstant());
  166. EXPECT_EQ(0x36c209c20987564eULL, m.Value());
  167. }
  168. TEST(Assignment, ConstantToUnconstrained) {
  169. Label l;
  170. l = 0xc02495f4d7f5a957ULL;
  171. EXPECT_TRUE(l.IsKnownConstant());
  172. EXPECT_EQ(0xc02495f4d7f5a957ULL, l.Value());
  173. }
  174. TEST(Assignment, ConstantToRelated) {
  175. Label l, m;
  176. l = m;
  177. l = 0x4577901cf275488dULL;
  178. EXPECT_TRUE(l.IsKnownConstant());
  179. EXPECT_EQ(0x4577901cf275488dULL, l.Value());
  180. EXPECT_TRUE(m.IsKnownConstant());
  181. EXPECT_EQ(0x4577901cf275488dULL, m.Value());
  182. }
  183. TEST(Assignment, ConstantToKnown) {
  184. Label l;
  185. l = 0xec0b9c369b7e8ea7ULL;
  186. l = 0xec0b9c369b7e8ea7ULL;
  187. EXPECT_TRUE(l.IsKnownConstant());
  188. EXPECT_EQ(0xec0b9c369b7e8ea7ULL, l.Value());
  189. }
  190. TEST(AssignmentDeathTest, Self) {
  191. Label l;
  192. ASSERT_DEATH(l = l, "binding != this");
  193. }
  194. TEST(AssignmentDeathTest, IndirectCycle) {
  195. Label l, m, n;
  196. l = m;
  197. m = n;
  198. ASSERT_DEATH(n = l, "binding != this");
  199. }
  200. TEST(AssignmentDeathTest, Cycle) {
  201. Label l, m, n, o;
  202. l = m;
  203. m = n;
  204. o = n;
  205. ASSERT_DEATH(o = l, "binding != this");
  206. }
  207. TEST(Addition, LabelConstant) {
  208. Label l, m;
  209. m = l + 0x5248d93e8bbe9497ULL;
  210. EXPECT_TRUE(m.IsKnownOffsetFrom(l));
  211. u_int64_t d;
  212. EXPECT_TRUE(m.IsKnownOffsetFrom(l, &d));
  213. EXPECT_EQ(0x5248d93e8bbe9497ULL, d);
  214. EXPECT_FALSE(m.IsKnownConstant());
  215. }
  216. TEST(Addition, ConstantLabel) {
  217. Label l, m;
  218. m = 0xf51e94e00d6e3c84ULL + l;
  219. EXPECT_TRUE(m.IsKnownOffsetFrom(l));
  220. u_int64_t d;
  221. EXPECT_TRUE(m.IsKnownOffsetFrom(l, &d));
  222. EXPECT_EQ(0xf51e94e00d6e3c84ULL, d);
  223. EXPECT_FALSE(m.IsKnownConstant());
  224. }
  225. TEST(Addition, KnownLabelConstant) {
  226. Label l, m;
  227. l = 0x16286307042ce0d8ULL;
  228. m = l + 0x3fdddd91306719d7ULL;
  229. EXPECT_TRUE(m.IsKnownOffsetFrom(l));
  230. u_int64_t d;
  231. EXPECT_TRUE(m.IsKnownOffsetFrom(l, &d));
  232. EXPECT_EQ(0x3fdddd91306719d7ULL, d);
  233. EXPECT_TRUE(m.IsKnownConstant());
  234. EXPECT_EQ(0x16286307042ce0d8ULL + 0x3fdddd91306719d7ULL, m.Value());
  235. }
  236. TEST(Addition, ConstantKnownLabel) {
  237. Label l, m;
  238. l = 0x50f62d0cdd1031deULL;
  239. m = 0x1b13462d8577c538ULL + l;
  240. EXPECT_TRUE(m.IsKnownOffsetFrom(l));
  241. u_int64_t d;
  242. EXPECT_TRUE(m.IsKnownOffsetFrom(l, &d));
  243. EXPECT_EQ(0x1b13462d8577c538ULL, d);
  244. EXPECT_TRUE(m.IsKnownConstant());
  245. EXPECT_EQ(0x50f62d0cdd1031deULL + 0x1b13462d8577c538ULL, m.Value());
  246. }
  247. TEST(Subtraction, LabelConstant) {
  248. Label l, m;
  249. m = l - 0x0620884d21d3138eULL;
  250. EXPECT_TRUE(m.IsKnownOffsetFrom(l));
  251. u_int64_t d;
  252. EXPECT_TRUE(m.IsKnownOffsetFrom(l, &d));
  253. EXPECT_EQ(-0x0620884d21d3138eULL, d);
  254. EXPECT_FALSE(m.IsKnownConstant());
  255. }
  256. TEST(Subtraction, KnownLabelConstant) {
  257. Label l, m;
  258. l = 0x6237fbaf9ef7929eULL;
  259. m = l - 0x317730995d2ab6eeULL;
  260. EXPECT_TRUE(m.IsKnownOffsetFrom(l));
  261. u_int64_t d;
  262. EXPECT_TRUE(m.IsKnownOffsetFrom(l, &d));
  263. EXPECT_EQ(-0x317730995d2ab6eeULL, d);
  264. EXPECT_TRUE(m.IsKnownConstant());
  265. EXPECT_EQ(0x6237fbaf9ef7929eULL - 0x317730995d2ab6eeULL, m.Value());
  266. }
  267. TEST(SubtractionDeathTest, LabelLabel) {
  268. Label l, m;
  269. ASSERT_DEATH(l - m, "IsKnownOffsetFrom\\(label, &offset\\)");
  270. }
  271. TEST(Subtraction, LabelLabel) {
  272. Label l, m;
  273. l = m + 0x7fa77ec63e28a17aULL;
  274. EXPECT_EQ(0x7fa77ec63e28a17aULL, l - m);
  275. EXPECT_EQ(-0x7fa77ec63e28a17aULL, m - l);
  276. }
  277. TEST(IsKnownConstant, Undefined) {
  278. Label l;
  279. EXPECT_FALSE(l.IsKnownConstant());
  280. }
  281. TEST(IsKnownConstant, RelatedLabel) {
  282. Label l, m;
  283. l = m;
  284. EXPECT_FALSE(l.IsKnownConstant());
  285. EXPECT_FALSE(m.IsKnownConstant());
  286. }
  287. TEST(IsKnownConstant, Constant) {
  288. Label l;
  289. l = 0xf374b1bdd6a22576ULL;
  290. EXPECT_TRUE(l.IsKnownConstant());
  291. }
  292. TEST(IsKnownOffsetFrom, Unrelated) {
  293. Label l, m;
  294. EXPECT_FALSE(l.IsKnownOffsetFrom(m));
  295. }
  296. TEST(IsKnownOffsetFrom, Related) {
  297. Label l, m;
  298. l = m;
  299. EXPECT_TRUE(l.IsKnownOffsetFrom(m));
  300. }
  301. // Test the construction of chains of related labels, and the
  302. // propagation of values through them.
  303. //
  304. // Although the relations between labels are supposed to behave
  305. // symmetrically --- that is, 'a = b' should put a and b in
  306. // indistinguishable states --- there's a distinction made internally
  307. // between the target (a) and the source (b).
  308. //
  309. // So there are five test axes to cover:
  310. //
  311. // - Do we construct the chain with assignment ("Assign") or with constructors
  312. // ("Construct")?
  313. //
  314. // - Do we set the value of the label at the start of the chain
  315. // ("Start") or the label at the end ("End")?
  316. //
  317. // - Are we testing the propagation of a relationship between variable
  318. // values ("Relation"), or the propagation of a known constant value
  319. // ("Value")?
  320. //
  321. // - Do we set the value before building the chain ("Before") or after
  322. // the chain has been built ("After")?
  323. //
  324. // - Do we add new relationships to the end of the existing chain
  325. // ("Forward") or to the beginning ("Backward")?
  326. //
  327. // Of course, "Construct" and "Backward" can't be combined, which
  328. // eliminates eight combinations, and "Construct", "End", and "Before"
  329. // can't be combined, which eliminates two more, so there are are 22
  330. // combinations, not 32.
  331. TEST(LabelChain, AssignStartRelationBeforeForward) {
  332. Label a, b, c, d;
  333. Label x;
  334. a = x;
  335. b = a + 0x1;
  336. c = b + 0x10;
  337. d = c + 0x100;
  338. EXPECT_EQ(0x111U, d-x);
  339. EXPECT_EQ(0x11U, c-x);
  340. EXPECT_EQ(0x1U, b-x);
  341. EXPECT_EQ(0U, a-x);
  342. }
  343. TEST(LabelChain, AssignStartRelationBeforeBackward) {
  344. Label a, b, c, d;
  345. Label x;
  346. a = x;
  347. d = c + 0x100;
  348. c = b + 0x10;
  349. b = a + 0x1;
  350. EXPECT_EQ(0x111U, d-x);
  351. EXPECT_EQ(0x11U, c-x);
  352. EXPECT_EQ(0x1U, b-x);
  353. EXPECT_EQ(0U, a-x);
  354. }
  355. TEST(LabelChain, AssignStartRelationAfterForward) {
  356. Label a, b, c, d;
  357. Label x;
  358. b = a + 0x1;
  359. c = b + 0x10;
  360. d = c + 0x100;
  361. a = x;
  362. EXPECT_EQ(0x111U, d-x);
  363. EXPECT_EQ(0x11U, c-x);
  364. EXPECT_EQ(0x1U, b-x);
  365. EXPECT_EQ(0U, a-x);
  366. }
  367. TEST(LabelChain, AssignStartRelationAfterBackward) {
  368. Label a, b, c, d;
  369. Label x;
  370. d = c + 0x100;
  371. c = b + 0x10;
  372. b = a + 0x1;
  373. a = x;
  374. EXPECT_EQ(0x111U, d-x);
  375. EXPECT_EQ(0x11U, c-x);
  376. EXPECT_EQ(0x1U, b-x);
  377. EXPECT_EQ(0U, a-x);
  378. }
  379. TEST(LabelChain, AssignStartValueBeforeForward) {
  380. Label a, b, c, d;
  381. a = 0xa131200190546ac2ULL;
  382. b = a + 0x1;
  383. c = b + 0x10;
  384. d = c + 0x100;
  385. EXPECT_EQ(0xa131200190546ac2ULL + 0x111U, d.Value());
  386. EXPECT_EQ(0xa131200190546ac2ULL + 0x11U, c.Value());
  387. EXPECT_EQ(0xa131200190546ac2ULL + 0x1U, b.Value());
  388. EXPECT_EQ(0xa131200190546ac2ULL + 0U, a.Value());
  389. }
  390. TEST(LabelChain, AssignStartValueBeforeBackward) {
  391. Label a, b, c, d;
  392. a = 0x8da17e1670ad4fa2ULL;
  393. d = c + 0x100;
  394. c = b + 0x10;
  395. b = a + 0x1;
  396. EXPECT_EQ(0x8da17e1670ad4fa2ULL + 0x111U, d.Value());
  397. EXPECT_EQ(0x8da17e1670ad4fa2ULL + 0x11U, c.Value());
  398. EXPECT_EQ(0x8da17e1670ad4fa2ULL + 0x1U, b.Value());
  399. EXPECT_EQ(0x8da17e1670ad4fa2ULL + 0U, a.Value());
  400. }
  401. TEST(LabelChain, AssignStartValueAfterForward) {
  402. Label a, b, c, d;
  403. b = a + 0x1;
  404. c = b + 0x10;
  405. d = c + 0x100;
  406. a = 0x99b8f51bafd41adaULL;
  407. EXPECT_EQ(0x99b8f51bafd41adaULL + 0x111U, d.Value());
  408. EXPECT_EQ(0x99b8f51bafd41adaULL + 0x11U, c.Value());
  409. EXPECT_EQ(0x99b8f51bafd41adaULL + 0x1U, b.Value());
  410. EXPECT_EQ(0x99b8f51bafd41adaULL + 0U, a.Value());
  411. }
  412. TEST(LabelChain, AssignStartValueAfterBackward) {
  413. Label a, b, c, d;
  414. d = c + 0x100;
  415. c = b + 0x10;
  416. b = a + 0x1;
  417. a = 0xc86ca1d97ab5df6eULL;
  418. EXPECT_EQ(0xc86ca1d97ab5df6eULL + 0x111U, d.Value());
  419. EXPECT_EQ(0xc86ca1d97ab5df6eULL + 0x11U, c.Value());
  420. EXPECT_EQ(0xc86ca1d97ab5df6eULL + 0x1U, b.Value());
  421. EXPECT_EQ(0xc86ca1d97ab5df6eULL + 0U, a.Value());
  422. }
  423. TEST(LabelChain, AssignEndRelationBeforeForward) {
  424. Label a, b, c, d;
  425. Label x;
  426. x = d;
  427. b = a + 0x1;
  428. c = b + 0x10;
  429. d = c + 0x100;
  430. EXPECT_EQ(-(u_int64_t)0x111U, a-x);
  431. EXPECT_EQ(-(u_int64_t)0x110U, b-x);
  432. EXPECT_EQ(-(u_int64_t)0x100U, c-x);
  433. EXPECT_EQ(-(u_int64_t)0U, d-x);
  434. }
  435. TEST(LabelChain, AssignEndRelationBeforeBackward) {
  436. Label a, b, c, d;
  437. Label x;
  438. x = d;
  439. d = c + 0x100;
  440. c = b + 0x10;
  441. b = a + 0x1;
  442. EXPECT_EQ(-(u_int64_t)0x111U, a-x);
  443. EXPECT_EQ(-(u_int64_t)0x110U, b-x);
  444. EXPECT_EQ(-(u_int64_t)0x100U, c-x);
  445. EXPECT_EQ(-(u_int64_t)0U, d-x);
  446. }
  447. TEST(LabelChain, AssignEndRelationAfterForward) {
  448. Label a, b, c, d;
  449. Label x;
  450. b = a + 0x1;
  451. c = b + 0x10;
  452. d = c + 0x100;
  453. x = d;
  454. EXPECT_EQ(-(u_int64_t)0x111U, a-x);
  455. EXPECT_EQ(-(u_int64_t)0x110U, b-x);
  456. EXPECT_EQ(-(u_int64_t)0x100U, c-x);
  457. EXPECT_EQ(-(u_int64_t)0x000U, d-x);
  458. }
  459. TEST(LabelChain, AssignEndRelationAfterBackward) {
  460. Label a, b, c, d;
  461. Label x;
  462. d = c + 0x100;
  463. c = b + 0x10;
  464. b = a + 0x1;
  465. x = d;
  466. EXPECT_EQ(-(u_int64_t)0x111U, a-x);
  467. EXPECT_EQ(-(u_int64_t)0x110U, b-x);
  468. EXPECT_EQ(-(u_int64_t)0x100U, c-x);
  469. EXPECT_EQ(-(u_int64_t)0x000U, d-x);
  470. }
  471. TEST(LabelChain, AssignEndValueBeforeForward) {
  472. Label a, b, c, d;
  473. d = 0xa131200190546ac2ULL;
  474. b = a + 0x1;
  475. c = b + 0x10;
  476. d = c + 0x100;
  477. EXPECT_EQ(0xa131200190546ac2ULL - 0x111, a.Value());
  478. EXPECT_EQ(0xa131200190546ac2ULL - 0x110, b.Value());
  479. EXPECT_EQ(0xa131200190546ac2ULL - 0x100, c.Value());
  480. EXPECT_EQ(0xa131200190546ac2ULL - 0x000, d.Value());
  481. }
  482. TEST(LabelChain, AssignEndValueBeforeBackward) {
  483. Label a, b, c, d;
  484. d = 0x8da17e1670ad4fa2ULL;
  485. d = c + 0x100;
  486. c = b + 0x10;
  487. b = a + 0x1;
  488. EXPECT_EQ(0x8da17e1670ad4fa2ULL - 0x111, a.Value());
  489. EXPECT_EQ(0x8da17e1670ad4fa2ULL - 0x110, b.Value());
  490. EXPECT_EQ(0x8da17e1670ad4fa2ULL - 0x100, c.Value());
  491. EXPECT_EQ(0x8da17e1670ad4fa2ULL - 0x000, d.Value());
  492. }
  493. TEST(LabelChain, AssignEndValueAfterForward) {
  494. Label a, b, c, d;
  495. b = a + 0x1;
  496. c = b + 0x10;
  497. d = c + 0x100;
  498. d = 0x99b8f51bafd41adaULL;
  499. EXPECT_EQ(0x99b8f51bafd41adaULL - 0x111, a.Value());
  500. EXPECT_EQ(0x99b8f51bafd41adaULL - 0x110, b.Value());
  501. EXPECT_EQ(0x99b8f51bafd41adaULL - 0x100, c.Value());
  502. EXPECT_EQ(0x99b8f51bafd41adaULL - 0x000, d.Value());
  503. }
  504. TEST(LabelChain, AssignEndValueAfterBackward) {
  505. Label a, b, c, d;
  506. d = c + 0x100;
  507. c = b + 0x10;
  508. b = a + 0x1;
  509. d = 0xc86ca1d97ab5df6eULL;
  510. EXPECT_EQ(0xc86ca1d97ab5df6eULL - 0x111, a.Value());
  511. EXPECT_EQ(0xc86ca1d97ab5df6eULL - 0x110, b.Value());
  512. EXPECT_EQ(0xc86ca1d97ab5df6eULL - 0x100, c.Value());
  513. EXPECT_EQ(0xc86ca1d97ab5df6eULL - 0x000, d.Value());
  514. }
  515. TEST(LabelChain, ConstructStartRelationBeforeForward) {
  516. Label x;
  517. Label a(x);
  518. Label b(a + 0x1);
  519. Label c(b + 0x10);
  520. Label d(c + 0x100);
  521. EXPECT_EQ(0x111U, d-x);
  522. EXPECT_EQ(0x11U, c-x);
  523. EXPECT_EQ(0x1U, b-x);
  524. EXPECT_EQ(0U, a-x);
  525. }
  526. TEST(LabelChain, ConstructStartRelationAfterForward) {
  527. Label x;
  528. Label a;
  529. Label b(a + 0x1);
  530. Label c(b + 0x10);
  531. Label d(c + 0x100);
  532. a = x;
  533. EXPECT_EQ(0x111U, d-x);
  534. EXPECT_EQ(0x11U, c-x);
  535. EXPECT_EQ(0x1U, b-x);
  536. EXPECT_EQ(0U, a-x);
  537. }
  538. TEST(LabelChain, ConstructStartValueBeforeForward) {
  539. Label a(0x5d234d177d01ccc8ULL);
  540. Label b(a + 0x1);
  541. Label c(b + 0x10);
  542. Label d(c + 0x100);
  543. EXPECT_EQ(0x5d234d177d01ccc8ULL + 0x111U, d.Value());
  544. EXPECT_EQ(0x5d234d177d01ccc8ULL + 0x011U, c.Value());
  545. EXPECT_EQ(0x5d234d177d01ccc8ULL + 0x001U, b.Value());
  546. EXPECT_EQ(0x5d234d177d01ccc8ULL + 0x000U, a.Value());
  547. }
  548. TEST(LabelChain, ConstructStartValueAfterForward) {
  549. Label a;
  550. Label b(a + 0x1);
  551. Label c(b + 0x10);
  552. Label d(c + 0x100);
  553. a = 0xded85d54586e84fcULL;
  554. EXPECT_EQ(0xded85d54586e84fcULL + 0x111U, d.Value());
  555. EXPECT_EQ(0xded85d54586e84fcULL + 0x011U, c.Value());
  556. EXPECT_EQ(0xded85d54586e84fcULL + 0x001U, b.Value());
  557. EXPECT_EQ(0xded85d54586e84fcULL + 0x000U, a.Value());
  558. }
  559. TEST(LabelChain, ConstructEndRelationAfterForward) {
  560. Label x;
  561. Label a;
  562. Label b(a + 0x1);
  563. Label c(b + 0x10);
  564. Label d(c + 0x100);
  565. x = d;
  566. EXPECT_EQ(-(u_int64_t)0x111U, a-x);
  567. EXPECT_EQ(-(u_int64_t)0x110U, b-x);
  568. EXPECT_EQ(-(u_int64_t)0x100U, c-x);
  569. EXPECT_EQ(-(u_int64_t)0x000U, d-x);
  570. }
  571. TEST(LabelChain, ConstructEndValueAfterForward) {
  572. Label a;
  573. Label b(a + 0x1);
  574. Label c(b + 0x10);
  575. Label d(c + 0x100);
  576. d = 0x99b8f51bafd41adaULL;
  577. EXPECT_EQ(0x99b8f51bafd41adaULL - 0x111, a.Value());
  578. EXPECT_EQ(0x99b8f51bafd41adaULL - 0x110, b.Value());
  579. EXPECT_EQ(0x99b8f51bafd41adaULL - 0x100, c.Value());
  580. EXPECT_EQ(0x99b8f51bafd41adaULL - 0x000, d.Value());
  581. }
  582. TEST(LabelTree, KnownValue) {
  583. Label l, m, n, o, p;
  584. l = m;
  585. m = n;
  586. o = p;
  587. p = n;
  588. l = 0x536b5de3d468a1b5ULL;
  589. EXPECT_EQ(0x536b5de3d468a1b5ULL, o.Value());
  590. }
  591. TEST(LabelTree, Related) {
  592. Label l, m, n, o, p;
  593. l = m - 1;
  594. m = n - 10;
  595. o = p + 100;
  596. p = n + 1000;
  597. EXPECT_EQ(1111U, o - l);
  598. }
  599. TEST(EquationDeathTest, EqualConstants) {
  600. Label m = 0x0d3962f280f07d24ULL;
  601. Label n = 0x0d3962f280f07d24ULL;
  602. m = n; // no death expected
  603. }
  604. TEST(EquationDeathTest, EqualIndirectConstants) {
  605. Label m = 0xa347f1e5238fe6a1ULL;
  606. Label n;
  607. Label o = n;
  608. n = 0xa347f1e5238fe6a1ULL;
  609. n = m; // no death expected
  610. }
  611. TEST(EquationDeathTest, ConstantClash) {
  612. Label m = 0xd4cc0f4f630ec741ULL;
  613. Label n = 0x934cd2d8254fc3eaULL;
  614. ASSERT_DEATH(m = n, "addend_ == addend");
  615. }
  616. TEST(EquationDeathTest, IndirectConstantClash) {
  617. Label m = 0xd4cc0f4f630ec741ULL;
  618. Label n, o;
  619. n = o;
  620. o = 0xcfbe3b83ac49ce86ULL;
  621. ASSERT_DEATH(m = n, "addend_ == addend");
  622. }
  623. // Assigning to a related label may free the next Binding on its
  624. // chain. This test always passes; it is interesting to memory
  625. // checkers and coverage analysis.
  626. TEST(LabelReferenceCount, AssignmentFree) {
  627. Label l;
  628. {
  629. Label m;
  630. l = m;
  631. }
  632. // This should free m's Binding.
  633. l = 0xca8bae92f0376d4fULL;
  634. ASSERT_EQ(0xca8bae92f0376d4fULL, l.Value());
  635. }
  636. // Finding the value of a label may free the Binding it refers to. This test
  637. // always passes; it is interesting to memory checkers and coverage analysis.
  638. TEST(LabelReferenceCount, FindValueFree) {
  639. Label l;
  640. {
  641. Label m, n;
  642. l = m;
  643. m = n;
  644. n = 0x7a0b0c576672daafULL;
  645. // At this point, l's Binding refers to m's Binding, which refers
  646. // to n's binding.
  647. }
  648. // Now, l is the only reference keeping the three Bindings alive.
  649. // Resolving its value should free l's and m's original bindings.
  650. ASSERT_EQ(0x7a0b0c576672daafULL, l.Value());
  651. }
  652. TEST(ConstructSection, Simple) {
  653. Section s;
  654. }
  655. TEST(ConstructSection, WithEndian) {
  656. Section s(kBigEndian);
  657. }
  658. // A fixture class for TestAssembler::Section tests.
  659. class SectionFixture {
  660. public:
  661. Section section;
  662. string contents;
  663. static const u_int8_t data[];
  664. static const size_t data_size;
  665. };
  666. const u_int8_t SectionFixture::data[] = {
  667. 0x87, 0x4f, 0x43, 0x67, 0x30, 0xd0, 0xd4, 0x0e
  668. };
  669. #define I0()
  670. #define I1(a) { a }
  671. #define I2(a,b) { a,b }
  672. #define I3(a,b,c) { a,b,c }
  673. #define I4(a,b,c,d) { a,b,c,d }
  674. #define I5(a,b,c,d,e) { a,b,c,d,e }
  675. #define I6(a,b,c,d,e,f) { a,b,c,d,e,f }
  676. #define I7(a,b,c,d,e,f,g) { a,b,c,d,e,f,g }
  677. #define I8(a,b,c,d,e,f,g,h) { a,b,c,d,e,f,g,h }
  678. #define I9(a,b,c,d,e,f,g,h,i) { a,b,c,d,e,f,g,h,i }
  679. #define ASSERT_BYTES(s, b) \
  680. do \
  681. { \
  682. static const u_int8_t expected_bytes[] = b; \
  683. ASSERT_EQ(sizeof(expected_bytes), s.size()); \
  684. ASSERT_TRUE(memcmp(s.data(), (const char *) expected_bytes, \
  685. sizeof(expected_bytes)) == 0); \
  686. } \
  687. while(0)
  688. class Append: public SectionFixture, public Test { };
  689. TEST_F(Append, Bytes) {
  690. section.Append(data, sizeof(data));
  691. ASSERT_TRUE(section.GetContents(&contents));
  692. ASSERT_EQ(sizeof(data), contents.size());
  693. EXPECT_TRUE(0 == memcmp(contents.data(), (const char *) data, sizeof(data)));
  694. }
  695. TEST_F(Append, BytesTwice) {
  696. section.Append(data, sizeof(data));
  697. section.Append(data, sizeof(data));
  698. ASSERT_TRUE(section.GetContents(&contents));
  699. ASSERT_EQ(2 * sizeof(data), contents.size());
  700. ASSERT_TRUE(0 == memcmp(contents.data(), (const char *) data, sizeof(data)));
  701. ASSERT_TRUE(0 == memcmp(contents.data() + sizeof(data),
  702. (const char *) data, sizeof(data)));
  703. }
  704. TEST_F(Append, String) {
  705. string s1 = "howdy ";
  706. string s2 = "there";
  707. section.Append(s1);
  708. section.Append(s2);
  709. ASSERT_TRUE(section.GetContents(&contents));
  710. ASSERT_STREQ(contents.c_str(), "howdy there");
  711. }
  712. TEST_F(Append, CString) {
  713. section.AppendCString("howdy");
  714. section.AppendCString("");
  715. section.AppendCString("there");
  716. ASSERT_TRUE(section.GetContents(&contents));
  717. ASSERT_EQ(string("howdy\0\0there\0", 13), contents);
  718. }
  719. TEST_F(Append, CStringSize) {
  720. section.AppendCString("howdy", 3);
  721. section.AppendCString("there", 5);
  722. section.AppendCString("fred", 6);
  723. section.AppendCString("natalie", 0);
  724. section.AppendCString("", 10);
  725. ASSERT_TRUE(section.GetContents(&contents));
  726. ASSERT_EQ(string("howtherefred\0\0\0\0\0\0\0\0\0\0\0\0", 24), contents);
  727. }
  728. TEST_F(Append, RepeatedBytes) {
  729. section.Append((size_t) 10, '*');
  730. ASSERT_TRUE(section.GetContents(&contents));
  731. ASSERT_STREQ(contents.c_str(), "**********");
  732. }
  733. TEST_F(Append, GeneralLE1) {
  734. section.Append(kLittleEndian, 1, 42);
  735. ASSERT_TRUE(section.GetContents(&contents));
  736. ASSERT_BYTES(contents, I1(42));
  737. }
  738. TEST_F(Append, GeneralLE2) {
  739. section.Append(kLittleEndian, 2, 0x15a1);
  740. ASSERT_TRUE(section.GetContents(&contents));
  741. ASSERT_BYTES(contents, I2(0xa1, 0x15));
  742. }
  743. TEST_F(Append, GeneralLE3) {
  744. section.Append(kLittleEndian, 3, 0x59ae8d);
  745. ASSERT_TRUE(section.GetContents(&contents));
  746. ASSERT_BYTES(contents, I3(0x8d, 0xae, 0x59));
  747. }
  748. TEST_F(Append, GeneralLE4) {
  749. section.Append(kLittleEndian, 4, 0x51603c56);
  750. ASSERT_TRUE(section.GetContents(&contents));
  751. ASSERT_BYTES(contents, I4(0x56, 0x3c, 0x60, 0x51));
  752. }
  753. TEST_F(Append, GeneralLE5) {
  754. section.Append(kLittleEndian, 5, 0x385e2803b4ULL);
  755. ASSERT_TRUE(section.GetContents(&contents));
  756. ASSERT_BYTES(contents, I5(0xb4, 0x03, 0x28, 0x5e, 0x38));
  757. }
  758. TEST_F(Append, GeneralLE6) {
  759. section.Append(kLittleEndian, 6, 0xc7db9534dd1fULL);
  760. ASSERT_TRUE(section.GetContents(&contents));
  761. ASSERT_BYTES(contents, I6(0x1f, 0xdd, 0x34, 0x95, 0xdb, 0xc7));
  762. }
  763. TEST_F(Append, GeneralLE7) {
  764. section.Append(kLittleEndian, 7, 0x1445c9f1b843e6ULL);
  765. ASSERT_TRUE(section.GetContents(&contents));
  766. ASSERT_BYTES(contents, I7(0xe6, 0x43, 0xb8, 0xf1, 0xc9, 0x45, 0x14));
  767. }
  768. TEST_F(Append, GeneralLE8) {
  769. section.Append(kLittleEndian, 8, 0xaf48019dfe5c01e5ULL);
  770. ASSERT_TRUE(section.GetContents(&contents));
  771. ASSERT_BYTES(contents, I8(0xe5, 0x01, 0x5c, 0xfe, 0x9d, 0x01, 0x48, 0xaf));
  772. }
  773. TEST_F(Append, GeneralBE1) {
  774. section.Append(kBigEndian, 1, 0xd0ULL);
  775. ASSERT_TRUE(section.GetContents(&contents));
  776. ASSERT_BYTES(contents, I1(0xd0));
  777. }
  778. TEST_F(Append, GeneralBE2) {
  779. section.Append(kBigEndian, 2, 0x2e7eULL);
  780. ASSERT_TRUE(section.GetContents(&contents));
  781. ASSERT_BYTES(contents, I2(0x2e, 0x7e));
  782. }
  783. TEST_F(Append, GeneralBE3) {
  784. section.Append(kBigEndian, 3, 0x37dad6ULL);
  785. ASSERT_TRUE(section.GetContents(&contents));
  786. ASSERT_BYTES(contents, I3(0x37, 0xda, 0xd6));
  787. }
  788. TEST_F(Append, GeneralBE4) {
  789. section.Append(kBigEndian, 4, 0x715935c7ULL);
  790. ASSERT_TRUE(section.GetContents(&contents));
  791. ASSERT_BYTES(contents, I4(0x71, 0x59, 0x35, 0xc7));
  792. }
  793. TEST_F(Append, GeneralBE5) {
  794. section.Append(kBigEndian, 5, 0x42baeb02b7ULL);
  795. ASSERT_TRUE(section.GetContents(&contents));
  796. ASSERT_BYTES(contents, I5(0x42, 0xba, 0xeb, 0x02, 0xb7));
  797. }
  798. TEST_F(Append, GeneralBE6) {
  799. section.Append(kBigEndian, 6, 0xf1cdf10e7b18ULL);
  800. ASSERT_TRUE(section.GetContents(&contents));
  801. ASSERT_BYTES(contents, I6(0xf1, 0xcd, 0xf1, 0x0e, 0x7b, 0x18));
  802. }
  803. TEST_F(Append, GeneralBE7) {
  804. section.Append(kBigEndian, 7, 0xf50a724f0b0d20ULL);
  805. ASSERT_TRUE(section.GetContents(&contents));
  806. ASSERT_BYTES(contents, I7(0xf5, 0x0a, 0x72, 0x4f, 0x0b, 0x0d, 0x20));
  807. }
  808. TEST_F(Append, GeneralBE8) {
  809. section.Append(kBigEndian, 8, 0xa6b2cb5e98dc9c16ULL);
  810. ASSERT_TRUE(section.GetContents(&contents));
  811. ASSERT_BYTES(contents, I8(0xa6, 0xb2, 0xcb, 0x5e, 0x98, 0xdc, 0x9c, 0x16));
  812. }
  813. TEST_F(Append, GeneralLE1Label) {
  814. Label l;
  815. section.Append(kLittleEndian, 1, l);
  816. l = 42;
  817. ASSERT_TRUE(section.GetContents(&contents));
  818. ASSERT_BYTES(contents, I1(42));
  819. }
  820. TEST_F(Append, GeneralLE2Label) {
  821. Label l;
  822. section.Append(kLittleEndian, 2, l);
  823. l = 0x15a1;
  824. ASSERT_TRUE(section.GetContents(&contents));
  825. ASSERT_BYTES(contents, I2(0xa1, 0x15));
  826. }
  827. TEST_F(Append, GeneralLE3Label) {
  828. Label l;
  829. section.Append(kLittleEndian, 3, l);
  830. l = 0x59ae8d;
  831. ASSERT_TRUE(section.GetContents(&contents));
  832. ASSERT_BYTES(contents, I3(0x8d, 0xae, 0x59));
  833. }
  834. TEST_F(Append, GeneralLE4Label) {
  835. Label l;
  836. section.Append(kLittleEndian, 4, l);
  837. l = 0x51603c56;
  838. ASSERT_TRUE(section.GetContents(&contents));
  839. ASSERT_BYTES(contents, I4(0x56, 0x3c, 0x60, 0x51));
  840. }
  841. TEST_F(Append, GeneralLE5Label) {
  842. Label l;
  843. section.Append(kLittleEndian, 5, l);
  844. l = 0x385e2803b4ULL;
  845. ASSERT_TRUE(section.GetContents(&contents));
  846. ASSERT_BYTES(contents, I5(0xb4, 0x03, 0x28, 0x5e, 0x38));
  847. }
  848. TEST_F(Append, GeneralLE6Label) {
  849. Label l;
  850. section.Append(kLittleEndian, 6, l);
  851. l = 0xc7db9534dd1fULL;
  852. ASSERT_TRUE(section.GetContents(&contents));
  853. ASSERT_BYTES(contents, I6(0x1f, 0xdd, 0x34, 0x95, 0xdb, 0xc7));
  854. }
  855. TEST_F(Append, GeneralLE7Label) {
  856. Label l;
  857. section.Append(kLittleEndian, 7, l);
  858. l = 0x1445c9f1b843e6ULL;
  859. ASSERT_TRUE(section.GetContents(&contents));
  860. ASSERT_BYTES(contents, I7(0xe6, 0x43, 0xb8, 0xf1, 0xc9, 0x45, 0x14));
  861. }
  862. TEST_F(Append, GeneralLE8Label) {
  863. Label l;
  864. section.Append(kLittleEndian, 8, l);
  865. l = 0xaf48019dfe5c01e5ULL;
  866. ASSERT_TRUE(section.GetContents(&contents));
  867. ASSERT_BYTES(contents, I8(0xe5, 0x01, 0x5c, 0xfe, 0x9d, 0x01, 0x48, 0xaf));
  868. }
  869. TEST_F(Append, GeneralBE1Label) {
  870. Label l;
  871. section.Append(kBigEndian, 1, l);
  872. l = 0xd0ULL;
  873. ASSERT_TRUE(section.GetContents(&contents));
  874. ASSERT_BYTES(contents, I1(0xd0));
  875. }
  876. TEST_F(Append, GeneralBE2Label) {
  877. Label l;
  878. section.Append(kBigEndian, 2, l);
  879. l = 0x2e7eULL;
  880. ASSERT_TRUE(section.GetContents(&contents));
  881. ASSERT_BYTES(contents, I2(0x2e, 0x7e));
  882. }
  883. TEST_F(Append, GeneralBE3Label) {
  884. Label l;
  885. section.Append(kBigEndian, 3, l);
  886. l = 0x37dad6ULL;
  887. ASSERT_TRUE(section.GetContents(&contents));
  888. ASSERT_BYTES(contents, I3(0x37, 0xda, 0xd6));
  889. }
  890. TEST_F(Append, GeneralBE4Label) {
  891. Label l;
  892. section.Append(kBigEndian, 4, l);
  893. l = 0x715935c7ULL;
  894. ASSERT_TRUE(section.GetContents(&contents));
  895. ASSERT_BYTES(contents, I4(0x71, 0x59, 0x35, 0xc7));
  896. }
  897. TEST_F(Append, GeneralBE5Label) {
  898. Label l;
  899. section.Append(kBigEndian, 5, l);
  900. l = 0x42baeb02b7ULL;
  901. ASSERT_TRUE(section.GetContents(&contents));
  902. ASSERT_BYTES(contents, I5(0x42, 0xba, 0xeb, 0x02, 0xb7));
  903. }
  904. TEST_F(Append, GeneralBE6Label) {
  905. Label l;
  906. section.Append(kBigEndian, 6, l);
  907. l = 0xf1cdf10e7b18ULL;
  908. ASSERT_TRUE(section.GetContents(&contents));
  909. ASSERT_BYTES(contents, I6(0xf1, 0xcd, 0xf1, 0x0e, 0x7b, 0x18));
  910. }
  911. TEST_F(Append, GeneralBE7Label) {
  912. Label l;
  913. section.Append(kBigEndian, 7, l);
  914. l = 0xf50a724f0b0d20ULL;
  915. ASSERT_TRUE(section.GetContents(&contents));
  916. ASSERT_BYTES(contents, I7(0xf5, 0x0a, 0x72, 0x4f, 0x0b, 0x0d, 0x20));
  917. }
  918. TEST_F(Append, GeneralBE8Label) {
  919. Label l;
  920. section.Append(kBigEndian, 8, l);
  921. l = 0xa6b2cb5e98dc9c16ULL;
  922. ASSERT_TRUE(section.GetContents(&contents));
  923. ASSERT_BYTES(contents, I8(0xa6, 0xb2, 0xcb, 0x5e, 0x98, 0xdc, 0x9c, 0x16));
  924. }
  925. TEST_F(Append, B8) {
  926. section.Append(1, 0x2a);
  927. section.B8(0xd3U);
  928. ASSERT_TRUE(section.GetContents(&contents));
  929. ASSERT_BYTES(contents, I2(0x2a, 0xd3));
  930. }
  931. TEST_F(Append, B8Label) {
  932. Label l;
  933. section.Append(1, 0x2a);
  934. section.B8(l);
  935. l = 0x4bU;
  936. ASSERT_TRUE(section.GetContents(&contents));
  937. ASSERT_BYTES(contents, I2(0x2a, 0x4b));
  938. }
  939. TEST_F(Append, B16) {
  940. section.Append(1, 0x2a);
  941. section.B16(0x472aU);
  942. ASSERT_TRUE(section.GetContents(&contents));
  943. ASSERT_BYTES(contents, I3(0x2a, 0x47, 0x2a));
  944. }
  945. TEST_F(Append, B16Label) {
  946. Label l;
  947. section.Append(1, 0x2a);
  948. section.B16(l);
  949. l = 0x55e8U;
  950. ASSERT_TRUE(section.GetContents(&contents));
  951. ASSERT_BYTES(contents, I3(0x2a, 0x55, 0xe8));
  952. }
  953. TEST_F(Append, B32) {
  954. section.Append(1, 0x2a);
  955. section.B32(0xbd412cbcU);
  956. ASSERT_TRUE(section.GetContents(&contents));
  957. ASSERT_BYTES(contents, I5(0x2a, 0xbd, 0x41, 0x2c, 0xbc));
  958. }
  959. TEST_F(Append, B32Label) {
  960. Label l;
  961. section.Append(1, 0x2a);
  962. section.B32(l);
  963. l = 0x208e37d5U;
  964. ASSERT_TRUE(section.GetContents(&contents));
  965. ASSERT_BYTES(contents, I5(0x2a, 0x20, 0x8e, 0x37, 0xd5));
  966. }
  967. TEST_F(Append, B64) {
  968. section.Append(1, 0x2a);
  969. section.B64(0x3402a013111e68adULL);
  970. ASSERT_TRUE(section.GetContents(&contents));
  971. ASSERT_BYTES(contents,
  972. I9(0x2a, 0x34, 0x02, 0xa0, 0x13, 0x11, 0x1e, 0x68, 0xad));
  973. }
  974. TEST_F(Append, B64Label) {
  975. Label l;
  976. section.Append(1, 0x2a);
  977. section.B64(l);
  978. l = 0x355dbfbb4ac6d57fULL;
  979. ASSERT_TRUE(section.GetContents(&contents));
  980. ASSERT_BYTES(contents,
  981. I9(0x2a, 0x35, 0x5d, 0xbf, 0xbb, 0x4a, 0xc6, 0xd5, 0x7f));
  982. }
  983. TEST_F(Append, L8) {
  984. section.Append(1, 0x2a);
  985. section.L8(0x26U);
  986. ASSERT_TRUE(section.GetContents(&contents));
  987. ASSERT_BYTES(contents, I2(0x2a, 0x26));
  988. }
  989. TEST_F(Append, L8Label) {
  990. Label l;
  991. section.Append(1, 0x2a);
  992. section.L8(l);
  993. l = 0xa8U;
  994. ASSERT_TRUE(section.GetContents(&contents));
  995. ASSERT_BYTES(contents, I2(0x2a, 0xa8));
  996. }
  997. TEST_F(Append, L16) {
  998. section.Append(1, 0x2a);
  999. section.L16(0xca6dU);
  1000. ASSERT_TRUE(section.GetContents(&contents));
  1001. ASSERT_BYTES(contents, I3(0x2a, 0x6d, 0xca));
  1002. }
  1003. TEST_F(Append, L16Label) {
  1004. Label l;
  1005. section.Append(1, 0x2a);
  1006. section.L16(l);
  1007. l = 0xd21fU;
  1008. ASSERT_TRUE(section.GetContents(&contents));
  1009. ASSERT_BYTES(contents, I3(0x2a, 0x1f, 0xd2));
  1010. }
  1011. TEST_F(Append, L32) {
  1012. section.Append(1, 0x2a);
  1013. section.L32(0x558f6181U);
  1014. ASSERT_TRUE(section.GetContents(&contents));
  1015. ASSERT_BYTES(contents, I5(0x2a, 0x81, 0x61, 0x8f, 0x55));
  1016. }
  1017. TEST_F(Append, L32Label) {
  1018. Label l;
  1019. section.Append(1, 0x2a);
  1020. section.L32(l);
  1021. l = 0x4b810f82U;
  1022. ASSERT_TRUE(section.GetContents(&contents));
  1023. ASSERT_BYTES(contents, I5(0x2a, 0x82, 0x0f, 0x81, 0x4b));
  1024. }
  1025. TEST_F(Append, L64) {
  1026. section.Append(1, 0x2a);
  1027. section.L64(0x564384f7579515bfULL);
  1028. ASSERT_TRUE(section.GetContents(&contents));
  1029. ASSERT_BYTES(contents,
  1030. I9(0x2a, 0xbf, 0x15, 0x95, 0x57, 0xf7, 0x84, 0x43, 0x56));
  1031. }
  1032. TEST_F(Append, L64Label) {
  1033. Label l;
  1034. section.Append(1, 0x2a);
  1035. section.L64(l);
  1036. l = 0x424b1d020667c8dbULL;
  1037. ASSERT_TRUE(section.GetContents(&contents));
  1038. ASSERT_BYTES(contents,
  1039. I9(0x2a, 0xdb, 0xc8, 0x67, 0x06, 0x02, 0x1d, 0x4b, 0x42));
  1040. }
  1041. TEST_F(Append, D8Big) {
  1042. section.set_endianness(kBigEndian);
  1043. section.Append(1, 0x2a);
  1044. section.D8(0xe6U);
  1045. ASSERT_TRUE(section.GetContents(&contents));
  1046. ASSERT_BYTES(contents, I2(0x2a, 0xe6));
  1047. }
  1048. TEST_F(Append, D8BigLabel) {
  1049. Label l;
  1050. section.set_endianness(kBigEndian);
  1051. section.Append(1, 0x2a);
  1052. section.D8(l);
  1053. l = 0xeeU;
  1054. ASSERT_TRUE(section.GetContents(&contents));
  1055. ASSERT_BYTES(contents, I2(0x2a, 0xee));
  1056. }
  1057. TEST_F(Append, D16Big) {
  1058. section.set_endianness(kBigEndian);
  1059. section.Append(1, 0x2a);
  1060. section.D16(0x83b1U);
  1061. ASSERT_TRUE(section.GetContents(&contents));
  1062. ASSERT_BYTES(contents, I3(0x2a, 0x83, 0xb1));
  1063. }
  1064. TEST_F(Append, D16BigLabel) {
  1065. Label l;
  1066. section.set_endianness(kBigEndian);
  1067. section.Append(1, 0x2a);
  1068. section.D16(l);
  1069. l = 0x5b55U;
  1070. ASSERT_TRUE(section.GetContents(&contents));
  1071. ASSERT_BYTES(contents, I3(0x2a, 0x5b, 0x55));
  1072. }
  1073. TEST_F(Append, D32Big) {
  1074. section.set_endianness(kBigEndian);
  1075. section.Append(1, 0x2a);
  1076. section.D32(0xd0b0e431U);
  1077. ASSERT_TRUE(section.GetContents(&contents));
  1078. ASSERT_BYTES(contents, I5(0x2a, 0xd0, 0xb0, 0xe4, 0x31));
  1079. }
  1080. TEST_F(Append, D32BigLabel) {
  1081. Label l;
  1082. section.set_endianness(kBigEndian);
  1083. section.Append(1, 0x2a);
  1084. section.D32(l);
  1085. l = 0x312fb340U;
  1086. ASSERT_TRUE(section.GetContents(&contents));
  1087. ASSERT_BYTES(contents, I5(0x2a, 0x31, 0x2f, 0xb3, 0x40));
  1088. }
  1089. TEST_F(Append, D64Big) {
  1090. section.set_endianness(kBigEndian);
  1091. section.Append(1, 0x2a);
  1092. section.D64(0xb109843500dbcb16ULL);
  1093. ASSERT_TRUE(section.GetContents(&contents));
  1094. ASSERT_BYTES(contents,
  1095. I9(0x2a, 0xb1, 0x09, 0x84, 0x35, 0x00, 0xdb, 0xcb, 0x16));
  1096. }
  1097. TEST_F(Append, D64BigLabel) {
  1098. Label l;
  1099. section.set_endianness(kBigEndian);
  1100. section.Append(1, 0x2a);
  1101. section.D64(l);
  1102. l = 0x9a0d61b70f671fd7ULL;
  1103. ASSERT_TRUE(section.GetContents(&contents));
  1104. ASSERT_BYTES(contents,
  1105. I9(0x2a, 0x9a, 0x0d, 0x61, 0xb7, 0x0f, 0x67, 0x1f, 0xd7));
  1106. }
  1107. TEST_F(Append, D8Little) {
  1108. section.set_endianness(kLittleEndian);
  1109. section.Append(1, 0x2a);
  1110. section.D8(0x42U);
  1111. ASSERT_TRUE(section.GetContents(&contents));
  1112. ASSERT_BYTES(contents, I2(0x2a, 0x42));
  1113. }
  1114. TEST_F(Append, D8LittleLabel) {
  1115. Label l;
  1116. section.set_endianness(kLittleEndian);
  1117. section.Append(1, 0x2a);
  1118. section.D8(l);
  1119. l = 0x05U;
  1120. ASSERT_TRUE(section.GetContents(&contents));
  1121. ASSERT_BYTES(contents, I2(0x2a, 0x05));
  1122. }
  1123. TEST_F(Append, D16Little) {
  1124. section.set_endianness(kLittleEndian);
  1125. section.Append(1, 0x2a);
  1126. section.D16(0xc5c5U);
  1127. ASSERT_TRUE(section.GetContents(&contents));
  1128. ASSERT_BYTES(contents, I3(0x2a, 0xc5, 0xc5));
  1129. }
  1130. TEST_F(Append, D16LittleLabel) {
  1131. Label l;
  1132. section.set_endianness(kLittleEndian);
  1133. section.Append(1, 0x2a);
  1134. section.D16(l);
  1135. l = 0xb620U;
  1136. ASSERT_TRUE(section.GetContents(&contents));
  1137. ASSERT_BYTES(contents, I3(0x2a, 0x20, 0xb6));
  1138. }
  1139. TEST_F(Append, D32Little) {
  1140. section.set_endianness(kLittleEndian);
  1141. section.Append(1, 0x2a);
  1142. section.D32(0x1a87d0feU);
  1143. ASSERT_TRUE(section.GetContents(&contents));
  1144. ASSERT_BYTES(contents, I5(0x2a, 0xfe, 0xd0, 0x87, 0x1a));
  1145. }
  1146. TEST_F(Append, D32LittleLabel) {
  1147. Label l;
  1148. section.set_endianness(kLittleEndian);
  1149. section.Append(1, 0x2a);
  1150. section.D32(l);
  1151. l = 0xb8012d6bU;
  1152. ASSERT_TRUE(section.GetContents(&contents));
  1153. ASSERT_BYTES(contents, I5(0x2a, 0x6b, 0x2d, 0x01, 0xb8));
  1154. }
  1155. TEST_F(Append, D64Little) {
  1156. section.set_endianness(kLittleEndian);
  1157. section.Append(1, 0x2a);
  1158. section.D64(0x42de75c61375a1deULL);
  1159. ASSERT_TRUE(section.GetContents(&contents));
  1160. ASSERT_BYTES(contents,
  1161. I9(0x2a, 0xde, 0xa1, 0x75, 0x13, 0xc6, 0x75, 0xde, 0x42));
  1162. }
  1163. TEST_F(Append, D64LittleLabel) {
  1164. Label l;
  1165. section.set_endianness(kLittleEndian);
  1166. section.Append(1, 0x2a);
  1167. section.D64(l);
  1168. l = 0x8b3bececf3fb5312ULL;
  1169. ASSERT_TRUE(section.GetContents(&contents));
  1170. ASSERT_BYTES(contents,
  1171. I9(0x2a, 0x12, 0x53, 0xfb, 0xf3, 0xec, 0xec, 0x3b, 0x8b));
  1172. }
  1173. TEST_F(Append, Variety) {
  1174. Label a, b, c, d, e, f, g, h;
  1175. section.Append(kBigEndian, 1, a)
  1176. .Append(kLittleEndian, 8, h)
  1177. .Append(kBigEndian, 1, 0x8bULL)
  1178. .Append(kLittleEndian, 8, 0x0ea56540448f4439ULL)
  1179. .Append(kBigEndian, 2, b)
  1180. .Append(kLittleEndian, 7, g)
  1181. .Append(kBigEndian, 2, 0xcf15ULL)
  1182. .Append(kLittleEndian, 7, 0x29694f04c5724aULL)
  1183. .Append(kBigEndian, 3, c)
  1184. .Append(kLittleEndian, 6, f)
  1185. .Append(kBigEndian, 3, 0x8c3ffdULL)
  1186. .Append(kLittleEndian, 6, 0x6f11ba80187aULL)
  1187. .Append(kBigEndian, 4, d)
  1188. .Append(kLittleEndian, 5, e)
  1189. .Append(kBigEndian, 4, 0x2fda2472ULL)
  1190. .Append(kLittleEndian, 5, 0x0aa02d423fULL)
  1191. .Append(kBigEndian, 5, e)
  1192. .Append(kLittleEndian, 4, d)
  1193. .Append(kBigEndian, 5, 0x53ba432138ULL)
  1194. .Append(kLittleEndian, 4, 0xf139ae60ULL)
  1195. .Append(kBigEndian, 6, f)
  1196. .Append(kLittleEndian, 3, c)
  1197. .Append(kBigEndian, 6, 0x168e436af716ULL)
  1198. .Append(kLittleEndian, 3, 0x3ef189ULL)
  1199. .Append(kBigEndian, 7, g)
  1200. .Append(kLittleEndian, 2, b)
  1201. .Append(kBigEndian, 7, 0xacd4ef233e47d9ULL)
  1202. .Append(kLittleEndian, 2, 0x5311ULL)
  1203. .Append(kBigEndian, 8, h)
  1204. .Append(kLittleEndian, 1, a)
  1205. .Append(kBigEndian, 8, 0x4668d5f1c93637a1ULL)
  1206. .Append(kLittleEndian, 1, 0x65ULL);
  1207. a = 0x79ac9bd8aa256b35ULL;
  1208. b = 0x22d13097ef86c91cULL;
  1209. c = 0xf204968b0a05862fULL;
  1210. d = 0x163177f15a0eb4ecULL;
  1211. e = 0xbd1b0f1d977f2246ULL;
  1212. f = 0x2b0842eee83c6461ULL;
  1213. g = 0x92f4b928a4bf875eULL;
  1214. h = 0x61a199a8f7286ba6ULL;
  1215. ASSERT_EQ(8 * 18U, section.Size());
  1216. ASSERT_TRUE(section.GetContents(&contents));
  1217. static const u_int8_t expected[] = {
  1218. 0x35, 0xa6, 0x6b, 0x28, 0xf7, 0xa8, 0x99, 0xa1, 0x61,
  1219. 0x8b, 0x39, 0x44, 0x8f, 0x44, 0x40, 0x65, 0xa5, 0x0e,
  1220. 0xc9, 0x1c, 0x5e, 0x87, 0xbf, 0xa4, 0x28, 0xb9, 0xf4,
  1221. 0xcf, 0x15, 0x4a, 0x72, 0xc5, 0x04, 0x4f, 0x69, 0x29,
  1222. 0x05, 0x86, 0x2f, 0x61, 0x64, 0x3c, 0xe8, 0xee, 0x42,
  1223. 0x8c, 0x3f, 0xfd, 0x7a, 0x18, 0x80, 0xba, 0x11, 0x6f,
  1224. 0x5a, 0x0e, 0xb4, 0xec, 0x46, 0x22, 0x7f, 0x97, 0x1d,
  1225. 0x2f, 0xda, 0x24, 0x72, 0x3f, 0x42, 0x2d, 0xa0, 0x0a,
  1226. 0x1d, 0x97, 0x7f, 0x22, 0x46, 0xec, 0xb4, 0x0e, 0x5a,
  1227. 0x53, 0xba, 0x43, 0x21, 0x38, 0x60, 0xae, 0x39, 0xf1,
  1228. 0x42, 0xee, 0xe8, 0x3c, 0x64, 0x61, 0x2f, 0x86, 0x05,
  1229. 0x16, 0x8e, 0x43, 0x6a, 0xf7, 0x16, 0x89, 0xf1, 0x3e,
  1230. 0xf4, 0xb9, 0x28, 0xa4, 0xbf, 0x87, 0x5e, 0x1c, 0xc9,
  1231. 0xac, 0xd4, 0xef, 0x23, 0x3e, 0x47, 0xd9, 0x11, 0x53,
  1232. 0x61, 0xa1, 0x99, 0xa8, 0xf7, 0x28, 0x6b, 0xa6, 0x35,
  1233. 0x46, 0x68, 0xd5, 0xf1, 0xc9, 0x36, 0x37, 0xa1, 0x65,
  1234. };
  1235. ASSERT_TRUE(0 == memcmp(contents.data(), expected, sizeof(expected)));
  1236. }
  1237. TEST_F(Append, Section) {
  1238. section.Append("murder");
  1239. {
  1240. Section middle;
  1241. middle.Append(" she");
  1242. section.Append(middle);
  1243. }
  1244. section.Append(" wrote");
  1245. EXPECT_EQ(16U, section.Size());
  1246. EXPECT_TRUE(section.GetContents(&contents));
  1247. EXPECT_STREQ(contents.c_str(), "murder she wrote");
  1248. }
  1249. TEST_F(Append, SectionRefs) {
  1250. section.Append("sugar ");
  1251. Label l;
  1252. {
  1253. Section middle;
  1254. Label m;
  1255. middle.B32(m);
  1256. section.Append(middle);
  1257. m = 0x66726565;
  1258. }
  1259. section.Append(" jazz");
  1260. EXPECT_EQ(15U, section.Size());
  1261. EXPECT_TRUE(section.GetContents(&contents));
  1262. EXPECT_STREQ(contents.c_str(), "sugar free jazz");
  1263. }
  1264. TEST_F(Append, LEB128_0) {
  1265. section.LEB128(0);
  1266. EXPECT_TRUE(section.GetContents(&contents));
  1267. EXPECT_EQ(string("\0", 1), contents);
  1268. }
  1269. TEST_F(Append, LEB128_0x3f) {
  1270. section.LEB128(0x3f);
  1271. EXPECT_TRUE(section.GetContents(&contents));
  1272. EXPECT_EQ(string("\x3f", 1), contents);
  1273. }
  1274. TEST_F(Append, LEB128_0x40) {
  1275. section.LEB128(0x40);
  1276. EXPECT_TRUE(section.GetContents(&contents));
  1277. EXPECT_EQ(string("\xc0\x00", 2), contents);
  1278. }
  1279. TEST_F(Append, LEB128_0x7f) {
  1280. section.LEB128(0x7f);
  1281. EXPECT_TRUE(section.GetContents(&contents));
  1282. EXPECT_EQ(string("\xff\x00", 2), contents);
  1283. }
  1284. TEST_F(Append, LEB128_0x80) {
  1285. section.LEB128(0x80);
  1286. EXPECT_TRUE(section.GetContents(&contents));
  1287. EXPECT_EQ(string("\x80\x01", 2), contents);
  1288. }
  1289. TEST_F(Append, LEB128_0xff) {
  1290. section.LEB128(0xff);
  1291. EXPECT_TRUE(section.GetContents(&contents));
  1292. EXPECT_EQ(string("\xff\x01", 2), contents);
  1293. }
  1294. TEST_F(Append, LEB128_0x1fff) {
  1295. section.LEB128(0x1fff);
  1296. EXPECT_TRUE(section.GetContents(&contents));
  1297. EXPECT_EQ(string("\xff\x3f", 2), contents);
  1298. }
  1299. TEST_F(Append, LEB128_0x2000) {
  1300. section.LEB128(0x2000);
  1301. EXPECT_TRUE(section.GetContents(&contents));
  1302. EXPECT_EQ(string("\x80\xc0\x00", 3), contents);
  1303. }
  1304. TEST_F(Append, LEB128_n1) {
  1305. section.LEB128(-1);
  1306. EXPECT_TRUE(section.GetContents(&contents));
  1307. EXPECT_EQ(string("\x7f", 1), contents);
  1308. }
  1309. TEST_F(Append, LEB128_n0x40) {
  1310. section.LEB128(-0x40);
  1311. EXPECT_TRUE(section.GetContents(&contents));
  1312. EXPECT_EQ(string("\x40", 1), contents);
  1313. }
  1314. TEST_F(Append, LEB128_n0x41) {
  1315. section.LEB128(-0x41);
  1316. EXPECT_TRUE(section.GetContents(&contents));
  1317. EXPECT_EQ(string("\xbf\x7f", 2), contents);
  1318. }
  1319. TEST_F(Append, LEB128_n0x7f) {
  1320. section.LEB128(-0x7f);
  1321. EXPECT_TRUE(section.GetContents(&contents));
  1322. EXPECT_EQ(string("\x81\x7f", 2), contents);
  1323. }
  1324. TEST_F(Append, LEB128_n0x80) {
  1325. section.LEB128(-0x80);
  1326. EXPECT_TRUE(section.GetContents(&contents));
  1327. EXPECT_EQ(string("\x80\x7f", 2), contents);
  1328. }
  1329. TEST_F(Append, LEB128_n0x2000) {
  1330. section.LEB128(-0x2000);
  1331. EXPECT_TRUE(section.GetContents(&contents));
  1332. EXPECT_EQ(string("\x80\x40", 2), contents);
  1333. }
  1334. TEST_F(Append, LEB128_n0x2001) {
  1335. section.LEB128(-0x2001);
  1336. EXPECT_TRUE(section.GetContents(&contents));
  1337. EXPECT_EQ(string("\xff\xbf\x7f", 3), contents);
  1338. }
  1339. TEST_F(Append,ULEB128_0) {
  1340. section.ULEB128(0);
  1341. EXPECT_TRUE(section.GetContents(&contents));
  1342. EXPECT_EQ(string("\0", 1), contents);
  1343. }
  1344. TEST_F(Append,ULEB128_1) {
  1345. section.ULEB128(1);
  1346. EXPECT_TRUE(section.GetContents(&contents));
  1347. EXPECT_EQ(string("\x01", 1), contents);
  1348. }
  1349. TEST_F(Append,ULEB128_0x3f) {
  1350. section.ULEB128(0x3f);
  1351. EXPECT_TRUE(section.GetContents(&contents));
  1352. EXPECT_EQ(string("\x3f", 1), contents);
  1353. }
  1354. TEST_F(Append,ULEB128_0x40) {
  1355. section.ULEB128(0x40);
  1356. EXPECT_TRUE(section.GetContents(&contents));
  1357. EXPECT_EQ(string("\x40", 1), contents);
  1358. }
  1359. TEST_F(Append,ULEB128_0x7f) {
  1360. section.ULEB128(0x7f);
  1361. EXPECT_TRUE(section.GetContents(&contents));
  1362. EXPECT_EQ(string("\x7f", 1), contents);
  1363. }
  1364. TEST_F(Append,ULEB128_0x80) {
  1365. section.ULEB128(0x80);
  1366. EXPECT_TRUE(section.GetContents(&contents));
  1367. EXPECT_EQ(string("\x80\x01", 2), contents);
  1368. }
  1369. TEST_F(Append,ULEB128_0xff) {
  1370. section.ULEB128(0xff);
  1371. EXPECT_TRUE(section.GetContents(&contents));
  1372. EXPECT_EQ(string("\xff\x01", 2), contents);
  1373. }
  1374. TEST_F(Append,ULEB128_0x100) {
  1375. section.ULEB128(0x100);
  1376. EXPECT_TRUE(section.GetContents(&contents));
  1377. EXPECT_EQ(string("\x80\x02", 2), contents);
  1378. }
  1379. TEST_F(Append,ULEB128_0x1fff) {
  1380. section.ULEB128(0x1fff);
  1381. EXPECT_TRUE(section.GetContents(&contents));
  1382. EXPECT_EQ(string("\xff\x3f", 2), contents);
  1383. }
  1384. TEST_F(Append,ULEB128_0x2000) {
  1385. section.ULEB128(0x2000);
  1386. EXPECT_TRUE(section.GetContents(&contents));
  1387. EXPECT_EQ(string("\x80\x40", 2), contents);
  1388. }
  1389. TEST_F(Append,ULEB128_0x3fff) {
  1390. section.ULEB128(0x3fff);
  1391. EXPECT_TRUE(section.GetContents(&contents));
  1392. EXPECT_EQ(string("\xff\x7f", 2), contents);
  1393. }
  1394. TEST_F(Append,ULEB128_0x4000) {
  1395. section.ULEB128(0x4000);
  1396. EXPECT_TRUE(section.GetContents(&contents));
  1397. EXPECT_EQ(string("\x80\x80\x01", 3), contents);
  1398. }
  1399. TEST_F(Append,ULEB128_12857) {
  1400. section.ULEB128(12857);
  1401. EXPECT_TRUE(section.GetContents(&contents));
  1402. EXPECT_EQ(string("\xb9\x64", 2), contents);
  1403. }
  1404. TEST_F(Append, LEBChain) {
  1405. section.LEB128(-0x80).ULEB128(12857).Append("*");
  1406. EXPECT_TRUE(section.GetContents(&contents));
  1407. EXPECT_EQ(string("\x80\x7f\xb9\x64*", 5), contents);
  1408. }
  1409. class GetContents: public SectionFixture, public Test { };
  1410. TEST_F(GetContents, Undefined) {
  1411. Label l;
  1412. section.Append(kLittleEndian, 8, l);
  1413. ASSERT_FALSE(section.GetContents(&contents));
  1414. }
  1415. TEST_F(GetContents, ClearsContents) {
  1416. section.Append((size_t) 10, '*');
  1417. EXPECT_EQ(10U, section.Size());
  1418. EXPECT_TRUE(section.GetContents(&contents));
  1419. EXPECT_EQ(0U, section.Size());
  1420. }
  1421. TEST_F(GetContents, ClearsReferences) {
  1422. Label l;
  1423. section.Append(kBigEndian, 1, l);
  1424. l = 42;
  1425. ASSERT_TRUE(section.GetContents(&contents));
  1426. ASSERT_BYTES(contents, I1(42));
  1427. ASSERT_TRUE(section.GetContents(&contents)); // should not die
  1428. }
  1429. class Miscellanea: public SectionFixture, public Test { };
  1430. TEST_F(Miscellanea, Clear) {
  1431. section.Append("howdy");
  1432. Label l;
  1433. section.L32(l);
  1434. EXPECT_EQ(9U, section.Size());
  1435. section.Clear();
  1436. EXPECT_EQ(0U, section.Size());
  1437. l = 0x8d231bf0U;
  1438. ASSERT_TRUE(section.GetContents(&contents)); // should not die
  1439. }
  1440. TEST_F(Miscellanea, Align) {
  1441. section.Append("*");
  1442. EXPECT_EQ(1U, section.Size());
  1443. section.Align(4).Append("*");
  1444. EXPECT_EQ(5U, section.Size());
  1445. section.Append("*").Align(2);
  1446. EXPECT_EQ(6U, section.Size());
  1447. }
  1448. TEST_F(Miscellanea, AlignPad) {
  1449. section.Append("*");
  1450. EXPECT_EQ(1U, section.Size());
  1451. section.Align(4, ' ').Append("*");
  1452. EXPECT_EQ(5U, section.Size());
  1453. section.Append("*").Align(2, ' ');
  1454. EXPECT_EQ(6U, section.Size());
  1455. ASSERT_TRUE(section.GetContents(&contents));
  1456. ASSERT_EQ(string("* **"), contents);
  1457. }
  1458. TEST_F(Miscellanea, StartHereMark) {
  1459. Label m;
  1460. section.Append(42, ' ').Mark(&m).Append(13, '+');
  1461. EXPECT_EQ(42U, m - section.start());
  1462. EXPECT_EQ(42U + 13U, section.Here() - section.start());
  1463. EXPECT_FALSE(section.start().IsKnownConstant());
  1464. EXPECT_FALSE(m.IsKnownConstant());
  1465. EXPECT_FALSE(section.Here().IsKnownConstant());
  1466. }
  1467. TEST_F(Miscellanea, Endianness) {
  1468. section.set_endianness(kBigEndian);
  1469. EXPECT_EQ(kBigEndian, section.endianness());
  1470. section.set_endianness(kLittleEndian);
  1471. EXPECT_EQ(kLittleEndian, section.endianness());
  1472. }