Gary Morain | 4178023 | 2012-07-31 15:08:31 -0700 | [diff] [blame] | 1 | // Copyright (c) 2012 The Chromium OS Authors. All rights reserved. |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
Ben Chan | dc80b32 | 2013-04-08 13:46:13 -0700 | [diff] [blame] | 5 | #include <arpa/inet.h> |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 6 | #include <endian.h> |
| 7 | |
| 8 | #include <gtest/gtest.h> |
| 9 | |
Wade Guthrie | c8f5892 | 2013-01-29 16:18:27 -0800 | [diff] [blame] | 10 | #include <string> |
| 11 | |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 12 | #include "shill/byte_string.h" |
| 13 | |
| 14 | using testing::Test; |
Wade Guthrie | c8f5892 | 2013-01-29 16:18:27 -0800 | [diff] [blame] | 15 | using std::string; |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 16 | |
| 17 | namespace shill { |
| 18 | |
| 19 | namespace { |
| 20 | const unsigned char kTest1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; |
Ben Chan | dc80b32 | 2013-04-08 13:46:13 -0700 | [diff] [blame] | 21 | const char kTest1HexString[] = "00010203040506070809"; |
| 22 | const char kTest1HexSubstring[] = "0203040506070809"; |
| 23 | const char kTest1HexSubstringReordered[] = "0504030209080706"; |
Darin Petkov | e3e1cfa | 2011-08-11 13:41:17 -0700 | [diff] [blame] | 24 | const unsigned char kTest2[] = { 1, 2, 3, 0xa }; |
| 25 | const char kTest2HexString[] = "0102030A"; |
| 26 | const unsigned int kTest2Uint32 = 0x0102030a; |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 27 | const unsigned char kTest3[] = { 0, 0, 0, 0 }; |
Paul Stewart | dd7df79 | 2011-07-15 11:09:50 -0700 | [diff] [blame] | 28 | const char kTest4[] = "Hello world"; |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 29 | } // namespace {} |
| 30 | |
| 31 | class ByteStringTest : public Test { |
Wade Guthrie | c8f5892 | 2013-01-29 16:18:27 -0800 | [diff] [blame] | 32 | public: |
Ben Chan | dc80b32 | 2013-04-08 13:46:13 -0700 | [diff] [blame] | 33 | bool IsCPUSameAsNetOrder() { |
| 34 | const uint32 kTestValue = 0x12345678; |
| 35 | return htonl(kTestValue) == kTestValue; |
| 36 | } |
| 37 | |
Wade Guthrie | c8f5892 | 2013-01-29 16:18:27 -0800 | [diff] [blame] | 38 | void CalculateBitwiseAndResult(ByteString *bs, |
| 39 | ByteString *mask, |
| 40 | ByteString *expected_result, |
| 41 | size_t count) { |
| 42 | ASSERT_NE(reinterpret_cast<ByteString *>(NULL), bs); |
| 43 | ASSERT_NE(reinterpret_cast<ByteString *>(NULL), mask); |
| 44 | ASSERT_NE(reinterpret_cast<ByteString *>(NULL), expected_result); |
| 45 | |
| 46 | for (size_t i = 0; i < count; i++) { |
| 47 | EXPECT_FALSE(bs->BitwiseAnd(*mask)); |
| 48 | unsigned char val = count - i; |
| 49 | mask->Append(ByteString(&val, 1)); |
| 50 | val &= bs->GetConstData()[i]; |
| 51 | expected_result->Append(ByteString(&val, 1)); |
| 52 | } |
| 53 | } |
| 54 | |
| 55 | void CalculateBitwiseOrResult(ByteString *bs, |
| 56 | ByteString *merge, |
| 57 | ByteString *expected_result, |
| 58 | size_t count) { |
| 59 | ASSERT_NE(reinterpret_cast<ByteString *>(NULL), bs); |
| 60 | ASSERT_NE(reinterpret_cast<ByteString *>(NULL), merge); |
| 61 | ASSERT_NE(reinterpret_cast<ByteString *>(NULL), expected_result); |
| 62 | |
| 63 | for (size_t i = 0; i < count; i++) { |
| 64 | EXPECT_FALSE(bs->BitwiseOr(*merge)); |
| 65 | unsigned char val = sizeof(kTest1) - i; |
| 66 | merge->Append(ByteString(&val, 1)); |
| 67 | val |= bs->GetConstData()[i]; |
| 68 | expected_result->Append(ByteString(&val, 1)); |
| 69 | } |
| 70 | } |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 71 | }; |
| 72 | |
| 73 | TEST_F(ByteStringTest, Empty) { |
| 74 | uint32 val; |
| 75 | |
| 76 | ByteString bs1(0); |
Darin Petkov | e3e1cfa | 2011-08-11 13:41:17 -0700 | [diff] [blame] | 77 | EXPECT_TRUE(bs1.IsEmpty()); |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 78 | EXPECT_EQ(0, bs1.GetLength()); |
| 79 | EXPECT_TRUE(bs1.GetData() == NULL); |
| 80 | EXPECT_FALSE(bs1.ConvertToNetUInt32(&val)); |
| 81 | EXPECT_TRUE(bs1.IsZero()); |
| 82 | } |
| 83 | |
| 84 | TEST_F(ByteStringTest, NonEmpty) { |
| 85 | ByteString bs1(kTest1, sizeof(kTest1)); |
| 86 | uint32 val; |
| 87 | |
Darin Petkov | e3e1cfa | 2011-08-11 13:41:17 -0700 | [diff] [blame] | 88 | EXPECT_FALSE(bs1.IsEmpty()); |
Wade Guthrie | c8f5892 | 2013-01-29 16:18:27 -0800 | [diff] [blame] | 89 | ASSERT_TRUE(bs1.GetData() != NULL); |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 90 | EXPECT_EQ(sizeof(kTest1), bs1.GetLength()); |
| 91 | for (unsigned int i = 0; i < sizeof(kTest1); i++) { |
| 92 | EXPECT_EQ(bs1.GetData()[i], kTest1[i]); |
| 93 | } |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 94 | EXPECT_FALSE(bs1.ConvertToNetUInt32(&val)); |
| 95 | EXPECT_FALSE(bs1.IsZero()); |
| 96 | |
Wade Guthrie | c8f5892 | 2013-01-29 16:18:27 -0800 | [diff] [blame] | 97 | // Build a ByteString (different to bs1), verify that the new ByteString |
| 98 | // looks as expected, verify that it's different to bs1. |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 99 | ByteString bs2(kTest2, sizeof(kTest2)); |
Wade Guthrie | c8f5892 | 2013-01-29 16:18:27 -0800 | [diff] [blame] | 100 | ASSERT_TRUE(bs2.GetData() != NULL); |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 101 | EXPECT_EQ(sizeof(kTest2), bs2.GetLength()); |
| 102 | for (unsigned int i = 0; i < sizeof(kTest2); i++) { |
| 103 | EXPECT_EQ(bs2.GetData()[i], kTest2[i]); |
| 104 | } |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 105 | EXPECT_FALSE(bs2.IsZero()); |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 106 | EXPECT_FALSE(bs2.Equals(bs1)); |
| 107 | |
Wade Guthrie | c8f5892 | 2013-01-29 16:18:27 -0800 | [diff] [blame] | 108 | // Build _another_ ByteString (different to bs1 and bs2), verify that the |
| 109 | // new ByteString looks as expected, verify that it's different to bs1 and |
| 110 | // bs2. |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 111 | ByteString bs3(kTest3, sizeof(kTest3)); |
Wade Guthrie | c8f5892 | 2013-01-29 16:18:27 -0800 | [diff] [blame] | 112 | ASSERT_TRUE(bs3.GetData() != NULL); |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 113 | EXPECT_EQ(sizeof(kTest3), bs3.GetLength()); |
| 114 | for (unsigned int i = 0; i < sizeof(kTest3); i++) { |
| 115 | EXPECT_EQ(bs3.GetData()[i], kTest3[i]); |
| 116 | } |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 117 | EXPECT_TRUE(bs3.IsZero()); |
| 118 | EXPECT_FALSE(bs2.Equals(bs1)); |
| 119 | EXPECT_FALSE(bs3.Equals(bs1)); |
| 120 | |
Wade Guthrie | c8f5892 | 2013-01-29 16:18:27 -0800 | [diff] [blame] | 121 | // Check two equal ByteStrings. |
| 122 | ByteString bs6(kTest1, sizeof(kTest1)); |
| 123 | EXPECT_TRUE(bs6.Equals(bs1)); |
| 124 | } |
| 125 | |
| 126 | TEST_F(ByteStringTest, CopyTerminator) { |
| 127 | ByteString bs4(string(kTest4), false); |
Paul Stewart | dd7df79 | 2011-07-15 11:09:50 -0700 | [diff] [blame] | 128 | EXPECT_EQ(strlen(kTest4), bs4.GetLength()); |
| 129 | EXPECT_EQ(0, memcmp(kTest4, bs4.GetData(), bs4.GetLength())); |
| 130 | |
Wade Guthrie | c8f5892 | 2013-01-29 16:18:27 -0800 | [diff] [blame] | 131 | ByteString bs5(string(kTest4), true); |
Paul Stewart | dd7df79 | 2011-07-15 11:09:50 -0700 | [diff] [blame] | 132 | EXPECT_EQ(strlen(kTest4) + 1, bs5.GetLength()); |
| 133 | EXPECT_EQ(0, memcmp(kTest4, bs5.GetData(), bs5.GetLength())); |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 134 | } |
| 135 | |
Paul Stewart | 91a5aac | 2012-07-20 11:55:40 -0700 | [diff] [blame] | 136 | TEST_F(ByteStringTest, SubString) { |
| 137 | ByteString bs1(kTest1, sizeof(kTest1)); |
Wade Guthrie | c8f5892 | 2013-01-29 16:18:27 -0800 | [diff] [blame] | 138 | ByteString fragment(kTest1 + 3, 4); |
| 139 | EXPECT_TRUE(fragment.Equals(bs1.GetSubstring(3, 4))); |
Paul Stewart | 91a5aac | 2012-07-20 11:55:40 -0700 | [diff] [blame] | 140 | const int kMargin = sizeof(kTest1) - 3; |
Wade Guthrie | c8f5892 | 2013-01-29 16:18:27 -0800 | [diff] [blame] | 141 | ByteString end_fragment(kTest1 + kMargin, sizeof(kTest1) - kMargin); |
| 142 | EXPECT_TRUE(end_fragment.Equals(bs1.GetSubstring(kMargin, sizeof(kTest1)))); |
| 143 | |
| 144 | // Verify that the ByteString correctly handles accessing a substring |
| 145 | // outside the range of the ByteString. |
| 146 | const size_t kBogusOffset = 10; |
| 147 | EXPECT_TRUE(bs1.GetSubstring(sizeof(kTest1), kBogusOffset).IsEmpty()); |
Paul Stewart | 91a5aac | 2012-07-20 11:55:40 -0700 | [diff] [blame] | 148 | } |
| 149 | |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 150 | TEST_F(ByteStringTest, UInt32) { |
Darin Petkov | e3e1cfa | 2011-08-11 13:41:17 -0700 | [diff] [blame] | 151 | ByteString bs1 = ByteString::CreateFromNetUInt32(kTest2Uint32); |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 152 | uint32 val; |
| 153 | |
| 154 | EXPECT_EQ(4, bs1.GetLength()); |
Wade Guthrie | c8f5892 | 2013-01-29 16:18:27 -0800 | [diff] [blame] | 155 | ASSERT_TRUE(bs1.GetData() != NULL); |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 156 | EXPECT_TRUE(bs1.ConvertToNetUInt32(&val)); |
Darin Petkov | e3e1cfa | 2011-08-11 13:41:17 -0700 | [diff] [blame] | 157 | EXPECT_EQ(kTest2Uint32, val); |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 158 | EXPECT_FALSE(bs1.IsZero()); |
| 159 | |
| 160 | ByteString bs2(kTest2, sizeof(kTest2)); |
| 161 | EXPECT_TRUE(bs1.Equals(bs2)); |
| 162 | EXPECT_TRUE(bs2.ConvertToNetUInt32(&val)); |
Darin Petkov | e3e1cfa | 2011-08-11 13:41:17 -0700 | [diff] [blame] | 163 | EXPECT_EQ(kTest2Uint32, val); |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 164 | |
| 165 | ByteString bs3 = ByteString::CreateFromCPUUInt32(0x1020304); |
| 166 | EXPECT_EQ(4, bs1.GetLength()); |
Wade Guthrie | c8f5892 | 2013-01-29 16:18:27 -0800 | [diff] [blame] | 167 | ASSERT_TRUE(bs3.GetData() != NULL); |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 168 | EXPECT_TRUE(bs3.ConvertToCPUUInt32(&val)); |
| 169 | EXPECT_EQ(0x1020304, val); |
| 170 | EXPECT_FALSE(bs3.IsZero()); |
| 171 | |
| 172 | #if __BYTE_ORDER == __LITTLE_ENDIAN |
| 173 | EXPECT_FALSE(bs1.Equals(bs3)); |
| 174 | #else |
| 175 | EXPECT_TRUE(bs1.Equals(bs3)); |
| 176 | #endif |
| 177 | } |
| 178 | |
Paul Stewart | dd7df79 | 2011-07-15 11:09:50 -0700 | [diff] [blame] | 179 | TEST_F(ByteStringTest, Resize) { |
Wade Guthrie | c8f5892 | 2013-01-29 16:18:27 -0800 | [diff] [blame] | 180 | ByteString bs(kTest2, sizeof(kTest2)); |
Paul Stewart | dd7df79 | 2011-07-15 11:09:50 -0700 | [diff] [blame] | 181 | |
Wade Guthrie | c8f5892 | 2013-01-29 16:18:27 -0800 | [diff] [blame] | 182 | const size_t kSizeExtension = 10; |
| 183 | bs.Resize(sizeof(kTest2) + kSizeExtension); |
| 184 | EXPECT_EQ(sizeof(kTest2) + kSizeExtension, bs.GetLength()); |
| 185 | ASSERT_TRUE(bs.GetData() != NULL); |
| 186 | EXPECT_EQ(0, memcmp(bs.GetData(), kTest2, sizeof(kTest2))); |
| 187 | for (size_t i = sizeof(kTest2); i < sizeof(kTest2) + kSizeExtension; ++i) { |
| 188 | EXPECT_EQ(0, bs.GetData()[i]); |
Paul Stewart | dd7df79 | 2011-07-15 11:09:50 -0700 | [diff] [blame] | 189 | } |
| 190 | |
Wade Guthrie | c8f5892 | 2013-01-29 16:18:27 -0800 | [diff] [blame] | 191 | const size_t kSizeReduction = 2; |
| 192 | bs.Resize(sizeof(kTest2) - kSizeReduction); |
| 193 | EXPECT_EQ(sizeof(kTest2) - kSizeReduction, bs.GetLength()); |
| 194 | EXPECT_EQ(0, memcmp(bs.GetData(), kTest2, sizeof(kTest2) - kSizeReduction)); |
Paul Stewart | dd7df79 | 2011-07-15 11:09:50 -0700 | [diff] [blame] | 195 | } |
| 196 | |
Darin Petkov | e3e1cfa | 2011-08-11 13:41:17 -0700 | [diff] [blame] | 197 | TEST_F(ByteStringTest, HexEncode) { |
| 198 | ByteString bs(kTest2, sizeof(kTest2)); |
| 199 | EXPECT_EQ(kTest2HexString, bs.HexEncode()); |
| 200 | } |
| 201 | |
Wade Guthrie | c8f5892 | 2013-01-29 16:18:27 -0800 | [diff] [blame] | 202 | TEST_F(ByteStringTest, BitwiseAndWithAndWithoutOffsets) { |
| 203 | const size_t kOffset[] = {0, 2, 7}; |
| 204 | for (size_t i = 0; i < arraysize(kOffset); ++i) { |
| 205 | ByteString bs(kTest1, sizeof(kTest1)); |
| 206 | bs.RemovePrefix(kOffset[i]); |
| 207 | ByteString mask; |
| 208 | ByteString expected_result; |
| 209 | CalculateBitwiseAndResult(&bs, &mask, &expected_result, |
| 210 | sizeof(kTest1) - kOffset[i]); |
| 211 | EXPECT_TRUE(bs.BitwiseAnd(mask)); |
| 212 | EXPECT_TRUE(bs.Equals(expected_result)); |
| 213 | bs.Resize(sizeof(kTest1) - 1); |
Paul Stewart | fe1c0e1 | 2012-04-30 19:57:04 -0700 | [diff] [blame] | 214 | EXPECT_FALSE(bs.BitwiseAnd(mask)); |
Paul Stewart | f7bf9bf | 2012-04-17 17:30:14 -0700 | [diff] [blame] | 215 | } |
Paul Stewart | fe1c0e1 | 2012-04-30 19:57:04 -0700 | [diff] [blame] | 216 | } |
| 217 | |
Wade Guthrie | c8f5892 | 2013-01-29 16:18:27 -0800 | [diff] [blame] | 218 | TEST_F(ByteStringTest, BitwiseOrWithAndWithoutOffsets) { |
| 219 | const size_t kOffset[] = {0, 2, 7}; |
| 220 | for (size_t i = 0; i < arraysize(kOffset); ++i) { |
| 221 | ByteString bs(kTest1, sizeof(kTest1)); |
| 222 | bs.RemovePrefix(kOffset[i]); |
| 223 | ByteString merge; |
| 224 | ByteString expected_result; |
| 225 | CalculateBitwiseOrResult(&bs, &merge, &expected_result, |
| 226 | sizeof(kTest1) - kOffset[i]); |
| 227 | EXPECT_TRUE(bs.BitwiseOr(merge)); |
| 228 | EXPECT_TRUE(bs.Equals(expected_result)); |
| 229 | bs.Resize(sizeof(kTest1) - 1); |
Paul Stewart | fe1c0e1 | 2012-04-30 19:57:04 -0700 | [diff] [blame] | 230 | EXPECT_FALSE(bs.BitwiseOr(merge)); |
Paul Stewart | fe1c0e1 | 2012-04-30 19:57:04 -0700 | [diff] [blame] | 231 | } |
Paul Stewart | fe1c0e1 | 2012-04-30 19:57:04 -0700 | [diff] [blame] | 232 | } |
| 233 | |
Wade Guthrie | c8f5892 | 2013-01-29 16:18:27 -0800 | [diff] [blame] | 234 | TEST_F(ByteStringTest, BitwiseInvertWithAndWithoutOffsets) { |
| 235 | const size_t kOffset[] = {0, 2, 7}; |
| 236 | for (size_t i = 0; i < arraysize(kOffset); ++i) { |
| 237 | ByteString bs(kTest1, sizeof(kTest1)); |
| 238 | bs.RemovePrefix(kOffset[i]); |
| 239 | ByteString invert; |
| 240 | for (size_t j = kOffset[i]; j < sizeof(kTest1); j++) { |
| 241 | unsigned char val = kTest1[j] ^ 0xff; |
| 242 | invert.Append(ByteString(&val, 1)); |
| 243 | } |
| 244 | bs.BitwiseInvert(); |
| 245 | EXPECT_TRUE(bs.Equals(invert)); |
Paul Stewart | fe1c0e1 | 2012-04-30 19:57:04 -0700 | [diff] [blame] | 246 | } |
Wade Guthrie | c8f5892 | 2013-01-29 16:18:27 -0800 | [diff] [blame] | 247 | } |
| 248 | |
| 249 | // The tests, below, test various ByteString operations where some bytes have |
| 250 | // been removed from the beginning of one or more of the ByteStrings in the |
| 251 | // test. |
| 252 | |
| 253 | TEST_F(ByteStringTest, EmptyOffset) { |
| 254 | uint32 val; |
| 255 | |
| 256 | ByteString bs1(kTest1, sizeof(kTest1)); |
| 257 | bs1.RemovePrefix(sizeof(kTest1)); |
| 258 | EXPECT_TRUE(bs1.IsEmpty()); |
| 259 | EXPECT_EQ(0, bs1.GetLength()); |
| 260 | EXPECT_TRUE(bs1.GetData() == NULL); |
| 261 | EXPECT_FALSE(bs1.ConvertToNetUInt32(&val)); |
| 262 | EXPECT_TRUE(bs1.IsZero()); |
| 263 | } |
| 264 | |
| 265 | TEST_F(ByteStringTest, NonEmptyOffset) { |
| 266 | ByteString bs1(kTest1, sizeof(kTest1)); |
| 267 | const size_t kNewLength1 = 2; |
| 268 | const size_t kOffset1 = sizeof(kTest1) - kNewLength1; |
| 269 | |
| 270 | { |
| 271 | bs1.RemovePrefix(kOffset1); |
| 272 | ASSERT_TRUE(bs1.GetData() != NULL); |
| 273 | EXPECT_FALSE(bs1.IsEmpty()); |
| 274 | EXPECT_EQ(kNewLength1, bs1.GetLength()); |
| 275 | for (unsigned int i = kOffset1; i < sizeof(kTest1); i++) { |
| 276 | EXPECT_EQ(bs1.GetData()[i - kOffset1], kTest1[i]); |
| 277 | } |
| 278 | uint32 val; |
| 279 | EXPECT_FALSE(bs1.ConvertToNetUInt32(&val)); |
| 280 | EXPECT_FALSE(bs1.IsZero()); |
| 281 | } |
| 282 | |
| 283 | // Check a non-equal ByteString. |
| 284 | { |
| 285 | const size_t kNewLength2 = 3; |
| 286 | const size_t kOffset2 = sizeof(kTest2) - kNewLength2; |
| 287 | ByteString bs2(kTest2, sizeof(kTest2)); |
| 288 | bs2.RemovePrefix(kOffset2); |
| 289 | ASSERT_TRUE(bs2.GetData() != NULL); |
| 290 | EXPECT_EQ(kNewLength2, bs2.GetLength()); |
| 291 | for (unsigned int i = kOffset2; i < sizeof(kTest2); i++) { |
| 292 | EXPECT_EQ(bs2.GetData()[i - kOffset2], kTest2[i]); |
| 293 | } |
| 294 | EXPECT_FALSE(bs2.IsZero()); |
| 295 | EXPECT_FALSE(bs2.Equals(bs1)); |
| 296 | } |
| 297 | |
| 298 | // Check whether two equal ByteStrings are, in fact, equal. |
| 299 | { |
| 300 | ByteString bs6(kTest1, sizeof(kTest1)); |
| 301 | bs6.RemovePrefix(kOffset1); |
| 302 | EXPECT_TRUE(bs6.Equals(bs1)); |
| 303 | } |
| 304 | } |
| 305 | |
| 306 | TEST_F(ByteStringTest, CopyTerminatorOffset) { |
| 307 | { |
| 308 | ByteString bs4(string(kTest4), false); |
| 309 | const size_t kOffset4 = 1; |
| 310 | bs4.RemovePrefix(kOffset4); |
| 311 | EXPECT_EQ(strlen(kTest4) - kOffset4, bs4.GetLength()); |
| 312 | EXPECT_EQ(0, memcmp(kTest4 + kOffset4, bs4.GetData(), bs4.GetLength())); |
| 313 | } |
| 314 | |
| 315 | { |
| 316 | ByteString bs5(string(kTest4), true); |
| 317 | const size_t kOffset5 = 1; |
| 318 | bs5.RemovePrefix(kOffset5); |
| 319 | EXPECT_EQ(strlen(kTest4) + 1 - kOffset5, bs5.GetLength()); |
| 320 | EXPECT_EQ(0, memcmp(kTest4 + kOffset5, bs5.GetData(), bs5.GetLength())); |
| 321 | } |
| 322 | } |
| 323 | |
| 324 | TEST_F(ByteStringTest, SubStringOffset) { |
| 325 | const size_t kFramgmetOffset = 3; |
| 326 | const size_t kFragmentLength = 4; |
| 327 | ByteString bs1(kTest1, sizeof(kTest1)); |
| 328 | ByteString fragment(kTest1, kFramgmetOffset + kFragmentLength); |
| 329 | fragment.RemovePrefix(kFramgmetOffset); |
| 330 | EXPECT_TRUE(fragment.Equals(bs1.GetSubstring(kFramgmetOffset, |
| 331 | kFragmentLength))); |
| 332 | |
| 333 | const int kMargin = sizeof(kTest1) - kFramgmetOffset; |
| 334 | ByteString end_fragment(kTest1 + kMargin, sizeof(kTest1) - kMargin); |
| 335 | EXPECT_TRUE(end_fragment.Equals(bs1.GetSubstring(kMargin, sizeof(kTest1)))); |
| 336 | |
| 337 | // Verify that the ByteString correctly handles accessing a substring |
| 338 | // outside the range of the ByteString. |
| 339 | const size_t kBogusOffset = 10; |
| 340 | EXPECT_TRUE(bs1.GetSubstring(sizeof(kTest1), kBogusOffset).IsEmpty()); |
| 341 | } |
| 342 | |
| 343 | TEST_F(ByteStringTest, ResizeOffset) { |
| 344 | ByteString bs(kTest2, sizeof(kTest2)); |
| 345 | const size_t kOffset = 1; |
| 346 | bs.RemovePrefix(kOffset); |
| 347 | |
| 348 | const size_t kSizeExtension = 10; |
| 349 | bs.Resize(sizeof(kTest2) + kSizeExtension); |
| 350 | EXPECT_EQ(sizeof(kTest2) + kSizeExtension, bs.GetLength()); |
| 351 | ASSERT_TRUE(bs.GetData() != NULL); |
| 352 | EXPECT_EQ(0, memcmp(bs.GetData(), |
| 353 | kTest2 + kOffset, |
| 354 | sizeof(kTest2) - kOffset)); |
| 355 | for (size_t i = sizeof(kTest2) - kOffset; |
| 356 | i < sizeof(kTest2) + kSizeExtension; ++i) { |
| 357 | EXPECT_EQ(0, bs.GetData()[i]); |
| 358 | } |
| 359 | |
| 360 | const size_t kSizeReduction = 2; |
| 361 | bs.Resize(sizeof(kTest2) - kSizeReduction); |
| 362 | EXPECT_EQ(sizeof(kTest2) - kSizeReduction, bs.GetLength()); |
| 363 | EXPECT_EQ(0, memcmp(bs.GetData(), kTest2 + kOffset, |
| 364 | sizeof(kTest2) - kSizeReduction)); |
| 365 | } |
| 366 | |
| 367 | TEST_F(ByteStringTest, HexEncodeWithOffset) { |
| 368 | ByteString bs(kTest2, sizeof(kTest2)); |
| 369 | const size_t kOffset = 2; |
| 370 | const size_t kBytesPerHexDigit = 2; |
| 371 | bs.RemovePrefix(kOffset); |
| 372 | EXPECT_EQ(kTest2HexString + kOffset * kBytesPerHexDigit, bs.HexEncode()); |
| 373 | } |
| 374 | |
| 375 | TEST_F(ByteStringTest, ChopByteClear) { |
| 376 | ByteString bs(kTest1, sizeof(kTest1)); |
| 377 | ByteString expected_result(kTest2, sizeof(kTest2)); |
| 378 | bs.RemovePrefix(5); |
| 379 | bs.Clear(); |
| 380 | bs.Append(ByteString(kTest2, sizeof(kTest2))); |
| 381 | |
| 382 | EXPECT_TRUE(bs.Equals(expected_result)); |
Paul Stewart | f7bf9bf | 2012-04-17 17:30:14 -0700 | [diff] [blame] | 383 | } |
| 384 | |
Ben Chan | dc80b32 | 2013-04-08 13:46:13 -0700 | [diff] [blame] | 385 | TEST_F(ByteStringTest, CreateFromHexString) { |
| 386 | ByteString bs = ByteString::CreateFromHexString(""); |
| 387 | EXPECT_TRUE(bs.IsEmpty()); |
| 388 | |
| 389 | ByteString bs1 = ByteString::CreateFromHexString("0"); |
| 390 | EXPECT_TRUE(bs1.IsEmpty()); |
| 391 | |
| 392 | ByteString bs2 = ByteString::CreateFromHexString("0y"); |
| 393 | EXPECT_TRUE(bs2.IsEmpty()); |
| 394 | |
| 395 | ByteString bs3 = ByteString::CreateFromHexString("ab"); |
| 396 | EXPECT_EQ(1, bs3.GetLength()); |
| 397 | EXPECT_EQ(0xab, bs3.GetData()[0]); |
| 398 | |
| 399 | ByteString bs4 = ByteString::CreateFromHexString(kTest1HexString); |
| 400 | EXPECT_EQ(kTest1HexString, bs4.HexEncode()); |
| 401 | } |
| 402 | |
| 403 | TEST_F(ByteStringTest, ConvertFromNetToCPUUInt32Array) { |
| 404 | ByteString bs1; |
| 405 | EXPECT_TRUE(bs1.ConvertFromNetToCPUUInt32Array()); |
| 406 | EXPECT_TRUE(bs1.IsEmpty()); |
| 407 | |
| 408 | // Conversion should fail when the length of ByteString is not a |
| 409 | // multiple of 4. |
| 410 | ByteString bs2(kTest1, sizeof(kTest1)); |
| 411 | EXPECT_EQ(kTest1HexString, bs2.HexEncode()); |
| 412 | EXPECT_FALSE(bs2.ConvertFromNetToCPUUInt32Array()); |
| 413 | EXPECT_EQ(kTest1HexString, bs2.HexEncode()); |
| 414 | |
| 415 | // Conversion should succeed when the length of ByteString is a |
| 416 | // multiple of 4. Also test the case when bytes stored in ByteString |
| 417 | // is not word-aligned after calling RemovePrefix(). |
| 418 | bs2.RemovePrefix(2); |
| 419 | EXPECT_EQ(kTest1HexSubstring, bs2.HexEncode()); |
| 420 | EXPECT_TRUE(bs2.ConvertFromNetToCPUUInt32Array()); |
| 421 | if (IsCPUSameAsNetOrder()) { |
| 422 | EXPECT_EQ(kTest1HexSubstring, bs2.HexEncode()); |
| 423 | } else { |
| 424 | EXPECT_EQ(kTest1HexSubstringReordered, bs2.HexEncode()); |
| 425 | } |
| 426 | } |
| 427 | |
| 428 | TEST_F(ByteStringTest, ConvertFromCPUToNetUInt32Array) { |
| 429 | ByteString bs1; |
| 430 | EXPECT_TRUE(bs1.ConvertFromCPUToNetUInt32Array()); |
| 431 | EXPECT_TRUE(bs1.IsEmpty()); |
| 432 | |
| 433 | // Conversion should fail when the length of ByteString is not a |
| 434 | // multiple of 4. |
| 435 | ByteString bs2(kTest1, sizeof(kTest1)); |
| 436 | EXPECT_EQ(kTest1HexString, bs2.HexEncode()); |
| 437 | EXPECT_FALSE(bs2.ConvertFromCPUToNetUInt32Array()); |
| 438 | EXPECT_EQ(kTest1HexString, bs2.HexEncode()); |
| 439 | |
| 440 | // Conversion should succeed when the length of ByteString is a |
| 441 | // multiple of 4. Also test the case when bytes stored in ByteString |
| 442 | // is not word-aligned after calling RemovePrefix(). |
| 443 | bs2.RemovePrefix(2); |
| 444 | EXPECT_EQ(kTest1HexSubstring, bs2.HexEncode()); |
| 445 | EXPECT_TRUE(bs2.ConvertFromCPUToNetUInt32Array()); |
| 446 | if (IsCPUSameAsNetOrder()) { |
| 447 | EXPECT_EQ(kTest1HexSubstring, bs2.HexEncode()); |
| 448 | } else { |
| 449 | EXPECT_EQ(kTest1HexSubstringReordered, bs2.HexEncode()); |
| 450 | } |
| 451 | } |
| 452 | |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 453 | } // namespace shill |