cpp_unittest.cc revision d0332953cda33fb4f8e24ebff9c49159b69c43d6 
1// Protocol Buffers - Google's data interchange format
2// Copyright 2008 Google Inc.  All rights reserved.
3// http://code.google.com/p/protobuf/
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: kenton@google.com (Kenton Varda)
32//  Based on original Protocol Buffers design by
33//  Sanjay Ghemawat, Jeff Dean, and others.
34//
35// To test the code generator, we actually use it to generate code for
36// google/protobuf/unittest.proto, then test that.  This means that we
37// are actually testing the parser and other parts of the system at the same
38// time, and that problems in the generator may show up as compile-time errors
39// rather than unittest failures, which may be surprising.  However, testing
40// the output of the C++ generator directly would be very hard.  We can't very
41// well just check it against golden files since those files would have to be
42// updated for any small change; such a test would be very brittle and probably
43// not very helpful.  What we really want to test is that the code compiles
44// correctly and produces the interfaces we expect, which is why this test
45// is written this way.
46
47#include <vector>
48
49#include <google/protobuf/unittest.pb.h>
50#include <google/protobuf/unittest_optimize_for.pb.h>
51#include <google/protobuf/unittest_embed_optimize_for.pb.h>
52#include <google/protobuf/unittest_no_generic_services.pb.h>
53#include <google/protobuf/test_util.h>
54#include <google/protobuf/compiler/cpp/cpp_test_bad_identifiers.pb.h>
55#include <google/protobuf/compiler/importer.h>
56#include <google/protobuf/io/coded_stream.h>
57#include <google/protobuf/io/zero_copy_stream_impl.h>
58#include <google/protobuf/descriptor.h>
59#include <google/protobuf/descriptor.pb.h>
60#include <google/protobuf/dynamic_message.h>
61
62#include <google/protobuf/stubs/common.h>
63#include <google/protobuf/stubs/strutil.h>
64#include <google/protobuf/stubs/substitute.h>
65#include <google/protobuf/testing/googletest.h>
66#include <gtest/gtest.h>
67#include <google/protobuf/stubs/stl_util-inl.h>
68
69namespace google {
70namespace protobuf {
71namespace compiler {
72namespace cpp {
73
74// Can't use an anonymous namespace here due to brokenness of Tru64 compiler.
75namespace cpp_unittest {
76
77
78class MockErrorCollector : public MultiFileErrorCollector {
79 public:
80  MockErrorCollector() {}
81  ~MockErrorCollector() {}
82
83  string text_;
84
85  // implements ErrorCollector ---------------------------------------
86  void AddError(const string& filename, int line, int column,
87                const string& message) {
88    strings::SubstituteAndAppend(&text_, "$0:$1:$2: $3\n",
89                                 filename, line, column, message);
90  }
91};
92
93#ifndef PROTOBUF_TEST_NO_DESCRIPTORS
94
95// Test that generated code has proper descriptors:
96// Parse a descriptor directly (using google::protobuf::compiler::Importer) and
97// compare it to the one that was produced by generated code.
98TEST(GeneratedDescriptorTest, IdenticalDescriptors) {
99  const FileDescriptor* generated_descriptor =
100    unittest::TestAllTypes::descriptor()->file();
101
102  // Set up the Importer.
103  MockErrorCollector error_collector;
104  DiskSourceTree source_tree;
105  source_tree.MapPath("", TestSourceDir());
106  Importer importer(&source_tree, &error_collector);
107
108  // Import (parse) unittest.proto.
109  const FileDescriptor* parsed_descriptor =
110    importer.Import("google/protobuf/unittest.proto");
111  EXPECT_EQ("", error_collector.text_);
112  ASSERT_TRUE(parsed_descriptor != NULL);
113
114  // Test that descriptors are generated correctly by converting them to
115  // FileDescriptorProtos and comparing.
116  FileDescriptorProto generated_decsriptor_proto, parsed_descriptor_proto;
117  generated_descriptor->CopyTo(&generated_decsriptor_proto);
118  parsed_descriptor->CopyTo(&parsed_descriptor_proto);
119
120  EXPECT_EQ(parsed_descriptor_proto.DebugString(),
121            generated_decsriptor_proto.DebugString());
122}
123
124#endif  // !PROTOBUF_TEST_NO_DESCRIPTORS
125
126// ===================================================================
127
128TEST(GeneratedMessageTest, Defaults) {
129  // Check that all default values are set correctly in the initial message.
130  unittest::TestAllTypes message;
131
132  TestUtil::ExpectClear(message);
133
134  // Messages should return pointers to default instances until first use.
135  // (This is not checked by ExpectClear() since it is not actually true after
136  // the fields have been set and then cleared.)
137  EXPECT_EQ(&unittest::TestAllTypes::OptionalGroup::default_instance(),
138            &message.optionalgroup());
139  EXPECT_EQ(&unittest::TestAllTypes::NestedMessage::default_instance(),
140            &message.optional_nested_message());
141  EXPECT_EQ(&unittest::ForeignMessage::default_instance(),
142            &message.optional_foreign_message());
143  EXPECT_EQ(&unittest_import::ImportMessage::default_instance(),
144            &message.optional_import_message());
145}
146
147TEST(GeneratedMessageTest, FloatingPointDefaults) {
148  const unittest::TestExtremeDefaultValues& extreme_default =
149      unittest::TestExtremeDefaultValues::default_instance();
150
151  EXPECT_EQ(0.0f, extreme_default.zero_float());
152  EXPECT_EQ(1.0f, extreme_default.one_float());
153  EXPECT_EQ(1.5f, extreme_default.small_float());
154  EXPECT_EQ(-1.0f, extreme_default.negative_one_float());
155  EXPECT_EQ(-1.5f, extreme_default.negative_float());
156  EXPECT_EQ(2.0e8f, extreme_default.large_float());
157  EXPECT_EQ(-8e-28f, extreme_default.small_negative_float());
158  EXPECT_EQ(numeric_limits<double>::infinity(),
159            extreme_default.inf_double());
160  EXPECT_EQ(-numeric_limits<double>::infinity(),
161            extreme_default.neg_inf_double());
162  EXPECT_TRUE(extreme_default.nan_double() != extreme_default.nan_double());
163  EXPECT_EQ(numeric_limits<float>::infinity(),
164            extreme_default.inf_float());
165  EXPECT_EQ(-numeric_limits<float>::infinity(),
166            extreme_default.neg_inf_float());
167  EXPECT_TRUE(extreme_default.nan_float() != extreme_default.nan_float());
168}
169
170TEST(GeneratedMessageTest, Accessors) {
171  // Set every field to a unique value then go back and check all those
172  // values.
173  unittest::TestAllTypes message;
174
175  TestUtil::SetAllFields(&message);
176  TestUtil::ExpectAllFieldsSet(message);
177
178  TestUtil::ModifyRepeatedFields(&message);
179  TestUtil::ExpectRepeatedFieldsModified(message);
180}
181
182TEST(GeneratedMessageTest, MutableStringDefault) {
183  // mutable_foo() for a string should return a string initialized to its
184  // default value.
185  unittest::TestAllTypes message;
186
187  EXPECT_EQ("hello", *message.mutable_default_string());
188
189  // Note that the first time we call mutable_foo(), we get a newly-allocated
190  // string, but if we clear it and call it again, we get the same object again.
191  // We should verify that it has its default value in both cases.
192  message.set_default_string("blah");
193  message.Clear();
194
195  EXPECT_EQ("hello", *message.mutable_default_string());
196}
197
198TEST(GeneratedMessageTest, Clear) {
199  // Set every field to a unique value, clear the message, then check that
200  // it is cleared.
201  unittest::TestAllTypes message;
202
203  TestUtil::SetAllFields(&message);
204  message.Clear();
205  TestUtil::ExpectClear(message);
206
207  // Unlike with the defaults test, we do NOT expect that requesting embedded
208  // messages will return a pointer to the default instance.  Instead, they
209  // should return the objects that were created when mutable_blah() was
210  // called.
211  EXPECT_NE(&unittest::TestAllTypes::OptionalGroup::default_instance(),
212            &message.optionalgroup());
213  EXPECT_NE(&unittest::TestAllTypes::NestedMessage::default_instance(),
214            &message.optional_nested_message());
215  EXPECT_NE(&unittest::ForeignMessage::default_instance(),
216            &message.optional_foreign_message());
217  EXPECT_NE(&unittest_import::ImportMessage::default_instance(),
218            &message.optional_import_message());
219}
220
221TEST(GeneratedMessageTest, EmbeddedNullsInBytesCharStar) {
222  unittest::TestAllTypes message;
223
224  const char* value = "\0lalala\0\0";
225  message.set_optional_bytes(value, 9);
226  ASSERT_EQ(9, message.optional_bytes().size());
227  EXPECT_EQ(0, memcmp(value, message.optional_bytes().data(), 9));
228
229  message.add_repeated_bytes(value, 9);
230  ASSERT_EQ(9, message.repeated_bytes(0).size());
231  EXPECT_EQ(0, memcmp(value, message.repeated_bytes(0).data(), 9));
232}
233
234TEST(GeneratedMessageTest, ClearOneField) {
235  // Set every field to a unique value, then clear one value and insure that
236  // only that one value is cleared.
237  unittest::TestAllTypes message;
238
239  TestUtil::SetAllFields(&message);
240  int64 original_value = message.optional_int64();
241
242  // Clear the field and make sure it shows up as cleared.
243  message.clear_optional_int64();
244  EXPECT_FALSE(message.has_optional_int64());
245  EXPECT_EQ(0, message.optional_int64());
246
247  // Other adjacent fields should not be cleared.
248  EXPECT_TRUE(message.has_optional_int32());
249  EXPECT_TRUE(message.has_optional_uint32());
250
251  // Make sure if we set it again, then all fields are set.
252  message.set_optional_int64(original_value);
253  TestUtil::ExpectAllFieldsSet(message);
254}
255
256TEST(GeneratedMessageTest, StringCharStarLength) {
257  // Verify that we can use a char*,length to set one of the string fields.
258  unittest::TestAllTypes message;
259  message.set_optional_string("abcdef", 3);
260  EXPECT_EQ("abc", message.optional_string());
261
262  // Verify that we can use a char*,length to add to a repeated string field.
263  message.add_repeated_string("abcdef", 3);
264  EXPECT_EQ(1, message.repeated_string_size());
265  EXPECT_EQ("abc", message.repeated_string(0));
266
267  // Verify that we can use a char*,length to set a repeated string field.
268  message.set_repeated_string(0, "wxyz", 2);
269  EXPECT_EQ("wx", message.repeated_string(0));
270}
271
272
273TEST(GeneratedMessageTest, CopyFrom) {
274  unittest::TestAllTypes message1, message2;
275
276  TestUtil::SetAllFields(&message1);
277  message2.CopyFrom(message1);
278  TestUtil::ExpectAllFieldsSet(message2);
279
280  // Copying from self should be a no-op.
281  message2.CopyFrom(message2);
282  TestUtil::ExpectAllFieldsSet(message2);
283}
284
285TEST(GeneratedMessageTest, SwapWithEmpty) {
286  unittest::TestAllTypes message1, message2;
287  TestUtil::SetAllFields(&message1);
288
289  TestUtil::ExpectAllFieldsSet(message1);
290  TestUtil::ExpectClear(message2);
291  message1.Swap(&message2);
292  TestUtil::ExpectAllFieldsSet(message2);
293  TestUtil::ExpectClear(message1);
294}
295
296TEST(GeneratedMessageTest, SwapWithSelf) {
297  unittest::TestAllTypes message;
298  TestUtil::SetAllFields(&message);
299  TestUtil::ExpectAllFieldsSet(message);
300  message.Swap(&message);
301  TestUtil::ExpectAllFieldsSet(message);
302}
303
304TEST(GeneratedMessageTest, SwapWithOther) {
305  unittest::TestAllTypes message1, message2;
306
307  message1.set_optional_int32(123);
308  message1.set_optional_string("abc");
309  message1.mutable_optional_nested_message()->set_bb(1);
310  message1.set_optional_nested_enum(unittest::TestAllTypes::FOO);
311  message1.add_repeated_int32(1);
312  message1.add_repeated_int32(2);
313  message1.add_repeated_string("a");
314  message1.add_repeated_string("b");
315  message1.add_repeated_nested_message()->set_bb(7);
316  message1.add_repeated_nested_message()->set_bb(8);
317  message1.add_repeated_nested_enum(unittest::TestAllTypes::FOO);
318  message1.add_repeated_nested_enum(unittest::TestAllTypes::BAR);
319
320  message2.set_optional_int32(456);
321  message2.set_optional_string("def");
322  message2.mutable_optional_nested_message()->set_bb(2);
323  message2.set_optional_nested_enum(unittest::TestAllTypes::BAR);
324  message2.add_repeated_int32(3);
325  message2.add_repeated_string("c");
326  message2.add_repeated_nested_message()->set_bb(9);
327  message2.add_repeated_nested_enum(unittest::TestAllTypes::BAZ);
328
329  message1.Swap(&message2);
330
331  EXPECT_EQ(456, message1.optional_int32());
332  EXPECT_EQ("def", message1.optional_string());
333  EXPECT_EQ(2, message1.optional_nested_message().bb());
334  EXPECT_EQ(unittest::TestAllTypes::BAR, message1.optional_nested_enum());
335  ASSERT_EQ(1, message1.repeated_int32_size());
336  EXPECT_EQ(3, message1.repeated_int32(0));
337  ASSERT_EQ(1, message1.repeated_string_size());
338  EXPECT_EQ("c", message1.repeated_string(0));
339  ASSERT_EQ(1, message1.repeated_nested_message_size());
340  EXPECT_EQ(9, message1.repeated_nested_message(0).bb());
341  ASSERT_EQ(1, message1.repeated_nested_enum_size());
342  EXPECT_EQ(unittest::TestAllTypes::BAZ, message1.repeated_nested_enum(0));
343
344  EXPECT_EQ(123, message2.optional_int32());
345  EXPECT_EQ("abc", message2.optional_string());
346  EXPECT_EQ(1, message2.optional_nested_message().bb());
347  EXPECT_EQ(unittest::TestAllTypes::FOO, message2.optional_nested_enum());
348  ASSERT_EQ(2, message2.repeated_int32_size());
349  EXPECT_EQ(1, message2.repeated_int32(0));
350  EXPECT_EQ(2, message2.repeated_int32(1));
351  ASSERT_EQ(2, message2.repeated_string_size());
352  EXPECT_EQ("a", message2.repeated_string(0));
353  EXPECT_EQ("b", message2.repeated_string(1));
354  ASSERT_EQ(2, message2.repeated_nested_message_size());
355  EXPECT_EQ(7, message2.repeated_nested_message(0).bb());
356  EXPECT_EQ(8, message2.repeated_nested_message(1).bb());
357  ASSERT_EQ(2, message2.repeated_nested_enum_size());
358  EXPECT_EQ(unittest::TestAllTypes::FOO, message2.repeated_nested_enum(0));
359  EXPECT_EQ(unittest::TestAllTypes::BAR, message2.repeated_nested_enum(1));
360}
361
362TEST(GeneratedMessageTest, CopyConstructor) {
363  unittest::TestAllTypes message1;
364  TestUtil::SetAllFields(&message1);
365
366  unittest::TestAllTypes message2(message1);
367  TestUtil::ExpectAllFieldsSet(message2);
368}
369
370TEST(GeneratedMessageTest, CopyAssignmentOperator) {
371  unittest::TestAllTypes message1;
372  TestUtil::SetAllFields(&message1);
373
374  unittest::TestAllTypes message2;
375  message2 = message1;
376  TestUtil::ExpectAllFieldsSet(message2);
377
378  // Make sure that self-assignment does something sane.
379  message2 = message2;
380  TestUtil::ExpectAllFieldsSet(message2);
381}
382
383TEST(GeneratedMessageTest, UpcastCopyFrom) {
384  // Test the CopyFrom method that takes in the generic const Message&
385  // parameter.
386  unittest::TestAllTypes message1, message2;
387
388  TestUtil::SetAllFields(&message1);
389
390  const Message* source = implicit_cast<const Message*>(&message1);
391  message2.CopyFrom(*source);
392
393  TestUtil::ExpectAllFieldsSet(message2);
394}
395
396#ifndef PROTOBUF_TEST_NO_DESCRIPTORS
397
398TEST(GeneratedMessageTest, DynamicMessageCopyFrom) {
399  // Test copying from a DynamicMessage, which must fall back to using
400  // reflection.
401  unittest::TestAllTypes message2;
402
403  // Construct a new version of the dynamic message via the factory.
404  DynamicMessageFactory factory;
405  scoped_ptr<Message> message1;
406  message1.reset(factory.GetPrototype(
407                     unittest::TestAllTypes::descriptor())->New());
408
409  TestUtil::ReflectionTester reflection_tester(
410    unittest::TestAllTypes::descriptor());
411  reflection_tester.SetAllFieldsViaReflection(message1.get());
412
413  message2.CopyFrom(*message1);
414
415  TestUtil::ExpectAllFieldsSet(message2);
416}
417
418#endif  // !PROTOBUF_TEST_NO_DESCRIPTORS
419
420TEST(GeneratedMessageTest, NonEmptyMergeFrom) {
421  // Test merging with a non-empty message. Code is a modified form
422  // of that found in google/protobuf/reflection_ops_unittest.cc.
423  unittest::TestAllTypes message1, message2;
424
425  TestUtil::SetAllFields(&message1);
426
427  // This field will test merging into an empty spot.
428  message2.set_optional_int32(message1.optional_int32());
429  message1.clear_optional_int32();
430
431  // This tests overwriting.
432  message2.set_optional_string(message1.optional_string());
433  message1.set_optional_string("something else");
434
435  // This tests concatenating.
436  message2.add_repeated_int32(message1.repeated_int32(1));
437  int32 i = message1.repeated_int32(0);
438  message1.clear_repeated_int32();
439  message1.add_repeated_int32(i);
440
441  message1.MergeFrom(message2);
442
443  TestUtil::ExpectAllFieldsSet(message1);
444}
445
446#ifdef GTEST_HAS_DEATH_TEST
447
448TEST(GeneratedMessageTest, MergeFromSelf) {
449  unittest::TestAllTypes message;
450  EXPECT_DEATH(message.MergeFrom(message), "&from");
451  EXPECT_DEATH(message.MergeFrom(implicit_cast<const Message&>(message)),
452               "&from");
453}
454
455#endif  // GTEST_HAS_DEATH_TEST
456
457// Test the generated SerializeWithCachedSizesToArray(),
458TEST(GeneratedMessageTest, SerializationToArray) {
459  unittest::TestAllTypes message1, message2;
460  string data;
461  TestUtil::SetAllFields(&message1);
462  int size = message1.ByteSize();
463  data.resize(size);
464  uint8* start = reinterpret_cast<uint8*>(string_as_array(&data));
465  uint8* end = message1.SerializeWithCachedSizesToArray(start);
466  EXPECT_EQ(size, end - start);
467  EXPECT_TRUE(message2.ParseFromString(data));
468  TestUtil::ExpectAllFieldsSet(message2);
469
470}
471
472TEST(GeneratedMessageTest, PackedFieldsSerializationToArray) {
473  unittest::TestPackedTypes packed_message1, packed_message2;
474  string packed_data;
475  TestUtil::SetPackedFields(&packed_message1);
476  int packed_size = packed_message1.ByteSize();
477  packed_data.resize(packed_size);
478  uint8* start = reinterpret_cast<uint8*>(string_as_array(&packed_data));
479  uint8* end = packed_message1.SerializeWithCachedSizesToArray(start);
480  EXPECT_EQ(packed_size, end - start);
481  EXPECT_TRUE(packed_message2.ParseFromString(packed_data));
482  TestUtil::ExpectPackedFieldsSet(packed_message2);
483}
484
485// Test the generated SerializeWithCachedSizes() by forcing the buffer to write
486// one byte at a time.
487TEST(GeneratedMessageTest, SerializationToStream) {
488  unittest::TestAllTypes message1, message2;
489  TestUtil::SetAllFields(&message1);
490  int size = message1.ByteSize();
491  string data;
492  data.resize(size);
493  {
494    // Allow the output stream to buffer only one byte at a time.
495    io::ArrayOutputStream array_stream(string_as_array(&data), size, 1);
496    io::CodedOutputStream output_stream(&array_stream);
497    message1.SerializeWithCachedSizes(&output_stream);
498    EXPECT_FALSE(output_stream.HadError());
499    EXPECT_EQ(size, output_stream.ByteCount());
500  }
501  EXPECT_TRUE(message2.ParseFromString(data));
502  TestUtil::ExpectAllFieldsSet(message2);
503
504}
505
506TEST(GeneratedMessageTest, PackedFieldsSerializationToStream) {
507  unittest::TestPackedTypes message1, message2;
508  TestUtil::SetPackedFields(&message1);
509  int size = message1.ByteSize();
510  string data;
511  data.resize(size);
512  {
513    // Allow the output stream to buffer only one byte at a time.
514    io::ArrayOutputStream array_stream(string_as_array(&data), size, 1);
515    io::CodedOutputStream output_stream(&array_stream);
516    message1.SerializeWithCachedSizes(&output_stream);
517    EXPECT_FALSE(output_stream.HadError());
518    EXPECT_EQ(size, output_stream.ByteCount());
519  }
520  EXPECT_TRUE(message2.ParseFromString(data));
521  TestUtil::ExpectPackedFieldsSet(message2);
522}
523
524
525TEST(GeneratedMessageTest, Required) {
526  // Test that IsInitialized() returns false if required fields are missing.
527  unittest::TestRequired message;
528
529  EXPECT_FALSE(message.IsInitialized());
530  message.set_a(1);
531  EXPECT_FALSE(message.IsInitialized());
532  message.set_b(2);
533  EXPECT_FALSE(message.IsInitialized());
534  message.set_c(3);
535  EXPECT_TRUE(message.IsInitialized());
536}
537
538TEST(GeneratedMessageTest, RequiredForeign) {
539  // Test that IsInitialized() returns false if required fields in nested
540  // messages are missing.
541  unittest::TestRequiredForeign message;
542
543  EXPECT_TRUE(message.IsInitialized());
544
545  message.mutable_optional_message();
546  EXPECT_FALSE(message.IsInitialized());
547
548  message.mutable_optional_message()->set_a(1);
549  message.mutable_optional_message()->set_b(2);
550  message.mutable_optional_message()->set_c(3);
551  EXPECT_TRUE(message.IsInitialized());
552
553  message.add_repeated_message();
554  EXPECT_FALSE(message.IsInitialized());
555
556  message.mutable_repeated_message(0)->set_a(1);
557  message.mutable_repeated_message(0)->set_b(2);
558  message.mutable_repeated_message(0)->set_c(3);
559  EXPECT_TRUE(message.IsInitialized());
560}
561
562TEST(GeneratedMessageTest, ForeignNested) {
563  // Test that TestAllTypes::NestedMessage can be embedded directly into
564  // another message.
565  unittest::TestForeignNested message;
566
567  // If this compiles and runs without crashing, it must work.  We have
568  // nothing more to test.
569  unittest::TestAllTypes::NestedMessage* nested =
570    message.mutable_foreign_nested();
571  nested->set_bb(1);
572}
573
574TEST(GeneratedMessageTest, ReallyLargeTagNumber) {
575  // Test that really large tag numbers don't break anything.
576  unittest::TestReallyLargeTagNumber message1, message2;
577  string data;
578
579  // For the most part, if this compiles and runs then we're probably good.
580  // (The most likely cause for failure would be if something were attempting
581  // to allocate a lookup table of some sort using tag numbers as the index.)
582  // We'll try serializing just for fun.
583  message1.set_a(1234);
584  message1.set_bb(5678);
585  message1.SerializeToString(&data);
586  EXPECT_TRUE(message2.ParseFromString(data));
587  EXPECT_EQ(1234, message2.a());
588  EXPECT_EQ(5678, message2.bb());
589}
590
591TEST(GeneratedMessageTest, MutualRecursion) {
592  // Test that mutually-recursive message types work.
593  unittest::TestMutualRecursionA message;
594  unittest::TestMutualRecursionA* nested = message.mutable_bb()->mutable_a();
595  unittest::TestMutualRecursionA* nested2 = nested->mutable_bb()->mutable_a();
596
597  // Again, if the above compiles and runs, that's all we really have to
598  // test, but just for run we'll check that the system didn't somehow come
599  // up with a pointer loop...
600  EXPECT_NE(&message, nested);
601  EXPECT_NE(&message, nested2);
602  EXPECT_NE(nested, nested2);
603}
604
605TEST(GeneratedMessageTest, CamelCaseFieldNames) {
606  // This test is mainly checking that the following compiles, which verifies
607  // that the field names were coerced to lower-case.
608  //
609  // Protocol buffers standard style is to use lowercase-with-underscores for
610  // field names.  Some old proto1 .protos unfortunately used camel-case field
611  // names.  In proto1, these names were forced to lower-case.  So, we do the
612  // same thing in proto2.
613
614  unittest::TestCamelCaseFieldNames message;
615
616  message.set_primitivefield(2);
617  message.set_stringfield("foo");
618  message.set_enumfield(unittest::FOREIGN_FOO);
619  message.mutable_messagefield()->set_c(6);
620
621  message.add_repeatedprimitivefield(8);
622  message.add_repeatedstringfield("qux");
623  message.add_repeatedenumfield(unittest::FOREIGN_BAR);
624  message.add_repeatedmessagefield()->set_c(15);
625
626  EXPECT_EQ(2, message.primitivefield());
627  EXPECT_EQ("foo", message.stringfield());
628  EXPECT_EQ(unittest::FOREIGN_FOO, message.enumfield());
629  EXPECT_EQ(6, message.messagefield().c());
630
631  EXPECT_EQ(8, message.repeatedprimitivefield(0));
632  EXPECT_EQ("qux", message.repeatedstringfield(0));
633  EXPECT_EQ(unittest::FOREIGN_BAR, message.repeatedenumfield(0));
634  EXPECT_EQ(15, message.repeatedmessagefield(0).c());
635}
636
637TEST(GeneratedMessageTest, TestConflictingSymbolNames) {
638  // test_bad_identifiers.proto successfully compiled, then it works.  The
639  // following is just a token usage to insure that the code is, in fact,
640  // being compiled and linked.
641
642  protobuf_unittest::TestConflictingSymbolNames message;
643  message.set_uint32(1);
644  EXPECT_EQ(3, message.ByteSize());
645
646  message.set_friend_(5);
647  EXPECT_EQ(5, message.friend_());
648}
649
650#ifndef PROTOBUF_TEST_NO_DESCRIPTORS
651
652TEST(GeneratedMessageTest, TestOptimizedForSize) {
653  // We rely on the tests in reflection_ops_unittest and wire_format_unittest
654  // to really test that reflection-based methods work.  Here we are mostly
655  // just making sure that TestOptimizedForSize actually builds and seems to
656  // function.
657
658  protobuf_unittest::TestOptimizedForSize message, message2;
659  message.set_i(1);
660  message.mutable_msg()->set_c(2);
661  message2.CopyFrom(message);
662  EXPECT_EQ(1, message2.i());
663  EXPECT_EQ(2, message2.msg().c());
664}
665
666TEST(GeneratedMessageTest, TestEmbedOptimizedForSize) {
667  // Verifies that something optimized for speed can contain something optimized
668  // for size.
669
670  protobuf_unittest::TestEmbedOptimizedForSize message, message2;
671  message.mutable_optional_message()->set_i(1);
672  message.add_repeated_message()->mutable_msg()->set_c(2);
673  string data;
674  message.SerializeToString(&data);
675  ASSERT_TRUE(message2.ParseFromString(data));
676  EXPECT_EQ(1, message2.optional_message().i());
677  EXPECT_EQ(2, message2.repeated_message(0).msg().c());
678}
679
680TEST(GeneratedMessageTest, TestSpaceUsed) {
681  unittest::TestAllTypes message1;
682  // sizeof provides a lower bound on SpaceUsed().
683  EXPECT_LE(sizeof(unittest::TestAllTypes), message1.SpaceUsed());
684  const int empty_message_size = message1.SpaceUsed();
685
686  // Setting primitive types shouldn't affect the space used.
687  message1.set_optional_int32(123);
688  message1.set_optional_int64(12345);
689  message1.set_optional_uint32(123);
690  message1.set_optional_uint64(12345);
691  EXPECT_EQ(empty_message_size, message1.SpaceUsed());
692
693  // On some STL implementations, setting the string to a small value should
694  // only increase SpaceUsed() by the size of a string object, though this is
695  // not true everywhere.
696  message1.set_optional_string("abc");
697  EXPECT_LE(empty_message_size + sizeof(string), message1.SpaceUsed());
698
699  // Setting a string to a value larger than the string object itself should
700  // increase SpaceUsed(), because it cannot store the value internally.
701  message1.set_optional_string(string(sizeof(string) + 1, 'x'));
702  int min_expected_increase = message1.optional_string().capacity() +
703      sizeof(string);
704  EXPECT_LE(empty_message_size + min_expected_increase,
705            message1.SpaceUsed());
706
707  int previous_size = message1.SpaceUsed();
708  // Adding an optional message should increase the size by the size of the
709  // nested message type. NestedMessage is simple enough (1 int field) that it
710  // is equal to sizeof(NestedMessage)
711  message1.mutable_optional_nested_message();
712  ASSERT_EQ(sizeof(unittest::TestAllTypes::NestedMessage),
713            message1.optional_nested_message().SpaceUsed());
714  EXPECT_EQ(previous_size +
715            sizeof(unittest::TestAllTypes::NestedMessage),
716            message1.SpaceUsed());
717}
718
719#endif  // !PROTOBUF_TEST_NO_DESCRIPTORS
720
721TEST(GeneratedMessageTest, FieldConstantValues) {
722  unittest::TestRequired message;
723  EXPECT_EQ(unittest::TestAllTypes_NestedMessage::kBbFieldNumber, 1);
724  EXPECT_EQ(unittest::TestAllTypes::kOptionalInt32FieldNumber, 1);
725  EXPECT_EQ(unittest::TestAllTypes::kOptionalgroupFieldNumber, 16);
726  EXPECT_EQ(unittest::TestAllTypes::kOptionalNestedMessageFieldNumber, 18);
727  EXPECT_EQ(unittest::TestAllTypes::kOptionalNestedEnumFieldNumber, 21);
728  EXPECT_EQ(unittest::TestAllTypes::kRepeatedInt32FieldNumber, 31);
729  EXPECT_EQ(unittest::TestAllTypes::kRepeatedgroupFieldNumber, 46);
730  EXPECT_EQ(unittest::TestAllTypes::kRepeatedNestedMessageFieldNumber, 48);
731  EXPECT_EQ(unittest::TestAllTypes::kRepeatedNestedEnumFieldNumber, 51);
732}
733
734TEST(GeneratedMessageTest, ExtensionConstantValues) {
735  EXPECT_EQ(unittest::TestRequired::kSingleFieldNumber, 1000);
736  EXPECT_EQ(unittest::TestRequired::kMultiFieldNumber, 1001);
737  EXPECT_EQ(unittest::kOptionalInt32ExtensionFieldNumber, 1);
738  EXPECT_EQ(unittest::kOptionalgroupExtensionFieldNumber, 16);
739  EXPECT_EQ(unittest::kOptionalNestedMessageExtensionFieldNumber, 18);
740  EXPECT_EQ(unittest::kOptionalNestedEnumExtensionFieldNumber, 21);
741  EXPECT_EQ(unittest::kRepeatedInt32ExtensionFieldNumber, 31);
742  EXPECT_EQ(unittest::kRepeatedgroupExtensionFieldNumber, 46);
743  EXPECT_EQ(unittest::kRepeatedNestedMessageExtensionFieldNumber, 48);
744  EXPECT_EQ(unittest::kRepeatedNestedEnumExtensionFieldNumber, 51);
745}
746
747// ===================================================================
748
749TEST(GeneratedEnumTest, EnumValuesAsSwitchCases) {
750  // Test that our nested enum values can be used as switch cases.  This test
751  // doesn't actually do anything, the proof that it works is that it
752  // compiles.
753  int i =0;
754  unittest::TestAllTypes::NestedEnum a = unittest::TestAllTypes::BAR;
755  switch (a) {
756    case unittest::TestAllTypes::FOO:
757      i = 1;
758      break;
759    case unittest::TestAllTypes::BAR:
760      i = 2;
761      break;
762    case unittest::TestAllTypes::BAZ:
763      i = 3;
764      break;
765    // no default case:  We want to make sure the compiler recognizes that
766    //   all cases are covered.  (GCC warns if you do not cover all cases of
767    //   an enum in a switch.)
768  }
769
770  // Token check just for fun.
771  EXPECT_EQ(2, i);
772}
773
774TEST(GeneratedEnumTest, IsValidValue) {
775  // Test enum IsValidValue.
776  EXPECT_TRUE(unittest::TestAllTypes::NestedEnum_IsValid(1));
777  EXPECT_TRUE(unittest::TestAllTypes::NestedEnum_IsValid(2));
778  EXPECT_TRUE(unittest::TestAllTypes::NestedEnum_IsValid(3));
779
780  EXPECT_FALSE(unittest::TestAllTypes::NestedEnum_IsValid(0));
781  EXPECT_FALSE(unittest::TestAllTypes::NestedEnum_IsValid(4));
782
783  // Make sure it also works when there are dups.
784  EXPECT_TRUE(unittest::TestEnumWithDupValue_IsValid(1));
785  EXPECT_TRUE(unittest::TestEnumWithDupValue_IsValid(2));
786  EXPECT_TRUE(unittest::TestEnumWithDupValue_IsValid(3));
787
788  EXPECT_FALSE(unittest::TestEnumWithDupValue_IsValid(0));
789  EXPECT_FALSE(unittest::TestEnumWithDupValue_IsValid(4));
790}
791
792TEST(GeneratedEnumTest, MinAndMax) {
793  EXPECT_EQ(unittest::TestAllTypes::FOO,
794            unittest::TestAllTypes::NestedEnum_MIN);
795  EXPECT_EQ(unittest::TestAllTypes::BAZ,
796            unittest::TestAllTypes::NestedEnum_MAX);
797  EXPECT_EQ(4, unittest::TestAllTypes::NestedEnum_ARRAYSIZE);
798
799  EXPECT_EQ(unittest::FOREIGN_FOO, unittest::ForeignEnum_MIN);
800  EXPECT_EQ(unittest::FOREIGN_BAZ, unittest::ForeignEnum_MAX);
801  EXPECT_EQ(7, unittest::ForeignEnum_ARRAYSIZE);
802
803  EXPECT_EQ(1, unittest::TestEnumWithDupValue_MIN);
804  EXPECT_EQ(3, unittest::TestEnumWithDupValue_MAX);
805  EXPECT_EQ(4, unittest::TestEnumWithDupValue_ARRAYSIZE);
806
807  EXPECT_EQ(unittest::SPARSE_E, unittest::TestSparseEnum_MIN);
808  EXPECT_EQ(unittest::SPARSE_C, unittest::TestSparseEnum_MAX);
809  EXPECT_EQ(12589235, unittest::TestSparseEnum_ARRAYSIZE);
810
811  // Make sure we can take the address of _MIN, _MAX and _ARRAYSIZE.
812  void* nullptr = 0;  // NULL may be integer-type, not pointer-type.
813  EXPECT_NE(nullptr, &unittest::TestAllTypes::NestedEnum_MIN);
814  EXPECT_NE(nullptr, &unittest::TestAllTypes::NestedEnum_MAX);
815  EXPECT_NE(nullptr, &unittest::TestAllTypes::NestedEnum_ARRAYSIZE);
816
817  EXPECT_NE(nullptr, &unittest::ForeignEnum_MIN);
818  EXPECT_NE(nullptr, &unittest::ForeignEnum_MAX);
819  EXPECT_NE(nullptr, &unittest::ForeignEnum_ARRAYSIZE);
820
821  // Make sure we can use _MIN, _MAX and _ARRAYSIZE as switch cases.
822  switch (unittest::SPARSE_A) {
823    case unittest::TestSparseEnum_MIN:
824    case unittest::TestSparseEnum_MAX:
825    case unittest::TestSparseEnum_ARRAYSIZE:
826      break;
827    default:
828      break;
829  }
830}
831
832#ifndef PROTOBUF_TEST_NO_DESCRIPTORS
833
834TEST(GeneratedEnumTest, Name) {
835  // "Names" in the presence of dup values are a bit arbitrary.
836  EXPECT_EQ("FOO1", unittest::TestEnumWithDupValue_Name(unittest::FOO1));
837  EXPECT_EQ("FOO1", unittest::TestEnumWithDupValue_Name(unittest::FOO2));
838
839  EXPECT_EQ("SPARSE_A", unittest::TestSparseEnum_Name(unittest::SPARSE_A));
840  EXPECT_EQ("SPARSE_B", unittest::TestSparseEnum_Name(unittest::SPARSE_B));
841  EXPECT_EQ("SPARSE_C", unittest::TestSparseEnum_Name(unittest::SPARSE_C));
842  EXPECT_EQ("SPARSE_D", unittest::TestSparseEnum_Name(unittest::SPARSE_D));
843  EXPECT_EQ("SPARSE_E", unittest::TestSparseEnum_Name(unittest::SPARSE_E));
844  EXPECT_EQ("SPARSE_F", unittest::TestSparseEnum_Name(unittest::SPARSE_F));
845  EXPECT_EQ("SPARSE_G", unittest::TestSparseEnum_Name(unittest::SPARSE_G));
846}
847
848TEST(GeneratedEnumTest, Parse) {
849  unittest::TestEnumWithDupValue dup_value = unittest::FOO1;
850  EXPECT_TRUE(unittest::TestEnumWithDupValue_Parse("FOO1", &dup_value));
851  EXPECT_EQ(unittest::FOO1, dup_value);
852  EXPECT_TRUE(unittest::TestEnumWithDupValue_Parse("FOO2", &dup_value));
853  EXPECT_EQ(unittest::FOO2, dup_value);
854  EXPECT_FALSE(unittest::TestEnumWithDupValue_Parse("FOO", &dup_value));
855}
856
857TEST(GeneratedEnumTest, GetEnumDescriptor) {
858  EXPECT_EQ(unittest::TestAllTypes::NestedEnum_descriptor(),
859            GetEnumDescriptor<unittest::TestAllTypes::NestedEnum>());
860  EXPECT_EQ(unittest::ForeignEnum_descriptor(),
861            GetEnumDescriptor<unittest::ForeignEnum>());
862  EXPECT_EQ(unittest::TestEnumWithDupValue_descriptor(),
863            GetEnumDescriptor<unittest::TestEnumWithDupValue>());
864  EXPECT_EQ(unittest::TestSparseEnum_descriptor(),
865            GetEnumDescriptor<unittest::TestSparseEnum>());
866}
867
868#endif  // PROTOBUF_TEST_NO_DESCRIPTORS
869
870// ===================================================================
871
872#ifndef PROTOBUF_TEST_NO_DESCRIPTORS
873
874// Support code for testing services.
875class GeneratedServiceTest : public testing::Test {
876 protected:
877  class MockTestService : public unittest::TestService {
878   public:
879    MockTestService()
880      : called_(false),
881        method_(""),
882        controller_(NULL),
883        request_(NULL),
884        response_(NULL),
885        done_(NULL) {}
886
887    ~MockTestService() {}
888
889    void Reset() { called_ = false; }
890
891    // implements TestService ----------------------------------------
892
893    void Foo(RpcController* controller,
894             const unittest::FooRequest* request,
895             unittest::FooResponse* response,
896             Closure* done) {
897      ASSERT_FALSE(called_);
898      called_ = true;
899      method_ = "Foo";
900      controller_ = controller;
901      request_ = request;
902      response_ = response;
903      done_ = done;
904    }
905
906    void Bar(RpcController* controller,
907             const unittest::BarRequest* request,
908             unittest::BarResponse* response,
909             Closure* done) {
910      ASSERT_FALSE(called_);
911      called_ = true;
912      method_ = "Bar";
913      controller_ = controller;
914      request_ = request;
915      response_ = response;
916      done_ = done;
917    }
918
919    // ---------------------------------------------------------------
920
921    bool called_;
922    string method_;
923    RpcController* controller_;
924    const Message* request_;
925    Message* response_;
926    Closure* done_;
927  };
928
929  class MockRpcChannel : public RpcChannel {
930   public:
931    MockRpcChannel()
932      : called_(false),
933        method_(NULL),
934        controller_(NULL),
935        request_(NULL),
936        response_(NULL),
937        done_(NULL),
938        destroyed_(NULL) {}
939
940    ~MockRpcChannel() {
941      if (destroyed_ != NULL) *destroyed_ = true;
942    }
943
944    void Reset() { called_ = false; }
945
946    // implements TestService ----------------------------------------
947
948    void CallMethod(const MethodDescriptor* method,
949                    RpcController* controller,
950                    const Message* request,
951                    Message* response,
952                    Closure* done) {
953      ASSERT_FALSE(called_);
954      called_ = true;
955      method_ = method;
956      controller_ = controller;
957      request_ = request;
958      response_ = response;
959      done_ = done;
960    }
961
962    // ---------------------------------------------------------------
963
964    bool called_;
965    const MethodDescriptor* method_;
966    RpcController* controller_;
967    const Message* request_;
968    Message* response_;
969    Closure* done_;
970    bool* destroyed_;
971  };
972
973  class MockController : public RpcController {
974   public:
975    void Reset() {
976      ADD_FAILURE() << "Reset() not expected during this test.";
977    }
978    bool Failed() const {
979      ADD_FAILURE() << "Failed() not expected during this test.";
980      return false;
981    }
982    string ErrorText() const {
983      ADD_FAILURE() << "ErrorText() not expected during this test.";
984      return "";
985    }
986    void StartCancel() {
987      ADD_FAILURE() << "StartCancel() not expected during this test.";
988    }
989    void SetFailed(const string& reason) {
990      ADD_FAILURE() << "SetFailed() not expected during this test.";
991    }
992    bool IsCanceled() const {
993      ADD_FAILURE() << "IsCanceled() not expected during this test.";
994      return false;
995    }
996    void NotifyOnCancel(Closure* callback) {
997      ADD_FAILURE() << "NotifyOnCancel() not expected during this test.";
998    }
999  };
1000
1001  GeneratedServiceTest()
1002    : descriptor_(unittest::TestService::descriptor()),
1003      foo_(descriptor_->FindMethodByName("Foo")),
1004      bar_(descriptor_->FindMethodByName("Bar")),
1005      stub_(&mock_channel_),
1006      done_(NewPermanentCallback(&DoNothing)) {}
1007
1008  virtual void SetUp() {
1009    ASSERT_TRUE(foo_ != NULL);
1010    ASSERT_TRUE(bar_ != NULL);
1011  }
1012
1013  const ServiceDescriptor* descriptor_;
1014  const MethodDescriptor* foo_;
1015  const MethodDescriptor* bar_;
1016
1017  MockTestService mock_service_;
1018  MockController mock_controller_;
1019
1020  MockRpcChannel mock_channel_;
1021  unittest::TestService::Stub stub_;
1022
1023  // Just so we don't have to re-define these with every test.
1024  unittest::FooRequest foo_request_;
1025  unittest::FooResponse foo_response_;
1026  unittest::BarRequest bar_request_;
1027  unittest::BarResponse bar_response_;
1028  scoped_ptr<Closure> done_;
1029};
1030
1031TEST_F(GeneratedServiceTest, GetDescriptor) {
1032  // Test that GetDescriptor() works.
1033
1034  EXPECT_EQ(descriptor_, mock_service_.GetDescriptor());
1035}
1036
1037TEST_F(GeneratedServiceTest, GetChannel) {
1038  EXPECT_EQ(&mock_channel_, stub_.channel());
1039}
1040
1041TEST_F(GeneratedServiceTest, OwnsChannel) {
1042  MockRpcChannel* channel = new MockRpcChannel;
1043  bool destroyed = false;
1044  channel->destroyed_ = &destroyed;
1045
1046  {
1047    unittest::TestService::Stub owning_stub(channel,
1048                                            Service::STUB_OWNS_CHANNEL);
1049    EXPECT_FALSE(destroyed);
1050  }
1051
1052  EXPECT_TRUE(destroyed);
1053}
1054
1055TEST_F(GeneratedServiceTest, CallMethod) {
1056  // Test that CallMethod() works.
1057
1058  // Call Foo() via CallMethod().
1059  mock_service_.CallMethod(foo_, &mock_controller_,
1060                           &foo_request_, &foo_response_, done_.get());
1061
1062  ASSERT_TRUE(mock_service_.called_);
1063
1064  EXPECT_EQ("Foo"            , mock_service_.method_    );
1065  EXPECT_EQ(&mock_controller_, mock_service_.controller_);
1066  EXPECT_EQ(&foo_request_    , mock_service_.request_   );
1067  EXPECT_EQ(&foo_response_   , mock_service_.response_  );
1068  EXPECT_EQ(done_.get()      , mock_service_.done_      );
1069
1070  // Try again, but call Bar() instead.
1071  mock_service_.Reset();
1072  mock_service_.CallMethod(bar_, &mock_controller_,
1073                           &bar_request_, &bar_response_, done_.get());
1074
1075  ASSERT_TRUE(mock_service_.called_);
1076  EXPECT_EQ("Bar", mock_service_.method_);
1077}
1078
1079TEST_F(GeneratedServiceTest, CallMethodTypeFailure) {
1080  // Verify death if we call Foo() with Bar's message types.
1081
1082#ifdef GTEST_HAS_DEATH_TEST  // death tests do not work on Windows yet
1083  EXPECT_DEBUG_DEATH(
1084    mock_service_.CallMethod(foo_, &mock_controller_,
1085                             &foo_request_, &bar_response_, done_.get()),
1086    "dynamic_cast");
1087
1088  mock_service_.Reset();
1089  EXPECT_DEBUG_DEATH(
1090    mock_service_.CallMethod(foo_, &mock_controller_,
1091                             &bar_request_, &foo_response_, done_.get()),
1092    "dynamic_cast");
1093#endif  // GTEST_HAS_DEATH_TEST
1094}
1095
1096TEST_F(GeneratedServiceTest, GetPrototypes) {
1097  // Test Get{Request,Response}Prototype() methods.
1098
1099  EXPECT_EQ(&unittest::FooRequest::default_instance(),
1100            &mock_service_.GetRequestPrototype(foo_));
1101  EXPECT_EQ(&unittest::BarRequest::default_instance(),
1102            &mock_service_.GetRequestPrototype(bar_));
1103
1104  EXPECT_EQ(&unittest::FooResponse::default_instance(),
1105            &mock_service_.GetResponsePrototype(foo_));
1106  EXPECT_EQ(&unittest::BarResponse::default_instance(),
1107            &mock_service_.GetResponsePrototype(bar_));
1108}
1109
1110TEST_F(GeneratedServiceTest, Stub) {
1111  // Test that the stub class works.
1112
1113  // Call Foo() via the stub.
1114  stub_.Foo(&mock_controller_, &foo_request_, &foo_response_, done_.get());
1115
1116  ASSERT_TRUE(mock_channel_.called_);
1117
1118  EXPECT_EQ(foo_             , mock_channel_.method_    );
1119  EXPECT_EQ(&mock_controller_, mock_channel_.controller_);
1120  EXPECT_EQ(&foo_request_    , mock_channel_.request_   );
1121  EXPECT_EQ(&foo_response_   , mock_channel_.response_  );
1122  EXPECT_EQ(done_.get()      , mock_channel_.done_      );
1123
1124  // Call Bar() via the stub.
1125  mock_channel_.Reset();
1126  stub_.Bar(&mock_controller_, &bar_request_, &bar_response_, done_.get());
1127
1128  ASSERT_TRUE(mock_channel_.called_);
1129  EXPECT_EQ(bar_, mock_channel_.method_);
1130}
1131
1132TEST_F(GeneratedServiceTest, NotImplemented) {
1133  // Test that failing to implement a method of a service causes it to fail
1134  // with a "not implemented" error message.
1135
1136  // A service which doesn't implement any methods.
1137  class UnimplementedService : public unittest::TestService {
1138   public:
1139    UnimplementedService() {}
1140  };
1141
1142  UnimplementedService unimplemented_service;
1143
1144  // And a controller which expects to get a "not implemented" error.
1145  class ExpectUnimplementedController : public MockController {
1146   public:
1147    ExpectUnimplementedController() : called_(false) {}
1148
1149    void SetFailed(const string& reason) {
1150      EXPECT_FALSE(called_);
1151      called_ = true;
1152      EXPECT_EQ("Method Foo() not implemented.", reason);
1153    }
1154
1155    bool called_;
1156  };
1157
1158  ExpectUnimplementedController controller;
1159
1160  // Call Foo.
1161  unimplemented_service.Foo(&controller, &foo_request_, &foo_response_,
1162                            done_.get());
1163
1164  EXPECT_TRUE(controller.called_);
1165}
1166
1167}  // namespace cpp_unittest
1168}  // namespace cpp
1169}  // namespace compiler
1170
1171namespace no_generic_services_test {
1172  // Verify that no class called "TestService" was defined in
1173  // unittest_no_generic_services.pb.h by defining a different type by the same
1174  // name.  If such a service was generated, this will not compile.
1175  struct TestService {
1176    int i;
1177  };
1178}
1179
1180namespace compiler {
1181namespace cpp {
1182namespace cpp_unittest {
1183
1184TEST_F(GeneratedServiceTest, NoGenericServices) {
1185  // Verify that non-services in unittest_no_generic_services.proto were
1186  // generated.
1187  no_generic_services_test::TestMessage message;
1188  message.set_a(1);
1189  message.SetExtension(no_generic_services_test::test_extension, 123);
1190  no_generic_services_test::TestEnum e = no_generic_services_test::FOO;
1191  EXPECT_EQ(e, 1);
1192
1193  // Verify that a ServiceDescriptor is generated for the service even if the
1194  // class itself is not.
1195  const FileDescriptor* file =
1196      no_generic_services_test::TestMessage::descriptor()->file();
1197
1198  ASSERT_EQ(1, file->service_count());
1199  EXPECT_EQ("TestService", file->service(0)->name());
1200  ASSERT_EQ(1, file->service(0)->method_count());
1201  EXPECT_EQ("Foo", file->service(0)->method(0)->name());
1202}
1203
1204#endif  // !PROTOBUF_TEST_NO_DESCRIPTORS
1205
1206// ===================================================================
1207
1208// This test must run last.  It verifies that descriptors were or were not
1209// initialized depending on whether PROTOBUF_TEST_NO_DESCRIPTORS was defined.
1210// When this is defined, we skip all tests which are expected to trigger
1211// descriptor initialization.  This verifies that everything else still works
1212// if descriptors are not initialized.
1213TEST(DescriptorInitializationTest, Initialized) {
1214#ifdef PROTOBUF_TEST_NO_DESCRIPTORS
1215  bool should_have_descriptors = false;
1216#else
1217  bool should_have_descriptors = true;
1218#endif
1219
1220  EXPECT_EQ(should_have_descriptors,
1221    DescriptorPool::generated_pool()->InternalIsFileLoaded(
1222      "google/protobuf/unittest.proto"));
1223}
1224
1225}  // namespace cpp_unittest
1226
1227}  // namespace cpp
1228}  // namespace compiler
1229}  // namespace protobuf
1230}  // namespace google
1231