1 /*
2  * Copyright (C) 2016 The Android Open Source Project
3  *
4  * Permission is hereby granted, free of charge, to any person
5  * obtaining a copy of this software and associated documentation
6  * files (the "Software"), to deal in the Software without
7  * restriction, including without limitation the rights to use, copy,
8  * modify, merge, publish, distribute, sublicense, and/or sell copies
9  * of the Software, and to permit persons to whom the Software is
10  * furnished to do so, subject to the following conditions:
11  *
12  * The above copyright notice and this permission notice shall be
13  * included in all copies or substantial portions of the Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
19  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
20  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
21  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22  * SOFTWARE.
23  */
24 
25 #include <endian.h>
26 #include <string.h>
27 
28 #include <gtest/gtest.h>
29 
30 #include <libavb/libavb.h>
31 
32 #include "avb_unittest_util.h"
33 
34 namespace avb {
35 
36 // Subclass BaseAvbToolTest to check for memory leaks.
37 class UtilTest : public BaseAvbToolTest {
38  public:
UtilTest()39   UtilTest() {}
40 };
41 
TEST_F(UtilTest,RSAPublicKeyHeaderByteswap)42 TEST_F(UtilTest, RSAPublicKeyHeaderByteswap) {
43   AvbRSAPublicKeyHeader h;
44   AvbRSAPublicKeyHeader s;
45   uint32_t n32;
46   uint64_t n64;
47 
48   n32 = 0x11223344;
49   n64 = 0x1122334455667788;
50 
51   h.key_num_bits = htobe32(n32);
52   n32++;
53   h.n0inv = htobe32(n32);
54   n32++;
55 
56   EXPECT_NE(0, avb_rsa_public_key_header_validate_and_byteswap(&h, &s));
57 
58   n32 = 0x11223344;
59   n64 = 0x1122334455667788;
60 
61   EXPECT_EQ(n32, s.key_num_bits);
62   n32++;
63   EXPECT_EQ(n32, s.n0inv);
64   n32++;
65 }
66 
TEST_F(UtilTest,FooterByteswap)67 TEST_F(UtilTest, FooterByteswap) {
68   AvbFooter h;
69   AvbFooter s;
70   AvbFooter other;
71   AvbFooter bad;
72   uint64_t n64;
73 
74   n64 = 0x1122334455667788;
75 
76   memcpy(h.magic, AVB_FOOTER_MAGIC, AVB_FOOTER_MAGIC_LEN);
77   h.version_major = htobe32(AVB_FOOTER_VERSION_MAJOR);
78   h.version_minor = htobe32(AVB_FOOTER_VERSION_MINOR);
79   h.original_image_size = htobe64(n64);
80   n64++;
81   h.vbmeta_offset = htobe64(n64);
82   n64++;
83   h.vbmeta_size = htobe64(n64);
84   n64++;
85 
86   EXPECT_NE(0, avb_footer_validate_and_byteswap(&h, &s));
87 
88   n64 = 0x1122334455667788;
89 
90   EXPECT_EQ((uint32_t)AVB_FOOTER_VERSION_MAJOR, s.version_major);
91   EXPECT_EQ((uint32_t)AVB_FOOTER_VERSION_MINOR, s.version_minor);
92   EXPECT_EQ(n64, s.original_image_size);
93   n64++;
94   EXPECT_EQ(n64, s.vbmeta_offset);
95   n64++;
96   EXPECT_EQ(n64, s.vbmeta_size);
97   n64++;
98 
99   // Check that the struct still validates if minor is bigger than
100   // what we expect.
101   other = h;
102   h.version_minor = htobe32(AVB_FOOTER_VERSION_MINOR + 1);
103   EXPECT_NE(0, avb_footer_validate_and_byteswap(&other, &s));
104 
105   // Check for bad magic.
106   bad = h;
107   bad.magic[0] = 'x';
108   EXPECT_EQ(0, avb_footer_validate_and_byteswap(&bad, &s));
109 
110   // Check for bad major version.
111   bad = h;
112   bad.version_major = htobe32(AVB_FOOTER_VERSION_MAJOR + 1);
113   EXPECT_EQ(0, avb_footer_validate_and_byteswap(&bad, &s));
114 }
115 
TEST_F(UtilTest,KernelCmdlineDescriptorByteswap)116 TEST_F(UtilTest, KernelCmdlineDescriptorByteswap) {
117   AvbKernelCmdlineDescriptor h;
118   AvbKernelCmdlineDescriptor s;
119   AvbKernelCmdlineDescriptor bad;
120   uint64_t nbf;
121   uint32_t n32;
122 
123   // Specify 40 bytes of data past the end of the descriptor struct.
124   nbf = 40 + sizeof(AvbKernelCmdlineDescriptor) - sizeof(AvbDescriptor);
125   h.parent_descriptor.num_bytes_following = htobe64(nbf);
126   h.parent_descriptor.tag = htobe64(AVB_DESCRIPTOR_TAG_KERNEL_CMDLINE);
127   h.kernel_cmdline_length = htobe32(40);
128 
129   n32 = 0x11223344;
130   h.flags = htobe32(n32);
131   n32++;
132 
133   EXPECT_NE(0, avb_kernel_cmdline_descriptor_validate_and_byteswap(&h, &s));
134 
135   n32 = 0x11223344;
136   EXPECT_EQ(n32, s.flags);
137   n32++;
138 
139   EXPECT_EQ(AVB_DESCRIPTOR_TAG_KERNEL_CMDLINE, s.parent_descriptor.tag);
140   EXPECT_EQ(nbf, s.parent_descriptor.num_bytes_following);
141   EXPECT_EQ(40UL, s.kernel_cmdline_length);
142 
143   // Check for bad tag.
144   bad = h;
145   bad.parent_descriptor.tag = htobe64(0xf00dd00d);
146   EXPECT_EQ(0, avb_kernel_cmdline_descriptor_validate_and_byteswap(&bad, &s));
147 
148   // Doesn't fit in 41 bytes.
149   bad = h;
150   bad.kernel_cmdline_length = htobe32(41);
151   EXPECT_EQ(0, avb_kernel_cmdline_descriptor_validate_and_byteswap(&bad, &s));
152 }
153 
TEST_F(UtilTest,HashtreeDescriptorByteswap)154 TEST_F(UtilTest, HashtreeDescriptorByteswap) {
155   AvbHashtreeDescriptor h;
156   AvbHashtreeDescriptor s;
157   AvbHashtreeDescriptor bad;
158   uint64_t nbf;
159   uint32_t n32;
160   uint64_t n64;
161 
162   // Specify 44 bytes of data past the end of the descriptor struct.
163   nbf = 44 + sizeof(AvbHashtreeDescriptor) - sizeof(AvbDescriptor);
164   h.parent_descriptor.num_bytes_following = htobe64(nbf);
165   h.parent_descriptor.tag = htobe64(AVB_DESCRIPTOR_TAG_HASHTREE);
166   h.partition_name_len = htobe32(10);
167   h.salt_len = htobe32(10);
168   h.root_digest_len = htobe32(10);
169 
170   n32 = 0x11223344;
171   n64 = 0x1122334455667788;
172 
173   h.dm_verity_version = htobe32(n32);
174   n32++;
175   h.image_size = htobe64(n64);
176   n64++;
177   h.tree_offset = htobe64(n64);
178   n64++;
179   h.tree_size = htobe64(n64);
180   n64++;
181   h.data_block_size = htobe32(n32);
182   n32++;
183   h.hash_block_size = htobe32(n32);
184   n32++;
185   h.fec_num_roots = htobe32(n32);
186   n32++;
187   h.fec_offset = htobe64(n64);
188   n64++;
189   h.fec_size = htobe64(n64);
190   n64++;
191 
192   EXPECT_TRUE(avb_hashtree_descriptor_validate_and_byteswap(&h, &s));
193 
194   n32 = 0x11223344;
195   n64 = 0x1122334455667788;
196 
197   EXPECT_EQ(n32, s.dm_verity_version);
198   n32++;
199   EXPECT_EQ(n64, s.image_size);
200   n64++;
201   EXPECT_EQ(n64, s.tree_offset);
202   n64++;
203   EXPECT_EQ(n64, s.tree_size);
204   n64++;
205   EXPECT_EQ(n32, s.data_block_size);
206   n32++;
207   EXPECT_EQ(n32, s.hash_block_size);
208   n32++;
209   EXPECT_EQ(n32, s.fec_num_roots);
210   n32++;
211   EXPECT_EQ(n64, s.fec_offset);
212   n64++;
213   EXPECT_EQ(n64, s.fec_size);
214   n64++;
215 
216   EXPECT_EQ(AVB_DESCRIPTOR_TAG_HASHTREE, s.parent_descriptor.tag);
217   EXPECT_EQ(nbf, s.parent_descriptor.num_bytes_following);
218   EXPECT_EQ(10UL, s.partition_name_len);
219   EXPECT_EQ(10UL, s.salt_len);
220   EXPECT_EQ(10UL, s.root_digest_len);
221 
222   // Check for bad tag.
223   bad = h;
224   bad.parent_descriptor.tag = htobe64(0xf00dd00d);
225   EXPECT_FALSE(avb_hashtree_descriptor_validate_and_byteswap(&bad, &s));
226 
227   // Doesn't fit in 44 bytes (30 + 10 + 10 = 50).
228   bad = h;
229   bad.partition_name_len = htobe32(30);
230   EXPECT_FALSE(avb_hashtree_descriptor_validate_and_byteswap(&bad, &s));
231 
232   // Doesn't fit in 44 bytes (10 + 30 + 10 = 50).
233   bad = h;
234   bad.salt_len = htobe32(30);
235   EXPECT_FALSE(avb_hashtree_descriptor_validate_and_byteswap(&bad, &s));
236 
237   // Doesn't fit in 44 bytes (10 + 10 + 30 = 50).
238   bad = h;
239   bad.root_digest_len = htobe32(30);
240   EXPECT_FALSE(avb_hashtree_descriptor_validate_and_byteswap(&bad, &s));
241 }
242 
TEST_F(UtilTest,HashDescriptorByteswap)243 TEST_F(UtilTest, HashDescriptorByteswap) {
244   AvbHashDescriptor h;
245   AvbHashDescriptor s;
246   AvbHashDescriptor bad;
247   uint64_t nbf;
248 
249   // Specify 44 bytes of data past the end of the descriptor struct.
250   nbf = 44 + sizeof(AvbHashDescriptor) - sizeof(AvbDescriptor);
251   h.parent_descriptor.num_bytes_following = htobe64(nbf);
252   h.parent_descriptor.tag = htobe64(AVB_DESCRIPTOR_TAG_HASH);
253   h.partition_name_len = htobe32(10);
254   h.salt_len = htobe32(10);
255   h.digest_len = htobe32(10);
256 
257   EXPECT_NE(0, avb_hash_descriptor_validate_and_byteswap(&h, &s));
258 
259   EXPECT_EQ(AVB_DESCRIPTOR_TAG_HASH, s.parent_descriptor.tag);
260   EXPECT_EQ(nbf, s.parent_descriptor.num_bytes_following);
261   EXPECT_EQ(10UL, s.partition_name_len);
262   EXPECT_EQ(10UL, s.salt_len);
263   EXPECT_EQ(10UL, s.digest_len);
264 
265   // Check for bad tag.
266   bad = h;
267   bad.parent_descriptor.tag = htobe64(0xf00dd00d);
268   EXPECT_EQ(0, avb_hash_descriptor_validate_and_byteswap(&bad, &s));
269 
270   // Doesn't fit in 44 bytes (30 + 10 + 10 = 50).
271   bad = h;
272   bad.partition_name_len = htobe32(30);
273   EXPECT_EQ(0, avb_hash_descriptor_validate_and_byteswap(&bad, &s));
274 
275   // Doesn't fit in 44 bytes (10 + 30 + 10 = 50).
276   bad = h;
277   bad.salt_len = htobe32(30);
278   EXPECT_EQ(0, avb_hash_descriptor_validate_and_byteswap(&bad, &s));
279 
280   // Doesn't fit in 44 bytes (10 + 10 + 30 = 50).
281   bad = h;
282   bad.digest_len = htobe32(30);
283   EXPECT_EQ(0, avb_hash_descriptor_validate_and_byteswap(&bad, &s));
284 }
285 
TEST_F(UtilTest,ChainPartitionDescriptorByteswap)286 TEST_F(UtilTest, ChainPartitionDescriptorByteswap) {
287   AvbChainPartitionDescriptor h;
288   AvbChainPartitionDescriptor s;
289   AvbChainPartitionDescriptor bad;
290   uint64_t nbf;
291 
292   // Specify 36 bytes of data past the end of the descriptor struct.
293   nbf = 36 + sizeof(AvbChainPartitionDescriptor) - sizeof(AvbDescriptor);
294   h.parent_descriptor.num_bytes_following = htobe64(nbf);
295   h.parent_descriptor.tag = htobe64(AVB_DESCRIPTOR_TAG_CHAIN_PARTITION);
296   h.rollback_index_location = htobe32(42);
297   h.partition_name_len = htobe32(16);
298   h.public_key_len = htobe32(17);
299 
300   EXPECT_NE(0, avb_chain_partition_descriptor_validate_and_byteswap(&h, &s));
301 
302   EXPECT_EQ(AVB_DESCRIPTOR_TAG_CHAIN_PARTITION, s.parent_descriptor.tag);
303   EXPECT_EQ(nbf, s.parent_descriptor.num_bytes_following);
304   EXPECT_EQ(42UL, s.rollback_index_location);
305   EXPECT_EQ(16UL, s.partition_name_len);
306   EXPECT_EQ(17UL, s.public_key_len);
307 
308   // Check for bad tag.
309   bad = h;
310   bad.parent_descriptor.tag = htobe64(0xf00dd00d);
311   EXPECT_EQ(0, avb_chain_partition_descriptor_validate_and_byteswap(&bad, &s));
312 
313   // Check for bad rollback index slot (must be at least 1).
314   bad = h;
315   bad.rollback_index_location = htobe32(0);
316   EXPECT_EQ(0, avb_chain_partition_descriptor_validate_and_byteswap(&bad, &s));
317 
318   // Doesn't fit in 40 bytes (24 + 17 = 41).
319   bad = h;
320   bad.partition_name_len = htobe32(24);
321   EXPECT_EQ(0, avb_chain_partition_descriptor_validate_and_byteswap(&bad, &s));
322 
323   // Doesn't fit in 40 bytes (16 + 25 = 41).
324   bad = h;
325   bad.public_key_len = htobe32(25);
326   EXPECT_EQ(0, avb_chain_partition_descriptor_validate_and_byteswap(&bad, &s));
327 }
328 
TEST_F(UtilTest,PropertyDescriptorByteswap)329 TEST_F(UtilTest, PropertyDescriptorByteswap) {
330   AvbPropertyDescriptor h;
331   AvbPropertyDescriptor s;
332   AvbPropertyDescriptor bad;
333   uint64_t nbf;
334 
335   // Specify 40 bytes of data past the end of the descriptor struct.
336   nbf = 40 + sizeof(AvbPropertyDescriptor) - sizeof(AvbDescriptor);
337   h.parent_descriptor.num_bytes_following = htobe64(nbf);
338   h.parent_descriptor.tag = htobe64(AVB_DESCRIPTOR_TAG_PROPERTY);
339   h.key_num_bytes = htobe64(16);
340   h.value_num_bytes = htobe64(17);
341 
342   EXPECT_NE(0, avb_property_descriptor_validate_and_byteswap(&h, &s));
343 
344   EXPECT_EQ(AVB_DESCRIPTOR_TAG_PROPERTY, s.parent_descriptor.tag);
345   EXPECT_EQ(nbf, s.parent_descriptor.num_bytes_following);
346   EXPECT_EQ(16UL, s.key_num_bytes);
347   EXPECT_EQ(17UL, s.value_num_bytes);
348 
349   // Check for bad tag.
350   bad = h;
351   bad.parent_descriptor.tag = htobe64(0xf00dd00d);
352   EXPECT_EQ(0, avb_property_descriptor_validate_and_byteswap(&bad, &s));
353 
354   // Doesn't fit in 40 bytes (22 + 17 + 2 = 41).
355   bad = h;
356   bad.key_num_bytes = htobe64(22);
357   EXPECT_EQ(0, avb_property_descriptor_validate_and_byteswap(&bad, &s));
358 
359   // Doesn't fit in 40 bytes (16 + 23 + 2 = 41).
360   bad = h;
361   bad.value_num_bytes = htobe64(23);
362   EXPECT_EQ(0, avb_property_descriptor_validate_and_byteswap(&bad, &s));
363 }
364 
TEST_F(UtilTest,DescriptorByteswap)365 TEST_F(UtilTest, DescriptorByteswap) {
366   AvbDescriptor h;
367   AvbDescriptor s;
368   uint64_t n64;
369 
370   n64 = 0x1122334455667788;
371 
372   h.num_bytes_following = htobe64(n64);
373   n64++;
374   h.tag = htobe64(n64);
375   n64++;
376 
377   EXPECT_NE(0, avb_descriptor_validate_and_byteswap(&h, &s));
378 
379   n64 = 0x1122334455667788;
380 
381   EXPECT_EQ(n64, s.num_bytes_following);
382   n64++;
383   EXPECT_EQ(n64, s.tag);
384   n64++;
385 
386   // Check that we catch if |num_bytes_following| isn't divisble by 8.
387   h.num_bytes_following = htobe64(7);
388   EXPECT_EQ(0, avb_descriptor_validate_and_byteswap(&h, &s));
389 }
390 
TEST_F(UtilTest,SafeAddition)391 TEST_F(UtilTest, SafeAddition) {
392   uint64_t value;
393   uint64_t pow2_60 = 1ULL << 60;
394 
395   value = 2;
396   EXPECT_NE(0, avb_safe_add_to(&value, 5));
397   EXPECT_EQ(7UL, value);
398 
399   /* These should not overflow */
400   value = 1 * pow2_60;
401   EXPECT_NE(0, avb_safe_add_to(&value, 2 * pow2_60));
402   EXPECT_EQ(3 * pow2_60, value);
403   value = 7 * pow2_60;
404   EXPECT_NE(0, avb_safe_add_to(&value, 8 * pow2_60));
405   EXPECT_EQ(15 * pow2_60, value);
406   value = 9 * pow2_60;
407   EXPECT_NE(0, avb_safe_add_to(&value, 3 * pow2_60));
408   EXPECT_EQ(12 * pow2_60, value);
409   value = 0xfffffffffffffffcUL;
410   EXPECT_NE(0, avb_safe_add_to(&value, 2));
411   EXPECT_EQ(0xfffffffffffffffeUL, value);
412 
413   /* These should overflow. */
414   value = 8 * pow2_60;
415   EXPECT_EQ(0, avb_safe_add_to(&value, 8 * pow2_60));
416   value = 0xfffffffffffffffcUL;
417   EXPECT_EQ(0, avb_safe_add_to(&value, 4));
418 }
419 
avb_validate_utf8z(const char * data)420 static int avb_validate_utf8z(const char* data) {
421   return avb_validate_utf8(reinterpret_cast<const uint8_t*>(data),
422                            strlen(data));
423 }
424 
TEST_F(UtilTest,UTF8Validation)425 TEST_F(UtilTest, UTF8Validation) {
426   // These should succeed.
427   EXPECT_NE(0, avb_validate_utf8z("foo bar"));
428   // Encoding of U+00E6 LATIN SMALL LETTER AE: æ
429   EXPECT_NE(0, avb_validate_utf8z("foo \xC3\xA6 bar"));
430   // Encoding of U+20AC EURO SIGN: €
431   EXPECT_NE(0, avb_validate_utf8z("foo \xE2\x82\xAC bar"));
432   // Encoding of U+1F466 BOY: ��
433   EXPECT_NE(0, avb_validate_utf8z("foo \xF0\x9F\x91\xA6 bar"));
434   // All three runes following each other.
435   EXPECT_NE(0, avb_validate_utf8z("\xC3\xA6\xE2\x82\xAC\xF0\x9F\x91\xA6"));
436 
437   // These should fail.
438   EXPECT_EQ(0, avb_validate_utf8z("foo \xF8 bar"));
439   EXPECT_EQ(0, avb_validate_utf8z("\xF8"));
440   // Stops in the middle of Unicode rune.
441   EXPECT_EQ(0, avb_validate_utf8z("foo \xC3"));
442 }
443 
TEST_F(UtilTest,StrConcat)444 TEST_F(UtilTest, StrConcat) {
445   char buf[8];
446 
447   // These should succeed.
448   EXPECT_NE(0, avb_str_concat(buf, sizeof buf, "foo", 3, "bar1", 4));
449 
450   // This should fail: Insufficient space.
451   EXPECT_EQ(0, avb_str_concat(buf, sizeof buf, "foo0", 4, "bar1", 4));
452 }
453 
TEST_F(UtilTest,StrStr)454 TEST_F(UtilTest, StrStr) {
455   const char* haystack = "abc def abcabc";
456 
457   EXPECT_EQ(nullptr, avb_strstr(haystack, "needle"));
458   EXPECT_EQ(haystack, avb_strstr(haystack, "abc"));
459   EXPECT_EQ(haystack + 4, avb_strstr(haystack, "def"));
460   EXPECT_EQ(haystack, avb_strstr(haystack, haystack));
461 }
462 
TEST_F(UtilTest,StrvFindStr)463 TEST_F(UtilTest, StrvFindStr) {
464   const char* strings[] = {"abcabc", "abc", "def", nullptr};
465 
466   EXPECT_EQ(nullptr, avb_strv_find_str(strings, "not there", 9));
467   EXPECT_EQ(strings[1], avb_strv_find_str(strings, "abc", 3));
468   EXPECT_EQ(strings[2], avb_strv_find_str(strings, "def", 3));
469   EXPECT_EQ(strings[0], avb_strv_find_str(strings, "abcabc", 6));
470 }
471 
TEST_F(UtilTest,StrReplace)472 TEST_F(UtilTest, StrReplace) {
473   char* str;
474 
475   str = avb_replace("$(FOO) blah bah $(FOO $(FOO) blah", "$(FOO)", "OK");
476   EXPECT_EQ("OK blah bah $(FOO OK blah", std::string(str));
477   avb_free(str);
478 
479   str = avb_replace("$(FOO)", "$(FOO)", "OK");
480   EXPECT_EQ("OK", std::string(str));
481   avb_free(str);
482 
483   str = avb_replace(" $(FOO)", "$(FOO)", "OK");
484   EXPECT_EQ(" OK", std::string(str));
485   avb_free(str);
486 
487   str = avb_replace("$(FOO) ", "$(FOO)", "OK");
488   EXPECT_EQ("OK ", std::string(str));
489   avb_free(str);
490 
491   str = avb_replace("$(FOO)$(FOO)", "$(FOO)", "LONGSTRING");
492   EXPECT_EQ("LONGSTRINGLONGSTRING", std::string(str));
493   avb_free(str);
494 }
495 
TEST_F(UtilTest,StrDupV)496 TEST_F(UtilTest, StrDupV) {
497   char* str;
498 
499   str = avb_strdupv("x", "y", "z", NULL);
500   EXPECT_EQ("xyz", std::string(str));
501   avb_free(str);
502 
503   str = avb_strdupv("Hello", "World", " XYZ", NULL);
504   EXPECT_EQ("HelloWorld XYZ", std::string(str));
505   avb_free(str);
506 }
507 
TEST_F(UtilTest,Crc32)508 TEST_F(UtilTest, Crc32) {
509   /* Compare with output of crc32(1):
510    *
511    *  $ (echo -n foobar > /tmp/crc32_input); crc32 /tmp/crc32_input
512    *  9ef61f95
513    */
514   EXPECT_EQ(uint32_t(0x9ef61f95), avb_crc32((const uint8_t*)"foobar", 6));
515 }
516 
TEST_F(UtilTest,htobe32)517 TEST_F(UtilTest, htobe32) {
518   EXPECT_EQ(avb_htobe32(0x12345678), htobe32(0x12345678));
519 }
520 
TEST_F(UtilTest,be32toh)521 TEST_F(UtilTest, be32toh) {
522   EXPECT_EQ(avb_be32toh(0x12345678), be32toh(0x12345678));
523 }
524 
TEST_F(UtilTest,htobe64)525 TEST_F(UtilTest, htobe64) {
526   EXPECT_EQ(avb_htobe64(0x123456789abcdef0), htobe64(0x123456789abcdef0));
527 }
528 
TEST_F(UtilTest,be64toh)529 TEST_F(UtilTest, be64toh) {
530   EXPECT_EQ(avb_be64toh(0x123456789abcdef0), be64toh(0x123456789abcdef0));
531 }
532 
TEST_F(UtilTest,Basename)533 TEST_F(UtilTest, Basename) {
534   EXPECT_EQ("foobar.c", std::string(avb_basename("foobar.c")));
535   EXPECT_EQ("foobar.c", std::string(avb_basename("/path/to/foobar.c")));
536   EXPECT_EQ("foobar.c", std::string(avb_basename("a/foobar.c")));
537   EXPECT_EQ("baz.c", std::string(avb_basename("/baz.c")));
538   EXPECT_EQ("some_dir/", std::string(avb_basename("some_dir/")));
539   EXPECT_EQ("some_dir/", std::string(avb_basename("/path/to/some_dir/")));
540   EXPECT_EQ("some_dir/", std::string(avb_basename("a/some_dir/")));
541   EXPECT_EQ("some_dir/", std::string(avb_basename("/some_dir/")));
542   EXPECT_EQ("/", std::string(avb_basename("/")));
543 }
544 
545 }  // namespace avb
546