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 // Author: ksroka@google.com (Krzysztof Sroka)
32
33 #include <google/protobuf/util/field_comparator.h>
34
35 #include <limits>
36
37 #include <google/protobuf/unittest.pb.h>
38 #include <google/protobuf/descriptor.h>
39 #include <gtest/gtest.h>
40 #include <google/protobuf/stubs/mathutil.h>
41
42 namespace google {
43 namespace protobuf {
44 namespace util {
45 namespace {
46
47 using protobuf_unittest::TestAllTypes;
48
49 class DefaultFieldComparatorTest : public ::testing::Test {
50 protected:
SetUp()51 void SetUp() { descriptor_ = TestAllTypes::descriptor(); }
52
53 const Descriptor* descriptor_;
54 DefaultFieldComparator comparator_;
55 TestAllTypes message_1_;
56 TestAllTypes message_2_;
57 };
58
TEST_F(DefaultFieldComparatorTest,RecursesIntoGroup)59 TEST_F(DefaultFieldComparatorTest, RecursesIntoGroup) {
60 const FieldDescriptor* field = descriptor_->FindFieldByName("optionalgroup");
61 EXPECT_EQ(FieldComparator::RECURSE,
62 comparator_.Compare(message_1_, message_2_, field, -1, -1, NULL));
63 }
64
TEST_F(DefaultFieldComparatorTest,RecursesIntoNestedMessage)65 TEST_F(DefaultFieldComparatorTest, RecursesIntoNestedMessage) {
66 const FieldDescriptor* field =
67 descriptor_->FindFieldByName("optional_nested_message");
68 EXPECT_EQ(FieldComparator::RECURSE,
69 comparator_.Compare(message_1_, message_2_, field, -1, -1, NULL));
70 }
71
TEST_F(DefaultFieldComparatorTest,RecursesIntoForeignMessage)72 TEST_F(DefaultFieldComparatorTest, RecursesIntoForeignMessage) {
73 const FieldDescriptor* field =
74 descriptor_->FindFieldByName("optional_foreign_message");
75 EXPECT_EQ(FieldComparator::RECURSE,
76 comparator_.Compare(message_1_, message_2_, field, -1, -1, NULL));
77 }
78
TEST_F(DefaultFieldComparatorTest,Int32Comparison)79 TEST_F(DefaultFieldComparatorTest, Int32Comparison) {
80 const FieldDescriptor* field = descriptor_->FindFieldByName("optional_int32");
81 message_1_.set_optional_int32(1);
82 message_2_.set_optional_int32(1);
83
84 EXPECT_EQ(FieldComparator::SAME,
85 comparator_.Compare(message_1_, message_2_, field, -1, -1, NULL));
86
87 message_2_.set_optional_int32(-1);
88 EXPECT_EQ(FieldComparator::DIFFERENT,
89 comparator_.Compare(message_1_, message_2_, field, -1, -1, NULL));
90 }
91
TEST_F(DefaultFieldComparatorTest,Int64Comparison)92 TEST_F(DefaultFieldComparatorTest, Int64Comparison) {
93 const FieldDescriptor* field = descriptor_->FindFieldByName("optional_int64");
94 message_1_.set_optional_int64(1L);
95 message_2_.set_optional_int64(1L);
96
97 EXPECT_EQ(FieldComparator::SAME,
98 comparator_.Compare(message_1_, message_2_, field, -1, -1, NULL));
99
100 message_2_.set_optional_int64(-1L);
101 EXPECT_EQ(FieldComparator::DIFFERENT,
102 comparator_.Compare(message_1_, message_2_, field, -1, -1, NULL));
103 }
104
TEST_F(DefaultFieldComparatorTest,UInt32Comparison)105 TEST_F(DefaultFieldComparatorTest, UInt32Comparison) {
106 const FieldDescriptor* field =
107 descriptor_->FindFieldByName("optional_uint32");
108 message_1_.set_optional_uint32(1);
109 message_2_.set_optional_uint32(1);
110
111 EXPECT_EQ(FieldComparator::SAME,
112 comparator_.Compare(message_1_, message_2_, field, -1, -1, NULL));
113
114 message_2_.set_optional_uint32(2);
115 EXPECT_EQ(FieldComparator::DIFFERENT,
116 comparator_.Compare(message_1_, message_2_, field, -1, -1, NULL));
117 }
118
TEST_F(DefaultFieldComparatorTest,UInt64Comparison)119 TEST_F(DefaultFieldComparatorTest, UInt64Comparison) {
120 const FieldDescriptor* field =
121 descriptor_->FindFieldByName("optional_uint64");
122 message_1_.set_optional_uint64(1L);
123 message_2_.set_optional_uint64(1L);
124
125 EXPECT_EQ(FieldComparator::SAME,
126 comparator_.Compare(message_1_, message_2_, field, -1, -1, NULL));
127
128 message_2_.set_optional_uint64(2L);
129 EXPECT_EQ(FieldComparator::DIFFERENT,
130 comparator_.Compare(message_1_, message_2_, field, -1, -1, NULL));
131 }
132
TEST_F(DefaultFieldComparatorTest,BooleanComparison)133 TEST_F(DefaultFieldComparatorTest, BooleanComparison) {
134 const FieldDescriptor* field = descriptor_->FindFieldByName("optional_bool");
135 message_1_.set_optional_bool(true);
136 message_2_.set_optional_bool(true);
137
138 EXPECT_EQ(FieldComparator::SAME,
139 comparator_.Compare(message_1_, message_2_, field, -1, -1, NULL));
140
141 message_2_.set_optional_bool(false);
142 EXPECT_EQ(FieldComparator::DIFFERENT,
143 comparator_.Compare(message_1_, message_2_, field, -1, -1, NULL));
144 }
145
TEST_F(DefaultFieldComparatorTest,EnumComparison)146 TEST_F(DefaultFieldComparatorTest, EnumComparison) {
147 const FieldDescriptor* field =
148 descriptor_->FindFieldByName("optional_nested_enum");
149 message_1_.set_optional_nested_enum(TestAllTypes::BAR);
150 message_2_.set_optional_nested_enum(TestAllTypes::BAR);
151
152 EXPECT_EQ(FieldComparator::SAME,
153 comparator_.Compare(message_1_, message_2_, field, -1, -1, NULL));
154
155 message_2_.set_optional_nested_enum(TestAllTypes::BAZ);
156 EXPECT_EQ(FieldComparator::DIFFERENT,
157 comparator_.Compare(message_1_, message_2_, field, -1, -1, NULL));
158 }
159
TEST_F(DefaultFieldComparatorTest,StringComparison)160 TEST_F(DefaultFieldComparatorTest, StringComparison) {
161 const FieldDescriptor* field =
162 descriptor_->FindFieldByName("optional_string");
163 message_1_.set_optional_string("foo");
164 message_2_.set_optional_string("foo");
165
166 EXPECT_EQ(FieldComparator::SAME,
167 comparator_.Compare(message_1_, message_2_, field, -1, -1, NULL));
168
169 message_2_.set_optional_string("bar");
170 EXPECT_EQ(FieldComparator::DIFFERENT,
171 comparator_.Compare(message_1_, message_2_, field, -1, -1, NULL));
172 }
173
TEST_F(DefaultFieldComparatorTest,FloatingPointComparisonExact)174 TEST_F(DefaultFieldComparatorTest, FloatingPointComparisonExact) {
175 const FieldDescriptor* field_float =
176 descriptor_->FindFieldByName("optional_float");
177 const FieldDescriptor* field_double =
178 descriptor_->FindFieldByName("optional_double");
179
180 message_1_.set_optional_float(0.1f);
181 message_2_.set_optional_float(0.1f);
182 message_1_.set_optional_double(0.1);
183 message_2_.set_optional_double(0.1);
184
185 EXPECT_EQ(
186 FieldComparator::SAME,
187 comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
188 EXPECT_EQ(
189 FieldComparator::SAME,
190 comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
191
192 message_2_.set_optional_float(0.2f);
193 message_2_.set_optional_double(0.2);
194
195 EXPECT_EQ(
196 FieldComparator::DIFFERENT,
197 comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
198 EXPECT_EQ(
199 FieldComparator::DIFFERENT,
200 comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
201 }
202
TEST_F(DefaultFieldComparatorTest,FloatingPointComparisonApproximate)203 TEST_F(DefaultFieldComparatorTest, FloatingPointComparisonApproximate) {
204 const FieldDescriptor* field_float =
205 descriptor_->FindFieldByName("optional_float");
206 const FieldDescriptor* field_double =
207 descriptor_->FindFieldByName("optional_double");
208
209 message_1_.set_optional_float(2.300005f);
210 message_2_.set_optional_float(2.300006f);
211 message_1_.set_optional_double(2.3000000000000003);
212 message_2_.set_optional_double(2.3000000000000007);
213
214 // Approximate comparison depends on MathUtil, so we assert on MathUtil
215 // results first to check if that's where the failure was introduced.
216 ASSERT_NE(message_1_.optional_float(), message_2_.optional_float());
217 ASSERT_NE(message_1_.optional_double(), message_2_.optional_double());
218 ASSERT_TRUE(MathUtil::AlmostEquals(message_1_.optional_float(),
219 message_2_.optional_float()));
220 ASSERT_TRUE(MathUtil::AlmostEquals(message_1_.optional_double(),
221 message_2_.optional_double()));
222
223 // DefaultFieldComparator's default float comparison mode is EXACT.
224 ASSERT_EQ(DefaultFieldComparator::EXACT, comparator_.float_comparison());
225 EXPECT_EQ(
226 FieldComparator::DIFFERENT,
227 comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
228 EXPECT_EQ(
229 FieldComparator::DIFFERENT,
230 comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
231
232 comparator_.set_float_comparison(DefaultFieldComparator::APPROXIMATE);
233
234 EXPECT_EQ(
235 FieldComparator::SAME,
236 comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
237 EXPECT_EQ(
238 FieldComparator::SAME,
239 comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
240 }
241
TEST_F(DefaultFieldComparatorTest,FloatingPointComparisonTreatNaNsAsEqual)242 TEST_F(DefaultFieldComparatorTest, FloatingPointComparisonTreatNaNsAsEqual) {
243 const FieldDescriptor* field_float =
244 descriptor_->FindFieldByName("optional_float");
245 const FieldDescriptor* field_double =
246 descriptor_->FindFieldByName("optional_double");
247
248 message_1_.set_optional_float(std::numeric_limits<float>::quiet_NaN());
249 message_2_.set_optional_float(std::numeric_limits<float>::quiet_NaN());
250 message_1_.set_optional_double(std::numeric_limits<double>::quiet_NaN());
251 message_2_.set_optional_double(std::numeric_limits<double>::quiet_NaN());
252
253 // DefaultFieldComparator's default float comparison mode is EXACT with
254 // treating NaNs as different.
255 ASSERT_EQ(DefaultFieldComparator::EXACT, comparator_.float_comparison());
256 ASSERT_EQ(false, comparator_.treat_nan_as_equal());
257 EXPECT_EQ(
258 FieldComparator::DIFFERENT,
259 comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
260 EXPECT_EQ(
261 FieldComparator::DIFFERENT,
262 comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
263 comparator_.set_float_comparison(DefaultFieldComparator::APPROXIMATE);
264 EXPECT_EQ(
265 FieldComparator::DIFFERENT,
266 comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
267 EXPECT_EQ(
268 FieldComparator::DIFFERENT,
269 comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
270
271 comparator_.set_treat_nan_as_equal(true);
272 ASSERT_EQ(true, comparator_.treat_nan_as_equal());
273 comparator_.set_float_comparison(DefaultFieldComparator::EXACT);
274 EXPECT_EQ(
275 FieldComparator::SAME,
276 comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
277 EXPECT_EQ(
278 FieldComparator::SAME,
279 comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
280 comparator_.set_float_comparison(DefaultFieldComparator::APPROXIMATE);
281 EXPECT_EQ(
282 FieldComparator::SAME,
283 comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
284 EXPECT_EQ(
285 FieldComparator::SAME,
286 comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
287 }
288
TEST_F(DefaultFieldComparatorTest,FloatingPointComparisonWithinFractionOrMargin)289 TEST_F(DefaultFieldComparatorTest,
290 FloatingPointComparisonWithinFractionOrMargin) {
291 const FieldDescriptor* field_float =
292 descriptor_->FindFieldByName("optional_float");
293 const FieldDescriptor* field_double =
294 descriptor_->FindFieldByName("optional_double");
295
296 message_1_.set_optional_float(100.0f);
297 message_2_.set_optional_float(109.9f);
298 message_1_.set_optional_double(100.0);
299 message_2_.set_optional_double(109.9);
300
301 comparator_.set_float_comparison(DefaultFieldComparator::APPROXIMATE);
302 EXPECT_EQ(
303 FieldComparator::DIFFERENT,
304 comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
305 EXPECT_EQ(
306 FieldComparator::DIFFERENT,
307 comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
308
309 // Should fail since the fraction is too low.
310 comparator_.SetFractionAndMargin(field_float, 0.01, 0.0);
311 comparator_.SetFractionAndMargin(field_double, 0.01, 0.0);
312
313 EXPECT_EQ(
314 FieldComparator::DIFFERENT,
315 comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
316 EXPECT_EQ(
317 FieldComparator::DIFFERENT,
318 comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
319
320 // Should fail since the margin is too low.
321 comparator_.SetFractionAndMargin(field_float, 0.0, 9.0);
322 comparator_.SetFractionAndMargin(field_double, 0.0, 9.0);
323 EXPECT_EQ(
324 FieldComparator::DIFFERENT,
325 comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
326 EXPECT_EQ(
327 FieldComparator::DIFFERENT,
328 comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
329
330 // Should succeed since the fraction is high enough.
331 comparator_.SetFractionAndMargin(field_float, 0.2, 0.0);
332 comparator_.SetFractionAndMargin(field_double, 0.2, 0.0);
333 EXPECT_EQ(
334 FieldComparator::SAME,
335 comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
336 EXPECT_EQ(
337 FieldComparator::SAME,
338 comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
339
340 // Should succeed since the margin is high enough.
341 comparator_.SetFractionAndMargin(field_float, 0.0, 10.0);
342 comparator_.SetFractionAndMargin(field_double, 0.0, 10.0);
343 EXPECT_EQ(
344 FieldComparator::SAME,
345 comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
346 EXPECT_EQ(
347 FieldComparator::SAME,
348 comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
349
350 // Setting values for one of the fields should not affect the other.
351 comparator_.SetFractionAndMargin(field_double, 0.0, 0.0);
352 EXPECT_EQ(
353 FieldComparator::SAME,
354 comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
355 EXPECT_EQ(
356 FieldComparator::DIFFERENT,
357 comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
358
359 // +inf should be equal even though they are not technically within margin or
360 // fraction.
361 message_1_.set_optional_float(std::numeric_limits<float>::infinity());
362 message_2_.set_optional_float(std::numeric_limits<float>::infinity());
363 message_1_.set_optional_double(std::numeric_limits<double>::infinity());
364 message_2_.set_optional_double(std::numeric_limits<double>::infinity());
365 comparator_.SetFractionAndMargin(field_float, 0.0, 0.0);
366 comparator_.SetFractionAndMargin(field_double, 0.0, 0.0);
367 EXPECT_EQ(
368 FieldComparator::SAME,
369 comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
370 EXPECT_EQ(
371 FieldComparator::SAME,
372 comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
373
374 // -inf should be equal even though they are not technically within margin or
375 // fraction.
376 message_1_.set_optional_float(-std::numeric_limits<float>::infinity());
377 message_2_.set_optional_float(-std::numeric_limits<float>::infinity());
378 message_1_.set_optional_double(-std::numeric_limits<double>::infinity());
379 message_2_.set_optional_double(-std::numeric_limits<double>::infinity());
380 comparator_.SetFractionAndMargin(field_float, 0.0, 0.0);
381 comparator_.SetFractionAndMargin(field_double, 0.0, 0.0);
382 EXPECT_EQ(
383 FieldComparator::SAME,
384 comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
385 EXPECT_EQ(
386 FieldComparator::SAME,
387 comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
388
389 // Finite values and inf should not be equal, even for a positive fraction.
390 message_1_.set_optional_float(std::numeric_limits<float>::infinity());
391 message_2_.set_optional_float(0.0f);
392 message_1_.set_optional_double(std::numeric_limits<double>::infinity());
393 message_2_.set_optional_double(0.0);
394 comparator_.SetFractionAndMargin(field_float, 0.1, 0.0);
395 comparator_.SetFractionAndMargin(field_double, 0.1, 0.0);
396 EXPECT_EQ(FieldComparator::DIFFERENT,
397 comparator_.Compare(message_1_, message_2_, field_float, -1, -1,
398 nullptr));
399 EXPECT_EQ(FieldComparator::DIFFERENT,
400 comparator_.Compare(message_1_, message_2_, field_double, -1, -1,
401 nullptr));
402 }
403
TEST_F(DefaultFieldComparatorTest,FloatingPointComparisonWithinDefaultFractionOrMargin)404 TEST_F(DefaultFieldComparatorTest,
405 FloatingPointComparisonWithinDefaultFractionOrMargin) {
406 const FieldDescriptor* field_float =
407 descriptor_->FindFieldByName("optional_float");
408 const FieldDescriptor* field_double =
409 descriptor_->FindFieldByName("optional_double");
410
411 message_1_.set_optional_float(100.0f);
412 message_2_.set_optional_float(109.9f);
413 message_1_.set_optional_double(100.0);
414 message_2_.set_optional_double(109.9);
415
416 comparator_.set_float_comparison(DefaultFieldComparator::APPROXIMATE);
417 EXPECT_EQ(
418 FieldComparator::DIFFERENT,
419 comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
420 EXPECT_EQ(
421 FieldComparator::DIFFERENT,
422 comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
423
424 // Set default fraction and margin.
425 comparator_.SetDefaultFractionAndMargin(0.01, 0.0);
426
427 // Float comparisons should fail since the fraction is too low.
428 EXPECT_EQ(
429 FieldComparator::DIFFERENT,
430 comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
431 EXPECT_EQ(
432 FieldComparator::DIFFERENT,
433 comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
434
435 // Set field-specific fraction and margin for one field (field_float) but not
436 // the other (field_double)
437 comparator_.SetFractionAndMargin(field_float, 0.2, 0.0);
438
439 // The field with the override should succeed, since its field-specific
440 // fraction is high enough.
441 EXPECT_EQ(
442 FieldComparator::SAME,
443 comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
444 // The field with no override should fail, since the default fraction is too
445 // low
446 EXPECT_EQ(
447 FieldComparator::DIFFERENT,
448 comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
449
450 // Set the default fraction and margin high enough so that fields that use
451 // the default should succeed
452 comparator_.SetDefaultFractionAndMargin(0.2, 0.0);
453 EXPECT_EQ(
454 FieldComparator::SAME,
455 comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
456
457 // The field with an override should still be OK
458 EXPECT_EQ(
459 FieldComparator::SAME,
460 comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
461
462 // Set fraction and margin for the field with an override to be too low
463 comparator_.SetFractionAndMargin(field_float, 0.01, 0.0);
464
465 // Now our default is high enough but field_float's override is too low.
466 EXPECT_EQ(
467 FieldComparator::DIFFERENT,
468 comparator_.Compare(message_1_, message_2_, field_float, -1, -1, NULL));
469 EXPECT_EQ(
470 FieldComparator::SAME,
471 comparator_.Compare(message_1_, message_2_, field_double, -1, -1, NULL));
472 }
473
474 // Simple test checking whether we compare values at correct indices.
TEST_F(DefaultFieldComparatorTest,RepeatedFieldComparison)475 TEST_F(DefaultFieldComparatorTest, RepeatedFieldComparison) {
476 const FieldDescriptor* field =
477 descriptor_->FindFieldByName("repeated_string");
478
479 message_1_.add_repeated_string("foo");
480 message_1_.add_repeated_string("bar");
481 message_2_.add_repeated_string("bar");
482 message_2_.add_repeated_string("baz");
483
484 EXPECT_EQ(FieldComparator::DIFFERENT,
485 comparator_.Compare(message_1_, message_2_, field, 0, 0, NULL));
486 EXPECT_EQ(FieldComparator::DIFFERENT,
487 comparator_.Compare(message_1_, message_2_, field, 1, 1, NULL));
488 EXPECT_EQ(FieldComparator::SAME,
489 comparator_.Compare(message_1_, message_2_, field, 1, 0, NULL));
490 }
491
492 } // namespace
493 } // namespace util
494 } // namespace protobuf
495 } // namespace google
496