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 | |
| 5 | #include <endian.h> |
| 6 | |
| 7 | #include <gtest/gtest.h> |
| 8 | |
| 9 | #include "shill/byte_string.h" |
| 10 | |
| 11 | using testing::Test; |
| 12 | |
| 13 | namespace shill { |
| 14 | |
| 15 | namespace { |
| 16 | const unsigned char kTest1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; |
Darin Petkov | e3e1cfa | 2011-08-11 13:41:17 -0700 | [diff] [blame] | 17 | const unsigned char kTest2[] = { 1, 2, 3, 0xa }; |
| 18 | const char kTest2HexString[] = "0102030A"; |
| 19 | const unsigned int kTest2Uint32 = 0x0102030a; |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 20 | const unsigned char kTest3[] = { 0, 0, 0, 0 }; |
Paul Stewart | dd7df79 | 2011-07-15 11:09:50 -0700 | [diff] [blame] | 21 | const char kTest4[] = "Hello world"; |
Gary Morain | 4178023 | 2012-07-31 15:08:31 -0700 | [diff] [blame] | 22 | const char kTest5[] = { 0, 1, 2, 3 }; |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 23 | } // namespace {} |
| 24 | |
| 25 | class ByteStringTest : public Test { |
| 26 | }; |
| 27 | |
| 28 | TEST_F(ByteStringTest, Empty) { |
| 29 | uint32 val; |
| 30 | |
| 31 | ByteString bs1(0); |
Darin Petkov | e3e1cfa | 2011-08-11 13:41:17 -0700 | [diff] [blame] | 32 | EXPECT_TRUE(bs1.IsEmpty()); |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 33 | EXPECT_EQ(0, bs1.GetLength()); |
| 34 | EXPECT_TRUE(bs1.GetData() == NULL); |
| 35 | EXPECT_FALSE(bs1.ConvertToNetUInt32(&val)); |
| 36 | EXPECT_TRUE(bs1.IsZero()); |
| 37 | } |
| 38 | |
| 39 | TEST_F(ByteStringTest, NonEmpty) { |
| 40 | ByteString bs1(kTest1, sizeof(kTest1)); |
| 41 | uint32 val; |
| 42 | |
Darin Petkov | e3e1cfa | 2011-08-11 13:41:17 -0700 | [diff] [blame] | 43 | EXPECT_FALSE(bs1.IsEmpty()); |
| 44 | |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 45 | EXPECT_EQ(sizeof(kTest1), bs1.GetLength()); |
| 46 | for (unsigned int i = 0; i < sizeof(kTest1); i++) { |
| 47 | EXPECT_EQ(bs1.GetData()[i], kTest1[i]); |
| 48 | } |
| 49 | EXPECT_TRUE(bs1.GetData() != NULL); |
| 50 | EXPECT_FALSE(bs1.ConvertToNetUInt32(&val)); |
| 51 | EXPECT_FALSE(bs1.IsZero()); |
| 52 | |
| 53 | ByteString bs2(kTest2, sizeof(kTest2)); |
| 54 | EXPECT_EQ(sizeof(kTest2), bs2.GetLength()); |
| 55 | for (unsigned int i = 0; i < sizeof(kTest2); i++) { |
| 56 | EXPECT_EQ(bs2.GetData()[i], kTest2[i]); |
| 57 | } |
| 58 | EXPECT_TRUE(bs2.GetData() != NULL); |
| 59 | EXPECT_FALSE(bs2.IsZero()); |
| 60 | |
| 61 | EXPECT_FALSE(bs2.Equals(bs1)); |
| 62 | |
| 63 | ByteString bs3(kTest3, sizeof(kTest3)); |
| 64 | EXPECT_EQ(sizeof(kTest3), bs3.GetLength()); |
| 65 | for (unsigned int i = 0; i < sizeof(kTest3); i++) { |
| 66 | EXPECT_EQ(bs3.GetData()[i], kTest3[i]); |
| 67 | } |
| 68 | EXPECT_TRUE(bs3.GetData() != NULL); |
| 69 | EXPECT_TRUE(bs3.IsZero()); |
| 70 | EXPECT_FALSE(bs2.Equals(bs1)); |
| 71 | EXPECT_FALSE(bs3.Equals(bs1)); |
| 72 | |
Gary Morain | 4178023 | 2012-07-31 15:08:31 -0700 | [diff] [blame] | 73 | ByteString bs4(std::string(kTest4), false); |
Paul Stewart | dd7df79 | 2011-07-15 11:09:50 -0700 | [diff] [blame] | 74 | EXPECT_EQ(strlen(kTest4), bs4.GetLength()); |
| 75 | EXPECT_EQ(0, memcmp(kTest4, bs4.GetData(), bs4.GetLength())); |
| 76 | |
Gary Morain | 4178023 | 2012-07-31 15:08:31 -0700 | [diff] [blame] | 77 | ByteString bs5(std::string(kTest4), true); |
Paul Stewart | dd7df79 | 2011-07-15 11:09:50 -0700 | [diff] [blame] | 78 | EXPECT_EQ(strlen(kTest4) + 1, bs5.GetLength()); |
| 79 | EXPECT_EQ(0, memcmp(kTest4, bs5.GetData(), bs5.GetLength())); |
| 80 | |
| 81 | ByteString bs6(kTest1, sizeof(kTest1)); |
| 82 | EXPECT_TRUE(bs6.Equals(bs1)); |
Gary Morain | 4178023 | 2012-07-31 15:08:31 -0700 | [diff] [blame] | 83 | |
| 84 | ByteString bs7(kTest5, sizeof(kTest5)); |
| 85 | ASSERT_TRUE(bs7.GetData() != NULL); |
| 86 | EXPECT_EQ(sizeof(kTest5), bs7.GetLength()); |
| 87 | for (unsigned int i = 0; i < sizeof(kTest5); i++) { |
| 88 | EXPECT_EQ(bs7.GetData()[i], kTest5[i]); |
| 89 | } |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 90 | } |
| 91 | |
Paul Stewart | 91a5aac | 2012-07-20 11:55:40 -0700 | [diff] [blame] | 92 | TEST_F(ByteStringTest, SubString) { |
| 93 | ByteString bs1(kTest1, sizeof(kTest1)); |
| 94 | ByteString bs2(kTest1 + 3, 4); |
| 95 | EXPECT_TRUE(bs2.Equals(bs1.GetSubstring(3, 4))); |
| 96 | const int kMargin = sizeof(kTest1) - 3; |
| 97 | ByteString bs3(kTest1 + kMargin, sizeof(kTest1) - kMargin); |
| 98 | EXPECT_TRUE(bs3.Equals(bs1.GetSubstring(kMargin, sizeof(kTest1)))); |
| 99 | EXPECT_TRUE(bs1.GetSubstring(sizeof(kTest1), 10).IsEmpty()); |
| 100 | } |
| 101 | |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 102 | TEST_F(ByteStringTest, UInt32) { |
Darin Petkov | e3e1cfa | 2011-08-11 13:41:17 -0700 | [diff] [blame] | 103 | ByteString bs1 = ByteString::CreateFromNetUInt32(kTest2Uint32); |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 104 | uint32 val; |
| 105 | |
| 106 | EXPECT_EQ(4, bs1.GetLength()); |
| 107 | EXPECT_TRUE(bs1.GetData() != NULL); |
| 108 | EXPECT_TRUE(bs1.ConvertToNetUInt32(&val)); |
Darin Petkov | e3e1cfa | 2011-08-11 13:41:17 -0700 | [diff] [blame] | 109 | EXPECT_EQ(kTest2Uint32, val); |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 110 | EXPECT_FALSE(bs1.IsZero()); |
| 111 | |
| 112 | ByteString bs2(kTest2, sizeof(kTest2)); |
| 113 | EXPECT_TRUE(bs1.Equals(bs2)); |
| 114 | EXPECT_TRUE(bs2.ConvertToNetUInt32(&val)); |
Darin Petkov | e3e1cfa | 2011-08-11 13:41:17 -0700 | [diff] [blame] | 115 | EXPECT_EQ(kTest2Uint32, val); |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 116 | |
| 117 | ByteString bs3 = ByteString::CreateFromCPUUInt32(0x1020304); |
| 118 | EXPECT_EQ(4, bs1.GetLength()); |
| 119 | EXPECT_TRUE(bs3.GetData() != NULL); |
| 120 | EXPECT_TRUE(bs3.ConvertToCPUUInt32(&val)); |
| 121 | EXPECT_EQ(0x1020304, val); |
| 122 | EXPECT_FALSE(bs3.IsZero()); |
| 123 | |
| 124 | #if __BYTE_ORDER == __LITTLE_ENDIAN |
| 125 | EXPECT_FALSE(bs1.Equals(bs3)); |
| 126 | #else |
| 127 | EXPECT_TRUE(bs1.Equals(bs3)); |
| 128 | #endif |
| 129 | } |
| 130 | |
Paul Stewart | dd7df79 | 2011-07-15 11:09:50 -0700 | [diff] [blame] | 131 | TEST_F(ByteStringTest, Resize) { |
| 132 | ByteString bs1(kTest2, sizeof(kTest2)); |
Paul Stewart | dd7df79 | 2011-07-15 11:09:50 -0700 | [diff] [blame] | 133 | |
| 134 | bs1.Resize(sizeof(kTest2) + 10); |
| 135 | EXPECT_EQ(sizeof(kTest2) + 10, bs1.GetLength()); |
| 136 | EXPECT_TRUE(bs1.GetData() != NULL); |
| 137 | EXPECT_EQ(0, memcmp(bs1.GetData(), kTest2, sizeof(kTest2))); |
| 138 | for (size_t i = sizeof(kTest2); i < sizeof(kTest2) + 10; ++i) { |
| 139 | EXPECT_EQ(0, bs1.GetData()[i]); |
| 140 | } |
| 141 | |
| 142 | bs1.Resize(sizeof(kTest2) - 2); |
| 143 | EXPECT_EQ(sizeof(kTest2) - 2, bs1.GetLength()); |
| 144 | EXPECT_EQ(0, memcmp(bs1.GetData(), kTest2, sizeof(kTest2) - 2)); |
| 145 | } |
| 146 | |
Darin Petkov | e3e1cfa | 2011-08-11 13:41:17 -0700 | [diff] [blame] | 147 | TEST_F(ByteStringTest, HexEncode) { |
| 148 | ByteString bs(kTest2, sizeof(kTest2)); |
| 149 | EXPECT_EQ(kTest2HexString, bs.HexEncode()); |
| 150 | } |
| 151 | |
Paul Stewart | fe1c0e1 | 2012-04-30 19:57:04 -0700 | [diff] [blame] | 152 | TEST_F(ByteStringTest, BitwiseAnd) { |
Paul Stewart | f7bf9bf | 2012-04-17 17:30:14 -0700 | [diff] [blame] | 153 | ByteString bs(kTest1, sizeof(kTest1)); |
| 154 | ByteString mask; |
| 155 | ByteString expected_result; |
| 156 | for (size_t i = 0; i < sizeof(kTest1); i++) { |
Paul Stewart | fe1c0e1 | 2012-04-30 19:57:04 -0700 | [diff] [blame] | 157 | EXPECT_FALSE(bs.BitwiseAnd(mask)); |
Paul Stewart | f7bf9bf | 2012-04-17 17:30:14 -0700 | [diff] [blame] | 158 | unsigned char val = sizeof(kTest1) - i; |
| 159 | mask.Append(ByteString(&val, 1)); |
| 160 | val &= bs.GetConstData()[i]; |
| 161 | expected_result.Append(ByteString(&val, 1)); |
| 162 | } |
Paul Stewart | fe1c0e1 | 2012-04-30 19:57:04 -0700 | [diff] [blame] | 163 | EXPECT_TRUE(bs.BitwiseAnd(mask)); |
Paul Stewart | f7bf9bf | 2012-04-17 17:30:14 -0700 | [diff] [blame] | 164 | EXPECT_TRUE(bs.Equals(expected_result)); |
| 165 | bs.Resize(sizeof(kTest1) - 1); |
Paul Stewart | fe1c0e1 | 2012-04-30 19:57:04 -0700 | [diff] [blame] | 166 | EXPECT_FALSE(bs.BitwiseAnd(mask)); |
| 167 | } |
| 168 | |
| 169 | TEST_F(ByteStringTest, BitwiseOr) { |
| 170 | ByteString bs(kTest1, sizeof(kTest1)); |
| 171 | ByteString merge; |
| 172 | ByteString expected_result; |
| 173 | for (size_t i = 0; i < sizeof(kTest1); i++) { |
| 174 | EXPECT_FALSE(bs.BitwiseOr(merge)); |
| 175 | unsigned char val = sizeof(kTest1) - i; |
| 176 | merge.Append(ByteString(&val, 1)); |
| 177 | val |= bs.GetConstData()[i]; |
| 178 | expected_result.Append(ByteString(&val, 1)); |
| 179 | } |
| 180 | EXPECT_TRUE(bs.BitwiseOr(merge)); |
| 181 | EXPECT_TRUE(bs.Equals(expected_result)); |
| 182 | bs.Resize(sizeof(kTest1) - 1); |
| 183 | EXPECT_FALSE(bs.BitwiseOr(merge)); |
| 184 | } |
| 185 | |
| 186 | TEST_F(ByteStringTest, BitwiseInvert) { |
| 187 | ByteString bs(kTest1, sizeof(kTest1)); |
| 188 | ByteString invert; |
| 189 | for (size_t i = 0; i < sizeof(kTest1); i++) { |
| 190 | unsigned char val = kTest1[i] ^ 0xff; |
| 191 | invert.Append(ByteString(&val, 1)); |
| 192 | } |
| 193 | bs.BitwiseInvert(); |
| 194 | EXPECT_TRUE(bs.Equals(invert)); |
Paul Stewart | f7bf9bf | 2012-04-17 17:30:14 -0700 | [diff] [blame] | 195 | } |
| 196 | |
Paul Stewart | 3ecfa2b | 2011-07-15 10:47:42 -0700 | [diff] [blame] | 197 | } // namespace shill |