1// Protocol Buffers - Google's data interchange format 2// Copyright 2008 Google Inc. All rights reserved. 3// http://code.google.com/p/protobuf/ 4// 5// Redistribution and use in source and binary forms, with or without 6// modification, are permitted provided that the following conditions are 7// met: 8// 9// * Redistributions of source code must retain the above copyright 10// notice, this list of conditions and the following disclaimer. 11// * Redistributions in binary form must reproduce the above 12// copyright notice, this list of conditions and the following disclaimer 13// in the documentation and/or other materials provided with the 14// distribution. 15// * Neither the name of Google Inc. nor the names of its 16// contributors may be used to endorse or promote products derived from 17// this software without specific prior written permission. 18// 19// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 22// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 23// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 24// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 25// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 31// Author: tgs@google.com (Tom Szymanski) 32// 33// Test reflection methods for aggregate access to Repeated[Ptr]Fields. 34// This test proto2 methods on a proto2 layout. 35 36#include <google/protobuf/stubs/common.h> 37#include <google/protobuf/stubs/stringprintf.h> 38#include <google/protobuf/unittest.pb.h> 39#include <google/protobuf/test_util.h> 40#include <gtest/gtest.h> 41 42namespace google { 43namespace protobuf { 44 45using unittest::ForeignMessage; 46using unittest::TestAllTypes; 47using unittest::TestAllExtensions; 48 49namespace { 50 51static int Func(int i, int j) { 52 return i * j; 53} 54 55static string StrFunc(int i, int j) { 56 string str; 57 SStringPrintf(&str, "%d", Func(i, 4)); 58 return str; 59} 60 61 62TEST(RepeatedFieldReflectionTest, RegularFields) { 63 TestAllTypes message; 64 const Reflection* refl = message.GetReflection(); 65 const Descriptor* desc = message.GetDescriptor(); 66 67 for (int i = 0; i < 10; ++i) { 68 message.add_repeated_int32(Func(i, 1)); 69 message.add_repeated_double(Func(i, 2)); 70 message.add_repeated_string(StrFunc(i, 5)); 71 message.add_repeated_foreign_message()->set_c(Func(i, 6)); 72 } 73 74 // Get FieldDescriptors for all the fields of interest. 75 const FieldDescriptor* fd_repeated_int32 = 76 desc->FindFieldByName("repeated_int32"); 77 const FieldDescriptor* fd_repeated_double = 78 desc->FindFieldByName("repeated_double"); 79 const FieldDescriptor* fd_repeated_string = 80 desc->FindFieldByName("repeated_string"); 81 const FieldDescriptor* fd_repeated_foreign_message = 82 desc->FindFieldByName("repeated_foreign_message"); 83 84 // Get RepeatedField objects for all fields of interest. 85 const RepeatedField<int32>& rf_int32 = 86 refl->GetRepeatedField<int32>(message, fd_repeated_int32); 87 const RepeatedField<double>& rf_double = 88 refl->GetRepeatedField<double>(message, fd_repeated_double); 89 90 // Get mutable RepeatedField objects for all fields of interest. 91 RepeatedField<int32>* mrf_int32 = 92 refl->MutableRepeatedField<int32>(&message, fd_repeated_int32); 93 RepeatedField<double>* mrf_double = 94 refl->MutableRepeatedField<double>(&message, fd_repeated_double); 95 96 // Get RepeatedPtrField objects for all fields of interest. 97 const RepeatedPtrField<string>& rpf_string = 98 refl->GetRepeatedPtrField<string>(message, fd_repeated_string); 99 const RepeatedPtrField<ForeignMessage>& rpf_foreign_message = 100 refl->GetRepeatedPtrField<ForeignMessage>( 101 message, fd_repeated_foreign_message); 102 const RepeatedPtrField<Message>& rpf_message = 103 refl->GetRepeatedPtrField<Message>( 104 message, fd_repeated_foreign_message); 105 106 // Get mutable RepeatedPtrField objects for all fields of interest. 107 RepeatedPtrField<string>* mrpf_string = 108 refl->MutableRepeatedPtrField<string>(&message, fd_repeated_string); 109 RepeatedPtrField<ForeignMessage>* mrpf_foreign_message = 110 refl->MutableRepeatedPtrField<ForeignMessage>( 111 &message, fd_repeated_foreign_message); 112 RepeatedPtrField<Message>* mrpf_message = 113 refl->MutableRepeatedPtrField<Message>( 114 &message, fd_repeated_foreign_message); 115 116 // Make sure we can do get and sets through the Repeated[Ptr]Field objects. 117 for (int i = 0; i < 10; ++i) { 118 // Check gets through const objects. 119 EXPECT_EQ(rf_int32.Get(i), Func(i, 1)); 120 EXPECT_EQ(rf_double.Get(i), Func(i, 2)); 121 EXPECT_EQ(rpf_string.Get(i), StrFunc(i, 5)); 122 EXPECT_EQ(rpf_foreign_message.Get(i).c(), Func(i, 6)); 123 EXPECT_EQ(down_cast<const ForeignMessage*>(&rpf_message.Get(i))->c(), 124 Func(i, 6)); 125 126 // Check gets through mutable objects. 127 EXPECT_EQ(mrf_int32->Get(i), Func(i, 1)); 128 EXPECT_EQ(mrf_double->Get(i), Func(i, 2)); 129 EXPECT_EQ(mrpf_string->Get(i), StrFunc(i, 5)); 130 EXPECT_EQ(mrpf_foreign_message->Get(i).c(), Func(i, 6)); 131 EXPECT_EQ(down_cast<const ForeignMessage*>(&mrpf_message->Get(i))->c(), 132 Func(i, 6)); 133 134 // Check sets through mutable objects. 135 mrf_int32->Set(i, Func(i, -1)); 136 mrf_double->Set(i, Func(i, -2)); 137 mrpf_string->Mutable(i)->assign(StrFunc(i, -5)); 138 mrpf_foreign_message->Mutable(i)->set_c(Func(i, -6)); 139 EXPECT_EQ(message.repeated_int32(i), Func(i, -1)); 140 EXPECT_EQ(message.repeated_double(i), Func(i, -2)); 141 EXPECT_EQ(message.repeated_string(i), StrFunc(i, -5)); 142 EXPECT_EQ(message.repeated_foreign_message(i).c(), Func(i, -6)); 143 down_cast<ForeignMessage*>(mrpf_message->Mutable(i))->set_c(Func(i, 7)); 144 EXPECT_EQ(message.repeated_foreign_message(i).c(), Func(i, 7)); 145 } 146 147#ifdef PROTOBUF_HAS_DEATH_TEST 148 // Make sure types are checked correctly at runtime. 149 const FieldDescriptor* fd_optional_int32 = 150 desc->FindFieldByName("optional_int32"); 151 EXPECT_DEATH(refl->GetRepeatedField<int32>( 152 message, fd_optional_int32), "requires a repeated field"); 153 EXPECT_DEATH(refl->GetRepeatedField<double>( 154 message, fd_repeated_int32), "not the right type"); 155 EXPECT_DEATH(refl->GetRepeatedPtrField<TestAllTypes>( 156 message, fd_repeated_foreign_message), "wrong submessage type"); 157#endif // PROTOBUF_HAS_DEATH_TEST 158} 159 160 161 162 163TEST(RepeatedFieldReflectionTest, ExtensionFields) { 164 TestAllExtensions extended_message; 165 const Reflection* refl = extended_message.GetReflection(); 166 const Descriptor* desc = extended_message.GetDescriptor(); 167 168 for (int i = 0; i < 10; ++i) { 169 extended_message.AddExtension( 170 unittest::repeated_int64_extension, Func(i, 1)); 171 } 172 173 const FieldDescriptor* fd_repeated_int64_extension = 174 desc->file()->FindExtensionByName("repeated_int64_extension"); 175 GOOGLE_CHECK(fd_repeated_int64_extension != NULL); 176 177 const RepeatedField<int64>& rf_int64_extension = 178 refl->GetRepeatedField<int64>(extended_message, 179 fd_repeated_int64_extension); 180 181 RepeatedField<int64>* mrf_int64_extension = 182 refl->MutableRepeatedField<int64>(&extended_message, 183 fd_repeated_int64_extension); 184 185 for (int i = 0; i < 10; ++i) { 186 EXPECT_EQ(Func(i, 1), rf_int64_extension.Get(i)); 187 mrf_int64_extension->Set(i, Func(i, -1)); 188 EXPECT_EQ(Func(i, -1), 189 extended_message.GetExtension(unittest::repeated_int64_extension, i)); 190 } 191} 192 193} // namespace 194} // namespace protobuf 195} // namespace google 196