Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(145)

Unified Diff: third_party/protobuf/src/google/protobuf/map_test.cc

Issue 2600753002: Reverts third_party/protobuf: Update to HEAD (f52e188fe4) (Closed)
Patch Set: Created 4 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
Index: third_party/protobuf/src/google/protobuf/map_test.cc
diff --git a/third_party/protobuf/src/google/protobuf/map_test.cc b/third_party/protobuf/src/google/protobuf/map_test.cc
index d0a34d01f58d156879dde1e0c4f6a0bb1149df23..9d4d6c13d057c0314281249b6563a7020e9d50ad 100644
--- a/third_party/protobuf/src/google/protobuf/map_test.cc
+++ b/third_party/protobuf/src/google/protobuf/map_test.cc
@@ -50,6 +50,7 @@
#include <google/protobuf/stubs/casts.h>
#include <google/protobuf/stubs/logging.h>
#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/scoped_ptr.h>
#include <google/protobuf/stubs/stringprintf.h>
#include <google/protobuf/testing/file.h>
#include <google/protobuf/arena_test_util.h>
@@ -74,10 +75,8 @@
#include <google/protobuf/io/tokenizer.h>
#include <google/protobuf/io/zero_copy_stream_impl.h>
#include <google/protobuf/util/time_util.h>
-#include <google/protobuf/util/message_differencer.h>
#include <google/protobuf/stubs/strutil.h>
#include <google/protobuf/stubs/substitute.h>
-#include <gmock/gmock.h>
#include <google/protobuf/testing/googletest.h>
#include <gtest/gtest.h>
@@ -298,7 +297,7 @@ TEST_P(MapImplTest, IteratorBasic) {
template <typename Iterator>
static int64 median(Iterator i0, Iterator i1) {
- std::vector<int64> v(i0, i1);
+ vector<int64> v(i0, i1);
std::nth_element(v.begin(), v.begin() + v.size() / 2, v.end());
return v[v.size() / 2];
}
@@ -334,7 +333,7 @@ TEST_P(MapImplTest, BeginIsFast) {
GOOGLE_DCHECK_GE(last_key, 0);
map[last_key] = last_key ^ 1;
}
- std::vector<int64> times;
+ vector<int64> times;
// We're going to do map.erase(map.begin()) over and over again. But,
// just in case one iteration is fast compared to the granularity of
// our time keeping, we measure kChunkSize iterations per outer-loop iter.
@@ -379,7 +378,7 @@ TEST_P(MapImplTest, HashFlood) {
// 1024 (or 512 or 2048 or ...) entries. This assumes that map_ uses powers
// of 2 for table sizes, and that it's sufficient to "flood" with respect to
// the low bits of the output of map_.hash_function().
- std::vector<int64> times;
+ vector<int64> times;
std::set<int>::iterator it = s.begin();
int count = 0;
do {
@@ -503,10 +502,10 @@ static void StressTestIterators(int n, bool test_old_style_proto2_maps) {
// Test old iterator vs new iterator, with table modification in between.
TestOldVersusNewIterator<Map<int, int>::const_iterator>(n % 3, &m);
TestOldVersusNewIterator<Map<int, int>::iterator>(n % (1 + (n / 40)), &m);
- // Finally, ensure erase(iterator) doesn't reorder anything, because that is
+ // Finally, ensure erase(iterator) doesn't reorder anything, becuase that is
// what its documentation says.
m[last_key] = m[last_key ^ 999] = 0;
- std::vector<Map<int, int>::iterator> v;
+ vector<Map<int, int>::iterator> v;
v.reserve(m.size());
int position_of_last_key = 0;
for (Map<int, int>::iterator it = m.begin(); it != m.end(); ++it) {
@@ -563,7 +562,7 @@ TEST_P(MapImplTest, EraseRevalidates) {
map_[3] = map_[13] = map_[20] = 0;
const int initial_size = map_.size();
EXPECT_EQ(3, initial_size);
- std::vector<Map<int, int>::iterator> v;
+ vector<Map<int, int>::iterator> v;
for (Map<int, int>::iterator it = map_.begin(); it != map_.end(); ++it) {
v.push_back(it);
}
@@ -916,55 +915,6 @@ TEST_P(MapImplTest, ConvertToStdVectorOfPairs) {
EXPECT_EQ(101, std_vec[0].second);
}
-TEST_P(MapImplTest, SwapSameStyle) {
- Map<int32, int32> another(GetParam()); // same old_style_ value
- map_[9398] = 41999;
- another[9398] = 41999;
- another[8070] = 42056;
- another.swap(map_);
- EXPECT_THAT(another, testing::UnorderedElementsAre(
- testing::Pair(9398, 41999)));
- EXPECT_THAT(map_, testing::UnorderedElementsAre(
- testing::Pair(8070, 42056),
- testing::Pair(9398, 41999)));
-}
-
-TEST_P(MapImplTest, SwapDifferentStyle) {
- Map<int32, int32> another(!GetParam()); // different old_style_ value
- map_[9398] = 41999;
- another[9398] = 41999;
- another[8070] = 42056;
- another.swap(map_);
- EXPECT_THAT(another, testing::UnorderedElementsAre(
- testing::Pair(9398, 41999)));
- EXPECT_THAT(map_, testing::UnorderedElementsAre(
- testing::Pair(8070, 42056),
- testing::Pair(9398, 41999)));
-}
-
-TEST_P(MapImplTest, SwapArena) {
- Arena arena1, arena2;
- Map<int32, int32> m1(&arena1, false);
- Map<int32, int32> m2(&arena2, false);
- map_[9398] = 41999;
- m1[9398] = 41999;
- m1[8070] = 42056;
- m2[10244] = 10247;
- m2[8070] = 42056;
- m1.swap(map_);
- EXPECT_THAT(m1, testing::UnorderedElementsAre(
- testing::Pair(9398, 41999)));
- EXPECT_THAT(map_, testing::UnorderedElementsAre(
- testing::Pair(8070, 42056),
- testing::Pair(9398, 41999)));
- m2.swap(m1);
- EXPECT_THAT(m1, testing::UnorderedElementsAre(
- testing::Pair(8070, 42056),
- testing::Pair(10244, 10247)));
- EXPECT_THAT(m2, testing::UnorderedElementsAre(
- testing::Pair(9398, 41999)));
-}
-
INSTANTIATE_TEST_CASE_P(BoolSequence, MapImplTest, testing::Bool());
// Map Field Reflection Test ========================================
@@ -2156,76 +2106,6 @@ TEST(GeneratedMapFieldTest, DuplicatedKeyWireFormat) {
EXPECT_TRUE(message.ParseFromString(data));
EXPECT_EQ(1, message.map_int32_int32().size());
EXPECT_EQ(1, message.map_int32_int32().at(2));
-
- // A similar test, but with a map from int to a message type.
- // Again, we want to be sure that the "second one wins" when
- // there are two separate entries with the same key.
- const int key = 99;
- unittest::TestRequiredMessageMap map_message;
- unittest::TestRequired with_dummy4;
- with_dummy4.set_a(0);
- with_dummy4.set_b(0);
- with_dummy4.set_c(0);
- with_dummy4.set_dummy4(11);
- (*map_message.mutable_map_field())[key] = with_dummy4;
- string s = map_message.SerializeAsString();
- unittest::TestRequired with_dummy5;
- with_dummy5.set_a(0);
- with_dummy5.set_b(0);
- with_dummy5.set_c(0);
- with_dummy5.set_dummy5(12);
- (*map_message.mutable_map_field())[key] = with_dummy5;
- string both = s + map_message.SerializeAsString();
- // We don't expect a merge now. The "second one wins."
- ASSERT_TRUE(map_message.ParseFromString(both));
- ASSERT_EQ(1, map_message.map_field().size());
- ASSERT_EQ(1, map_message.map_field().count(key));
- EXPECT_EQ(0, map_message.map_field().find(key)->second.a());
- EXPECT_EQ(0, map_message.map_field().find(key)->second.b());
- EXPECT_EQ(0, map_message.map_field().find(key)->second.c());
- EXPECT_FALSE(map_message.map_field().find(key)->second.has_dummy4());
- ASSERT_TRUE(map_message.map_field().find(key)->second.has_dummy5());
- EXPECT_EQ(12, map_message.map_field().find(key)->second.dummy5());
-}
-
-// Exhaustive combinations of keys, values, and junk in any order.
-// This re-tests some of the things tested above, but if it fails
-// it's more work to determine what went wrong, so it isn't necessarily
-// bad that we have the simpler tests too.
-TEST(GeneratedMapFieldTest, KeysValuesUnknownsWireFormat) {
- unittest::TestMap message;
- const int kMaxNumKeysAndValuesAndJunk = 4;
- const char kKeyTag = 0x08;
- const char kValueTag = 0x10;
- const char kJunkTag = 0x20;
- for (int items = 0; items <= kMaxNumKeysAndValuesAndJunk; items++) {
- string data = "\x0A";
- // Encode length of what will follow.
- data.push_back(items * 2);
- static const int kBitsOfIPerItem = 4;
- static const int mask = (1 << kBitsOfIPerItem) - 1;
- // Each iteration of the following is a test. It uses i as bit vector
- // encoding the keys and values to put in the wire format.
- for (int i = 0; i < (1 << (items * kBitsOfIPerItem)); i++) {
- string wire_format = data;
- int expected_key = 0;
- int expected_value = 0;
- for (int k = i, j = 0; j < items; j++, k >>= kBitsOfIPerItem) {
- bool is_key = k & 0x1;
- bool is_value = !is_key && (k & 0x2);
- wire_format.push_back(is_key ? kKeyTag :
- is_value ? kValueTag : kJunkTag);
- char c = static_cast<char>(k & mask) >> 2; // One char after the tag.
- wire_format.push_back(c);
- if (is_key) expected_key = static_cast<int>(c);
- if (is_value) expected_value = static_cast<int>(c);
- ASSERT_TRUE(message.ParseFromString(wire_format));
- ASSERT_EQ(1, message.map_int32_int32().size());
- ASSERT_EQ(expected_key, message.map_int32_int32().begin()->first);
- ASSERT_EQ(expected_value, message.map_int32_int32().begin()->second);
- }
- }
- }
}
TEST(GeneratedMapFieldTest, DuplicatedValueWireFormat) {
@@ -2309,74 +2189,6 @@ TEST(GeneratedMapFieldTest, IsInitialized) {
EXPECT_TRUE(map_message.IsInitialized());
}
-TEST(GeneratedMapFieldTest, MessagesMustMerge) {
- unittest::TestRequiredMessageMap map_message;
- unittest::TestRequired with_dummy4;
- with_dummy4.set_a(97);
- with_dummy4.set_b(0);
- with_dummy4.set_c(0);
- with_dummy4.set_dummy4(98);
-
- EXPECT_TRUE(with_dummy4.IsInitialized());
- (*map_message.mutable_map_field())[0] = with_dummy4;
- EXPECT_TRUE(map_message.IsInitialized());
- string s = map_message.SerializeAsString();
-
- // Modify s so that there are two values in the entry for key 0.
- // The first will have no value for c. The second will have no value for a.
- // Those are required fields. Also, make some other little changes, to
- // ensure we are merging the two values (because they're messages).
- ASSERT_EQ(s.size() - 2, s[1]); // encoding of the length of what follows
- string encoded_val(s.data() + 4, s.data() + s.size());
- // In s, change the encoding of c to an encoding of dummy32.
- s[s.size() - 3] -= 8;
- // Make encoded_val slightly different from what's in s.
- encoded_val[encoded_val.size() - 1] += 33; // Encode c = 33.
- for (int i = 0; i < encoded_val.size(); i++) {
- if (encoded_val[i] == 97) {
- // Encode b = 91 instead of a = 97. But this won't matter, because
- // we also encode b = 0 right after this. The point is to leave out
- // a required field, and make sure the parser doesn't complain, because
- // every required field is set after the merge of the two values.
- encoded_val[i - 1] += 16;
- encoded_val[i] = 91;
- } else if (encoded_val[i] == 98) {
- // Encode dummy5 = 99 instead of dummy4 = 98.
- encoded_val[i - 1] += 8; // The tag for dummy5 is 8 more.
- encoded_val[i]++;
- break;
- }
- }
-
- s += encoded_val; // Add the second message.
- s[1] += encoded_val.size(); // Adjust encoded size.
-
- // Test key then value then value.
- int key = 0;
- ASSERT_TRUE(map_message.ParseFromString(s));
- ASSERT_EQ(1, map_message.map_field().size());
- ASSERT_EQ(1, map_message.map_field().count(key));
- EXPECT_EQ(97, map_message.map_field().find(key)->second.a());
- EXPECT_EQ(0, map_message.map_field().find(key)->second.b());
- EXPECT_EQ(33, map_message.map_field().find(key)->second.c());
- EXPECT_EQ(98, map_message.map_field().find(key)->second.dummy4());
- EXPECT_EQ(99, map_message.map_field().find(key)->second.dummy5());
-
- // Test key then value then value then key.
- s.push_back(s[2]); // Copy the key's tag.
- key = 19;
- s.push_back(key); // Second key is 19 instead of 0.
- s[1] += 2; // Adjust encoded size.
- ASSERT_TRUE(map_message.ParseFromString(s));
- ASSERT_EQ(1, map_message.map_field().size());
- ASSERT_EQ(1, map_message.map_field().count(key));
- EXPECT_EQ(97, map_message.map_field().find(key)->second.a());
- EXPECT_EQ(0, map_message.map_field().find(key)->second.b());
- EXPECT_EQ(33, map_message.map_field().find(key)->second.c());
- EXPECT_EQ(98, map_message.map_field().find(key)->second.dummy4());
- EXPECT_EQ(99, map_message.map_field().find(key)->second.dummy5());
-}
-
// Generated Message Reflection Test ================================
TEST(GeneratedMapFieldReflectionTest, SpaceUsed) {
@@ -2437,7 +2249,7 @@ TEST(GeneratedMapFieldReflectionTest, SwapFields) {
MapTestUtil::SetMapFields(&message2);
- std::vector<const FieldDescriptor*> fields;
+ vector<const FieldDescriptor*> fields;
const Reflection* reflection = message1.GetReflection();
reflection->ListFields(message2, &fields);
reflection->SwapFields(&message1, &message2, fields);
@@ -2870,112 +2682,6 @@ TEST(WireFormatForMapFieldTest, MapParseHelpers) {
}
}
-// Deterministic Serialization Test ==========================================
-
-template <typename T>
-static string DeterministicSerializationWithSerializePartialToCodedStream(
- const T& t) {
- const int size = t.ByteSize();
- string result(size, '\0');
- io::ArrayOutputStream array_stream(string_as_array(&result), size);
- io::CodedOutputStream output_stream(&array_stream);
- output_stream.SetSerializationDeterministic(true);
- t.SerializePartialToCodedStream(&output_stream);
- EXPECT_FALSE(output_stream.HadError());
- EXPECT_EQ(size, output_stream.ByteCount());
- return result;
-}
-
-template <typename T>
-static string DeterministicSerializationWithSerializeToCodedStream(const T& t) {
- const int size = t.ByteSize();
- string result(size, '\0');
- io::ArrayOutputStream array_stream(string_as_array(&result), size);
- io::CodedOutputStream output_stream(&array_stream);
- output_stream.SetSerializationDeterministic(true);
- t.SerializeToCodedStream(&output_stream);
- EXPECT_FALSE(output_stream.HadError());
- EXPECT_EQ(size, output_stream.ByteCount());
- return result;
-}
-
-template <typename T>
-static string DeterministicSerialization(const T& t) {
- const int size = t.ByteSize();
- string result(size, '\0');
- io::ArrayOutputStream array_stream(string_as_array(&result), size);
- io::CodedOutputStream output_stream(&array_stream);
- output_stream.SetSerializationDeterministic(true);
- t.SerializeWithCachedSizes(&output_stream);
- EXPECT_FALSE(output_stream.HadError());
- EXPECT_EQ(size, output_stream.ByteCount());
- EXPECT_EQ(result, DeterministicSerializationWithSerializeToCodedStream(t));
- EXPECT_EQ(result,
- DeterministicSerializationWithSerializePartialToCodedStream(t));
- return result;
-}
-
-// Helper to test the serialization of the first arg against a golden file.
-static void TestDeterministicSerialization(const protobuf_unittest::TestMaps& t,
- const string& filename) {
- string expected;
- GOOGLE_CHECK_OK(File::GetContents(
- TestSourceDir() + "/google/protobuf/testdata/" + filename,
- &expected, true));
- const string actual = DeterministicSerialization(t);
- EXPECT_EQ(expected, actual);
- protobuf_unittest::TestMaps u;
- EXPECT_TRUE(u.ParseFromString(actual));
- EXPECT_TRUE(google::protobuf::util::MessageDifferencer::Equals(u, t));
-}
-
-// Helper for MapSerializationTest. Return a 7-bit ASCII string.
-static string ConstructKey(uint64 n) {
- string s(n % static_cast<uint64>(9), '\0');
- if (s.empty()) {
- return StrCat(n);
- } else {
- while (n != 0) {
- s[n % s.size()] = (n >> 10) & 0x7f;
- n /= 888;
- }
- return s;
- }
-}
-
-TEST(MapSerializationTest, Deterministic) {
- const int kIters = 25;
- protobuf_unittest::TestMaps t;
- protobuf_unittest::TestIntIntMap inner;
- (*inner.mutable_m())[0] = (*inner.mutable_m())[10] =
- (*inner.mutable_m())[-200] = 0;
- uint64 frog = 9;
- const uint64 multiplier = 0xa29cd16f;
- for (int i = 0; i < kIters; i++) {
- const int32 i32 = static_cast<int32>(frog & 0xffffffff);
- const uint32 u32 = static_cast<uint32>(i32) * 91919;
- const int64 i64 = static_cast<int64>(frog);
- const uint64 u64 = frog * static_cast<uint64>(187321);
- const bool b = i32 > 0;
- const string s = ConstructKey(frog);
- (*inner.mutable_m())[i] = i32;
- (*t.mutable_m_int32())[i32] = (*t.mutable_m_sint32())[i32] =
- (*t.mutable_m_sfixed32())[i32] = inner;
- (*t.mutable_m_uint32())[u32] = (*t.mutable_m_fixed32())[u32] = inner;
- (*t.mutable_m_int64())[i64] = (*t.mutable_m_sint64())[i64] =
- (*t.mutable_m_sfixed64())[i64] = inner;
- (*t.mutable_m_uint64())[u64] = (*t.mutable_m_fixed64())[u64] = inner;
- (*t.mutable_m_bool())[b] = inner;
- (*t.mutable_m_string())[s] = inner;
- (*t.mutable_m_string())[s + string(1 << (u32 % static_cast<uint32>(9)),
- b)] = inner;
- inner.mutable_m()->erase(i);
- frog = frog * multiplier + i;
- frog ^= (frog >> 41);
- }
- TestDeterministicSerialization(t, "golden_message_maps");
-}
-
// Text Format Test =================================================
TEST(TextFormatMapTest, SerializeAndParse) {
@@ -3013,18 +2719,6 @@ TEST(TextFormatMapTest, Sorted) {
EXPECT_EQ(message2.DebugString(), expected_text);
}
-TEST(TextFormatMapTest, ParseCorruptedString) {
- string serialized_message;
- GOOGLE_CHECK_OK(File::GetContents(
- TestSourceDir() +
- "/google/protobuf/testdata/golden_message_maps",
- &serialized_message, true));
- protobuf_unittest::TestMaps message;
- GOOGLE_CHECK(message.ParseFromString(serialized_message));
- TestParseCorruptedString<protobuf_unittest::TestMaps, true>(message);
- TestParseCorruptedString<protobuf_unittest::TestMaps, false>(message);
-}
-
// arena support =================================================
TEST(ArenaTest, ParsingAndSerializingNoHeapAllocation) {
@@ -3089,21 +2783,6 @@ TEST(ArenaTest, StringMapNoLeak) {
ASSERT_FALSE(message == NULL);
}
-TEST(ArenaTest, IsInitialized) {
- // Allocate a large initial polluted block.
- std::vector<char> arena_block(128 * 1024);
- std::fill(arena_block.begin(), arena_block.end(), '\xff');
-
- ArenaOptions options;
- options.initial_block = &arena_block[0];
- options.initial_block_size = arena_block.size();
- Arena arena(options);
-
- unittest::TestArenaMap* message =
- Arena::CreateMessage<unittest::TestArenaMap>(&arena);
- EXPECT_EQ(0, (*message->mutable_map_int32_int32())[0]);
-}
-
} // namespace internal
} // namespace protobuf
} // namespace google

Powered by Google App Engine
This is Rietveld 408576698