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