1 // Protocol Buffers - Google's data interchange format 2 // Copyright 2008 Google Inc. All rights reserved. 3 // https://developers.google.com/protocol-buffers/ 4 // 5 // Redistribution and use in source and binary forms, with or without 6 // modification, are permitted provided that the following conditions are 7 // met: 8 // 9 // * Redistributions of source code must retain the above copyright 10 // notice, this list of conditions and the following disclaimer. 11 // * Redistributions in binary form must reproduce the above 12 // copyright notice, this list of conditions and the following disclaimer 13 // in the documentation and/or other materials provided with the 14 // distribution. 15 // * Neither the name of Google Inc. nor the names of its 16 // contributors may be used to endorse or promote products derived from 17 // this software without specific prior written permission. 18 // 19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 31 // A hack to include windows.h first, which ensures the GetMessage macro can 32 // be undefined when we include <google/protobuf/stubs/common.h> 33 #if defined(_WIN32) 34 #define _WINSOCKAPI_ // to avoid re-definition in WinSock2.h 35 #define NOMINMAX // to avoid defining min/max macros 36 #include <windows.h> 37 #endif // _WIN32 38 39 #include <algorithm> 40 #include <google/protobuf/stubs/hash.h> 41 #include <map> 42 #include <memory> 43 #ifndef _SHARED_PTR_H 44 #include <google/protobuf/stubs/shared_ptr.h> 45 #endif 46 #include <set> 47 #include <sstream> 48 #include <vector> 49 50 #include <google/protobuf/stubs/casts.h> 51 #include <google/protobuf/stubs/logging.h> 52 #include <google/protobuf/stubs/common.h> 53 #include <google/protobuf/stubs/stringprintf.h> 54 #include <google/protobuf/testing/file.h> 55 #include <google/protobuf/arena_test_util.h> 56 #include <google/protobuf/map_proto2_unittest.pb.h> 57 #include <google/protobuf/map_unittest.pb.h> 58 #include <google/protobuf/map_test_util.h> 59 #include <google/protobuf/test_util.h> 60 #include <google/protobuf/unittest.pb.h> 61 #include <google/protobuf/descriptor.pb.h> 62 #include <google/protobuf/descriptor.h> 63 #include <google/protobuf/descriptor_database.h> 64 #include <google/protobuf/dynamic_message.h> 65 #include <google/protobuf/map.h> 66 #include <google/protobuf/map_field_inl.h> 67 #include <google/protobuf/message.h> 68 #include <google/protobuf/reflection.h> 69 #include <google/protobuf/reflection_ops.h> 70 #include <google/protobuf/text_format.h> 71 #include <google/protobuf/wire_format.h> 72 #include <google/protobuf/wire_format_lite_inl.h> 73 #include <google/protobuf/io/coded_stream.h> 74 #include <google/protobuf/io/tokenizer.h> 75 #include <google/protobuf/io/zero_copy_stream_impl.h> 76 #include <google/protobuf/util/time_util.h> 77 #include <google/protobuf/util/message_differencer.h> 78 #include <google/protobuf/stubs/strutil.h> 79 #include <google/protobuf/stubs/substitute.h> 80 #include <gmock/gmock.h> 81 #include <google/protobuf/testing/googletest.h> 82 #include <gtest/gtest.h> 83 84 namespace google { 85 86 using google::protobuf::unittest::ForeignMessage; 87 using google::protobuf::unittest::TestAllTypes; 88 using google::protobuf::unittest::TestMap; 89 using google::protobuf::unittest::TestRecursiveMapMessage; 90 91 namespace protobuf { 92 namespace internal { 93 94 // Map API Test ===================================================== 95 96 // Parameterized tests on whether to use old style maps. 97 class MapImplTest : public testing::TestWithParam<bool> { 98 protected: MapImplTest()99 MapImplTest() 100 : map_ptr_(new Map<int32, int32>(GetParam())), 101 map_(*map_ptr_), 102 const_map_(*map_ptr_) { 103 EXPECT_TRUE(map_.empty()); 104 EXPECT_EQ(0, map_.size()); 105 } ~MapImplTest()106 ~MapImplTest() {} 107 ExpectSingleElement(int32 key,int32 value)108 void ExpectSingleElement(int32 key, int32 value) { 109 EXPECT_FALSE(map_.empty()); 110 EXPECT_EQ(1, map_.size()); 111 ExpectElement(key, value); 112 } 113 ExpectElements(const std::map<int32,int32> & map)114 void ExpectElements(const std::map<int32, int32>& map) { 115 EXPECT_FALSE(map_.empty()); 116 EXPECT_EQ(map.size(), map_.size()); 117 for (std::map<int32, int32>::const_iterator it = map.begin(); 118 it != map.end(); ++it) { 119 ExpectElement(it->first, it->second); 120 } 121 } 122 ExpectElement(int32 key,int32 value)123 void ExpectElement(int32 key, int32 value) { 124 // Test map size is correct. 125 EXPECT_EQ(value, map_[key]); 126 EXPECT_EQ(1, map_.count(key)); 127 128 // Check mutable at and find work correctly. 129 EXPECT_EQ(value, map_.at(key)); 130 Map<int32, int32>::iterator it = map_.find(key); 131 132 // interator dereferenceable 133 EXPECT_EQ(key, (*it).first); 134 EXPECT_EQ(value, (*it).second); 135 EXPECT_EQ(key, it->first); 136 EXPECT_EQ(value, it->second); 137 138 // iterator mutable 139 ((*it).second) = value + 1; 140 EXPECT_EQ(value + 1, map_[key]); 141 ((*it).second) = value; 142 EXPECT_EQ(value, map_[key]); 143 144 it->second = value + 1; 145 EXPECT_EQ(value + 1, map_[key]); 146 it->second = value; 147 EXPECT_EQ(value, map_[key]); 148 149 // copy constructor 150 Map<int32, int32>::iterator it_copy = it; 151 EXPECT_EQ(key, it_copy->first); 152 EXPECT_EQ(value, it_copy->second); 153 154 // Immutable API ================================================ 155 156 // Check immutable at and find work correctly. 157 EXPECT_EQ(value, const_map_.at(key)); 158 Map<int32, int32>::const_iterator const_it = const_map_.find(key); 159 160 // interator dereferenceable 161 EXPECT_EQ(key, (*const_it).first); 162 EXPECT_EQ(value, (*const_it).second); 163 EXPECT_EQ(key, const_it->first); 164 EXPECT_EQ(value, const_it->second); 165 166 // copy constructor 167 Map<int32, int32>::const_iterator const_it_copy = const_it; 168 EXPECT_EQ(key, const_it_copy->first); 169 EXPECT_EQ(value, const_it_copy->second); 170 } 171 172 google::protobuf::scoped_ptr<Map<int32, int32> > map_ptr_; 173 Map<int32, int32>& map_; 174 const Map<int32, int32>& const_map_; 175 }; 176 TEST_P(MapImplTest,OperatorBracket)177 TEST_P(MapImplTest, OperatorBracket) { 178 int32 key = 0; 179 int32 value1 = 100; 180 int32 value2 = 101; 181 182 EXPECT_EQ(0, map_[key]); 183 184 map_[key] = value1; 185 ExpectSingleElement(key, value1); 186 187 map_[key] = value2; 188 ExpectSingleElement(key, value2); 189 } 190 TEST_P(MapImplTest,OperatorBracketNonExist)191 TEST_P(MapImplTest, OperatorBracketNonExist) { 192 int32 key = 0; 193 int32 default_value = 0; 194 195 EXPECT_EQ(default_value, map_[key]); 196 ExpectSingleElement(key, default_value); 197 } 198 TEST_P(MapImplTest,MutableAt)199 TEST_P(MapImplTest, MutableAt) { 200 int32 key = 0; 201 int32 value1 = 100; 202 int32 value2 = 101; 203 204 map_[key] = value1; 205 ExpectSingleElement(key, value1); 206 207 map_.at(key) = value2; 208 ExpectSingleElement(key, value2); 209 } 210 211 #ifdef PROTOBUF_HAS_DEATH_TEST 212 TEST_P(MapImplTest,MutableAtNonExistDeathTest)213 TEST_P(MapImplTest, MutableAtNonExistDeathTest) { 214 EXPECT_DEATH(map_.at(0), ""); 215 } 216 TEST_P(MapImplTest,ImmutableAtNonExistDeathTest)217 TEST_P(MapImplTest, ImmutableAtNonExistDeathTest) { 218 EXPECT_DEATH(const_map_.at(0), ""); 219 } 220 TEST_P(MapImplTest,UsageErrors)221 TEST_P(MapImplTest, UsageErrors) { 222 MapKey key; 223 key.SetInt64Value(1); 224 EXPECT_DEATH(key.GetUInt64Value(), 225 "Protocol Buffer map usage error:\n" 226 "MapKey::GetUInt64Value type does not match\n" 227 " Expected : uint64\n" 228 " Actual : int64"); 229 230 MapValueRef value; 231 EXPECT_DEATH(value.SetFloatValue(0.1), 232 "Protocol Buffer map usage error:\n" 233 "MapValueRef::type MapValueRef is not initialized."); 234 } 235 236 #endif // PROTOBUF_HAS_DEATH_TEST 237 TEST_P(MapImplTest,CountNonExist)238 TEST_P(MapImplTest, CountNonExist) { 239 EXPECT_EQ(0, map_.count(0)); 240 } 241 TEST_P(MapImplTest,MutableFindNonExist)242 TEST_P(MapImplTest, MutableFindNonExist) { 243 EXPECT_TRUE(map_.end() == map_.find(0)); 244 } 245 TEST_P(MapImplTest,ImmutableFindNonExist)246 TEST_P(MapImplTest, ImmutableFindNonExist) { 247 EXPECT_TRUE(const_map_.end() == const_map_.find(0)); 248 } 249 TEST_P(MapImplTest,ConstEnd)250 TEST_P(MapImplTest, ConstEnd) { 251 EXPECT_TRUE(const_map_.end() == const_map_.cend()); 252 } 253 TEST_P(MapImplTest,GetReferenceFromIterator)254 TEST_P(MapImplTest, GetReferenceFromIterator) { 255 for (int i = 0; i < 10; i++) { 256 map_[i] = i; 257 } 258 259 for (Map<int32, int32>::const_iterator it = map_.cbegin(); 260 it != map_.cend();) { 261 Map<int32, int32>::const_reference entry = *it++; 262 EXPECT_EQ(entry.first, entry.second); 263 } 264 265 for (Map<int32, int32>::const_iterator it = const_map_.begin(); 266 it != const_map_.end();) { 267 Map<int32, int32>::const_reference entry = *it++; 268 EXPECT_EQ(entry.first, entry.second); 269 } 270 271 for (Map<int32, int32>::iterator it = map_.begin(); it != map_.end();) { 272 Map<int32, int32>::reference entry = *it++; 273 EXPECT_EQ(entry.first + 1, ++entry.second); 274 } 275 } 276 TEST_P(MapImplTest,IteratorBasic)277 TEST_P(MapImplTest, IteratorBasic) { 278 map_[0] = 0; 279 280 // Default constructible (per forward iterator requirements). 281 Map<int, int>::const_iterator cit; 282 Map<int, int>::iterator it; 283 284 it = map_.begin(); 285 cit = it; // Converts to const_iterator 286 287 // Can compare between them. 288 EXPECT_TRUE(it == cit); 289 EXPECT_FALSE(cit != it); 290 291 // Pre increment. 292 EXPECT_FALSE(it == ++cit); 293 294 // Post increment. 295 EXPECT_FALSE(it++ == cit); 296 EXPECT_TRUE(it == cit); 297 } 298 299 template <typename Iterator> median(Iterator i0,Iterator i1)300 static int64 median(Iterator i0, Iterator i1) { 301 vector<int64> v(i0, i1); 302 std::nth_element(v.begin(), v.begin() + v.size() / 2, v.end()); 303 return v[v.size() / 2]; 304 } 305 Now()306 static int64 Now() { 307 return google::protobuf::util::TimeUtil::TimestampToNanoseconds( 308 google::protobuf::util::TimeUtil::GetCurrentTime()); 309 } 310 311 // Arbitrary odd integers for creating test data. 312 static int k0 = 812398771; 313 static int k1 = 1312938717; 314 static int k2 = 1321555333; 315 316 // A naive begin() implementation will cause begin() to get slower and slower 317 // if one erases elements at the "front" of the hash map, and we'd like to 318 // avoid that, as std::unordered_map does. TEST_P(MapImplTest,BeginIsFast)319 TEST_P(MapImplTest, BeginIsFast) { 320 // Disable this test for both new and old implementations. 321 if (/*GetParam()*/true) return; 322 Map<int32, int32> map(false); // This test uses new-style maps only. 323 const int kTestSize = 250000; 324 // Create a random-looking map of size n. Use non-negative integer keys. 325 uint32 frog = 123983; 326 int last_key = 0; 327 int counter = 0; 328 while (map.size() < kTestSize) { 329 frog *= static_cast<uint32>(k0); 330 frog ^= frog >> 17; 331 frog += counter++; 332 last_key = 333 static_cast<int>(frog) >= 0 ? static_cast<int>(frog) : last_key ^ 1; 334 GOOGLE_DCHECK_GE(last_key, 0); 335 map[last_key] = last_key ^ 1; 336 } 337 vector<int64> times; 338 // We're going to do map.erase(map.begin()) over and over again. But, 339 // just in case one iteration is fast compared to the granularity of 340 // our time keeping, we measure kChunkSize iterations per outer-loop iter. 341 const int kChunkSize = 1000; 342 GOOGLE_CHECK_EQ(kTestSize % kChunkSize, 0); 343 do { 344 const int64 start = Now(); 345 for (int i = 0; i < kChunkSize; i++) { 346 map.erase(map.begin()); 347 } 348 const int64 end = Now(); 349 if (end > start) { 350 times.push_back(end - start); 351 } 352 } while (!map.empty()); 353 if (times.size() < .99 * kTestSize / kChunkSize) { 354 GOOGLE_LOG(WARNING) << "Now() isn't helping us measure time"; 355 return; 356 } 357 int64 x0 = median(times.begin(), times.begin() + 9); 358 int64 x1 = median(times.begin() + times.size() - 9, times.end()); 359 GOOGLE_LOG(INFO) << "x0=" << x0 << ", x1=" << x1; 360 // x1 will greatly exceed x0 if the code we just executed took O(n^2) time. 361 // And we'll probably time out and never get here. So, this test is 362 // intentionally loose: we check that x0 and x1 are within a factor of 8. 363 EXPECT_GE(x1, x0 / 8); 364 EXPECT_GE(x0, x1 / 8); 365 } 366 367 // Try to create kTestSize keys that will land in just a few buckets, and 368 // time the insertions, to get a rough estimate of whether an O(n^2) worst case 369 // was triggered. This test is a hacky, but probably better than nothing. TEST_P(MapImplTest,HashFlood)370 TEST_P(MapImplTest, HashFlood) { 371 const int kTestSize = 1024; // must be a power of 2 372 std::set<int> s; 373 for (int i = 0; s.size() < kTestSize; i++) { 374 if ((map_.hash_function()(i) & (kTestSize - 1)) < 3) { 375 s.insert(i); 376 } 377 } 378 // Create hash table with kTestSize entries that hash flood a table with 379 // 1024 (or 512 or 2048 or ...) entries. This assumes that map_ uses powers 380 // of 2 for table sizes, and that it's sufficient to "flood" with respect to 381 // the low bits of the output of map_.hash_function(). 382 vector<int64> times; 383 std::set<int>::iterator it = s.begin(); 384 int count = 0; 385 do { 386 const int64 start = Now(); 387 map_[*it] = 0; 388 const int64 end = Now(); 389 if (end > start) { 390 times.push_back(end - start); 391 } 392 ++count; 393 ++it; 394 } while (it != s.end()); 395 if (times.size() < .99 * count) return; 396 int64 x0 = median(times.begin(), times.begin() + 9); 397 int64 x1 = median(times.begin() + times.size() - 9, times.end()); 398 // x1 will greatly exceed x0 if the code we just executed took O(n^2) time. 399 // But we want to allow O(n log n). A factor of 20 should be generous enough. 400 EXPECT_LE(x1, x0 * 20); 401 } 402 403 template <typename T, typename U> TestValidityForAllKeysExcept(int key_to_avoid,const T & check_map,const U & map)404 static void TestValidityForAllKeysExcept(int key_to_avoid, 405 const T& check_map, 406 const U& map) { 407 typedef typename U::value_type value_type; // a key-value pair 408 for (typename U::const_iterator it = map.begin(); it != map.end(); ++it) { 409 const int key = it->first; 410 if (key == key_to_avoid) continue; 411 // All iterators relevant to this key, whether old (from check_map) or new, 412 // must point to the same memory. So, test pointer equality here. 413 const value_type* check_val = &*check_map.find(key)->second; 414 EXPECT_EQ(check_val, &*it); 415 EXPECT_EQ(check_val, &*map.find(key)); 416 } 417 } 418 419 // EXPECT i0 and i1 to be the same. Advancing them should have the same effect, 420 // too. 421 template <typename Iter> TestEqualIterators(Iter i0,Iter i1,Iter end)422 static void TestEqualIterators(Iter i0, Iter i1, Iter end) { 423 const int kMaxAdvance = 10; 424 for (int i = 0; i < kMaxAdvance; i++) { 425 EXPECT_EQ(i0 == end, i1 == end); 426 if (i0 == end) return; 427 EXPECT_EQ(&*i0, &*i1) << "iter " << i; 428 ++i0; 429 ++i1; 430 } 431 } 432 433 template <typename IteratorType> TestOldVersusNewIterator(int skip,Map<int,int> * m)434 static void TestOldVersusNewIterator(int skip, Map<int, int>* m) { 435 const int initial_size = m->size(); 436 IteratorType it = m->begin(); 437 for (int i = 0; i < skip && it != m->end(); it++, i++) {} 438 if (it == m->end()) return; 439 const IteratorType old = it; 440 GOOGLE_LOG(INFO) << "skip=" << skip << ", old->first=" << old->first; 441 const int target_size = 442 initial_size < 100 ? initial_size * 5 : initial_size * 5 / 4; 443 for (int i = 0; m->size() <= target_size; i++) { 444 (*m)[i] = 0; 445 } 446 // Iterator 'old' should still work just fine despite the growth of *m. 447 const IteratorType after_growth = m->find(old->first); 448 TestEqualIterators<IteratorType>(old, after_growth, m->end()); 449 450 // Now shrink the number of elements. Do this with a mix of erases and 451 // inserts to increase the chance that the hashtable will resize to a lower 452 // number of buckets. (But, in any case, the test is still useful.) 453 for (int i = 0; i < 2 * (target_size - initial_size); i++) { 454 if (i != old->first) { 455 m->erase(i); 456 } 457 if (((i ^ m->begin()->first) & 15) == 0) { 458 (*m)[i * 342] = i; 459 } 460 } 461 // Now, the table has grown and shrunk; test again. 462 TestEqualIterators<IteratorType>(old, m->find(old->first), m->end()); 463 TestEqualIterators<IteratorType>(old, after_growth, m->end()); 464 } 465 466 // Create and test an n-element Map, with emphasis on iterator correctness. StressTestIterators(int n,bool test_old_style_proto2_maps)467 static void StressTestIterators(int n, bool test_old_style_proto2_maps) { 468 GOOGLE_LOG(INFO) << "StressTestIterators " << n; 469 GOOGLE_CHECK_GT(n, 0); 470 // Create a random-looking map of size n. Use non-negative integer keys. 471 Map<int, int> m(test_old_style_proto2_maps); 472 uint32 frog = 123987 + n; 473 int last_key = 0; 474 int counter = 0; 475 while (m.size() < n) { 476 frog *= static_cast<uint32>(k0); 477 frog ^= frog >> 17; 478 frog += counter++; 479 last_key = 480 static_cast<int>(frog) >= 0 ? static_cast<int>(frog) : last_key ^ 1; 481 GOOGLE_DCHECK_GE(last_key, 0); 482 m[last_key] = last_key ^ 1; 483 } 484 // Test it. 485 ASSERT_EQ(n, m.size()); 486 // Create maps of pointers and iterators. 487 // These should remain valid even if we modify m. 488 hash_map<int, Map<int, int>::value_type*> mp(n); 489 hash_map<int, Map<int, int>::iterator> mi(n); 490 for (Map<int, int>::iterator it = m.begin(); it != m.end(); ++it) { 491 mp[it->first] = &*it; 492 mi[it->first] = it; 493 } 494 ASSERT_EQ(m.size(), mi.size()); 495 ASSERT_EQ(m.size(), mp.size()); 496 m.erase(last_key); 497 ASSERT_EQ(n - 1, m.size()); 498 TestValidityForAllKeysExcept(last_key, mp, m); 499 TestValidityForAllKeysExcept(last_key, mi, m); 500 501 m[last_key] = 0; 502 ASSERT_EQ(n, m.size()); 503 // Test old iterator vs new iterator, with table modification in between. 504 TestOldVersusNewIterator<Map<int, int>::const_iterator>(n % 3, &m); 505 TestOldVersusNewIterator<Map<int, int>::iterator>(n % (1 + (n / 40)), &m); 506 // Finally, ensure erase(iterator) doesn't reorder anything, because that is 507 // what its documentation says. 508 m[last_key] = m[last_key ^ 999] = 0; 509 vector<Map<int, int>::iterator> v; 510 v.reserve(m.size()); 511 int position_of_last_key = 0; 512 for (Map<int, int>::iterator it = m.begin(); it != m.end(); ++it) { 513 if (it->first == last_key) { 514 position_of_last_key = v.size(); 515 } 516 v.push_back(it); 517 } 518 ASSERT_EQ(m.size(), v.size()); 519 const Map<int, int>::iterator erase_result = m.erase(m.find(last_key)); 520 int index = 0; 521 for (Map<int, int>::iterator it = m.begin(); it != m.end(); ++it, ++index) { 522 if (index == position_of_last_key) { 523 EXPECT_EQ(&*erase_result, &*v[++index]); 524 } 525 ASSERT_EQ(&*it, &*v[index]); 526 } 527 } 528 TEST_P(MapImplTest,IteratorInvalidation)529 TEST_P(MapImplTest, IteratorInvalidation) { 530 // As multiple underlying hash_map implementations do not follow the 531 // validation requirement, the test is disabled for old-style maps. 532 if (GetParam()) return; 533 // Create a set of pseudo-random sizes to test. 534 #ifndef NDEBUG 535 const int kMaxSizeToTest = 100 * 1000; 536 #else 537 const int kMaxSizeToTest = 1000 * 1000; 538 #endif 539 std::set<int> s; 540 int n = kMaxSizeToTest; 541 int frog = k1 + n; 542 while (n > 1 && s.size() < 25) { 543 s.insert(n); 544 n = static_cast<int>(n * 100 / (101.0 + (frog & 63))); 545 frog *= k2; 546 frog ^= frog >> 17; 547 } 548 // Ensure we test a few small sizes. 549 s.insert(1); 550 s.insert(2); 551 s.insert(3); 552 // Now, the real work. 553 for (std::set<int>::iterator i = s.begin(); i != s.end(); ++i) { 554 StressTestIterators(*i, GetParam()); 555 } 556 } 557 558 // Test that erase() revalidates iterators. TEST_P(MapImplTest,EraseRevalidates)559 TEST_P(MapImplTest, EraseRevalidates) { 560 // As multiple underlying hash_map implementations do not follow the 561 // validation requirement, the test is disabled for old-style maps. 562 if (GetParam()) return; 563 map_[3] = map_[13] = map_[20] = 0; 564 const int initial_size = map_.size(); 565 EXPECT_EQ(3, initial_size); 566 vector<Map<int, int>::iterator> v; 567 for (Map<int, int>::iterator it = map_.begin(); it != map_.end(); ++it) { 568 v.push_back(it); 569 } 570 EXPECT_EQ(initial_size, v.size()); 571 for (int i = 0; map_.size() <= initial_size * 20; i++) { 572 map_[i] = 0; 573 } 574 const int larger_size = map_.size(); 575 // We've greatly increased the size of the map, so it is highly likely that 576 // the following will corrupt m if erase() doesn't properly revalidate 577 // iterators passed to it. Finishing this routine without crashing indicates 578 // success. 579 for (int i = 0; i < v.size(); i++) { 580 map_.erase(v[i]); 581 } 582 EXPECT_EQ(larger_size - v.size(), map_.size()); 583 } 584 585 template <typename T> IsConstHelper(T &)586 bool IsConstHelper(T& /*t*/) { // NOLINT. We want to catch non-const refs here. 587 return false; 588 } 589 template <typename T> IsConstHelper(const T &)590 bool IsConstHelper(const T& /*t*/) { 591 return true; 592 } 593 TEST_P(MapImplTest,IteratorConstness)594 TEST_P(MapImplTest, IteratorConstness) { 595 map_[0] = 0; 596 EXPECT_TRUE(IsConstHelper(*map_.cbegin())); 597 EXPECT_TRUE(IsConstHelper(*const_map_.begin())); 598 EXPECT_FALSE(IsConstHelper(*map_.begin())); 599 } 600 IsForwardIteratorHelper(std::forward_iterator_tag)601 bool IsForwardIteratorHelper(std::forward_iterator_tag /*tag*/) { return true; } 602 template <typename T> IsForwardIteratorHelper(T)603 bool IsForwardIteratorHelper(T /*t*/) { 604 return false; 605 } 606 TEST_P(MapImplTest,IteratorCategory)607 TEST_P(MapImplTest, IteratorCategory) { 608 EXPECT_TRUE(IsForwardIteratorHelper( 609 std::iterator_traits<Map<int, int>::iterator>::iterator_category())); 610 EXPECT_TRUE(IsForwardIteratorHelper(std::iterator_traits< 611 Map<int, int>::const_iterator>::iterator_category())); 612 } 613 TEST_P(MapImplTest,InsertSingle)614 TEST_P(MapImplTest, InsertSingle) { 615 int32 key = 0; 616 int32 value1 = 100; 617 int32 value2 = 101; 618 619 // Insert a non-existed key. 620 std::pair<Map<int32, int32>::iterator, bool> result1 = 621 map_.insert(Map<int32, int32>::value_type(key, value1)); 622 ExpectSingleElement(key, value1); 623 624 Map<int32, int32>::iterator it1 = result1.first; 625 EXPECT_EQ(key, it1->first); 626 EXPECT_EQ(value1, it1->second); 627 EXPECT_TRUE(result1.second); 628 629 // Insert an existed key. 630 std::pair<Map<int32, int32>::iterator, bool> result2 = 631 map_.insert(Map<int32, int32>::value_type(key, value2)); 632 ExpectSingleElement(key, value1); 633 634 Map<int32, int32>::iterator it2 = result2.first; 635 EXPECT_TRUE(it1 == it2); 636 EXPECT_FALSE(result2.second); 637 } 638 TEST_P(MapImplTest,InsertByIterator)639 TEST_P(MapImplTest, InsertByIterator) { 640 int32 key1 = 0; 641 int32 key2 = 1; 642 int32 value1a = 100; 643 int32 value1b = 101; 644 int32 value2a = 200; 645 int32 value2b = 201; 646 647 std::map<int32, int32> map1; 648 map1[key1] = value1a; 649 map1[key2] = value2a; 650 651 map_.insert(map1.begin(), map1.end()); 652 ExpectElements(map1); 653 654 std::map<int32, int32> map2; 655 map2[key1] = value1b; 656 map2[key2] = value2b; 657 658 map_.insert(map2.begin(), map2.end()); 659 ExpectElements(map1); 660 } 661 TEST_P(MapImplTest,EraseSingleByKey)662 TEST_P(MapImplTest, EraseSingleByKey) { 663 int32 key = 0; 664 int32 value = 100; 665 666 map_[key] = value; 667 ExpectSingleElement(key, value); 668 669 // Erase an existing key. 670 EXPECT_EQ(1, map_.erase(key)); 671 EXPECT_TRUE(map_.empty()); 672 EXPECT_EQ(0, map_.size()); 673 EXPECT_TRUE(map_.end() == map_.find(key)); 674 EXPECT_TRUE(map_.begin() == map_.end()); 675 676 // Erase a non-existing key. 677 EXPECT_EQ(0, map_.erase(key)); 678 } 679 TEST_P(MapImplTest,EraseMutipleByKey)680 TEST_P(MapImplTest, EraseMutipleByKey) { 681 // erase in one specific order to trigger corner cases 682 for (int i = 0; i < 5; i++) { 683 map_[i] = i; 684 } 685 686 map_.erase(0); 687 EXPECT_EQ(4, map_.size()); 688 EXPECT_TRUE(map_.end() == map_.find(0)); 689 690 map_.erase(1); 691 EXPECT_EQ(3, map_.size()); 692 EXPECT_TRUE(map_.end() == map_.find(1)); 693 694 map_.erase(3); 695 EXPECT_EQ(2, map_.size()); 696 EXPECT_TRUE(map_.end() == map_.find(3)); 697 698 map_.erase(4); 699 EXPECT_EQ(1, map_.size()); 700 EXPECT_TRUE(map_.end() == map_.find(4)); 701 702 map_.erase(2); 703 EXPECT_EQ(0, map_.size()); 704 EXPECT_TRUE(map_.end() == map_.find(2)); 705 } 706 TEST_P(MapImplTest,EraseSingleByIterator)707 TEST_P(MapImplTest, EraseSingleByIterator) { 708 int32 key = 0; 709 int32 value = 100; 710 711 map_[key] = value; 712 ExpectSingleElement(key, value); 713 714 Map<int32, int32>::iterator it = map_.find(key); 715 map_.erase(it); 716 EXPECT_TRUE(map_.empty()); 717 EXPECT_EQ(0, map_.size()); 718 EXPECT_TRUE(map_.end() == map_.find(key)); 719 EXPECT_TRUE(map_.begin() == map_.end()); 720 } 721 TEST_P(MapImplTest,ValidIteratorAfterErase)722 TEST_P(MapImplTest, ValidIteratorAfterErase) { 723 for (int i = 0; i < 10; i++) { 724 map_[i] = i; 725 } 726 727 int count = 0; 728 729 for (Map<int32, int32>::iterator it = map_.begin(); it != map_.end();) { 730 count++; 731 if (it->first % 2 == 1) { 732 map_.erase(it++); 733 } else { 734 ++it; 735 } 736 } 737 738 EXPECT_EQ(10, count); 739 EXPECT_EQ(5, map_.size()); 740 } 741 TEST_P(MapImplTest,EraseByIterator)742 TEST_P(MapImplTest, EraseByIterator) { 743 int32 key1 = 0; 744 int32 key2 = 1; 745 int32 value1 = 100; 746 int32 value2 = 101; 747 748 std::map<int32, int32> map; 749 map[key1] = value1; 750 map[key2] = value2; 751 752 map_.insert(map.begin(), map.end()); 753 ExpectElements(map); 754 755 map_.erase(map_.begin(), map_.end()); 756 EXPECT_TRUE(map_.empty()); 757 EXPECT_EQ(0, map_.size()); 758 EXPECT_TRUE(map_.end() == map_.find(key1)); 759 EXPECT_TRUE(map_.end() == map_.find(key2)); 760 EXPECT_TRUE(map_.begin() == map_.end()); 761 } 762 TEST_P(MapImplTest,Clear)763 TEST_P(MapImplTest, Clear) { 764 int32 key = 0; 765 int32 value = 100; 766 767 map_[key] = value; 768 ExpectSingleElement(key, value); 769 770 map_.clear(); 771 772 EXPECT_TRUE(map_.empty()); 773 EXPECT_EQ(0, map_.size()); 774 EXPECT_TRUE(map_.end() == map_.find(key)); 775 EXPECT_TRUE(map_.begin() == map_.end()); 776 } 777 CopyConstructorHelper(Arena * arena,Map<int32,int32> * m)778 static void CopyConstructorHelper(Arena* arena, Map<int32, int32>* m) { 779 int32 key1 = 0; 780 int32 key2 = 1; 781 int32 value1 = 100; 782 int32 value2 = 101; 783 784 std::map<int32, int32> map; 785 map[key1] = value1; 786 map[key2] = value2; 787 788 m->insert(map.begin(), map.end()); 789 790 Map<int32, int32> other(*m); 791 792 EXPECT_EQ(2, other.size()); 793 EXPECT_EQ(value1, other.at(key1)); 794 EXPECT_EQ(value2, other.at(key2)); 795 } 796 TEST_P(MapImplTest,CopyConstructorWithArena)797 TEST_P(MapImplTest, CopyConstructorWithArena) { 798 Arena a; 799 CopyConstructorHelper(&a, &map_); 800 } 801 TEST_P(MapImplTest,CopyConstructorWithoutArena)802 TEST_P(MapImplTest, CopyConstructorWithoutArena) { 803 CopyConstructorHelper(NULL, &map_); 804 } 805 TEST_P(MapImplTest,IterConstructor)806 TEST_P(MapImplTest, IterConstructor) { 807 int32 key1 = 0; 808 int32 key2 = 1; 809 int32 value1 = 100; 810 int32 value2 = 101; 811 812 std::map<int32, int32> map; 813 map[key1] = value1; 814 map[key2] = value2; 815 816 Map<int32, int32> new_map(map.begin(), map.end(), 817 GetParam()); 818 819 EXPECT_EQ(2, new_map.size()); 820 EXPECT_EQ(value1, new_map.at(key1)); 821 EXPECT_EQ(value2, new_map.at(key2)); 822 } 823 TEST_P(MapImplTest,Assigner)824 TEST_P(MapImplTest, Assigner) { 825 int32 key1 = 0; 826 int32 key2 = 1; 827 int32 value1 = 100; 828 int32 value2 = 101; 829 830 std::map<int32, int32> map; 831 map[key1] = value1; 832 map[key2] = value2; 833 834 map_.insert(map.begin(), map.end()); 835 836 Map<int32, int32> other(GetParam()); 837 int32 key_other = 123; 838 int32 value_other = 321; 839 other[key_other] = value_other; 840 EXPECT_EQ(1, other.size()); 841 842 other = map_; 843 844 EXPECT_EQ(2, other.size()); 845 EXPECT_EQ(value1, other.at(key1)); 846 EXPECT_EQ(value2, other.at(key2)); 847 EXPECT_TRUE(other.find(key_other) == other.end()); 848 849 // Self assign 850 other = other; 851 EXPECT_EQ(2, other.size()); 852 EXPECT_EQ(value1, other.at(key1)); 853 EXPECT_EQ(value2, other.at(key2)); 854 855 // Try assignment to a map with a different choice of "style." 856 Map<int32, int32> m(!GetParam()); 857 m = other; 858 EXPECT_EQ(2, m.size()); 859 EXPECT_EQ(value1, m.at(key1)); 860 EXPECT_EQ(value2, m.at(key2)); 861 } 862 TEST_P(MapImplTest,Rehash)863 TEST_P(MapImplTest, Rehash) { 864 const int test_size = 50; 865 std::map<int32, int32> reference_map; 866 for (int i = 0; i < test_size; i++) { 867 reference_map[i] = i; 868 } 869 for (int i = 0; i < test_size; i++) { 870 map_[i] = reference_map[i]; 871 EXPECT_EQ(reference_map[i], map_[i]); 872 } 873 for (int i = 0; i < test_size; i++) { 874 map_.erase(i); 875 EXPECT_TRUE(map_.end() == map_.find(i)); 876 } 877 EXPECT_TRUE(map_.empty()); 878 } 879 TEST_P(MapImplTest,EqualRange)880 TEST_P(MapImplTest, EqualRange) { 881 int key = 100, key_missing = 101; 882 map_[key] = 100; 883 884 std::pair<google::protobuf::Map<int32, int32>::iterator, 885 google::protobuf::Map<int32, int32>::iterator> range = map_.equal_range(key); 886 EXPECT_TRUE(map_.find(key) == range.first); 887 EXPECT_TRUE(++map_.find(key) == range.second); 888 889 range = map_.equal_range(key_missing); 890 EXPECT_TRUE(map_.end() == range.first); 891 EXPECT_TRUE(map_.end() == range.second); 892 893 std::pair<google::protobuf::Map<int32, int32>::const_iterator, 894 google::protobuf::Map<int32, int32>::const_iterator> const_range = 895 const_map_.equal_range(key); 896 EXPECT_TRUE(const_map_.find(key) == const_range.first); 897 EXPECT_TRUE(++const_map_.find(key) == const_range.second); 898 899 const_range = const_map_.equal_range(key_missing); 900 EXPECT_TRUE(const_map_.end() == const_range.first); 901 EXPECT_TRUE(const_map_.end() == const_range.second); 902 } 903 TEST_P(MapImplTest,ConvertToStdMap)904 TEST_P(MapImplTest, ConvertToStdMap) { 905 map_[100] = 101; 906 std::map<int32, int32> std_map(map_.begin(), map_.end()); 907 EXPECT_EQ(1, std_map.size()); 908 EXPECT_EQ(101, std_map[100]); 909 } 910 TEST_P(MapImplTest,ConvertToStdVectorOfPairs)911 TEST_P(MapImplTest, ConvertToStdVectorOfPairs) { 912 map_[100] = 101; 913 std::vector<std::pair<int32, int32> > std_vec(map_.begin(), map_.end()); 914 EXPECT_EQ(1, std_vec.size()); 915 EXPECT_EQ(100, std_vec[0].first); 916 EXPECT_EQ(101, std_vec[0].second); 917 } 918 TEST_P(MapImplTest,SwapSameStyle)919 TEST_P(MapImplTest, SwapSameStyle) { 920 Map<int32, int32> another(GetParam()); // same old_style_ value 921 map_[9398] = 41999; 922 another[9398] = 41999; 923 another[8070] = 42056; 924 another.swap(map_); 925 EXPECT_THAT(another, testing::UnorderedElementsAre( 926 testing::Pair(9398, 41999))); 927 EXPECT_THAT(map_, testing::UnorderedElementsAre( 928 testing::Pair(8070, 42056), 929 testing::Pair(9398, 41999))); 930 } 931 TEST_P(MapImplTest,SwapDifferentStyle)932 TEST_P(MapImplTest, SwapDifferentStyle) { 933 Map<int32, int32> another(!GetParam()); // different old_style_ value 934 map_[9398] = 41999; 935 another[9398] = 41999; 936 another[8070] = 42056; 937 another.swap(map_); 938 EXPECT_THAT(another, testing::UnorderedElementsAre( 939 testing::Pair(9398, 41999))); 940 EXPECT_THAT(map_, testing::UnorderedElementsAre( 941 testing::Pair(8070, 42056), 942 testing::Pair(9398, 41999))); 943 } 944 TEST_P(MapImplTest,SwapArena)945 TEST_P(MapImplTest, SwapArena) { 946 Arena arena1, arena2; 947 Map<int32, int32> m1(&arena1, false); 948 Map<int32, int32> m2(&arena2, false); 949 map_[9398] = 41999; 950 m1[9398] = 41999; 951 m1[8070] = 42056; 952 m2[10244] = 10247; 953 m2[8070] = 42056; 954 m1.swap(map_); 955 EXPECT_THAT(m1, testing::UnorderedElementsAre( 956 testing::Pair(9398, 41999))); 957 EXPECT_THAT(map_, testing::UnorderedElementsAre( 958 testing::Pair(8070, 42056), 959 testing::Pair(9398, 41999))); 960 m2.swap(m1); 961 EXPECT_THAT(m1, testing::UnorderedElementsAre( 962 testing::Pair(8070, 42056), 963 testing::Pair(10244, 10247))); 964 EXPECT_THAT(m2, testing::UnorderedElementsAre( 965 testing::Pair(9398, 41999))); 966 } 967 968 INSTANTIATE_TEST_CASE_P(BoolSequence, MapImplTest, testing::Bool()); 969 970 // Map Field Reflection Test ======================================== 971 Func(int i,int j)972 static int Func(int i, int j) { 973 return i * j; 974 } 975 StrFunc(int i,int j)976 static string StrFunc(int i, int j) { 977 string str; 978 SStringPrintf(&str, "%d", Func(i, j)); 979 return str; 980 } 981 Int(const string & value)982 static int Int(const string& value) { 983 int result = 0; 984 std::istringstream(value) >> result; 985 return result; 986 } 987 988 class MapFieldReflectionTest : public testing::Test { 989 protected: 990 typedef FieldDescriptor FD; 991 }; 992 TEST_F(MapFieldReflectionTest,RegularFields)993 TEST_F(MapFieldReflectionTest, RegularFields) { 994 TestMap message; 995 const Reflection* refl = message.GetReflection(); 996 const Descriptor* desc = message.GetDescriptor(); 997 998 Map<int32, int32>* map_int32_int32 = message.mutable_map_int32_int32(); 999 Map<int32, double>* map_int32_double = message.mutable_map_int32_double(); 1000 Map<string, string>* map_string_string = message.mutable_map_string_string(); 1001 Map<int32, ForeignMessage>* map_int32_foreign_message = 1002 message.mutable_map_int32_foreign_message(); 1003 1004 for (int i = 0; i < 10; ++i) { 1005 (*map_int32_int32)[i] = Func(i, 1); 1006 (*map_int32_double)[i] = Func(i, 2); 1007 (*map_string_string)[StrFunc(i, 1)] = StrFunc(i, 5); 1008 (*map_int32_foreign_message)[i].set_c(Func(i, 6)); 1009 } 1010 1011 // Get FieldDescriptors for all the fields of interest. 1012 const FieldDescriptor* fd_map_int32_int32 = 1013 desc->FindFieldByName("map_int32_int32"); 1014 const FieldDescriptor* fd_map_int32_double = 1015 desc->FindFieldByName("map_int32_double"); 1016 const FieldDescriptor* fd_map_string_string = 1017 desc->FindFieldByName("map_string_string"); 1018 const FieldDescriptor* fd_map_int32_foreign_message = 1019 desc->FindFieldByName("map_int32_foreign_message"); 1020 1021 const FieldDescriptor* fd_map_int32_in32_key = 1022 fd_map_int32_int32->message_type()->FindFieldByName("key"); 1023 const FieldDescriptor* fd_map_int32_in32_value = 1024 fd_map_int32_int32->message_type()->FindFieldByName("value"); 1025 const FieldDescriptor* fd_map_int32_double_key = 1026 fd_map_int32_double->message_type()->FindFieldByName("key"); 1027 const FieldDescriptor* fd_map_int32_double_value = 1028 fd_map_int32_double->message_type()->FindFieldByName("value"); 1029 const FieldDescriptor* fd_map_string_string_key = 1030 fd_map_string_string->message_type()->FindFieldByName("key"); 1031 const FieldDescriptor* fd_map_string_string_value = 1032 fd_map_string_string->message_type()->FindFieldByName("value"); 1033 const FieldDescriptor* fd_map_int32_foreign_message_key = 1034 fd_map_int32_foreign_message->message_type()->FindFieldByName("key"); 1035 const FieldDescriptor* fd_map_int32_foreign_message_value = 1036 fd_map_int32_foreign_message->message_type()->FindFieldByName("value"); 1037 1038 // Get RepeatedPtrField objects for all fields of interest. 1039 const RepeatedPtrField<Message>& mf_int32_int32 = 1040 refl->GetRepeatedPtrField<Message>(message, fd_map_int32_int32); 1041 const RepeatedPtrField<Message>& mf_int32_double = 1042 refl->GetRepeatedPtrField<Message>(message, fd_map_int32_double); 1043 const RepeatedPtrField<Message>& mf_string_string = 1044 refl->GetRepeatedPtrField<Message>(message, fd_map_string_string); 1045 const RepeatedPtrField<Message>& 1046 mf_int32_foreign_message = 1047 refl->GetRepeatedPtrField<Message>( 1048 message, fd_map_int32_foreign_message); 1049 1050 // Get mutable RepeatedPtrField objects for all fields of interest. 1051 RepeatedPtrField<Message>* mmf_int32_int32 = 1052 refl->MutableRepeatedPtrField<Message>(&message, fd_map_int32_int32); 1053 RepeatedPtrField<Message>* mmf_int32_double = 1054 refl->MutableRepeatedPtrField<Message>(&message, fd_map_int32_double); 1055 RepeatedPtrField<Message>* mmf_string_string = 1056 refl->MutableRepeatedPtrField<Message>(&message, fd_map_string_string); 1057 RepeatedPtrField<Message>* mmf_int32_foreign_message = 1058 refl->MutableRepeatedPtrField<Message>( 1059 &message, fd_map_int32_foreign_message); 1060 1061 // Make sure we can do gets through the RepeatedPtrField objects. 1062 for (int i = 0; i < 10; ++i) { 1063 { 1064 // Check gets through const objects. 1065 const Message& message_int32_int32 = mf_int32_int32.Get(i); 1066 int32 key_int32_int32 = message_int32_int32.GetReflection()->GetInt32( 1067 message_int32_int32, fd_map_int32_in32_key); 1068 int32 value_int32_int32 = message_int32_int32.GetReflection()->GetInt32( 1069 message_int32_int32, fd_map_int32_in32_value); 1070 EXPECT_EQ(value_int32_int32, Func(key_int32_int32, 1)); 1071 1072 const Message& message_int32_double = mf_int32_double.Get(i); 1073 int32 key_int32_double = message_int32_double.GetReflection()->GetInt32( 1074 message_int32_double, fd_map_int32_double_key); 1075 double value_int32_double = 1076 message_int32_double.GetReflection()->GetDouble( 1077 message_int32_double, fd_map_int32_double_value); 1078 EXPECT_EQ(value_int32_double, Func(key_int32_double, 2)); 1079 1080 const Message& message_string_string = mf_string_string.Get(i); 1081 string key_string_string = 1082 message_string_string.GetReflection()->GetString( 1083 message_string_string, fd_map_string_string_key); 1084 string value_string_string = 1085 message_string_string.GetReflection()->GetString( 1086 message_string_string, fd_map_string_string_value); 1087 EXPECT_EQ(value_string_string, StrFunc(Int(key_string_string), 5)); 1088 1089 const Message& message_int32_message = mf_int32_foreign_message.Get(i); 1090 int32 key_int32_message = message_int32_message.GetReflection()->GetInt32( 1091 message_int32_message, fd_map_int32_foreign_message_key); 1092 const ForeignMessage& value_int32_message = 1093 down_cast<const ForeignMessage&>( 1094 message_int32_message.GetReflection() 1095 ->GetMessage(message_int32_message, 1096 fd_map_int32_foreign_message_value)); 1097 EXPECT_EQ(value_int32_message.c(), Func(key_int32_message, 6)); 1098 } 1099 1100 { 1101 // Check gets through mutable objects. 1102 const Message& message_int32_int32 = mmf_int32_int32->Get(i); 1103 int32 key_int32_int32 = message_int32_int32.GetReflection()->GetInt32( 1104 message_int32_int32, fd_map_int32_in32_key); 1105 int32 value_int32_int32 = message_int32_int32.GetReflection()->GetInt32( 1106 message_int32_int32, fd_map_int32_in32_value); 1107 EXPECT_EQ(value_int32_int32, Func(key_int32_int32, 1)); 1108 1109 const Message& message_int32_double = mmf_int32_double->Get(i); 1110 int32 key_int32_double = message_int32_double.GetReflection()->GetInt32( 1111 message_int32_double, fd_map_int32_double_key); 1112 double value_int32_double = 1113 message_int32_double.GetReflection()->GetDouble( 1114 message_int32_double, fd_map_int32_double_value); 1115 EXPECT_EQ(value_int32_double, Func(key_int32_double, 2)); 1116 1117 const Message& message_string_string = mmf_string_string->Get(i); 1118 string key_string_string = 1119 message_string_string.GetReflection()->GetString( 1120 message_string_string, fd_map_string_string_key); 1121 string value_string_string = 1122 message_string_string.GetReflection()->GetString( 1123 message_string_string, fd_map_string_string_value); 1124 EXPECT_EQ(value_string_string, StrFunc(Int(key_string_string), 5)); 1125 1126 const Message& message_int32_message = mmf_int32_foreign_message->Get(i); 1127 int32 key_int32_message = message_int32_message.GetReflection()->GetInt32( 1128 message_int32_message, fd_map_int32_foreign_message_key); 1129 const ForeignMessage& value_int32_message = 1130 down_cast<const ForeignMessage&>( 1131 message_int32_message.GetReflection() 1132 ->GetMessage(message_int32_message, 1133 fd_map_int32_foreign_message_value)); 1134 EXPECT_EQ(value_int32_message.c(), Func(key_int32_message, 6)); 1135 } 1136 } 1137 1138 // Do sets through the RepeatedPtrField objects. 1139 for (int i = 0; i < 10; i++) { 1140 { 1141 Message* message_int32_int32 = mmf_int32_int32->Mutable(i); 1142 int32 key_int32_int32 = message_int32_int32->GetReflection()->GetInt32( 1143 *message_int32_int32, fd_map_int32_in32_key); 1144 message_int32_int32->GetReflection()->SetInt32(message_int32_int32, 1145 fd_map_int32_in32_value, 1146 Func(key_int32_int32, -1)); 1147 1148 Message* message_int32_double = mmf_int32_double->Mutable(i); 1149 int32 key_int32_double = message_int32_double->GetReflection()->GetInt32( 1150 *message_int32_double, fd_map_int32_double_key); 1151 message_int32_double->GetReflection()->SetDouble( 1152 message_int32_double, fd_map_int32_double_value, 1153 Func(key_int32_double, -2)); 1154 1155 Message* message_string_string = mmf_string_string->Mutable(i); 1156 string key_string_string = 1157 message_string_string->GetReflection()->GetString( 1158 *message_string_string, fd_map_string_string_key); 1159 message_string_string->GetReflection()->SetString( 1160 message_string_string, fd_map_string_string_value, 1161 StrFunc(Int(key_string_string), -5)); 1162 1163 Message* message_int32_message = mmf_int32_foreign_message->Mutable(i); 1164 int32 key_int32_message = 1165 message_int32_message->GetReflection()->GetInt32( 1166 *message_int32_message, fd_map_int32_foreign_message_key); 1167 ForeignMessage* value_int32_message = down_cast<ForeignMessage*>( 1168 message_int32_message->GetReflection() 1169 ->MutableMessage(message_int32_message, 1170 fd_map_int32_foreign_message_value)); 1171 value_int32_message->set_c(Func(key_int32_message, -6)); 1172 } 1173 } 1174 1175 // Check gets through mutable objects. 1176 for (int i = 0; i < 10; i++) { 1177 EXPECT_EQ(Func(i, -1), message.map_int32_int32().at(i)); 1178 EXPECT_EQ(Func(i, -2), message.map_int32_double().at(i)); 1179 EXPECT_EQ(StrFunc(i, -5), message.map_string_string().at(StrFunc(i, 1))); 1180 EXPECT_EQ(Func(i, -6), message.map_int32_foreign_message().at(i).c()); 1181 } 1182 } 1183 TEST_F(MapFieldReflectionTest,RepeatedFieldRefForRegularFields)1184 TEST_F(MapFieldReflectionTest, RepeatedFieldRefForRegularFields) { 1185 TestMap message; 1186 const Reflection* refl = message.GetReflection(); 1187 const Descriptor* desc = message.GetDescriptor(); 1188 1189 Map<int32, int32>* map_int32_int32 = message.mutable_map_int32_int32(); 1190 Map<int32, double>* map_int32_double = message.mutable_map_int32_double(); 1191 Map<string, string>* map_string_string = message.mutable_map_string_string(); 1192 Map<int32, ForeignMessage>* map_int32_foreign_message = 1193 message.mutable_map_int32_foreign_message(); 1194 1195 for (int i = 0; i < 10; ++i) { 1196 (*map_int32_int32)[i] = Func(i, 1); 1197 (*map_int32_double)[i] = Func(i, 2); 1198 (*map_string_string)[StrFunc(i, 1)] = StrFunc(i, 5); 1199 (*map_int32_foreign_message)[i].set_c(Func(i, 6)); 1200 } 1201 1202 // Get FieldDescriptors for all the fields of interest. 1203 const FieldDescriptor* fd_map_int32_int32 = 1204 desc->FindFieldByName("map_int32_int32"); 1205 const FieldDescriptor* fd_map_int32_double = 1206 desc->FindFieldByName("map_int32_double"); 1207 const FieldDescriptor* fd_map_string_string = 1208 desc->FindFieldByName("map_string_string"); 1209 const FieldDescriptor* fd_map_int32_foreign_message = 1210 desc->FindFieldByName("map_int32_foreign_message"); 1211 1212 const FieldDescriptor* fd_map_int32_in32_key = 1213 fd_map_int32_int32->message_type()->FindFieldByName("key"); 1214 const FieldDescriptor* fd_map_int32_in32_value = 1215 fd_map_int32_int32->message_type()->FindFieldByName("value"); 1216 const FieldDescriptor* fd_map_int32_double_key = 1217 fd_map_int32_double->message_type()->FindFieldByName("key"); 1218 const FieldDescriptor* fd_map_int32_double_value = 1219 fd_map_int32_double->message_type()->FindFieldByName("value"); 1220 const FieldDescriptor* fd_map_string_string_key = 1221 fd_map_string_string->message_type()->FindFieldByName("key"); 1222 const FieldDescriptor* fd_map_string_string_value = 1223 fd_map_string_string->message_type()->FindFieldByName("value"); 1224 const FieldDescriptor* fd_map_int32_foreign_message_key = 1225 fd_map_int32_foreign_message->message_type()->FindFieldByName("key"); 1226 const FieldDescriptor* fd_map_int32_foreign_message_value = 1227 fd_map_int32_foreign_message->message_type()->FindFieldByName("value"); 1228 1229 // Get RepeatedFieldRef objects for all fields of interest. 1230 const RepeatedFieldRef<Message> mf_int32_int32 = 1231 refl->GetRepeatedFieldRef<Message>(message, fd_map_int32_int32); 1232 const RepeatedFieldRef<Message> mf_int32_double = 1233 refl->GetRepeatedFieldRef<Message>(message, fd_map_int32_double); 1234 const RepeatedFieldRef<Message> mf_string_string = 1235 refl->GetRepeatedFieldRef<Message>(message, fd_map_string_string); 1236 const RepeatedFieldRef<Message> mf_int32_foreign_message = 1237 refl->GetRepeatedFieldRef<Message>(message, fd_map_int32_foreign_message); 1238 1239 // Get mutable RepeatedFieldRef objects for all fields of interest. 1240 const MutableRepeatedFieldRef<Message> mmf_int32_int32 = 1241 refl->GetMutableRepeatedFieldRef<Message>(&message, fd_map_int32_int32); 1242 const MutableRepeatedFieldRef<Message> mmf_int32_double = 1243 refl->GetMutableRepeatedFieldRef<Message>(&message, fd_map_int32_double); 1244 const MutableRepeatedFieldRef<Message> mmf_string_string = 1245 refl->GetMutableRepeatedFieldRef<Message>(&message, fd_map_string_string); 1246 const MutableRepeatedFieldRef<Message> 1247 mmf_int32_foreign_message = 1248 refl->GetMutableRepeatedFieldRef<Message>( 1249 &message, fd_map_int32_foreign_message); 1250 1251 // Get entry default instances 1252 google::protobuf::scoped_ptr<Message> entry_int32_int32( 1253 MessageFactory::generated_factory() 1254 ->GetPrototype(fd_map_int32_int32->message_type()) 1255 ->New()); 1256 google::protobuf::scoped_ptr<Message> entry_int32_double( 1257 MessageFactory::generated_factory() 1258 ->GetPrototype(fd_map_int32_double->message_type()) 1259 ->New()); 1260 google::protobuf::scoped_ptr<Message> entry_string_string( 1261 MessageFactory::generated_factory() 1262 ->GetPrototype(fd_map_string_string->message_type()) 1263 ->New()); 1264 google::protobuf::scoped_ptr<Message> entry_int32_foreign_message( 1265 MessageFactory::generated_factory() 1266 ->GetPrototype(fd_map_int32_foreign_message->message_type()) 1267 ->New()); 1268 1269 EXPECT_EQ(10, mf_int32_int32.size()); 1270 EXPECT_EQ(10, mmf_int32_int32.size()); 1271 EXPECT_EQ(10, mf_int32_double.size()); 1272 EXPECT_EQ(10, mmf_int32_double.size()); 1273 EXPECT_EQ(10, mf_string_string.size()); 1274 EXPECT_EQ(10, mmf_string_string.size()); 1275 EXPECT_EQ(10, mf_int32_foreign_message.size()); 1276 EXPECT_EQ(10, mmf_int32_foreign_message.size()); 1277 1278 EXPECT_FALSE(mf_int32_int32.empty()); 1279 EXPECT_FALSE(mmf_int32_int32.empty()); 1280 EXPECT_FALSE(mf_int32_double.empty()); 1281 EXPECT_FALSE(mmf_int32_double.empty()); 1282 EXPECT_FALSE(mf_string_string.empty()); 1283 EXPECT_FALSE(mmf_string_string.empty()); 1284 EXPECT_FALSE(mf_int32_foreign_message.empty()); 1285 EXPECT_FALSE(mmf_int32_foreign_message.empty()); 1286 1287 // Make sure we can do gets through the RepeatedFieldRef objects. 1288 for (int i = 0; i < 10; ++i) { 1289 { 1290 // Check gets through const objects. 1291 const Message& message_int32_int32 = 1292 mf_int32_int32.Get(i, entry_int32_int32.get()); 1293 int32 key_int32_int32 = message_int32_int32.GetReflection()->GetInt32( 1294 message_int32_int32, fd_map_int32_in32_key); 1295 int32 value_int32_int32 = message_int32_int32.GetReflection()->GetInt32( 1296 message_int32_int32, fd_map_int32_in32_value); 1297 EXPECT_EQ(value_int32_int32, Func(key_int32_int32, 1)); 1298 1299 const Message& message_int32_double = 1300 mf_int32_double.Get(i, entry_int32_double.get()); 1301 int32 key_int32_double = message_int32_double.GetReflection()->GetInt32( 1302 message_int32_double, fd_map_int32_double_key); 1303 double value_int32_double = 1304 message_int32_double.GetReflection()->GetDouble( 1305 message_int32_double, fd_map_int32_double_value); 1306 EXPECT_EQ(value_int32_double, Func(key_int32_double, 2)); 1307 1308 const Message& message_string_string = 1309 mf_string_string.Get(i, entry_string_string.get()); 1310 string key_string_string = 1311 message_string_string.GetReflection()->GetString( 1312 message_string_string, fd_map_string_string_key); 1313 string value_string_string = 1314 message_string_string.GetReflection()->GetString( 1315 message_string_string, fd_map_string_string_value); 1316 EXPECT_EQ(value_string_string, StrFunc(Int(key_string_string), 5)); 1317 1318 const Message& message_int32_message = 1319 mf_int32_foreign_message.Get(i, entry_int32_foreign_message.get()); 1320 int32 key_int32_message = message_int32_message.GetReflection()->GetInt32( 1321 message_int32_message, fd_map_int32_foreign_message_key); 1322 const ForeignMessage& value_int32_message = 1323 down_cast<const ForeignMessage&>( 1324 message_int32_message.GetReflection() 1325 ->GetMessage(message_int32_message, 1326 fd_map_int32_foreign_message_value)); 1327 EXPECT_EQ(value_int32_message.c(), Func(key_int32_message, 6)); 1328 } 1329 1330 { 1331 // Check gets through mutable objects. 1332 const Message& message_int32_int32 = 1333 mmf_int32_int32.Get(i, entry_int32_int32.get()); 1334 int32 key_int32_int32 = message_int32_int32.GetReflection()->GetInt32( 1335 message_int32_int32, fd_map_int32_in32_key); 1336 int32 value_int32_int32 = message_int32_int32.GetReflection()->GetInt32( 1337 message_int32_int32, fd_map_int32_in32_value); 1338 EXPECT_EQ(value_int32_int32, Func(key_int32_int32, 1)); 1339 1340 const Message& message_int32_double = 1341 mmf_int32_double.Get(i, entry_int32_double.get()); 1342 int32 key_int32_double = message_int32_double.GetReflection()->GetInt32( 1343 message_int32_double, fd_map_int32_double_key); 1344 double value_int32_double = 1345 message_int32_double.GetReflection()->GetDouble( 1346 message_int32_double, fd_map_int32_double_value); 1347 EXPECT_EQ(value_int32_double, Func(key_int32_double, 2)); 1348 1349 const Message& message_string_string = 1350 mmf_string_string.Get(i, entry_string_string.get()); 1351 string key_string_string = 1352 message_string_string.GetReflection()->GetString( 1353 message_string_string, fd_map_string_string_key); 1354 string value_string_string = 1355 message_string_string.GetReflection()->GetString( 1356 message_string_string, fd_map_string_string_value); 1357 EXPECT_EQ(value_string_string, StrFunc(Int(key_string_string), 5)); 1358 1359 const Message& message_int32_message = 1360 mmf_int32_foreign_message.Get(i, entry_int32_foreign_message.get()); 1361 int32 key_int32_message = message_int32_message.GetReflection()->GetInt32( 1362 message_int32_message, fd_map_int32_foreign_message_key); 1363 const ForeignMessage& value_int32_message = 1364 down_cast<const ForeignMessage&>( 1365 message_int32_message.GetReflection() 1366 ->GetMessage(message_int32_message, 1367 fd_map_int32_foreign_message_value)); 1368 EXPECT_EQ(value_int32_message.c(), Func(key_int32_message, 6)); 1369 } 1370 } 1371 1372 // Make sure we can do sets through the RepeatedFieldRef objects. 1373 for (int i = 0; i < 10; i++) { 1374 const Message& message_int32_int32 = 1375 mmf_int32_int32.Get(i, entry_int32_int32.get()); 1376 int key = message_int32_int32.GetReflection()->GetInt32( 1377 message_int32_int32, fd_map_int32_in32_key); 1378 1379 entry_int32_int32->GetReflection()->SetInt32( 1380 entry_int32_int32.get(), fd_map_int32_int32->message_type()->field(0), 1381 key); 1382 entry_int32_int32->GetReflection()->SetInt32( 1383 entry_int32_int32.get(), fd_map_int32_int32->message_type()->field(1), 1384 Func(key, -1)); 1385 entry_int32_double->GetReflection()->SetInt32( 1386 entry_int32_double.get(), fd_map_int32_double->message_type()->field(0), 1387 key); 1388 entry_int32_double->GetReflection()->SetDouble( 1389 entry_int32_double.get(), fd_map_int32_double->message_type()->field(1), 1390 Func(key, -2)); 1391 entry_string_string->GetReflection()->SetString( 1392 entry_string_string.get(), 1393 fd_map_string_string->message_type()->field(0), StrFunc(key, 1)); 1394 entry_string_string->GetReflection()->SetString( 1395 entry_string_string.get(), 1396 fd_map_string_string->message_type()->field(1), StrFunc(key, -5)); 1397 entry_int32_foreign_message->GetReflection()->SetInt32( 1398 entry_int32_foreign_message.get(), 1399 fd_map_int32_foreign_message->message_type()->field(0), key); 1400 Message* value_message = 1401 entry_int32_foreign_message->GetReflection()->MutableMessage( 1402 entry_int32_foreign_message.get(), 1403 fd_map_int32_foreign_message->message_type()->field(1)); 1404 value_message->GetReflection()->SetInt32( 1405 value_message, value_message->GetDescriptor()->FindFieldByName("c"), 1406 Func(key, -6)); 1407 1408 mmf_int32_int32.Set(i, *entry_int32_int32); 1409 mmf_int32_double.Set(i, *entry_int32_double); 1410 mmf_string_string.Set(i, *entry_string_string); 1411 mmf_int32_foreign_message.Set(i, *entry_int32_foreign_message); 1412 } 1413 1414 for (int i = 0; i < 10; i++) { 1415 EXPECT_EQ(Func(i, -1), message.map_int32_int32().at(i)); 1416 EXPECT_EQ(Func(i, -2), message.map_int32_double().at(i)); 1417 EXPECT_EQ(StrFunc(i, -5), message.map_string_string().at(StrFunc(i, 1))); 1418 EXPECT_EQ(Func(i, -6), message.map_int32_foreign_message().at(i).c()); 1419 } 1420 1421 // Test iterators. 1422 { 1423 int index = 0; 1424 hash_map<int32, int32> result; 1425 for (RepeatedFieldRef<Message>::iterator it = mf_int32_int32.begin(); 1426 it != mf_int32_int32.end(); ++it) { 1427 const Message& message = *it; 1428 int32 key = 1429 message.GetReflection()->GetInt32(message, fd_map_int32_in32_key); 1430 int32 value = 1431 message.GetReflection()->GetInt32(message, fd_map_int32_in32_value); 1432 result[key] = value; 1433 ++index; 1434 } 1435 EXPECT_EQ(10, index); 1436 for (hash_map<int32, int32>::const_iterator it = result.begin(); 1437 it != result.end(); ++it) { 1438 EXPECT_EQ(message.map_int32_int32().at(it->first), it->second); 1439 } 1440 } 1441 1442 { 1443 int index = 0; 1444 hash_map<int32, double> result; 1445 for (RepeatedFieldRef<Message>::iterator it = mf_int32_double.begin(); 1446 it != mf_int32_double.end(); ++it) { 1447 const Message& message = *it; 1448 int32 key = 1449 message.GetReflection()->GetInt32(message, fd_map_int32_double_key); 1450 double value = message.GetReflection()->GetDouble( 1451 message, fd_map_int32_double_value); 1452 result[key] = value; 1453 ++index; 1454 } 1455 EXPECT_EQ(10, index); 1456 for (hash_map<int32, double>::const_iterator it = result.begin(); 1457 it != result.end(); ++it) { 1458 EXPECT_EQ(message.map_int32_double().at(it->first), it->second); 1459 } 1460 } 1461 1462 { 1463 int index = 0; 1464 hash_map<string, string> result; 1465 for (RepeatedFieldRef<Message>::iterator it = mf_string_string.begin(); 1466 it != mf_string_string.end(); ++it) { 1467 const Message& message = *it; 1468 string key = 1469 message.GetReflection()->GetString(message, fd_map_string_string_key); 1470 string value = message.GetReflection()->GetString( 1471 message, fd_map_string_string_value); 1472 result[key] = value; 1473 ++index; 1474 } 1475 EXPECT_EQ(10, index); 1476 for (hash_map<string, string>::const_iterator it = result.begin(); 1477 it != result.end(); ++it) { 1478 EXPECT_EQ(message.map_string_string().at(it->first), it->second); 1479 } 1480 } 1481 1482 { 1483 int index = 0; 1484 std::map<int32, ForeignMessage> result; 1485 for (RepeatedFieldRef<Message>::iterator it = 1486 mf_int32_foreign_message.begin(); 1487 it != mf_int32_foreign_message.end(); ++it) { 1488 const Message& message = *it; 1489 int32 key = message.GetReflection()->GetInt32( 1490 message, fd_map_int32_foreign_message_key); 1491 const ForeignMessage& sub_message = down_cast<const ForeignMessage&>( 1492 message.GetReflection() 1493 ->GetMessage(message, fd_map_int32_foreign_message_value)); 1494 result[key].MergeFrom(sub_message); 1495 ++index; 1496 } 1497 EXPECT_EQ(10, index); 1498 for (std::map<int32, ForeignMessage>::const_iterator it = result.begin(); 1499 it != result.end(); ++it) { 1500 EXPECT_EQ(message.map_int32_foreign_message().at(it->first).c(), 1501 it->second.c()); 1502 } 1503 } 1504 1505 // Test MutableRepeatedFieldRef::Add() 1506 entry_int32_int32->GetReflection()->SetInt32( 1507 entry_int32_int32.get(), fd_map_int32_int32->message_type()->field(0), 1508 4321); 1509 entry_int32_int32->GetReflection()->SetInt32( 1510 entry_int32_int32.get(), fd_map_int32_int32->message_type()->field(1), 1511 1234); 1512 mmf_int32_int32.Add(*entry_int32_int32); 1513 EXPECT_EQ(1234, message.map_int32_int32().at(4321)); 1514 1515 entry_int32_double->GetReflection()->SetInt32( 1516 entry_int32_double.get(), fd_map_int32_double->message_type()->field(0), 1517 4321); 1518 entry_int32_double->GetReflection()->SetDouble( 1519 entry_int32_double.get(), fd_map_int32_double->message_type()->field(1), 1520 1234.0); 1521 mmf_int32_double.Add(*entry_int32_double); 1522 EXPECT_EQ(1234.0, message.map_int32_double().at(4321)); 1523 1524 entry_string_string->GetReflection()->SetString( 1525 entry_string_string.get(), 1526 fd_map_string_string->message_type()->field(0), "4321"); 1527 entry_string_string->GetReflection()->SetString( 1528 entry_string_string.get(), fd_map_string_string->message_type()->field(1), 1529 "1234"); 1530 mmf_string_string.Add(*entry_string_string); 1531 EXPECT_EQ("1234", message.map_string_string().at("4321")); 1532 1533 entry_int32_foreign_message->GetReflection()->SetInt32( 1534 entry_int32_foreign_message.get(), 1535 fd_map_int32_foreign_message->message_type()->field(0), 4321); 1536 Message* value_message = 1537 entry_int32_foreign_message->GetReflection()->MutableMessage( 1538 entry_int32_foreign_message.get(), 1539 fd_map_int32_foreign_message->message_type()->field(1)); 1540 ForeignMessage foreign_message; 1541 foreign_message.set_c(1234); 1542 value_message->CopyFrom(foreign_message); 1543 1544 mmf_int32_foreign_message.Add(*entry_int32_foreign_message); 1545 EXPECT_EQ(1234, message.map_int32_foreign_message().at(4321).c()); 1546 1547 // Test Reflection::AddAllocatedMessage 1548 Message* free_entry_string_string = MessageFactory::generated_factory() 1549 ->GetPrototype(fd_map_string_string->message_type()) 1550 ->New(); 1551 entry_string_string->GetReflection()->SetString( 1552 free_entry_string_string, 1553 fd_map_string_string->message_type()->field(0), "4321"); 1554 entry_string_string->GetReflection()->SetString( 1555 free_entry_string_string, fd_map_string_string->message_type()->field(1), 1556 "1234"); 1557 refl->AddAllocatedMessage(&message, fd_map_string_string, 1558 free_entry_string_string); 1559 1560 // Test MutableRepeatedFieldRef::RemoveLast() 1561 mmf_int32_int32.RemoveLast(); 1562 mmf_int32_double.RemoveLast(); 1563 mmf_string_string.RemoveLast(); 1564 mmf_int32_foreign_message.RemoveLast(); 1565 EXPECT_EQ(10, message.map_int32_int32().size()); 1566 EXPECT_EQ(10, message.map_int32_double().size()); 1567 EXPECT_EQ(11, message.map_string_string().size()); 1568 EXPECT_EQ(10, message.map_int32_foreign_message().size()); 1569 1570 // Test MutableRepeatedFieldRef::SwapElements() 1571 { 1572 const Message& message0a = mmf_int32_int32.Get(0, entry_int32_int32.get()); 1573 int32 int32_value0a = 1574 message0a.GetReflection()->GetInt32(message0a, fd_map_int32_in32_value); 1575 const Message& message9a = mmf_int32_int32.Get(9, entry_int32_int32.get()); 1576 int32 int32_value9a = 1577 message9a.GetReflection()->GetInt32(message9a, fd_map_int32_in32_value); 1578 1579 mmf_int32_int32.SwapElements(0, 9); 1580 1581 const Message& message0b = mmf_int32_int32.Get(0, entry_int32_int32.get()); 1582 int32 int32_value0b = 1583 message0b.GetReflection()->GetInt32(message0b, fd_map_int32_in32_value); 1584 const Message& message9b = mmf_int32_int32.Get(9, entry_int32_int32.get()); 1585 int32 int32_value9b = 1586 message9b.GetReflection()->GetInt32(message9b, fd_map_int32_in32_value); 1587 1588 EXPECT_EQ(int32_value9a, int32_value0b); 1589 EXPECT_EQ(int32_value0a, int32_value9b); 1590 } 1591 1592 { 1593 const Message& message0a = 1594 mmf_int32_double.Get(0, entry_int32_double.get()); 1595 double double_value0a = message0a.GetReflection()->GetDouble( 1596 message0a, fd_map_int32_double_value); 1597 const Message& message9a = 1598 mmf_int32_double.Get(9, entry_int32_double.get()); 1599 double double_value9a = message9a.GetReflection()->GetDouble( 1600 message9a, fd_map_int32_double_value); 1601 1602 mmf_int32_double.SwapElements(0, 9); 1603 1604 const Message& message0b = 1605 mmf_int32_double.Get(0, entry_int32_double.get()); 1606 double double_value0b = message0b.GetReflection()->GetDouble( 1607 message0b, fd_map_int32_double_value); 1608 const Message& message9b = 1609 mmf_int32_double.Get(9, entry_int32_double.get()); 1610 double double_value9b = message9b.GetReflection()->GetDouble( 1611 message9b, fd_map_int32_double_value); 1612 1613 EXPECT_EQ(double_value9a, double_value0b); 1614 EXPECT_EQ(double_value0a, double_value9b); 1615 } 1616 1617 { 1618 const Message& message0a = 1619 mmf_string_string.Get(0, entry_string_string.get()); 1620 string string_value0a = message0a.GetReflection()->GetString( 1621 message0a, fd_map_string_string_value); 1622 const Message& message9a = 1623 mmf_string_string.Get(9, entry_string_string.get()); 1624 string string_value9a = message9a.GetReflection()->GetString( 1625 message9a, fd_map_string_string_value); 1626 1627 mmf_string_string.SwapElements(0, 9); 1628 1629 const Message& message0b = 1630 mmf_string_string.Get(0, entry_string_string.get()); 1631 string string_value0b = message0b.GetReflection()->GetString( 1632 message0b, fd_map_string_string_value); 1633 const Message& message9b = 1634 mmf_string_string.Get(9, entry_string_string.get()); 1635 string string_value9b = message9b.GetReflection()->GetString( 1636 message9b, fd_map_string_string_value); 1637 1638 EXPECT_EQ(string_value9a, string_value0b); 1639 EXPECT_EQ(string_value0a, string_value9b); 1640 } 1641 1642 { 1643 const Message& message0a = 1644 mmf_int32_foreign_message.Get(0, entry_int32_foreign_message.get()); 1645 const ForeignMessage& sub_message0a = down_cast<const ForeignMessage&>( 1646 message0a.GetReflection() 1647 ->GetMessage(message0a, fd_map_int32_foreign_message_value)); 1648 int32 int32_value0a = sub_message0a.c(); 1649 const Message& message9a = 1650 mmf_int32_foreign_message.Get(9, entry_int32_foreign_message.get()); 1651 const ForeignMessage& sub_message9a = down_cast<const ForeignMessage&>( 1652 message9a.GetReflection() 1653 ->GetMessage(message9a, fd_map_int32_foreign_message_value)); 1654 int32 int32_value9a = sub_message9a.c(); 1655 1656 mmf_int32_foreign_message.SwapElements(0, 9); 1657 1658 const Message& message0b = 1659 mmf_int32_foreign_message.Get(0, entry_int32_foreign_message.get()); 1660 const ForeignMessage& sub_message0b = down_cast<const ForeignMessage&>( 1661 message0b.GetReflection() 1662 ->GetMessage(message0b, fd_map_int32_foreign_message_value)); 1663 int32 int32_value0b = sub_message0b.c(); 1664 const Message& message9b = 1665 mmf_int32_foreign_message.Get(9, entry_int32_foreign_message.get()); 1666 const ForeignMessage& sub_message9b = down_cast<const ForeignMessage&>( 1667 message9b.GetReflection() 1668 ->GetMessage(message9b, fd_map_int32_foreign_message_value)); 1669 int32 int32_value9b = sub_message9b.c(); 1670 1671 EXPECT_EQ(int32_value9a, int32_value0b); 1672 EXPECT_EQ(int32_value0a, int32_value9b); 1673 } 1674 } 1675 TEST_F(MapFieldReflectionTest,RepeatedFieldRefMergeFromAndSwap)1676 TEST_F(MapFieldReflectionTest, RepeatedFieldRefMergeFromAndSwap) { 1677 // Set-up message content. 1678 TestMap m0, m1, m2; 1679 for (int i = 0; i < 10; ++i) { 1680 (*m0.mutable_map_int32_int32())[i] = Func(i, 1); 1681 (*m0.mutable_map_int32_double())[i] = Func(i, 2); 1682 (*m0.mutable_map_string_string())[StrFunc(i, 1)] = StrFunc(i, 5); 1683 (*m0.mutable_map_int32_foreign_message())[i].set_c(Func(i, 6)); 1684 (*m1.mutable_map_int32_int32())[i + 10] = Func(i, 11); 1685 (*m1.mutable_map_int32_double())[i + 10] = Func(i, 12); 1686 (*m1.mutable_map_string_string())[StrFunc(i + 10, 1)] = StrFunc(i, 15); 1687 (*m1.mutable_map_int32_foreign_message())[i + 10].set_c(Func(i, 16)); 1688 (*m2.mutable_map_int32_int32())[i + 20] = Func(i, 21); 1689 (*m2.mutable_map_int32_double())[i + 20] = Func(i, 22); 1690 (*m2.mutable_map_string_string())[StrFunc(i + 20, 1)] = StrFunc(i, 25); 1691 (*m2.mutable_map_int32_foreign_message())[i + 20].set_c(Func(i, 26)); 1692 } 1693 1694 const Reflection* refl = m0.GetReflection(); 1695 const Descriptor* desc = m0.GetDescriptor(); 1696 1697 // Get FieldDescriptors for all the fields of interest. 1698 const FieldDescriptor* fd_map_int32_int32 = 1699 desc->FindFieldByName("map_int32_int32"); 1700 const FieldDescriptor* fd_map_int32_double = 1701 desc->FindFieldByName("map_int32_double"); 1702 const FieldDescriptor* fd_map_string_string = 1703 desc->FindFieldByName("map_string_string"); 1704 const FieldDescriptor* fd_map_int32_foreign_message = 1705 desc->FindFieldByName("map_int32_foreign_message"); 1706 1707 // Get MutableRepeatedFieldRef objects for all fields of interest. 1708 const MutableRepeatedFieldRef<Message> mmf_int32_int32 = 1709 refl->GetMutableRepeatedFieldRef<Message>( 1710 &m0, fd_map_int32_int32); 1711 const MutableRepeatedFieldRef<Message> mmf_int32_double = 1712 refl->GetMutableRepeatedFieldRef<Message>( 1713 &m0, fd_map_int32_double); 1714 const MutableRepeatedFieldRef<Message> mmf_string_string = 1715 refl->GetMutableRepeatedFieldRef<Message>( 1716 &m0, fd_map_string_string); 1717 const MutableRepeatedFieldRef<Message> 1718 mmf_int32_foreign_message = 1719 refl->GetMutableRepeatedFieldRef<Message>( 1720 &m0, fd_map_int32_foreign_message); 1721 1722 // Test MutableRepeatedRef::CopyFrom 1723 mmf_int32_int32.CopyFrom( 1724 refl->GetRepeatedFieldRef<Message>( 1725 m1, fd_map_int32_int32)); 1726 mmf_int32_double.CopyFrom( 1727 refl->GetRepeatedFieldRef<Message>( 1728 m1, fd_map_int32_double)); 1729 mmf_string_string.CopyFrom( 1730 refl->GetRepeatedFieldRef<Message>( 1731 m1, fd_map_string_string)); 1732 mmf_int32_foreign_message.CopyFrom( 1733 refl->GetRepeatedFieldRef<Message>( 1734 m1, fd_map_int32_foreign_message)); 1735 1736 for (int i = 0; i < 10; ++i) { 1737 EXPECT_EQ(Func(i, 11), m0.map_int32_int32().at(i + 10)); 1738 EXPECT_EQ(Func(i, 12), m0.map_int32_double().at(i + 10)); 1739 EXPECT_EQ(StrFunc(i, 15), m0.map_string_string().at(StrFunc(i + 10, 1))); 1740 EXPECT_EQ(Func(i, 16), m0.map_int32_foreign_message().at(i + 10).c()); 1741 } 1742 1743 // Test MutableRepeatedRef::MergeFrom 1744 mmf_int32_int32.MergeFrom( 1745 refl->GetRepeatedFieldRef<Message>( 1746 m2, fd_map_int32_int32)); 1747 mmf_int32_double.MergeFrom( 1748 refl->GetRepeatedFieldRef<Message>( 1749 m2, fd_map_int32_double)); 1750 mmf_string_string.MergeFrom( 1751 refl->GetRepeatedFieldRef<Message>( 1752 m2, fd_map_string_string)); 1753 mmf_int32_foreign_message.MergeFrom( 1754 refl->GetRepeatedFieldRef<Message>( 1755 m2, fd_map_int32_foreign_message)); 1756 for (int i = 0; i < 10; ++i) { 1757 EXPECT_EQ(Func(i, 21), m0.map_int32_int32().at(i + 20)); 1758 EXPECT_EQ(Func(i, 22), m0.map_int32_double().at(i + 20)); 1759 EXPECT_EQ(StrFunc(i, 25), m0.map_string_string().at(StrFunc(i + 20, 1))); 1760 EXPECT_EQ(Func(i, 26), m0.map_int32_foreign_message().at(i + 20).c()); 1761 } 1762 1763 // Test MutableRepeatedRef::Swap 1764 // Swap between m0 and m2. 1765 mmf_int32_int32.Swap( 1766 refl->GetMutableRepeatedFieldRef<Message>( 1767 &m2, fd_map_int32_int32)); 1768 mmf_int32_double.Swap( 1769 refl->GetMutableRepeatedFieldRef<Message>( 1770 &m2, fd_map_int32_double)); 1771 mmf_string_string.Swap( 1772 refl->GetMutableRepeatedFieldRef<Message>( 1773 &m2, fd_map_string_string)); 1774 mmf_int32_foreign_message.Swap( 1775 refl->GetMutableRepeatedFieldRef<Message>( 1776 &m2, fd_map_int32_foreign_message)); 1777 for (int i = 0; i < 10; ++i) { 1778 // Check the content of m0. 1779 EXPECT_EQ(Func(i, 21), m0.map_int32_int32().at(i + 20)); 1780 EXPECT_EQ(Func(i, 22), m0.map_int32_double().at(i + 20)); 1781 EXPECT_EQ(StrFunc(i, 25), m0.map_string_string().at(StrFunc(i + 20, 1))); 1782 EXPECT_EQ(Func(i, 26), m0.map_int32_foreign_message().at(i + 20).c()); 1783 1784 // Check the content of m2. 1785 EXPECT_EQ(Func(i, 11), m2.map_int32_int32().at(i + 10)); 1786 EXPECT_EQ(Func(i, 12), m2.map_int32_double().at(i + 10)); 1787 EXPECT_EQ(StrFunc(i, 15), m2.map_string_string().at(StrFunc(i + 10, 1))); 1788 EXPECT_EQ(Func(i, 16), m2.map_int32_foreign_message().at(i + 10).c()); 1789 EXPECT_EQ(Func(i, 21), m2.map_int32_int32().at(i + 20)); 1790 EXPECT_EQ(Func(i, 22), m2.map_int32_double().at(i + 20)); 1791 EXPECT_EQ(StrFunc(i, 25), m2.map_string_string().at(StrFunc(i + 20, 1))); 1792 EXPECT_EQ(Func(i, 26), m2.map_int32_foreign_message().at(i + 20).c()); 1793 } 1794 1795 // TODO(teboring): add test for duplicated key 1796 } 1797 1798 // Generated Message Test =========================================== 1799 TEST(GeneratedMapFieldTest,Accessors)1800 TEST(GeneratedMapFieldTest, Accessors) { 1801 unittest::TestMap message; 1802 1803 MapTestUtil::SetMapFields(&message); 1804 MapTestUtil::ExpectMapFieldsSet(message); 1805 1806 MapTestUtil::ModifyMapFields(&message); 1807 MapTestUtil::ExpectMapFieldsModified(message); 1808 } 1809 TEST(GeneratedMapFieldTest,SetMapFieldsInitialized)1810 TEST(GeneratedMapFieldTest, SetMapFieldsInitialized) { 1811 unittest::TestMap message; 1812 1813 MapTestUtil::SetMapFieldsInitialized(&message); 1814 MapTestUtil::ExpectMapFieldsSetInitialized(message); 1815 } 1816 TEST(GeneratedMapFieldTest,Proto2SetMapFieldsInitialized)1817 TEST(GeneratedMapFieldTest, Proto2SetMapFieldsInitialized) { 1818 unittest::TestEnumMap message; 1819 EXPECT_EQ(unittest::PROTO2_MAP_ENUM_FOO, 1820 (*message.mutable_known_map_field())[0]); 1821 } 1822 TEST(GeneratedMapFieldTest,Clear)1823 TEST(GeneratedMapFieldTest, Clear) { 1824 unittest::TestMap message; 1825 1826 MapTestUtil::SetMapFields(&message); 1827 message.Clear(); 1828 MapTestUtil::ExpectClear(message); 1829 } 1830 TEST(GeneratedMapFieldTest,ClearMessageMap)1831 TEST(GeneratedMapFieldTest, ClearMessageMap) { 1832 unittest::TestMessageMap message; 1833 1834 // Creates a TestAllTypes with default value 1835 TestUtil::ExpectClear((*message.mutable_map_int32_message())[0]); 1836 } 1837 TEST(GeneratedMapFieldTest,CopyFrom)1838 TEST(GeneratedMapFieldTest, CopyFrom) { 1839 unittest::TestMap message1, message2; 1840 1841 MapTestUtil::SetMapFields(&message1); 1842 message2.CopyFrom(message1); 1843 MapTestUtil::ExpectMapFieldsSet(message2); 1844 1845 // Copying from self should be a no-op. 1846 message2.CopyFrom(message2); 1847 MapTestUtil::ExpectMapFieldsSet(message2); 1848 } 1849 TEST(GeneratedMapFieldTest,CopyFromMessageMap)1850 TEST(GeneratedMapFieldTest, CopyFromMessageMap) { 1851 unittest::TestMessageMap message1, message2; 1852 1853 (*message1.mutable_map_int32_message())[0].add_repeated_int32(100); 1854 (*message2.mutable_map_int32_message())[0].add_repeated_int32(101); 1855 1856 message1.CopyFrom(message2); 1857 1858 // Checks repeated field is overwritten. 1859 EXPECT_EQ(1, message1.map_int32_message().at(0).repeated_int32_size()); 1860 EXPECT_EQ(101, message1.map_int32_message().at(0).repeated_int32(0)); 1861 } 1862 TEST(GeneratedMapFieldTest,SwapWithEmpty)1863 TEST(GeneratedMapFieldTest, SwapWithEmpty) { 1864 unittest::TestMap message1, message2; 1865 1866 MapTestUtil::SetMapFields(&message1); 1867 MapTestUtil::ExpectMapFieldsSet(message1); 1868 MapTestUtil::ExpectClear(message2); 1869 1870 message1.Swap(&message2); 1871 MapTestUtil::ExpectMapFieldsSet(message2); 1872 MapTestUtil::ExpectClear(message1); 1873 } 1874 TEST(GeneratedMapFieldTest,SwapWithSelf)1875 TEST(GeneratedMapFieldTest, SwapWithSelf) { 1876 unittest::TestMap message; 1877 1878 MapTestUtil::SetMapFields(&message); 1879 MapTestUtil::ExpectMapFieldsSet(message); 1880 1881 message.Swap(&message); 1882 MapTestUtil::ExpectMapFieldsSet(message); 1883 } 1884 TEST(GeneratedMapFieldTest,SwapWithOther)1885 TEST(GeneratedMapFieldTest, SwapWithOther) { 1886 unittest::TestMap message1, message2; 1887 1888 MapTestUtil::SetMapFields(&message1); 1889 MapTestUtil::SetMapFields(&message2); 1890 MapTestUtil::ModifyMapFields(&message2); 1891 1892 message1.Swap(&message2); 1893 MapTestUtil::ExpectMapFieldsModified(message1); 1894 MapTestUtil::ExpectMapFieldsSet(message2); 1895 } 1896 TEST(GeneratedMapFieldTest,CopyConstructor)1897 TEST(GeneratedMapFieldTest, CopyConstructor) { 1898 unittest::TestMap message1; 1899 MapTestUtil::SetMapFields(&message1); 1900 1901 unittest::TestMap message2(message1); 1902 MapTestUtil::ExpectMapFieldsSet(message2); 1903 } 1904 TEST(GeneratedMapFieldTest,CopyAssignmentOperator)1905 TEST(GeneratedMapFieldTest, CopyAssignmentOperator) { 1906 unittest::TestMap message1; 1907 MapTestUtil::SetMapFields(&message1); 1908 1909 unittest::TestMap message2; 1910 message2 = message1; 1911 MapTestUtil::ExpectMapFieldsSet(message2); 1912 1913 // Make sure that self-assignment does something sane. 1914 message2.operator=(message2); 1915 MapTestUtil::ExpectMapFieldsSet(message2); 1916 } 1917 1918 #if !defined(PROTOBUF_TEST_NO_DESCRIPTORS) || \ 1919 !defined(GOOGLE_PROTOBUF_NO_RTTI) TEST(GeneratedMapFieldTest,UpcastCopyFrom)1920 TEST(GeneratedMapFieldTest, UpcastCopyFrom) { 1921 // Test the CopyFrom method that takes in the generic const Message& 1922 // parameter. 1923 unittest::TestMap message1, message2; 1924 1925 MapTestUtil::SetMapFields(&message1); 1926 1927 const Message* source = implicit_cast<const Message*>(&message1); 1928 message2.CopyFrom(*source); 1929 1930 MapTestUtil::ExpectMapFieldsSet(message2); 1931 } 1932 #endif 1933 1934 #ifndef PROTOBUF_TEST_NO_DESCRIPTORS 1935 TEST(GeneratedMapFieldTest,CopyFromDynamicMessage)1936 TEST(GeneratedMapFieldTest, CopyFromDynamicMessage) { 1937 // Test copying from a DynamicMessage, which must fall back to using 1938 // reflection. 1939 unittest::TestMap message2; 1940 1941 // Construct a new version of the dynamic message via the factory. 1942 DynamicMessageFactory factory; 1943 google::protobuf::scoped_ptr<Message> message1; 1944 message1.reset( 1945 factory.GetPrototype(unittest::TestMap::descriptor())->New()); 1946 MapReflectionTester reflection_tester( 1947 unittest::TestMap::descriptor()); 1948 reflection_tester.SetMapFieldsViaReflection(message1.get()); 1949 reflection_tester.ExpectMapFieldsSetViaReflection(*message1); 1950 reflection_tester.ExpectMapFieldsSetViaReflectionIterator(message1.get()); 1951 message2.CopyFrom(*message1); 1952 MapTestUtil::ExpectMapFieldsSet(message2); 1953 } 1954 TEST(GeneratedMapFieldTest,CopyFromDynamicMessageMapReflection)1955 TEST(GeneratedMapFieldTest, CopyFromDynamicMessageMapReflection) { 1956 unittest::TestMap message2; 1957 1958 // Construct a new version of the dynamic message via the factory. 1959 DynamicMessageFactory factory; 1960 google::protobuf::scoped_ptr<Message> message1; 1961 message1.reset( 1962 factory.GetPrototype(unittest::TestMap::descriptor())->New()); 1963 MapReflectionTester reflection_tester( 1964 unittest::TestMap::descriptor()); 1965 reflection_tester.SetMapFieldsViaMapReflection(message1.get()); 1966 reflection_tester.ExpectMapFieldsSetViaReflection(*message1); 1967 reflection_tester.ExpectMapFieldsSetViaReflectionIterator(message1.get()); 1968 message2.CopyFrom(*message1); 1969 MapTestUtil::ExpectMapFieldsSet(message2); 1970 } 1971 TEST(GeneratedMapFieldTest,DynamicMessageCopyFrom)1972 TEST(GeneratedMapFieldTest, DynamicMessageCopyFrom) { 1973 // Test copying to a DynamicMessage, which must fall back to using reflection. 1974 unittest::TestMap message2; 1975 MapTestUtil::SetMapFields(&message2); 1976 1977 // Construct a new version of the dynamic message via the factory. 1978 DynamicMessageFactory factory; 1979 google::protobuf::scoped_ptr<Message> message1; 1980 message1.reset( 1981 factory.GetPrototype(unittest::TestMap::descriptor())->New()); 1982 1983 MapReflectionTester reflection_tester( 1984 unittest::TestMap::descriptor()); 1985 message1->MergeFrom(message2); 1986 reflection_tester.ExpectMapFieldsSetViaReflection(*message1); 1987 reflection_tester.ExpectMapFieldsSetViaReflectionIterator(message1.get()); 1988 } 1989 TEST(GeneratedMapFieldTest,DynamicMessageCopyFromMapReflection)1990 TEST(GeneratedMapFieldTest, DynamicMessageCopyFromMapReflection) { 1991 MapReflectionTester reflection_tester( 1992 unittest::TestMap::descriptor()); 1993 unittest::TestMap message2; 1994 reflection_tester.SetMapFieldsViaMapReflection(&message2); 1995 1996 // Construct a dynamic message via the factory. 1997 DynamicMessageFactory factory; 1998 google::protobuf::scoped_ptr<Message> message1; 1999 message1.reset( 2000 factory.GetPrototype(unittest::TestMap::descriptor())->New()); 2001 2002 message1->MergeFrom(message2); 2003 reflection_tester.ExpectMapFieldsSetViaReflectionIterator(message1.get()); 2004 reflection_tester.ExpectMapFieldsSetViaReflection(*message1); 2005 } 2006 TEST(GeneratedMapFieldTest,SyncDynamicMapWithRepeatedField)2007 TEST(GeneratedMapFieldTest, SyncDynamicMapWithRepeatedField) { 2008 // Construct a dynamic message via the factory. 2009 MapReflectionTester reflection_tester( 2010 unittest::TestMap::descriptor()); 2011 DynamicMessageFactory factory; 2012 google::protobuf::scoped_ptr<Message> message; 2013 message.reset( 2014 factory.GetPrototype(unittest::TestMap::descriptor())->New()); 2015 reflection_tester.SetMapFieldsViaReflection(message.get()); 2016 reflection_tester.ExpectMapFieldsSetViaReflectionIterator(message.get()); 2017 reflection_tester.ExpectMapFieldsSetViaReflection(*message); 2018 } 2019 2020 #endif // !PROTOBUF_TEST_NO_DESCRIPTORS 2021 TEST(GeneratedMapFieldTest,NonEmptyMergeFrom)2022 TEST(GeneratedMapFieldTest, NonEmptyMergeFrom) { 2023 unittest::TestMap message1, message2; 2024 2025 MapTestUtil::SetMapFields(&message1); 2026 2027 // This field will test merging into an empty spot. 2028 (*message2.mutable_map_int32_int32())[1] = 1; 2029 message1.mutable_map_int32_int32()->erase(1); 2030 2031 // This tests overwriting. 2032 (*message2.mutable_map_int32_double())[1] = 1; 2033 (*message1.mutable_map_int32_double())[1] = 2; 2034 2035 message1.MergeFrom(message2); 2036 MapTestUtil::ExpectMapFieldsSet(message1); 2037 } 2038 TEST(GeneratedMapFieldTest,MergeFromMessageMap)2039 TEST(GeneratedMapFieldTest, MergeFromMessageMap) { 2040 unittest::TestMessageMap message1, message2; 2041 2042 (*message1.mutable_map_int32_message())[0].add_repeated_int32(100); 2043 (*message2.mutable_map_int32_message())[0].add_repeated_int32(101); 2044 2045 message1.MergeFrom(message2); 2046 2047 // Checks repeated field is overwritten. 2048 EXPECT_EQ(1, message1.map_int32_message().at(0).repeated_int32_size()); 2049 EXPECT_EQ(101, message1.map_int32_message().at(0).repeated_int32(0)); 2050 } 2051 2052 // Test the generated SerializeWithCachedSizesToArray() TEST(GeneratedMapFieldTest,SerializationToArray)2053 TEST(GeneratedMapFieldTest, SerializationToArray) { 2054 unittest::TestMap message1, message2; 2055 string data; 2056 MapTestUtil::SetMapFields(&message1); 2057 int size = message1.ByteSize(); 2058 data.resize(size); 2059 uint8* start = reinterpret_cast<uint8*>(string_as_array(&data)); 2060 uint8* end = message1.SerializeWithCachedSizesToArray(start); 2061 EXPECT_EQ(size, end - start); 2062 EXPECT_TRUE(message2.ParseFromString(data)); 2063 MapTestUtil::ExpectMapFieldsSet(message2); 2064 } 2065 2066 // Test the generated SerializeWithCachedSizes() TEST(GeneratedMapFieldTest,SerializationToStream)2067 TEST(GeneratedMapFieldTest, SerializationToStream) { 2068 unittest::TestMap message1, message2; 2069 MapTestUtil::SetMapFields(&message1); 2070 int size = message1.ByteSize(); 2071 string data; 2072 data.resize(size); 2073 { 2074 // Allow the output stream to buffer only one byte at a time. 2075 io::ArrayOutputStream array_stream(string_as_array(&data), size, 1); 2076 io::CodedOutputStream output_stream(&array_stream); 2077 message1.SerializeWithCachedSizes(&output_stream); 2078 EXPECT_FALSE(output_stream.HadError()); 2079 EXPECT_EQ(size, output_stream.ByteCount()); 2080 } 2081 EXPECT_TRUE(message2.ParseFromString(data)); 2082 MapTestUtil::ExpectMapFieldsSet(message2); 2083 } 2084 2085 TEST(GeneratedMapFieldTest,SameTypeMaps)2086 TEST(GeneratedMapFieldTest, SameTypeMaps) { 2087 const Descriptor* map1 = unittest::TestSameTypeMap::descriptor() 2088 ->FindFieldByName("map1") 2089 ->message_type(); 2090 const Descriptor* map2 = unittest::TestSameTypeMap::descriptor() 2091 ->FindFieldByName("map2") 2092 ->message_type(); 2093 2094 const Message* map1_entry = 2095 MessageFactory::generated_factory()->GetPrototype(map1); 2096 const Message* map2_entry = 2097 MessageFactory::generated_factory()->GetPrototype(map2); 2098 2099 EXPECT_EQ(map1, map1_entry->GetDescriptor()); 2100 EXPECT_EQ(map2, map2_entry->GetDescriptor()); 2101 } 2102 TEST(GeneratedMapFieldTest,Proto2UnknownEnum)2103 TEST(GeneratedMapFieldTest, Proto2UnknownEnum) { 2104 unittest::TestEnumMapPlusExtra from; 2105 (*from.mutable_known_map_field())[0] = unittest::E_PROTO2_MAP_ENUM_FOO; 2106 (*from.mutable_unknown_map_field())[0] = unittest::E_PROTO2_MAP_ENUM_EXTRA; 2107 string data; 2108 from.SerializeToString(&data); 2109 2110 unittest::TestEnumMap to; 2111 EXPECT_TRUE(to.ParseFromString(data)); 2112 EXPECT_EQ(0, to.unknown_map_field().size()); 2113 const UnknownFieldSet& unknown_field_set = 2114 to.GetReflection()->GetUnknownFields(to); 2115 EXPECT_EQ(1, unknown_field_set.field_count()); 2116 EXPECT_EQ(1, to.known_map_field().size()); 2117 EXPECT_EQ(unittest::PROTO2_MAP_ENUM_FOO, to.known_map_field().at(0)); 2118 2119 data.clear(); 2120 from.Clear(); 2121 to.SerializeToString(&data); 2122 EXPECT_TRUE(from.ParseFromString(data)); 2123 EXPECT_EQ(0, from.GetReflection()->GetUnknownFields(from).field_count()); 2124 EXPECT_EQ(1, from.known_map_field().size()); 2125 EXPECT_EQ(unittest::E_PROTO2_MAP_ENUM_FOO, from.known_map_field().at(0)); 2126 EXPECT_EQ(1, from.unknown_map_field().size()); 2127 EXPECT_EQ(unittest::E_PROTO2_MAP_ENUM_EXTRA, from.unknown_map_field().at(0)); 2128 } 2129 TEST(GeneratedMapFieldTest,StandardWireFormat)2130 TEST(GeneratedMapFieldTest, StandardWireFormat) { 2131 unittest::TestMap message; 2132 string data = "\x0A\x04\x08\x01\x10\x01"; 2133 2134 EXPECT_TRUE(message.ParseFromString(data)); 2135 EXPECT_EQ(1, message.map_int32_int32().size()); 2136 EXPECT_EQ(1, message.map_int32_int32().at(1)); 2137 } 2138 TEST(GeneratedMapFieldTest,UnorderedWireFormat)2139 TEST(GeneratedMapFieldTest, UnorderedWireFormat) { 2140 unittest::TestMap message; 2141 2142 // put value before key in wire format 2143 string data = "\x0A\x04\x10\x01\x08\x02"; 2144 2145 EXPECT_TRUE(message.ParseFromString(data)); 2146 EXPECT_EQ(1, message.map_int32_int32().size()); 2147 EXPECT_EQ(1, message.map_int32_int32().at(2)); 2148 } 2149 TEST(GeneratedMapFieldTest,DuplicatedKeyWireFormat)2150 TEST(GeneratedMapFieldTest, DuplicatedKeyWireFormat) { 2151 unittest::TestMap message; 2152 2153 // Two key fields in wire format 2154 string data = "\x0A\x06\x08\x01\x08\x02\x10\x01"; 2155 2156 EXPECT_TRUE(message.ParseFromString(data)); 2157 EXPECT_EQ(1, message.map_int32_int32().size()); 2158 EXPECT_EQ(1, message.map_int32_int32().at(2)); 2159 2160 // A similar test, but with a map from int to a message type. 2161 // Again, we want to be sure that the "second one wins" when 2162 // there are two separate entries with the same key. 2163 const int key = 99; 2164 unittest::TestRequiredMessageMap map_message; 2165 unittest::TestRequired with_dummy4; 2166 with_dummy4.set_a(0); 2167 with_dummy4.set_b(0); 2168 with_dummy4.set_c(0); 2169 with_dummy4.set_dummy4(11); 2170 (*map_message.mutable_map_field())[key] = with_dummy4; 2171 string s = map_message.SerializeAsString(); 2172 unittest::TestRequired with_dummy5; 2173 with_dummy5.set_a(0); 2174 with_dummy5.set_b(0); 2175 with_dummy5.set_c(0); 2176 with_dummy5.set_dummy5(12); 2177 (*map_message.mutable_map_field())[key] = with_dummy5; 2178 string both = s + map_message.SerializeAsString(); 2179 // We don't expect a merge now. The "second one wins." 2180 ASSERT_TRUE(map_message.ParseFromString(both)); 2181 ASSERT_EQ(1, map_message.map_field().size()); 2182 ASSERT_EQ(1, map_message.map_field().count(key)); 2183 EXPECT_EQ(0, map_message.map_field().find(key)->second.a()); 2184 EXPECT_EQ(0, map_message.map_field().find(key)->second.b()); 2185 EXPECT_EQ(0, map_message.map_field().find(key)->second.c()); 2186 EXPECT_FALSE(map_message.map_field().find(key)->second.has_dummy4()); 2187 ASSERT_TRUE(map_message.map_field().find(key)->second.has_dummy5()); 2188 EXPECT_EQ(12, map_message.map_field().find(key)->second.dummy5()); 2189 } 2190 2191 // Exhaustive combinations of keys, values, and junk in any order. 2192 // This re-tests some of the things tested above, but if it fails 2193 // it's more work to determine what went wrong, so it isn't necessarily 2194 // bad that we have the simpler tests too. TEST(GeneratedMapFieldTest,KeysValuesUnknownsWireFormat)2195 TEST(GeneratedMapFieldTest, KeysValuesUnknownsWireFormat) { 2196 unittest::TestMap message; 2197 const int kMaxNumKeysAndValuesAndJunk = 4; 2198 const char kKeyTag = 0x08; 2199 const char kValueTag = 0x10; 2200 const char kJunkTag = 0x20; 2201 for (int items = 0; items <= kMaxNumKeysAndValuesAndJunk; items++) { 2202 string data = "\x0A"; 2203 // Encode length of what will follow. 2204 data.push_back(items * 2); 2205 static const int kBitsOfIPerItem = 4; 2206 static const int mask = (1 << kBitsOfIPerItem) - 1; 2207 // Each iteration of the following is a test. It uses i as bit vector 2208 // encoding the keys and values to put in the wire format. 2209 for (int i = 0; i < (1 << (items * kBitsOfIPerItem)); i++) { 2210 string wire_format = data; 2211 int expected_key = 0; 2212 int expected_value = 0; 2213 for (int k = i, j = 0; j < items; j++, k >>= kBitsOfIPerItem) { 2214 bool is_key = k & 0x1; 2215 bool is_value = !is_key && (k & 0x2); 2216 wire_format.push_back(is_key ? kKeyTag : 2217 is_value ? kValueTag : kJunkTag); 2218 char c = static_cast<char>(k & mask) >> 2; // One char after the tag. 2219 wire_format.push_back(c); 2220 if (is_key) expected_key = static_cast<int>(c); 2221 if (is_value) expected_value = static_cast<int>(c); 2222 ASSERT_TRUE(message.ParseFromString(wire_format)); 2223 ASSERT_EQ(1, message.map_int32_int32().size()); 2224 ASSERT_EQ(expected_key, message.map_int32_int32().begin()->first); 2225 ASSERT_EQ(expected_value, message.map_int32_int32().begin()->second); 2226 } 2227 } 2228 } 2229 } 2230 TEST(GeneratedMapFieldTest,DuplicatedValueWireFormat)2231 TEST(GeneratedMapFieldTest, DuplicatedValueWireFormat) { 2232 unittest::TestMap message; 2233 2234 // Two value fields in wire format 2235 string data = "\x0A\x06\x08\x01\x10\x01\x10\x02"; 2236 2237 EXPECT_TRUE(message.ParseFromString(data)); 2238 EXPECT_EQ(1, message.map_int32_int32().size()); 2239 EXPECT_EQ(2, message.map_int32_int32().at(1)); 2240 } 2241 TEST(GeneratedMapFieldTest,MissedKeyWireFormat)2242 TEST(GeneratedMapFieldTest, MissedKeyWireFormat) { 2243 unittest::TestMap message; 2244 2245 // No key field in wire format 2246 string data = "\x0A\x02\x10\x01"; 2247 2248 EXPECT_TRUE(message.ParseFromString(data)); 2249 EXPECT_EQ(1, message.map_int32_int32().size()); 2250 EXPECT_EQ(1, message.map_int32_int32().at(0)); 2251 } 2252 TEST(GeneratedMapFieldTest,MissedValueWireFormat)2253 TEST(GeneratedMapFieldTest, MissedValueWireFormat) { 2254 unittest::TestMap message; 2255 2256 // No value field in wire format 2257 string data = "\x0A\x02\x08\x01"; 2258 2259 EXPECT_TRUE(message.ParseFromString(data)); 2260 EXPECT_EQ(1, message.map_int32_int32().size()); 2261 EXPECT_EQ(0, message.map_int32_int32().at(1)); 2262 } 2263 TEST(GeneratedMapFieldTest,MissedValueTextFormat)2264 TEST(GeneratedMapFieldTest, MissedValueTextFormat) { 2265 unittest::TestMap message; 2266 2267 // No value field in text format 2268 string text = 2269 "map_int32_foreign_message {\n" 2270 " key: 1234567890\n" 2271 "}"; 2272 2273 EXPECT_TRUE(google::protobuf::TextFormat::ParseFromString(text, &message)); 2274 EXPECT_EQ(1, message.map_int32_foreign_message().size()); 2275 EXPECT_EQ(11, message.ByteSize()); 2276 } 2277 TEST(GeneratedMapFieldTest,UnknownFieldWireFormat)2278 TEST(GeneratedMapFieldTest, UnknownFieldWireFormat) { 2279 unittest::TestMap message; 2280 2281 // Unknown field in wire format 2282 string data = "\x0A\x06\x08\x02\x10\x03\x18\x01"; 2283 2284 EXPECT_TRUE(message.ParseFromString(data)); 2285 EXPECT_EQ(1, message.map_int32_int32().size()); 2286 EXPECT_EQ(3, message.map_int32_int32().at(2)); 2287 } 2288 TEST(GeneratedMapFieldTest,CorruptedWireFormat)2289 TEST(GeneratedMapFieldTest, CorruptedWireFormat) { 2290 unittest::TestMap message; 2291 2292 // corrupted data in wire format 2293 string data = "\x0A\x06\x08\x02\x11\x03"; 2294 2295 EXPECT_FALSE(message.ParseFromString(data)); 2296 } 2297 TEST(GeneratedMapFieldTest,IsInitialized)2298 TEST(GeneratedMapFieldTest, IsInitialized) { 2299 unittest::TestRequiredMessageMap map_message; 2300 2301 // Add an uninitialized message. 2302 (*map_message.mutable_map_field())[0]; 2303 EXPECT_FALSE(map_message.IsInitialized()); 2304 2305 // Initialize uninitialized message 2306 (*map_message.mutable_map_field())[0].set_a(0); 2307 (*map_message.mutable_map_field())[0].set_b(0); 2308 (*map_message.mutable_map_field())[0].set_c(0); 2309 EXPECT_TRUE(map_message.IsInitialized()); 2310 } 2311 TEST(GeneratedMapFieldTest,MessagesMustMerge)2312 TEST(GeneratedMapFieldTest, MessagesMustMerge) { 2313 unittest::TestRequiredMessageMap map_message; 2314 unittest::TestRequired with_dummy4; 2315 with_dummy4.set_a(97); 2316 with_dummy4.set_b(0); 2317 with_dummy4.set_c(0); 2318 with_dummy4.set_dummy4(98); 2319 2320 EXPECT_TRUE(with_dummy4.IsInitialized()); 2321 (*map_message.mutable_map_field())[0] = with_dummy4; 2322 EXPECT_TRUE(map_message.IsInitialized()); 2323 string s = map_message.SerializeAsString(); 2324 2325 // Modify s so that there are two values in the entry for key 0. 2326 // The first will have no value for c. The second will have no value for a. 2327 // Those are required fields. Also, make some other little changes, to 2328 // ensure we are merging the two values (because they're messages). 2329 ASSERT_EQ(s.size() - 2, s[1]); // encoding of the length of what follows 2330 string encoded_val(s.data() + 4, s.data() + s.size()); 2331 // In s, change the encoding of c to an encoding of dummy32. 2332 s[s.size() - 3] -= 8; 2333 // Make encoded_val slightly different from what's in s. 2334 encoded_val[encoded_val.size() - 1] += 33; // Encode c = 33. 2335 for (int i = 0; i < encoded_val.size(); i++) { 2336 if (encoded_val[i] == 97) { 2337 // Encode b = 91 instead of a = 97. But this won't matter, because 2338 // we also encode b = 0 right after this. The point is to leave out 2339 // a required field, and make sure the parser doesn't complain, because 2340 // every required field is set after the merge of the two values. 2341 encoded_val[i - 1] += 16; 2342 encoded_val[i] = 91; 2343 } else if (encoded_val[i] == 98) { 2344 // Encode dummy5 = 99 instead of dummy4 = 98. 2345 encoded_val[i - 1] += 8; // The tag for dummy5 is 8 more. 2346 encoded_val[i]++; 2347 break; 2348 } 2349 } 2350 2351 s += encoded_val; // Add the second message. 2352 s[1] += encoded_val.size(); // Adjust encoded size. 2353 2354 // Test key then value then value. 2355 int key = 0; 2356 ASSERT_TRUE(map_message.ParseFromString(s)); 2357 ASSERT_EQ(1, map_message.map_field().size()); 2358 ASSERT_EQ(1, map_message.map_field().count(key)); 2359 EXPECT_EQ(97, map_message.map_field().find(key)->second.a()); 2360 EXPECT_EQ(0, map_message.map_field().find(key)->second.b()); 2361 EXPECT_EQ(33, map_message.map_field().find(key)->second.c()); 2362 EXPECT_EQ(98, map_message.map_field().find(key)->second.dummy4()); 2363 EXPECT_EQ(99, map_message.map_field().find(key)->second.dummy5()); 2364 2365 // Test key then value then value then key. 2366 s.push_back(s[2]); // Copy the key's tag. 2367 key = 19; 2368 s.push_back(key); // Second key is 19 instead of 0. 2369 s[1] += 2; // Adjust encoded size. 2370 ASSERT_TRUE(map_message.ParseFromString(s)); 2371 ASSERT_EQ(1, map_message.map_field().size()); 2372 ASSERT_EQ(1, map_message.map_field().count(key)); 2373 EXPECT_EQ(97, map_message.map_field().find(key)->second.a()); 2374 EXPECT_EQ(0, map_message.map_field().find(key)->second.b()); 2375 EXPECT_EQ(33, map_message.map_field().find(key)->second.c()); 2376 EXPECT_EQ(98, map_message.map_field().find(key)->second.dummy4()); 2377 EXPECT_EQ(99, map_message.map_field().find(key)->second.dummy5()); 2378 } 2379 2380 // Generated Message Reflection Test ================================ 2381 TEST(GeneratedMapFieldReflectionTest,SpaceUsed)2382 TEST(GeneratedMapFieldReflectionTest, SpaceUsed) { 2383 unittest::TestMap message; 2384 MapReflectionTester reflection_tester( 2385 unittest::TestMap::descriptor()); 2386 reflection_tester.SetMapFieldsViaReflection(&message); 2387 2388 EXPECT_LT(0, message.GetReflection()->SpaceUsed(message)); 2389 } 2390 TEST(GeneratedMapFieldReflectionTest,Accessors)2391 TEST(GeneratedMapFieldReflectionTest, Accessors) { 2392 // Set every field to a unique value then go back and check all those 2393 // values. 2394 unittest::TestMap message; 2395 MapReflectionTester reflection_tester( 2396 unittest::TestMap::descriptor()); 2397 reflection_tester.SetMapFieldsViaReflection(&message); 2398 MapTestUtil::ExpectMapFieldsSet(message); 2399 reflection_tester.ExpectMapFieldsSetViaReflection(message); 2400 reflection_tester.ExpectMapFieldsSetViaReflectionIterator(&message); 2401 2402 reflection_tester.ModifyMapFieldsViaReflection(&message); 2403 MapTestUtil::ExpectMapFieldsModified(message); 2404 } 2405 TEST(GeneratedMapFieldReflectionTest,Swap)2406 TEST(GeneratedMapFieldReflectionTest, Swap) { 2407 unittest::TestMap message1; 2408 unittest::TestMap message2; 2409 2410 MapTestUtil::SetMapFields(&message1); 2411 2412 const Reflection* reflection = message1.GetReflection(); 2413 reflection->Swap(&message1, &message2); 2414 2415 MapTestUtil::ExpectClear(message1); 2416 MapTestUtil::ExpectMapFieldsSet(message2); 2417 } 2418 TEST(GeneratedMapFieldReflectionTest,SwapWithBothSet)2419 TEST(GeneratedMapFieldReflectionTest, SwapWithBothSet) { 2420 unittest::TestMap message1; 2421 unittest::TestMap message2; 2422 2423 MapTestUtil::SetMapFields(&message1); 2424 MapTestUtil::SetMapFields(&message2); 2425 MapTestUtil::ModifyMapFields(&message2); 2426 2427 const Reflection* reflection = message1.GetReflection(); 2428 reflection->Swap(&message1, &message2); 2429 2430 MapTestUtil::ExpectMapFieldsModified(message1); 2431 MapTestUtil::ExpectMapFieldsSet(message2); 2432 } 2433 TEST(GeneratedMapFieldReflectionTest,SwapFields)2434 TEST(GeneratedMapFieldReflectionTest, SwapFields) { 2435 unittest::TestMap message1; 2436 unittest::TestMap message2; 2437 2438 MapTestUtil::SetMapFields(&message2); 2439 2440 vector<const FieldDescriptor*> fields; 2441 const Reflection* reflection = message1.GetReflection(); 2442 reflection->ListFields(message2, &fields); 2443 reflection->SwapFields(&message1, &message2, fields); 2444 2445 MapTestUtil::ExpectMapFieldsSet(message1); 2446 MapTestUtil::ExpectClear(message2); 2447 } 2448 TEST(GeneratedMapFieldReflectionTest,ClearField)2449 TEST(GeneratedMapFieldReflectionTest, ClearField) { 2450 unittest::TestMap message; 2451 MapTestUtil::SetMapFields(&message); 2452 MapTestUtil::ExpectMapFieldsSet(message); 2453 2454 MapReflectionTester reflection_tester( 2455 unittest::TestMap::descriptor()); 2456 reflection_tester.ClearMapFieldsViaReflection(&message); 2457 reflection_tester.ExpectClearViaReflection(message); 2458 reflection_tester.ExpectClearViaReflectionIterator(&message); 2459 } 2460 TEST(GeneratedMapFieldReflectionTest,RemoveLast)2461 TEST(GeneratedMapFieldReflectionTest, RemoveLast) { 2462 unittest::TestMap message; 2463 MapReflectionTester reflection_tester( 2464 unittest::TestMap::descriptor()); 2465 2466 MapTestUtil::SetMapFields(&message); 2467 MapTestUtil::ExpectMapsSize(message, 2); 2468 std::vector<const Message*> expected_entries = 2469 MapTestUtil::GetMapEntries(message, 0); 2470 2471 reflection_tester.RemoveLastMapsViaReflection(&message); 2472 2473 MapTestUtil::ExpectMapsSize(message, 1); 2474 std::vector<const Message*> remained_entries = 2475 MapTestUtil::GetMapEntries(message, 0); 2476 EXPECT_TRUE(expected_entries == remained_entries); 2477 } 2478 TEST(GeneratedMapFieldReflectionTest,ReleaseLast)2479 TEST(GeneratedMapFieldReflectionTest, ReleaseLast) { 2480 unittest::TestMap message; 2481 const Descriptor* descriptor = message.GetDescriptor(); 2482 MapReflectionTester reflection_tester(descriptor); 2483 2484 MapTestUtil::SetMapFields(&message); 2485 2486 MapTestUtil::ExpectMapsSize(message, 2); 2487 2488 reflection_tester.ReleaseLastMapsViaReflection(&message); 2489 2490 MapTestUtil::ExpectMapsSize(message, 1); 2491 2492 // Now test that we actually release the right message. 2493 message.Clear(); 2494 MapTestUtil::SetMapFields(&message); 2495 2496 MapTestUtil::ExpectMapsSize(message, 2); 2497 std::vector<const Message*> expect_last = 2498 MapTestUtil::GetMapEntries(message, 1); 2499 std::vector<const Message*> release_last = 2500 MapTestUtil::GetMapEntriesFromRelease(&message); 2501 MapTestUtil::ExpectMapsSize(message, 1); 2502 EXPECT_TRUE(expect_last == release_last); 2503 for (std::vector<const Message*>::iterator it = release_last.begin(); 2504 it != release_last.end(); ++it) { 2505 delete *it; 2506 } 2507 } 2508 TEST(GeneratedMapFieldReflectionTest,SwapElements)2509 TEST(GeneratedMapFieldReflectionTest, SwapElements) { 2510 unittest::TestMap message; 2511 MapReflectionTester reflection_tester( 2512 unittest::TestMap::descriptor()); 2513 2514 MapTestUtil::SetMapFields(&message); 2515 2516 // Get pointers of map entries at their original position 2517 std::vector<const Message*> entries0 = MapTestUtil::GetMapEntries(message, 0); 2518 std::vector<const Message*> entries1 = MapTestUtil::GetMapEntries(message, 1); 2519 2520 // Swap the first time. 2521 reflection_tester.SwapMapsViaReflection(&message); 2522 2523 // Get pointer of map entry after swap once. 2524 std::vector<const Message*> entries0_once = 2525 MapTestUtil::GetMapEntries(message, 0); 2526 std::vector<const Message*> entries1_once = 2527 MapTestUtil::GetMapEntries(message, 1); 2528 2529 // Test map entries are swapped. 2530 MapTestUtil::ExpectMapsSize(message, 2); 2531 EXPECT_TRUE(entries0 == entries1_once); 2532 EXPECT_TRUE(entries1 == entries0_once); 2533 2534 // Swap the second time. 2535 reflection_tester.SwapMapsViaReflection(&message); 2536 2537 // Get pointer of map entry after swap once. 2538 std::vector<const Message*> entries0_twice = 2539 MapTestUtil::GetMapEntries(message, 0); 2540 std::vector<const Message*> entries1_twice = 2541 MapTestUtil::GetMapEntries(message, 1); 2542 2543 // Test map entries are swapped back. 2544 MapTestUtil::ExpectMapsSize(message, 2); 2545 EXPECT_TRUE(entries0 == entries0_twice); 2546 EXPECT_TRUE(entries1 == entries1_twice); 2547 } 2548 TEST(GeneratedMapFieldReflectionTest,MutableUnknownFields)2549 TEST(GeneratedMapFieldReflectionTest, MutableUnknownFields) { 2550 unittest::TestMap message; 2551 MapReflectionTester reflection_tester( 2552 unittest::TestMap::descriptor()); 2553 reflection_tester.MutableUnknownFieldsOfMapFieldsViaReflection(&message); 2554 } 2555 TEST(GeneratedMapFieldReflectionTest,EmbedProto2Message)2556 TEST(GeneratedMapFieldReflectionTest, EmbedProto2Message) { 2557 unittest::TestMessageMap message; 2558 2559 const FieldDescriptor* map_field = 2560 unittest::TestMessageMap::descriptor()->FindFieldByName( 2561 "map_int32_message"); 2562 const FieldDescriptor* value = 2563 map_field->message_type()->FindFieldByName("value"); 2564 2565 Message* entry_message = 2566 message.GetReflection()->AddMessage(&message, map_field); 2567 EXPECT_EQ( 2568 &entry_message->GetReflection()->GetMessage(*entry_message, value), 2569 reinterpret_cast<const Message*>(&TestAllTypes::default_instance())); 2570 2571 Message* proto2_message = 2572 entry_message->GetReflection()->MutableMessage(entry_message, value); 2573 EXPECT_EQ(unittest::TestAllTypes::descriptor(), 2574 proto2_message->GetDescriptor()); 2575 ASSERT_EQ(1, message.map_int32_message().size()); 2576 } 2577 TEST(GeneratedMapFieldReflectionTest,MergeFromClearMapEntry)2578 TEST(GeneratedMapFieldReflectionTest, MergeFromClearMapEntry) { 2579 unittest::TestMap message; 2580 const FieldDescriptor* map_field = 2581 unittest::TestMap::descriptor()->FindFieldByName("map_int32_int32"); 2582 const FieldDescriptor* key = 2583 map_field->message_type()->FindFieldByName("key"); 2584 const FieldDescriptor* value = 2585 map_field->message_type()->FindFieldByName("value"); 2586 2587 Message* entry_message1 = 2588 message.GetReflection()->AddMessage(&message, map_field); 2589 EXPECT_FALSE(entry_message1->GetReflection()->HasField(*entry_message1, key)); 2590 EXPECT_FALSE( 2591 entry_message1->GetReflection()->HasField(*entry_message1, value)); 2592 2593 Message* entry_message2 = 2594 message.GetReflection()->AddMessage(&message, map_field); 2595 EXPECT_FALSE(entry_message2->GetReflection()->HasField(*entry_message2, key)); 2596 EXPECT_FALSE( 2597 entry_message2->GetReflection()->HasField(*entry_message2, value)); 2598 2599 entry_message1->MergeFrom(*entry_message2); 2600 EXPECT_FALSE(entry_message1->GetReflection()->HasField(*entry_message1, key)); 2601 EXPECT_FALSE( 2602 entry_message1->GetReflection()->HasField(*entry_message1, value)); 2603 } 2604 TEST(GeneratedMapFieldReflectionTest,MapEntryClear)2605 TEST(GeneratedMapFieldReflectionTest, MapEntryClear) { 2606 unittest::TestMap message; 2607 MapReflectionTester reflection_tester( 2608 unittest::TestMap::descriptor()); 2609 reflection_tester.MutableUnknownFieldsOfMapFieldsViaReflection(&message); 2610 } 2611 TEST(GeneratedMapFieldReflectionTest,Proto2MapEntryClear)2612 TEST(GeneratedMapFieldReflectionTest, Proto2MapEntryClear) { 2613 unittest::TestEnumMap message; 2614 const Descriptor* descriptor = message.GetDescriptor(); 2615 const FieldDescriptor* field_descriptor = 2616 descriptor->FindFieldByName("known_map_field"); 2617 const FieldDescriptor* value_descriptor = 2618 field_descriptor->message_type()->FindFieldByName("value"); 2619 Message* sub_message = 2620 message.GetReflection()->AddMessage(&message, field_descriptor); 2621 EXPECT_EQ(0, sub_message->GetReflection()->GetEnumValue(*sub_message, 2622 value_descriptor)); 2623 } 2624 2625 // Map Reflection API Test ========================================= 2626 TEST(GeneratedMapFieldReflectionTest,SetViaMapReflection)2627 TEST(GeneratedMapFieldReflectionTest, SetViaMapReflection) { 2628 unittest::TestMap message; 2629 MapReflectionTester reflection_tester( 2630 unittest::TestMap::descriptor()); 2631 reflection_tester.SetMapFieldsViaMapReflection(&message); 2632 reflection_tester.ExpectMapFieldsSetViaReflection(message); 2633 reflection_tester.ExpectMapFieldsSetViaReflectionIterator(&message); 2634 } 2635 2636 // Dynamic Message Test ============================================= 2637 2638 class MapFieldInDynamicMessageTest : public testing::Test { 2639 protected: 2640 const DescriptorPool* pool_; 2641 DynamicMessageFactory factory_; 2642 const Descriptor* map_descriptor_; 2643 const Descriptor* recursive_map_descriptor_; 2644 const Message* map_prototype_; 2645 MapFieldInDynamicMessageTest()2646 MapFieldInDynamicMessageTest() 2647 : pool_(DescriptorPool::generated_pool()), factory_(pool_) {} 2648 SetUp()2649 virtual void SetUp() { 2650 map_descriptor_ = 2651 pool_->FindMessageTypeByName("protobuf_unittest.TestMap"); 2652 recursive_map_descriptor_ = 2653 pool_->FindMessageTypeByName("protobuf_unittest.TestRecursiveMapMessage"); 2654 ASSERT_TRUE(map_descriptor_ != NULL); 2655 ASSERT_TRUE(recursive_map_descriptor_ != NULL); 2656 map_prototype_ = factory_.GetPrototype(map_descriptor_); 2657 } 2658 }; 2659 TEST_F(MapFieldInDynamicMessageTest,MapIndependentOffsets)2660 TEST_F(MapFieldInDynamicMessageTest, MapIndependentOffsets) { 2661 // Check that all fields have independent offsets by setting each 2662 // one to a unique value then checking that they all still have those 2663 // unique values (i.e. they don't stomp each other). 2664 google::protobuf::scoped_ptr<Message> message(map_prototype_->New()); 2665 MapReflectionTester reflection_tester(map_descriptor_); 2666 2667 reflection_tester.SetMapFieldsViaReflection(message.get()); 2668 reflection_tester.ExpectMapFieldsSetViaReflection(*message); 2669 } 2670 TEST_F(MapFieldInDynamicMessageTest,DynamicMapReflection)2671 TEST_F(MapFieldInDynamicMessageTest, DynamicMapReflection) { 2672 // Check that map fields work properly. 2673 google::protobuf::scoped_ptr<Message> message(map_prototype_->New()); 2674 2675 // Check set functions. 2676 MapReflectionTester reflection_tester(map_descriptor_); 2677 reflection_tester.SetMapFieldsViaMapReflection(message.get()); 2678 reflection_tester.ExpectMapFieldsSetViaReflection(*message); 2679 } 2680 TEST_F(MapFieldInDynamicMessageTest,MapSpaceUsed)2681 TEST_F(MapFieldInDynamicMessageTest, MapSpaceUsed) { 2682 // Test that SpaceUsed() works properly 2683 2684 // Since we share the implementation with generated messages, we don't need 2685 // to test very much here. Just make sure it appears to be working. 2686 2687 google::protobuf::scoped_ptr<Message> message(map_prototype_->New()); 2688 MapReflectionTester reflection_tester(map_descriptor_); 2689 2690 int initial_space_used = message->SpaceUsed(); 2691 2692 reflection_tester.SetMapFieldsViaReflection(message.get()); 2693 EXPECT_LT(initial_space_used, message->SpaceUsed()); 2694 } 2695 TEST_F(MapFieldInDynamicMessageTest,RecursiveMap)2696 TEST_F(MapFieldInDynamicMessageTest, RecursiveMap) { 2697 TestRecursiveMapMessage from; 2698 (*from.mutable_a())[""]; 2699 string data = from.SerializeAsString(); 2700 google::protobuf::scoped_ptr<Message> to( 2701 factory_.GetPrototype(recursive_map_descriptor_)->New()); 2702 ASSERT_TRUE(to->ParseFromString(data)); 2703 } 2704 2705 // ReflectionOps Test =============================================== 2706 TEST(ReflectionOpsForMapFieldTest,MapSanityCheck)2707 TEST(ReflectionOpsForMapFieldTest, MapSanityCheck) { 2708 unittest::TestMap message; 2709 2710 MapTestUtil::SetMapFields(&message); 2711 MapTestUtil::ExpectMapFieldsSet(message); 2712 } 2713 TEST(ReflectionOpsForMapFieldTest,MapCopy)2714 TEST(ReflectionOpsForMapFieldTest, MapCopy) { 2715 unittest::TestMap message, message2; 2716 2717 MapTestUtil::SetMapFields(&message); 2718 2719 ReflectionOps::Copy(message, &message2); 2720 2721 MapTestUtil::ExpectMapFieldsSet(message2); 2722 2723 // Copying from self should be a no-op. 2724 ReflectionOps::Copy(message2, &message2); 2725 MapTestUtil::ExpectMapFieldsSet(message2); 2726 } 2727 TEST(ReflectionOpsForMapFieldTest,MergeMap)2728 TEST(ReflectionOpsForMapFieldTest, MergeMap) { 2729 // Note: Copy is implemented in terms of Merge() so technically the Copy 2730 // test already tested most of this. 2731 2732 unittest::TestMap message, message2; 2733 2734 MapTestUtil::SetMapFields(&message); 2735 2736 ReflectionOps::Merge(message2, &message); 2737 2738 MapTestUtil::ExpectMapFieldsSet(message); 2739 } 2740 TEST(ReflectionOpsForMapFieldTest,ClearMap)2741 TEST(ReflectionOpsForMapFieldTest, ClearMap) { 2742 unittest::TestMap message; 2743 2744 MapTestUtil::SetMapFields(&message); 2745 2746 ReflectionOps::Clear(&message); 2747 2748 MapTestUtil::ExpectClear(message); 2749 } 2750 TEST(ReflectionOpsForMapFieldTest,MapDiscardUnknownFields)2751 TEST(ReflectionOpsForMapFieldTest, MapDiscardUnknownFields) { 2752 unittest::TestMap message; 2753 MapTestUtil::SetMapFields(&message); 2754 2755 // Set some unknown fields in message. 2756 message.GetReflection()->MutableUnknownFields(&message)-> 2757 AddVarint(123456, 654321); 2758 2759 // Discard them. 2760 ReflectionOps::DiscardUnknownFields(&message); 2761 MapTestUtil::ExpectMapFieldsSet(message); 2762 2763 EXPECT_EQ(0, message.GetReflection()-> 2764 GetUnknownFields(message).field_count()); 2765 } 2766 2767 // Wire Format Test ================================================= 2768 TEST(WireFormatForMapFieldTest,ParseMap)2769 TEST(WireFormatForMapFieldTest, ParseMap) { 2770 unittest::TestMap source, dest; 2771 string data; 2772 2773 // Serialize using the generated code. 2774 MapTestUtil::SetMapFields(&source); 2775 source.SerializeToString(&data); 2776 2777 // Parse using WireFormat. 2778 io::ArrayInputStream raw_input(data.data(), data.size()); 2779 io::CodedInputStream input(&raw_input); 2780 WireFormat::ParseAndMergePartial(&input, &dest); 2781 2782 // Check. 2783 MapTestUtil::ExpectMapFieldsSet(dest); 2784 } 2785 TEST(WireFormatForMapFieldTest,MapByteSize)2786 TEST(WireFormatForMapFieldTest, MapByteSize) { 2787 unittest::TestMap message; 2788 MapTestUtil::SetMapFields(&message); 2789 2790 EXPECT_EQ(message.ByteSize(), WireFormat::ByteSize(message)); 2791 message.Clear(); 2792 EXPECT_EQ(0, message.ByteSize()); 2793 EXPECT_EQ(0, WireFormat::ByteSize(message)); 2794 } 2795 TEST(WireFormatForMapFieldTest,SerializeMap)2796 TEST(WireFormatForMapFieldTest, SerializeMap) { 2797 unittest::TestMap message; 2798 string generated_data; 2799 string dynamic_data; 2800 2801 MapTestUtil::SetMapFields(&message); 2802 2803 // Serialize using the generated code. 2804 { 2805 message.ByteSize(); 2806 io::StringOutputStream raw_output(&generated_data); 2807 io::CodedOutputStream output(&raw_output); 2808 message.SerializeWithCachedSizes(&output); 2809 ASSERT_FALSE(output.HadError()); 2810 } 2811 2812 // Serialize using WireFormat. 2813 { 2814 io::StringOutputStream raw_output(&dynamic_data); 2815 io::CodedOutputStream output(&raw_output); 2816 int size = WireFormat::ByteSize(message); 2817 WireFormat::SerializeWithCachedSizes(message, size, &output); 2818 ASSERT_FALSE(output.HadError()); 2819 } 2820 2821 // Should be the same. 2822 // Don't use EXPECT_EQ here because we're comparing raw binary data and 2823 // we really don't want it dumped to stdout on failure. 2824 EXPECT_TRUE(dynamic_data == generated_data); 2825 } 2826 TEST(WireFormatForMapFieldTest,MapParseHelpers)2827 TEST(WireFormatForMapFieldTest, MapParseHelpers) { 2828 string data; 2829 2830 { 2831 // Set up. 2832 protobuf_unittest::TestMap message; 2833 MapTestUtil::SetMapFields(&message); 2834 message.SerializeToString(&data); 2835 } 2836 2837 { 2838 // Test ParseFromString. 2839 protobuf_unittest::TestMap message; 2840 EXPECT_TRUE(message.ParseFromString(data)); 2841 MapTestUtil::ExpectMapFieldsSet(message); 2842 } 2843 2844 { 2845 // Test ParseFromIstream. 2846 protobuf_unittest::TestMap message; 2847 stringstream stream(data); 2848 EXPECT_TRUE(message.ParseFromIstream(&stream)); 2849 EXPECT_TRUE(stream.eof()); 2850 MapTestUtil::ExpectMapFieldsSet(message); 2851 } 2852 2853 { 2854 // Test ParseFromBoundedZeroCopyStream. 2855 string data_with_junk(data); 2856 data_with_junk.append("some junk on the end"); 2857 io::ArrayInputStream stream(data_with_junk.data(), data_with_junk.size()); 2858 protobuf_unittest::TestMap message; 2859 EXPECT_TRUE(message.ParseFromBoundedZeroCopyStream(&stream, data.size())); 2860 MapTestUtil::ExpectMapFieldsSet(message); 2861 } 2862 2863 { 2864 // Test that ParseFromBoundedZeroCopyStream fails (but doesn't crash) if 2865 // EOF is reached before the expected number of bytes. 2866 io::ArrayInputStream stream(data.data(), data.size()); 2867 protobuf_unittest::TestAllTypes message; 2868 EXPECT_FALSE( 2869 message.ParseFromBoundedZeroCopyStream(&stream, data.size() + 1)); 2870 } 2871 } 2872 2873 // Deterministic Serialization Test ========================================== 2874 2875 template <typename T> DeterministicSerialization(const T & t)2876 static string DeterministicSerialization(const T& t) { 2877 const int size = t.ByteSize(); 2878 string result(size, '\0'); 2879 io::ArrayOutputStream array_stream(string_as_array(&result), size); 2880 io::CodedOutputStream output_stream(&array_stream); 2881 output_stream.SetSerializationDeterministic(true); 2882 t.SerializeWithCachedSizes(&output_stream); 2883 EXPECT_FALSE(output_stream.HadError()); 2884 EXPECT_EQ(size, output_stream.ByteCount()); 2885 return result; 2886 } 2887 2888 // Helper to test the serialization of the first arg against a golden file. TestDeterministicSerialization(const protobuf_unittest::TestMaps & t,const string & filename)2889 static void TestDeterministicSerialization(const protobuf_unittest::TestMaps& t, 2890 const string& filename) { 2891 string expected; 2892 GOOGLE_CHECK_OK(File::GetContents( 2893 TestSourceDir() + "/google/protobuf/testdata/" + filename, 2894 &expected, true)); 2895 const string actual = DeterministicSerialization(t); 2896 EXPECT_EQ(expected, actual); 2897 protobuf_unittest::TestMaps u; 2898 EXPECT_TRUE(u.ParseFromString(actual)); 2899 EXPECT_TRUE(google::protobuf::util::MessageDifferencer::Equals(u, t)); 2900 } 2901 2902 // Helper for MapSerializationTest. Return a 7-bit ASCII string. ConstructKey(uint64 n)2903 static string ConstructKey(uint64 n) { 2904 string s(n % static_cast<uint64>(9), '\0'); 2905 if (s.empty()) { 2906 return StrCat(n); 2907 } else { 2908 while (n != 0) { 2909 s[n % s.size()] = (n >> 10) & 0x7f; 2910 n /= 888; 2911 } 2912 return s; 2913 } 2914 } 2915 TEST(MapSerializationTest,Deterministic)2916 TEST(MapSerializationTest, Deterministic) { 2917 const int kIters = 25; 2918 protobuf_unittest::TestMaps t; 2919 protobuf_unittest::TestIntIntMap inner; 2920 (*inner.mutable_m())[0] = (*inner.mutable_m())[10] = 2921 (*inner.mutable_m())[-200] = 0; 2922 uint64 frog = 9; 2923 const uint64 multiplier = 0xa29cd16f; 2924 for (int i = 0; i < kIters; i++) { 2925 const int32 i32 = static_cast<int32>(frog & 0xffffffff); 2926 const uint32 u32 = static_cast<uint32>(i32) * 91919; 2927 const int64 i64 = static_cast<int64>(frog); 2928 const uint64 u64 = frog * static_cast<uint64>(187321); 2929 const bool b = i32 > 0; 2930 const string s = ConstructKey(frog); 2931 (*inner.mutable_m())[i] = i32; 2932 (*t.mutable_m_int32())[i32] = (*t.mutable_m_sint32())[i32] = 2933 (*t.mutable_m_sfixed32())[i32] = inner; 2934 (*t.mutable_m_uint32())[u32] = (*t.mutable_m_fixed32())[u32] = inner; 2935 (*t.mutable_m_int64())[i64] = (*t.mutable_m_sint64())[i64] = 2936 (*t.mutable_m_sfixed64())[i64] = inner; 2937 (*t.mutable_m_uint64())[u64] = (*t.mutable_m_fixed64())[u64] = inner; 2938 (*t.mutable_m_bool())[b] = inner; 2939 (*t.mutable_m_string())[s] = inner; 2940 (*t.mutable_m_string())[s + string(1 << (u32 % static_cast<uint32>(9)), 2941 b)] = inner; 2942 inner.mutable_m()->erase(i); 2943 frog = frog * multiplier + i; 2944 frog ^= (frog >> 41); 2945 } 2946 TestDeterministicSerialization(t, "golden_message_maps"); 2947 } 2948 2949 // Text Format Test ================================================= 2950 TEST(TextFormatMapTest,SerializeAndParse)2951 TEST(TextFormatMapTest, SerializeAndParse) { 2952 unittest::TestMap source; 2953 unittest::TestMap dest; 2954 MapTestUtil::SetMapFields(&source); 2955 string output; 2956 2957 // Test compact ASCII 2958 TextFormat::Printer printer; 2959 printer.PrintToString(source, &output); 2960 TextFormat::Parser parser; 2961 EXPECT_TRUE(parser.ParseFromString(output, &dest)); 2962 MapTestUtil::ExpectMapFieldsSet(dest); 2963 } 2964 TEST(TextFormatMapTest,Sorted)2965 TEST(TextFormatMapTest, Sorted) { 2966 unittest::TestMap message; 2967 MapReflectionTester tester(message.GetDescriptor()); 2968 tester.SetMapFieldsViaReflection(&message); 2969 2970 string expected_text; 2971 GOOGLE_CHECK_OK(File::GetContents( 2972 TestSourceDir() + 2973 "/google/protobuf/" 2974 "testdata/map_test_data.txt", 2975 &expected_text, true)); 2976 2977 EXPECT_EQ(message.DebugString(), expected_text); 2978 2979 // Test again on the reverse order. 2980 unittest::TestMap message2; 2981 tester.SetMapFieldsViaReflection(&message2); 2982 tester.SwapMapsViaReflection(&message2); 2983 EXPECT_EQ(message2.DebugString(), expected_text); 2984 } 2985 2986 2987 // arena support ================================================= TEST(ArenaTest,ParsingAndSerializingNoHeapAllocation)2988 TEST(ArenaTest, ParsingAndSerializingNoHeapAllocation) { 2989 // Allocate a large initial block to avoid mallocs during hooked test. 2990 std::vector<char> arena_block(128 * 1024); 2991 ArenaOptions options; 2992 options.initial_block = &arena_block[0]; 2993 options.initial_block_size = arena_block.size(); 2994 Arena arena(options); 2995 string data; 2996 data.reserve(128 * 1024); 2997 2998 { 2999 // TODO(teboring): Enable no heap check when ArenaStringPtr is used in map. 3000 // NoHeapChecker no_heap; 3001 3002 unittest::TestArenaMap* from = 3003 Arena::CreateMessage<unittest::TestArenaMap>(&arena); 3004 MapTestUtil::SetArenaMapFields(from); 3005 from->SerializeToString(&data); 3006 3007 unittest::TestArenaMap* to = 3008 Arena::CreateMessage<unittest::TestArenaMap>(&arena); 3009 to->ParseFromString(data); 3010 MapTestUtil::ExpectArenaMapFieldsSet(*to); 3011 } 3012 } 3013 3014 // Use text format parsing and serializing to test reflection api. TEST(ArenaTest,RelfectionInTextFormat)3015 TEST(ArenaTest, RelfectionInTextFormat) { 3016 Arena arena; 3017 string data; 3018 3019 TextFormat::Printer printer; 3020 TextFormat::Parser parser; 3021 3022 unittest::TestArenaMap* from = 3023 Arena::CreateMessage<unittest::TestArenaMap>(&arena); 3024 unittest::TestArenaMap* to = 3025 Arena::CreateMessage<unittest::TestArenaMap>(&arena); 3026 3027 MapTestUtil::SetArenaMapFields(from); 3028 printer.PrintToString(*from, &data); 3029 3030 EXPECT_TRUE(parser.ParseFromString(data, to)); 3031 MapTestUtil::ExpectArenaMapFieldsSet(*to); 3032 } 3033 3034 // Make sure the memory allocated for string in map is deallocated. TEST(ArenaTest,StringMapNoLeak)3035 TEST(ArenaTest, StringMapNoLeak) { 3036 Arena arena; 3037 unittest::TestArenaMap* message = 3038 Arena::CreateMessage<unittest::TestArenaMap>(&arena); 3039 string data; 3040 // String with length less than 16 will not be allocated from heap. 3041 int original_capacity = data.capacity(); 3042 while (data.capacity() <= original_capacity) { 3043 data.append("a"); 3044 } 3045 (*message->mutable_map_string_string())[data] = data; 3046 // We rely on heap checkers to detect memory leak for us. 3047 ASSERT_FALSE(message == NULL); 3048 } 3049 TEST(ArenaTest,IsInitialized)3050 TEST(ArenaTest, IsInitialized) { 3051 // Allocate a large initial polluted block. 3052 std::vector<char> arena_block(128 * 1024); 3053 std::fill(arena_block.begin(), arena_block.end(), '\xff'); 3054 3055 ArenaOptions options; 3056 options.initial_block = &arena_block[0]; 3057 options.initial_block_size = arena_block.size(); 3058 Arena arena(options); 3059 3060 unittest::TestArenaMap* message = 3061 Arena::CreateMessage<unittest::TestArenaMap>(&arena); 3062 EXPECT_EQ(0, (*message->mutable_map_int32_int32())[0]); 3063 } 3064 3065 } // namespace internal 3066 } // namespace protobuf 3067 } // namespace google 3068