1 /* 2 * Copyright 2004 The WebRTC Project Authors. All rights reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11 #include "webrtc/base/common.h" 12 #include "webrtc/base/gunit.h" 13 #include "webrtc/base/stringencode.h" 14 #include "webrtc/base/stringutils.h" 15 16 namespace rtc { 17 18 TEST(Utf8EncodeTest, EncodeDecode) { 19 const struct Utf8Test { 20 const char* encoded; 21 size_t encsize, enclen; 22 unsigned long decoded; 23 } kTests[] = { 24 { "a ", 5, 1, 'a' }, 25 { "\x7F ", 5, 1, 0x7F }, 26 { "\xC2\x80 ", 5, 2, 0x80 }, 27 { "\xDF\xBF ", 5, 2, 0x7FF }, 28 { "\xE0\xA0\x80 ", 5, 3, 0x800 }, 29 { "\xEF\xBF\xBF ", 5, 3, 0xFFFF }, 30 { "\xF0\x90\x80\x80 ", 5, 4, 0x10000 }, 31 { "\xF0\x90\x80\x80 ", 3, 0, 0x10000 }, 32 { "\xF0\xF0\x80\x80 ", 5, 0, 0 }, 33 { "\xF0\x90\x80 ", 5, 0, 0 }, 34 { "\x90\x80\x80 ", 5, 0, 0 }, 35 { NULL, 0, 0 }, 36 }; 37 for (size_t i = 0; kTests[i].encoded; ++i) { 38 unsigned long val = 0; 39 ASSERT_EQ(kTests[i].enclen, utf8_decode(kTests[i].encoded, 40 kTests[i].encsize, 41 &val)); 42 unsigned long result = (kTests[i].enclen == 0) ? 0 : kTests[i].decoded; 43 ASSERT_EQ(result, val); 44 45 if (kTests[i].decoded == 0) { 46 // Not an interesting encoding test case 47 continue; 48 } 49 50 char buffer[5]; 51 memset(buffer, 0x01, ARRAY_SIZE(buffer)); 52 ASSERT_EQ(kTests[i].enclen, utf8_encode(buffer, 53 kTests[i].encsize, 54 kTests[i].decoded)); 55 ASSERT_TRUE(memcmp(buffer, kTests[i].encoded, kTests[i].enclen) == 0); 56 // Make sure remainder of buffer is unchanged 57 ASSERT_TRUE(memory_check(buffer + kTests[i].enclen, 58 0x1, 59 ARRAY_SIZE(buffer) - kTests[i].enclen)); 60 } 61 } 62 63 class HexEncodeTest : public testing::Test { 64 public: 65 HexEncodeTest() : enc_res_(0), dec_res_(0) { 66 for (size_t i = 0; i < sizeof(data_); ++i) { 67 data_[i] = (i + 128) & 0xff; 68 } 69 memset(decoded_, 0x7f, sizeof(decoded_)); 70 } 71 72 char data_[10]; 73 char encoded_[31]; 74 char decoded_[11]; 75 size_t enc_res_; 76 size_t dec_res_; 77 }; 78 79 // Test that we can convert to/from hex with no delimiter. 80 TEST_F(HexEncodeTest, TestWithNoDelimiter) { 81 enc_res_ = hex_encode(encoded_, sizeof(encoded_), data_, sizeof(data_)); 82 ASSERT_EQ(sizeof(data_) * 2, enc_res_); 83 ASSERT_STREQ("80818283848586878889", encoded_); 84 dec_res_ = hex_decode(decoded_, sizeof(decoded_), encoded_, enc_res_); 85 ASSERT_EQ(sizeof(data_), dec_res_); 86 ASSERT_EQ(0, memcmp(data_, decoded_, dec_res_)); 87 } 88 89 // Test that we can convert to/from hex with a colon delimiter. 90 TEST_F(HexEncodeTest, TestWithDelimiter) { 91 enc_res_ = hex_encode_with_delimiter(encoded_, sizeof(encoded_), 92 data_, sizeof(data_), ':'); 93 ASSERT_EQ(sizeof(data_) * 3 - 1, enc_res_); 94 ASSERT_STREQ("80:81:82:83:84:85:86:87:88:89", encoded_); 95 dec_res_ = hex_decode_with_delimiter(decoded_, sizeof(decoded_), 96 encoded_, enc_res_, ':'); 97 ASSERT_EQ(sizeof(data_), dec_res_); 98 ASSERT_EQ(0, memcmp(data_, decoded_, dec_res_)); 99 } 100 101 // Test that encoding with one delimiter and decoding with another fails. 102 TEST_F(HexEncodeTest, TestWithWrongDelimiter) { 103 enc_res_ = hex_encode_with_delimiter(encoded_, sizeof(encoded_), 104 data_, sizeof(data_), ':'); 105 ASSERT_EQ(sizeof(data_) * 3 - 1, enc_res_); 106 dec_res_ = hex_decode_with_delimiter(decoded_, sizeof(decoded_), 107 encoded_, enc_res_, '/'); 108 ASSERT_EQ(0U, dec_res_); 109 } 110 111 // Test that encoding without a delimiter and decoding with one fails. 112 TEST_F(HexEncodeTest, TestExpectedDelimiter) { 113 enc_res_ = hex_encode(encoded_, sizeof(encoded_), data_, sizeof(data_)); 114 ASSERT_EQ(sizeof(data_) * 2, enc_res_); 115 dec_res_ = hex_decode_with_delimiter(decoded_, sizeof(decoded_), 116 encoded_, enc_res_, ':'); 117 ASSERT_EQ(0U, dec_res_); 118 } 119 120 // Test that encoding with a delimiter and decoding without one fails. 121 TEST_F(HexEncodeTest, TestExpectedNoDelimiter) { 122 enc_res_ = hex_encode_with_delimiter(encoded_, sizeof(encoded_), 123 data_, sizeof(data_), ':'); 124 ASSERT_EQ(sizeof(data_) * 3 - 1, enc_res_); 125 dec_res_ = hex_decode(decoded_, sizeof(decoded_), encoded_, enc_res_); 126 ASSERT_EQ(0U, dec_res_); 127 } 128 129 // Test that we handle a zero-length buffer with no delimiter. 130 TEST_F(HexEncodeTest, TestZeroLengthNoDelimiter) { 131 enc_res_ = hex_encode(encoded_, sizeof(encoded_), "", 0); 132 ASSERT_EQ(0U, enc_res_); 133 dec_res_ = hex_decode(decoded_, sizeof(decoded_), encoded_, enc_res_); 134 ASSERT_EQ(0U, dec_res_); 135 } 136 137 // Test that we handle a zero-length buffer with a delimiter. 138 TEST_F(HexEncodeTest, TestZeroLengthWithDelimiter) { 139 enc_res_ = hex_encode_with_delimiter(encoded_, sizeof(encoded_), "", 0, ':'); 140 ASSERT_EQ(0U, enc_res_); 141 dec_res_ = hex_decode_with_delimiter(decoded_, sizeof(decoded_), 142 encoded_, enc_res_, ':'); 143 ASSERT_EQ(0U, dec_res_); 144 } 145 146 // Test the std::string variants that take no delimiter. 147 TEST_F(HexEncodeTest, TestHelpersNoDelimiter) { 148 std::string result = hex_encode(data_, sizeof(data_)); 149 ASSERT_EQ("80818283848586878889", result); 150 dec_res_ = hex_decode(decoded_, sizeof(decoded_), result); 151 ASSERT_EQ(sizeof(data_), dec_res_); 152 ASSERT_EQ(0, memcmp(data_, decoded_, dec_res_)); 153 } 154 155 // Test the std::string variants that use a delimiter. 156 TEST_F(HexEncodeTest, TestHelpersWithDelimiter) { 157 std::string result = hex_encode_with_delimiter(data_, sizeof(data_), ':'); 158 ASSERT_EQ("80:81:82:83:84:85:86:87:88:89", result); 159 dec_res_ = hex_decode_with_delimiter(decoded_, sizeof(decoded_), result, ':'); 160 ASSERT_EQ(sizeof(data_), dec_res_); 161 ASSERT_EQ(0, memcmp(data_, decoded_, dec_res_)); 162 } 163 164 // Test that encoding into a too-small output buffer (without delimiter) fails. 165 TEST_F(HexEncodeTest, TestEncodeTooShort) { 166 enc_res_ = hex_encode_with_delimiter(encoded_, sizeof(data_) * 2, 167 data_, sizeof(data_), 0); 168 ASSERT_EQ(0U, enc_res_); 169 } 170 171 // Test that encoding into a too-small output buffer (with delimiter) fails. 172 TEST_F(HexEncodeTest, TestEncodeWithDelimiterTooShort) { 173 enc_res_ = hex_encode_with_delimiter(encoded_, sizeof(data_) * 3 - 1, 174 data_, sizeof(data_), ':'); 175 ASSERT_EQ(0U, enc_res_); 176 } 177 178 // Test that decoding into a too-small output buffer fails. 179 TEST_F(HexEncodeTest, TestDecodeTooShort) { 180 dec_res_ = hex_decode_with_delimiter(decoded_, 4, "0123456789", 10, 0); 181 ASSERT_EQ(0U, dec_res_); 182 ASSERT_EQ(0x7f, decoded_[4]); 183 } 184 185 // Test that decoding non-hex data fails. 186 TEST_F(HexEncodeTest, TestDecodeBogusData) { 187 dec_res_ = hex_decode_with_delimiter(decoded_, sizeof(decoded_), "xyz", 3, 0); 188 ASSERT_EQ(0U, dec_res_); 189 } 190 191 // Test that decoding an odd number of hex characters fails. 192 TEST_F(HexEncodeTest, TestDecodeOddHexDigits) { 193 dec_res_ = hex_decode_with_delimiter(decoded_, sizeof(decoded_), "012", 3, 0); 194 ASSERT_EQ(0U, dec_res_); 195 } 196 197 // Test that decoding a string with too many delimiters fails. 198 TEST_F(HexEncodeTest, TestDecodeWithDelimiterTooManyDelimiters) { 199 dec_res_ = hex_decode_with_delimiter(decoded_, 4, "01::23::45::67", 14, ':'); 200 ASSERT_EQ(0U, dec_res_); 201 } 202 203 // Test that decoding a string with a leading delimiter fails. 204 TEST_F(HexEncodeTest, TestDecodeWithDelimiterLeadingDelimiter) { 205 dec_res_ = hex_decode_with_delimiter(decoded_, 4, ":01:23:45:67", 12, ':'); 206 ASSERT_EQ(0U, dec_res_); 207 } 208 209 // Test that decoding a string with a trailing delimiter fails. 210 TEST_F(HexEncodeTest, TestDecodeWithDelimiterTrailingDelimiter) { 211 dec_res_ = hex_decode_with_delimiter(decoded_, 4, "01:23:45:67:", 12, ':'); 212 ASSERT_EQ(0U, dec_res_); 213 } 214 215 // Tests counting substrings. 216 TEST(TokenizeTest, CountSubstrings) { 217 std::vector<std::string> fields; 218 219 EXPECT_EQ(5ul, tokenize("one two three four five", ' ', &fields)); 220 fields.clear(); 221 EXPECT_EQ(1ul, tokenize("one", ' ', &fields)); 222 223 // Extra spaces should be ignored. 224 fields.clear(); 225 EXPECT_EQ(5ul, tokenize(" one two three four five ", ' ', &fields)); 226 fields.clear(); 227 EXPECT_EQ(1ul, tokenize(" one ", ' ', &fields)); 228 fields.clear(); 229 EXPECT_EQ(0ul, tokenize(" ", ' ', &fields)); 230 } 231 232 // Tests comparing substrings. 233 TEST(TokenizeTest, CompareSubstrings) { 234 std::vector<std::string> fields; 235 236 tokenize("find middle one", ' ', &fields); 237 ASSERT_EQ(3ul, fields.size()); 238 ASSERT_STREQ("middle", fields.at(1).c_str()); 239 fields.clear(); 240 241 // Extra spaces should be ignored. 242 tokenize(" find middle one ", ' ', &fields); 243 ASSERT_EQ(3ul, fields.size()); 244 ASSERT_STREQ("middle", fields.at(1).c_str()); 245 fields.clear(); 246 tokenize(" ", ' ', &fields); 247 ASSERT_EQ(0ul, fields.size()); 248 } 249 250 TEST(TokenizeTest, TokenizeAppend) { 251 ASSERT_EQ(0ul, tokenize_append("A B C", ' ', NULL)); 252 253 std::vector<std::string> fields; 254 255 tokenize_append("A B C", ' ', &fields); 256 ASSERT_EQ(3ul, fields.size()); 257 ASSERT_STREQ("B", fields.at(1).c_str()); 258 259 tokenize_append("D E", ' ', &fields); 260 ASSERT_EQ(5ul, fields.size()); 261 ASSERT_STREQ("B", fields.at(1).c_str()); 262 ASSERT_STREQ("E", fields.at(4).c_str()); 263 } 264 265 TEST(TokenizeTest, TokenizeWithMarks) { 266 ASSERT_EQ(0ul, tokenize("D \"A B", ' ', '(', ')', NULL)); 267 268 std::vector<std::string> fields; 269 tokenize("A B C", ' ', '"', '"', &fields); 270 ASSERT_EQ(3ul, fields.size()); 271 ASSERT_STREQ("C", fields.at(2).c_str()); 272 273 tokenize("\"A B\" C", ' ', '"', '"', &fields); 274 ASSERT_EQ(2ul, fields.size()); 275 ASSERT_STREQ("A B", fields.at(0).c_str()); 276 277 tokenize("D \"A B\" C", ' ', '"', '"', &fields); 278 ASSERT_EQ(3ul, fields.size()); 279 ASSERT_STREQ("D", fields.at(0).c_str()); 280 ASSERT_STREQ("A B", fields.at(1).c_str()); 281 282 tokenize("D \"A B\" C \"E F\"", ' ', '"', '"', &fields); 283 ASSERT_EQ(4ul, fields.size()); 284 ASSERT_STREQ("D", fields.at(0).c_str()); 285 ASSERT_STREQ("A B", fields.at(1).c_str()); 286 ASSERT_STREQ("E F", fields.at(3).c_str()); 287 288 // No matching marks. 289 tokenize("D \"A B", ' ', '"', '"', &fields); 290 ASSERT_EQ(3ul, fields.size()); 291 ASSERT_STREQ("D", fields.at(0).c_str()); 292 ASSERT_STREQ("\"A", fields.at(1).c_str()); 293 294 tokenize("D (A B) C (E F) G", ' ', '(', ')', &fields); 295 ASSERT_EQ(5ul, fields.size()); 296 ASSERT_STREQ("D", fields.at(0).c_str()); 297 ASSERT_STREQ("A B", fields.at(1).c_str()); 298 ASSERT_STREQ("E F", fields.at(3).c_str()); 299 } 300 301 // Tests counting substrings. 302 TEST(SplitTest, CountSubstrings) { 303 std::vector<std::string> fields; 304 305 EXPECT_EQ(5ul, split("one,two,three,four,five", ',', &fields)); 306 fields.clear(); 307 EXPECT_EQ(1ul, split("one", ',', &fields)); 308 309 // Empty fields between commas count. 310 fields.clear(); 311 EXPECT_EQ(5ul, split("one,,three,four,five", ',', &fields)); 312 fields.clear(); 313 EXPECT_EQ(3ul, split(",three,", ',', &fields)); 314 fields.clear(); 315 EXPECT_EQ(1ul, split("", ',', &fields)); 316 } 317 318 // Tests comparing substrings. 319 TEST(SplitTest, CompareSubstrings) { 320 std::vector<std::string> fields; 321 322 split("find,middle,one", ',', &fields); 323 ASSERT_EQ(3ul, fields.size()); 324 ASSERT_STREQ("middle", fields.at(1).c_str()); 325 fields.clear(); 326 327 // Empty fields between commas count. 328 split("find,,middle,one", ',', &fields); 329 ASSERT_EQ(4ul, fields.size()); 330 ASSERT_STREQ("middle", fields.at(2).c_str()); 331 fields.clear(); 332 split("", ',', &fields); 333 ASSERT_EQ(1ul, fields.size()); 334 ASSERT_STREQ("", fields.at(0).c_str()); 335 } 336 337 TEST(BoolTest, DecodeValid) { 338 bool value; 339 EXPECT_TRUE(FromString("true", &value)); 340 EXPECT_TRUE(value); 341 EXPECT_TRUE(FromString("true,", &value)); 342 EXPECT_TRUE(value); 343 EXPECT_TRUE(FromString("true , true", &value)); 344 EXPECT_TRUE(value); 345 EXPECT_TRUE(FromString("true ,\n false", &value)); 346 EXPECT_TRUE(value); 347 EXPECT_TRUE(FromString(" true \n", &value)); 348 EXPECT_TRUE(value); 349 350 EXPECT_TRUE(FromString("false", &value)); 351 EXPECT_FALSE(value); 352 EXPECT_TRUE(FromString(" false ", &value)); 353 EXPECT_FALSE(value); 354 EXPECT_TRUE(FromString(" false, ", &value)); 355 EXPECT_FALSE(value); 356 357 EXPECT_TRUE(FromString<bool>("true\n")); 358 EXPECT_FALSE(FromString<bool>("false\n")); 359 } 360 361 TEST(BoolTest, DecodeInvalid) { 362 bool value; 363 EXPECT_FALSE(FromString("True", &value)); 364 EXPECT_FALSE(FromString("TRUE", &value)); 365 EXPECT_FALSE(FromString("False", &value)); 366 EXPECT_FALSE(FromString("FALSE", &value)); 367 EXPECT_FALSE(FromString("0", &value)); 368 EXPECT_FALSE(FromString("1", &value)); 369 EXPECT_FALSE(FromString("0,", &value)); 370 EXPECT_FALSE(FromString("1,", &value)); 371 EXPECT_FALSE(FromString("1,0", &value)); 372 EXPECT_FALSE(FromString("1.", &value)); 373 EXPECT_FALSE(FromString("1.0", &value)); 374 EXPECT_FALSE(FromString("", &value)); 375 EXPECT_FALSE(FromString<bool>("false\nfalse")); 376 } 377 378 TEST(BoolTest, RoundTrip) { 379 bool value; 380 EXPECT_TRUE(FromString(ToString(true), &value)); 381 EXPECT_TRUE(value); 382 EXPECT_TRUE(FromString(ToString(false), &value)); 383 EXPECT_FALSE(value); 384 } 385 } // namespace rtc 386
