Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / protobuf-javalite / 20bfd9bf5015b21adab17fce4bd78510f25137d9 / . / src / ProtocolBuffers.Test / ReflectionTester.cs
blob: c146a82395aa977009319b8d78ed584805434b1e [file] [log] [blame]
Jon Skeet68036862008-10-22 13:30:34 +0100[diff] [blame]1// Protocol Buffers - Google's data interchange format
2// Copyright 2008 Google Inc.
3// http://code.google.com/p/protobuf/
4//
5// Licensed under the Apache License, Version 2.0 (the "License");
6// you may not use this file except in compliance with the License.
7// You may obtain a copy of the License at
8//
9// http://www.apache.org/licenses/LICENSE-2.0
10//
11// Unless required by applicable law or agreed to in writing, software
12// distributed under the License is distributed on an "AS IS" BASIS,
13// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14// See the License for the specific language governing permissions and
15// limitations under the License.
16using System;
17using Google.ProtocolBuffers.Descriptors;
18using Google.ProtocolBuffers.TestProtos;
19using NUnit.Framework;
20
21namespace Google.ProtocolBuffers {
22 /// <summary>
23 /// Performs the same things that the methods of TestUtil do, but
24 /// via the reflection interface. This is its own class because it needs
25 /// to know what descriptor to use.
26 /// </summary>
27 internal class ReflectionTester {
28 private readonly MessageDescriptor baseDescriptor;
29 private readonly ExtensionRegistry extensionRegistry;
30
31 private readonly FileDescriptor file;
32 private readonly FileDescriptor importFile;
33
34 private readonly MessageDescriptor optionalGroup;
35 private readonly MessageDescriptor repeatedGroup;
36 private readonly MessageDescriptor nestedMessage;
37 private readonly MessageDescriptor foreignMessage;
38 private readonly MessageDescriptor importMessage;
39
40 private readonly FieldDescriptor groupA;
41 private readonly FieldDescriptor repeatedGroupA;
42 private readonly FieldDescriptor nestedB;
43 private readonly FieldDescriptor foreignC;
44 private readonly FieldDescriptor importD;
45
46 private readonly EnumDescriptor nestedEnum;
47 private readonly EnumDescriptor foreignEnum;
48 private readonly EnumDescriptor importEnum;
49
50 private readonly EnumValueDescriptor nestedFoo;
51 private readonly EnumValueDescriptor nestedBar;
52 private readonly EnumValueDescriptor nestedBaz;
53 private readonly EnumValueDescriptor foreignFoo;
54 private readonly EnumValueDescriptor foreignBar;
55 private readonly EnumValueDescriptor foreignBaz;
56 private readonly EnumValueDescriptor importFoo;
57 private readonly EnumValueDescriptor importBar;
58 private readonly EnumValueDescriptor importBaz;
59
60 /// <summary>
61 /// Constructs an instance that will expect messages using the given
62 /// descriptor. Normally <paramref name="baseDescriptor"/> should be
63 /// a descriptor for TestAllTypes. However, if extensionRegistry is non-null,
64 /// then baseDescriptor should be for TestAllExtensions instead, and instead of
65 /// reading and writing normal fields, the tester will read and write extensions.
66 /// All of the TestAllExtensions extensions must be registered in the registry.
67 /// </summary>
68 private ReflectionTester(MessageDescriptor baseDescriptor,
69 ExtensionRegistry extensionRegistry) {
70 this.baseDescriptor = baseDescriptor;
71 this.extensionRegistry = extensionRegistry;
72
73 this.file = baseDescriptor.File;
74 // TODO(jonskeet): We've got 3 dependencies, not 1 - because of the C# options. Hmm.
75// Assert.AreEqual(1, file.Dependencies.Count);
76 // TODO(jonskeet): Find dependency by name instead of number?
77 this.importFile = file.Dependencies[2];
78
79 MessageDescriptor testAllTypes;
80 if (extensionRegistry == null) {
81 testAllTypes = baseDescriptor;
82 } else {
83 testAllTypes = file.FindTypeByName<MessageDescriptor>("TestAllTypes");
84 Assert.IsNotNull(testAllTypes);
85 }
86
87 if (extensionRegistry == null) {
88 this.optionalGroup =
89 baseDescriptor.FindDescriptor<MessageDescriptor>("OptionalGroup");
90 this.repeatedGroup =
91 baseDescriptor.FindDescriptor<MessageDescriptor>("RepeatedGroup");
92 } else {
93 this.optionalGroup =
94 file.FindTypeByName<MessageDescriptor>("OptionalGroup_extension");
95 this.repeatedGroup =
96 file.FindTypeByName<MessageDescriptor>("RepeatedGroup_extension");
97 }
98 this.nestedMessage = testAllTypes.FindDescriptor<MessageDescriptor>("NestedMessage");
99 this.foreignMessage = file.FindTypeByName<MessageDescriptor>("ForeignMessage");
100 this.importMessage = importFile.FindTypeByName<MessageDescriptor>("ImportMessage");
101
102 this.nestedEnum = testAllTypes.FindDescriptor<EnumDescriptor>("NestedEnum");
103 this.foreignEnum = file.FindTypeByName<EnumDescriptor>("ForeignEnum");
104 this.importEnum = importFile.FindTypeByName<EnumDescriptor>("ImportEnum");
105
106 Assert.IsNotNull(optionalGroup );
107 Assert.IsNotNull(repeatedGroup );
108 Assert.IsNotNull(nestedMessage );
109 Assert.IsNotNull(foreignMessage);
110 Assert.IsNotNull(importMessage );
111 Assert.IsNotNull(nestedEnum );
112 Assert.IsNotNull(foreignEnum );
113 Assert.IsNotNull(importEnum );
114
115 this.nestedB = nestedMessage.FindDescriptor<FieldDescriptor>("bb");
116 this.foreignC = foreignMessage.FindDescriptor<FieldDescriptor>("c");
117 this.importD = importMessage .FindDescriptor<FieldDescriptor>("d");
118 this.nestedFoo = nestedEnum.FindValueByName("FOO");
119 this.nestedBar = nestedEnum.FindValueByName("BAR");
120 this.nestedBaz = nestedEnum.FindValueByName("BAZ");
121 this.foreignFoo = foreignEnum.FindValueByName("FOREIGN_FOO");
122 this.foreignBar = foreignEnum.FindValueByName("FOREIGN_BAR");
123 this.foreignBaz = foreignEnum.FindValueByName("FOREIGN_BAZ");
124 this.importFoo = importEnum.FindValueByName("IMPORT_FOO");
125 this.importBar = importEnum.FindValueByName("IMPORT_BAR");
126 this.importBaz = importEnum.FindValueByName("IMPORT_BAZ");
127
128 this.groupA = optionalGroup.FindDescriptor<FieldDescriptor>("a");
129 this.repeatedGroupA = repeatedGroup.FindDescriptor<FieldDescriptor>("a");
130
131 Assert.IsNotNull(groupA );
132 Assert.IsNotNull(repeatedGroupA);
133 Assert.IsNotNull(nestedB );
134 Assert.IsNotNull(foreignC );
135 Assert.IsNotNull(importD );
136 Assert.IsNotNull(nestedFoo );
137 Assert.IsNotNull(nestedBar );
138 Assert.IsNotNull(nestedBaz );
139 Assert.IsNotNull(foreignFoo );
140 Assert.IsNotNull(foreignBar );
141 Assert.IsNotNull(foreignBaz );
142 Assert.IsNotNull(importFoo );
143 Assert.IsNotNull(importBar );
144 Assert.IsNotNull(importBaz );
145 }
146
147 /// <summary>
148 /// Creates an instance for the TestAllTypes message, with no extension registry.
149 /// </summary>
150 public static ReflectionTester CreateTestAllTypesInstance() {
151 return new ReflectionTester(TestAllTypes.Descriptor, null);
152 }
153
154 /// <summary>
155 /// Creates an instance for the TestAllExtensions message, with an
156 /// extension registry from TestUtil.CreateExtensionRegistry.
157 /// </summary>
158 public static ReflectionTester CreateTestAllExtensionsInstance() {
159 return new ReflectionTester(TestAllExtensions.Descriptor, TestUtil.CreateExtensionRegistry());
160 }
161
162 /// <summary>
163 /// Shorthand to get a FieldDescriptor for a field of unittest::TestAllTypes.
164 /// </summary>
165 private FieldDescriptor f(String name) {
166 FieldDescriptor result;
167 if (extensionRegistry == null) {
168 result = baseDescriptor.FindDescriptor<FieldDescriptor>(name);
169 } else {
170 result = file.FindTypeByName<FieldDescriptor>(name + "_extension");
171 }
172 Assert.IsNotNull(result);
173 return result;
174 }
175
176 /// <summary>
177 /// Calls parent.CreateBuilderForField() or uses the extension registry
178 /// to find an appropriate builder, depending on what type is being tested.
179 /// </summary>
180 private IBuilder CreateBuilderForField(IBuilder parent, FieldDescriptor field) {
181 if (extensionRegistry == null) {
182 return parent.CreateBuilderForField(field);
183 } else {
184 ExtensionInfo extension = extensionRegistry[field.ContainingType, field.FieldNumber];
185 Assert.IsNotNull(extension);
186 Assert.IsNotNull(extension.DefaultInstance);
187 return extension.DefaultInstance.WeakCreateBuilderForType();
188 }
189 }
190
191 /// <summary>
192 /// Sets every field of the message to the values expected by
193 /// AssertAllFieldsSet, using the reflection interface.
194 /// </summary>
195 /// <param name="message"></param>
196 internal void SetAllFieldsViaReflection(IBuilder message) {
197 message[f("optional_int32" )] = 101 ;
198 message[f("optional_int64" )] = 102L;
199 message[f("optional_uint32" )] = 103U ;
200 message[f("optional_uint64" )] = 104UL;
201 message[f("optional_sint32" )] = 105 ;
202 message[f("optional_sint64" )] = 106L;
203 message[f("optional_fixed32" )] = 107U ;
204 message[f("optional_fixed64" )] = 108UL;
205 message[f("optional_sfixed32")] = 109 ;
206 message[f("optional_sfixed64")] = 110L;
207 message[f("optional_float" )] = 111F;
208 message[f("optional_double" )] = 112D;
209 message[f("optional_bool" )] = true;
210 message[f("optional_string" )] = "115";
211 message[f("optional_bytes")] = TestUtil.ToBytes("116");
212
213 message[f("optionalgroup")] = CreateBuilderForField(message, f("optionalgroup")).SetField(groupA, 117).WeakBuild();
214 message[f("optional_nested_message")] = CreateBuilderForField(message, f("optional_nested_message")).SetField(nestedB, 118).WeakBuild();
215 message[f("optional_foreign_message")] = CreateBuilderForField(message, f("optional_foreign_message")).SetField(foreignC, 119).WeakBuild();
216 message[f("optional_import_message")] = CreateBuilderForField(message, f("optional_import_message")).SetField(importD, 120).WeakBuild();
217
218 message[f("optional_nested_enum" )] = nestedBaz;
219 message[f("optional_foreign_enum")] = foreignBaz;
220 message[f("optional_import_enum" )] = importBaz;
221
222 message[f("optional_string_piece" )] = "124";
223 message[f("optional_cord" )] = "125";
224
225 // -----------------------------------------------------------------
226
227 message.WeakAddRepeatedField(f("repeated_int32" ), 201 );
228 message.WeakAddRepeatedField(f("repeated_int64" ), 202L);
229 message.WeakAddRepeatedField(f("repeated_uint32" ), 203U );
230 message.WeakAddRepeatedField(f("repeated_uint64" ), 204UL);
231 message.WeakAddRepeatedField(f("repeated_sint32" ), 205 );
232 message.WeakAddRepeatedField(f("repeated_sint64" ), 206L);
233 message.WeakAddRepeatedField(f("repeated_fixed32" ), 207U );
234 message.WeakAddRepeatedField(f("repeated_fixed64" ), 208UL);
235 message.WeakAddRepeatedField(f("repeated_sfixed32"), 209 );
236 message.WeakAddRepeatedField(f("repeated_sfixed64"), 210L);
237 message.WeakAddRepeatedField(f("repeated_float" ), 211F);
238 message.WeakAddRepeatedField(f("repeated_double" ), 212D);
239 message.WeakAddRepeatedField(f("repeated_bool" ), true);
240 message.WeakAddRepeatedField(f("repeated_string" ), "215");
241 message.WeakAddRepeatedField(f("repeated_bytes" ), TestUtil.ToBytes("216"));
242
243
244 message.WeakAddRepeatedField(f("repeatedgroup"), CreateBuilderForField(message, f("repeatedgroup")).SetField(repeatedGroupA, 217).WeakBuild());
245 message.WeakAddRepeatedField(f("repeated_nested_message"), CreateBuilderForField(message, f("repeated_nested_message")).SetField(nestedB, 218).WeakBuild());
246 message.WeakAddRepeatedField(f("repeated_foreign_message"), CreateBuilderForField(message, f("repeated_foreign_message")).SetField(foreignC, 219).WeakBuild());
247 message.WeakAddRepeatedField(f("repeated_import_message"), CreateBuilderForField(message, f("repeated_import_message")).SetField(importD, 220).WeakBuild());
248
249 message.WeakAddRepeatedField(f("repeated_nested_enum" ), nestedBar);
250 message.WeakAddRepeatedField(f("repeated_foreign_enum"), foreignBar);
251 message.WeakAddRepeatedField(f("repeated_import_enum" ), importBar);
252
253 message.WeakAddRepeatedField(f("repeated_string_piece" ), "224");
254 message.WeakAddRepeatedField(f("repeated_cord" ), "225");
255
256 // Add a second one of each field.
257 message.WeakAddRepeatedField(f("repeated_int32" ), 301 );
258 message.WeakAddRepeatedField(f("repeated_int64" ), 302L);
259 message.WeakAddRepeatedField(f("repeated_uint32" ), 303U );
260 message.WeakAddRepeatedField(f("repeated_uint64" ), 304UL);
261 message.WeakAddRepeatedField(f("repeated_sint32" ), 305 );
262 message.WeakAddRepeatedField(f("repeated_sint64" ), 306L);
263 message.WeakAddRepeatedField(f("repeated_fixed32" ), 307U );
264 message.WeakAddRepeatedField(f("repeated_fixed64" ), 308UL);
265 message.WeakAddRepeatedField(f("repeated_sfixed32"), 309 );
266 message.WeakAddRepeatedField(f("repeated_sfixed64"), 310L);
267 message.WeakAddRepeatedField(f("repeated_float" ), 311F);
268 message.WeakAddRepeatedField(f("repeated_double" ), 312D);
269 message.WeakAddRepeatedField(f("repeated_bool" ), false);
270 message.WeakAddRepeatedField(f("repeated_string" ), "315");
271 message.WeakAddRepeatedField(f("repeated_bytes" ), TestUtil.ToBytes("316"));
272
273 message.WeakAddRepeatedField(f("repeatedgroup"),
274 CreateBuilderForField(message, f("repeatedgroup"))
275 .SetField(repeatedGroupA, 317).WeakBuild());
276 message.WeakAddRepeatedField(f("repeated_nested_message"),
277 CreateBuilderForField(message, f("repeated_nested_message"))
278 .SetField(nestedB, 318).WeakBuild());
279 message.WeakAddRepeatedField(f("repeated_foreign_message"),
280 CreateBuilderForField(message, f("repeated_foreign_message"))
281 .SetField(foreignC, 319).WeakBuild());
282 message.WeakAddRepeatedField(f("repeated_import_message"),
283 CreateBuilderForField(message, f("repeated_import_message"))
284 .SetField(importD, 320).WeakBuild());
285
286 message.WeakAddRepeatedField(f("repeated_nested_enum" ), nestedBaz);
287 message.WeakAddRepeatedField(f("repeated_foreign_enum"), foreignBaz);
288 message.WeakAddRepeatedField(f("repeated_import_enum" ), importBaz);
289
290 message.WeakAddRepeatedField(f("repeated_string_piece" ), "324");
291 message.WeakAddRepeatedField(f("repeated_cord" ), "325");
292
293 // -----------------------------------------------------------------
294
295 message[f("default_int32" )] = 401 ;
296 message[f("default_int64" )] = 402L;
297 message[f("default_uint32" )] = 403U ;
298 message[f("default_uint64" )] = 404UL;
299 message[f("default_sint32" )] = 405 ;
300 message[f("default_sint64" )] = 406L;
301 message[f("default_fixed32" )] = 407U ;
302 message[f("default_fixed64" )] = 408UL;
303 message[f("default_sfixed32")] = 409 ;
304 message[f("default_sfixed64")] = 410L;
305 message[f("default_float" )] = 411F;
306 message[f("default_double" )] = 412D;
307 message[f("default_bool" )] = false;
308 message[f("default_string" )] = "415";
309 message[f("default_bytes" )] = TestUtil.ToBytes("416");
310
311 message[f("default_nested_enum" )] = nestedFoo;
312 message[f("default_foreign_enum")] = foreignFoo;
313 message[f("default_import_enum" )] = importFoo;
314
315 message[f("default_string_piece" )] = "424";
316 message[f("default_cord" )] = "425";
317 }
318
319 // -------------------------------------------------------------------
320
321 /// <summary>
322 /// Modify the repeated fields of the specified message to contain the
323 /// values expected by AssertRepeatedFieldsModified, using the IBuilder
324 /// reflection interface.
325 /// </summary>
326 internal void ModifyRepeatedFieldsViaReflection(IBuilder message) {
327 message[f("repeated_int32" ), 1] = 501 ;
328 message[f("repeated_int64" ), 1] = 502L;
329 message[f("repeated_uint32" ), 1] = 503U ;
330 message[f("repeated_uint64" ), 1] = 504UL;
331 message[f("repeated_sint32" ), 1] = 505 ;
332 message[f("repeated_sint64" ), 1] = 506L;
333 message[f("repeated_fixed32" ), 1] = 507U ;
334 message[f("repeated_fixed64" ), 1] = 508UL;
335 message[f("repeated_sfixed32"), 1] = 509 ;
336 message[f("repeated_sfixed64"), 1] = 510L;
337 message[f("repeated_float" ), 1] = 511F;
338 message[f("repeated_double" ), 1] = 512D;
339 message[f("repeated_bool" ), 1] = true;
340 message[f("repeated_string" ), 1] = "515";
341 message.SetRepeatedField(f("repeated_bytes" ), 1, TestUtil.ToBytes("516"));
342
343 message.SetRepeatedField(f("repeatedgroup"), 1, CreateBuilderForField(message, f("repeatedgroup")).SetField(repeatedGroupA, 517).WeakBuild());
344 message.SetRepeatedField(f("repeated_nested_message"), 1, CreateBuilderForField(message, f("repeated_nested_message")).SetField(nestedB, 518).WeakBuild());
345 message.SetRepeatedField(f("repeated_foreign_message"), 1, CreateBuilderForField(message, f("repeated_foreign_message")).SetField(foreignC, 519).WeakBuild());
346 message.SetRepeatedField(f("repeated_import_message"), 1, CreateBuilderForField(message, f("repeated_import_message")).SetField(importD, 520).WeakBuild());
347
348 message[f("repeated_nested_enum" ), 1] = nestedFoo;
349 message[f("repeated_foreign_enum"), 1] = foreignFoo;
350 message[f("repeated_import_enum" ), 1] = importFoo;
351
352 message[f("repeated_string_piece"), 1] = "524";
353 message[f("repeated_cord"), 1] = "525";
354 }
355
356 // -------------------------------------------------------------------
357
358 /// <summary>
359 /// Asserts that all fields of the specified message are set to the values
360 /// assigned by SetAllFields, using the IMessage reflection interface.
361 /// </summary>
362 public void AssertAllFieldsSetViaReflection(IMessage message) {
363 Assert.IsTrue(message.HasField(f("optional_int32" )));
364 Assert.IsTrue(message.HasField(f("optional_int64" )));
365 Assert.IsTrue(message.HasField(f("optional_uint32" )));
366 Assert.IsTrue(message.HasField(f("optional_uint64" )));
367 Assert.IsTrue(message.HasField(f("optional_sint32" )));
368 Assert.IsTrue(message.HasField(f("optional_sint64" )));
369 Assert.IsTrue(message.HasField(f("optional_fixed32" )));
370 Assert.IsTrue(message.HasField(f("optional_fixed64" )));
371 Assert.IsTrue(message.HasField(f("optional_sfixed32")));
372 Assert.IsTrue(message.HasField(f("optional_sfixed64")));
373 Assert.IsTrue(message.HasField(f("optional_float" )));
374 Assert.IsTrue(message.HasField(f("optional_double" )));
375 Assert.IsTrue(message.HasField(f("optional_bool" )));
376 Assert.IsTrue(message.HasField(f("optional_string" )));
377 Assert.IsTrue(message.HasField(f("optional_bytes" )));
378
379 Assert.IsTrue(message.HasField(f("optionalgroup" )));
380 Assert.IsTrue(message.HasField(f("optional_nested_message" )));
381 Assert.IsTrue(message.HasField(f("optional_foreign_message")));
382 Assert.IsTrue(message.HasField(f("optional_import_message" )));
383
384 Assert.IsTrue(((IMessage)message[f("optionalgroup")]).HasField(groupA));
385 Assert.IsTrue(((IMessage)message[f("optional_nested_message")]).HasField(nestedB));
386 Assert.IsTrue(((IMessage)message[f("optional_foreign_message")]).HasField(foreignC));
387 Assert.IsTrue(((IMessage)message[f("optional_import_message")]).HasField(importD));
388
389 Assert.IsTrue(message.HasField(f("optional_nested_enum" )));
390 Assert.IsTrue(message.HasField(f("optional_foreign_enum")));
391 Assert.IsTrue(message.HasField(f("optional_import_enum" )));
392
393 Assert.IsTrue(message.HasField(f("optional_string_piece")));
394 Assert.IsTrue(message.HasField(f("optional_cord")));
395
396 Assert.AreEqual(101 , message[f("optional_int32" )]);
397 Assert.AreEqual(102L , message[f("optional_int64" )]);
398 Assert.AreEqual(103U , message[f("optional_uint32" )]);
399 Assert.AreEqual(104UL , message[f("optional_uint64" )]);
400 Assert.AreEqual(105 , message[f("optional_sint32" )]);
401 Assert.AreEqual(106L , message[f("optional_sint64" )]);
402 Assert.AreEqual(107U , message[f("optional_fixed32" )]);
403 Assert.AreEqual(108UL , message[f("optional_fixed64" )]);
404 Assert.AreEqual(109 , message[f("optional_sfixed32")]);
405 Assert.AreEqual(110L , message[f("optional_sfixed64")]);
406 Assert.AreEqual(111F , message[f("optional_float" )]);
407 Assert.AreEqual(112D , message[f("optional_double" )]);
408 Assert.AreEqual(true , message[f("optional_bool" )]);
409 Assert.AreEqual("115", message[f("optional_string" )]);
410 Assert.AreEqual(TestUtil.ToBytes("116"), message[f("optional_bytes")]);
411
412 Assert.AreEqual(117,((IMessage)message[f("optionalgroup")])[groupA]);
413 Assert.AreEqual(118,((IMessage)message[f("optional_nested_message")])[nestedB]);
414 Assert.AreEqual(119,((IMessage)message[f("optional_foreign_message")])[foreignC]);
415 Assert.AreEqual(120,((IMessage)message[f("optional_import_message")])[importD]);
416
417 Assert.AreEqual( nestedBaz, message[f("optional_nested_enum" )]);
418 Assert.AreEqual(foreignBaz, message[f("optional_foreign_enum")]);
419 Assert.AreEqual( importBaz, message[f("optional_import_enum" )]);
420
421 Assert.AreEqual("124", message[f("optional_string_piece")]);
422 Assert.AreEqual("125", message[f("optional_cord")]);
423
424 // -----------------------------------------------------------------
425
426 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_int32" )));
427 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_int64" )));
428 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_uint32" )));
429 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_uint64" )));
430 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sint32" )));
431 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sint64" )));
432 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_fixed32" )));
433 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_fixed64" )));
434 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sfixed32")));
435 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sfixed64")));
436 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_float" )));
437 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_double" )));
438 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_bool" )));
439 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_string" )));
440 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_bytes" )));
441
442 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeatedgroup" )));
443 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_nested_message" )));
444 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_foreign_message")));
445 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_import_message" )));
446 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_nested_enum" )));
447 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_foreign_enum" )));
448 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_import_enum" )));
449
450 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_string_piece")));
451 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_cord")));
452
453 Assert.AreEqual(201 , message[f("repeated_int32" ), 0]);
454 Assert.AreEqual(202L , message[f("repeated_int64" ), 0]);
455 Assert.AreEqual(203U , message[f("repeated_uint32" ), 0]);
456 Assert.AreEqual(204UL, message[f("repeated_uint64" ), 0]);
457 Assert.AreEqual(205 , message[f("repeated_sint32" ), 0]);
458 Assert.AreEqual(206L , message[f("repeated_sint64" ), 0]);
459 Assert.AreEqual(207U , message[f("repeated_fixed32" ), 0]);
460 Assert.AreEqual(208UL, message[f("repeated_fixed64" ), 0]);
461 Assert.AreEqual(209 , message[f("repeated_sfixed32"), 0]);
462 Assert.AreEqual(210L , message[f("repeated_sfixed64"), 0]);
463 Assert.AreEqual(211F , message[f("repeated_float" ), 0]);
464 Assert.AreEqual(212D , message[f("repeated_double" ), 0]);
465 Assert.AreEqual(true , message[f("repeated_bool" ), 0]);
466 Assert.AreEqual("215", message[f("repeated_string" ), 0]);
467 Assert.AreEqual(TestUtil.ToBytes("216"), message[f("repeated_bytes"), 0]);
468
469 Assert.AreEqual(217,((IMessage)message[f("repeatedgroup"), 0])[repeatedGroupA]);
470 Assert.AreEqual(218,((IMessage)message[f("repeated_nested_message"), 0])[nestedB]);
471 Assert.AreEqual(219,((IMessage)message[f("repeated_foreign_message"), 0])[foreignC]);
472 Assert.AreEqual(220,((IMessage)message[f("repeated_import_message"), 0])[importD]);
473
474 Assert.AreEqual( nestedBar, message[f("repeated_nested_enum" ),0]);
475 Assert.AreEqual(foreignBar, message[f("repeated_foreign_enum"),0]);
476 Assert.AreEqual( importBar, message[f("repeated_import_enum" ),0]);
477
478 Assert.AreEqual("224", message[f("repeated_string_piece"), 0]);
479 Assert.AreEqual("225", message[f("repeated_cord"), 0]);
480
481 Assert.AreEqual(301 , message[f("repeated_int32" ), 1]);
482 Assert.AreEqual(302L , message[f("repeated_int64" ), 1]);
483 Assert.AreEqual(303U , message[f("repeated_uint32" ), 1]);
484 Assert.AreEqual(304UL, message[f("repeated_uint64" ), 1]);
485 Assert.AreEqual(305 , message[f("repeated_sint32" ), 1]);
486 Assert.AreEqual(306L , message[f("repeated_sint64" ), 1]);
487 Assert.AreEqual(307U , message[f("repeated_fixed32" ), 1]);
488 Assert.AreEqual(308UL, message[f("repeated_fixed64" ), 1]);
489 Assert.AreEqual(309 , message[f("repeated_sfixed32"), 1]);
490 Assert.AreEqual(310L , message[f("repeated_sfixed64"), 1]);
491 Assert.AreEqual(311F , message[f("repeated_float" ), 1]);
492 Assert.AreEqual(312D , message[f("repeated_double" ), 1]);
493 Assert.AreEqual(false, message[f("repeated_bool" ), 1]);
494 Assert.AreEqual("315", message[f("repeated_string" ), 1]);
495 Assert.AreEqual(TestUtil.ToBytes("316"), message[f("repeated_bytes"), 1]);
496
497 Assert.AreEqual(317,((IMessage)message[f("repeatedgroup"), 1])[repeatedGroupA]);
498 Assert.AreEqual(318,((IMessage)message[f("repeated_nested_message"), 1])[nestedB]);
499 Assert.AreEqual(319,((IMessage)message[f("repeated_foreign_message"), 1])[foreignC]);
500 Assert.AreEqual(320,((IMessage)message[f("repeated_import_message"), 1])[importD]);
501
502 Assert.AreEqual( nestedBaz, message[f("repeated_nested_enum" ),1]);
503 Assert.AreEqual(foreignBaz, message[f("repeated_foreign_enum"),1]);
504 Assert.AreEqual( importBaz, message[f("repeated_import_enum" ),1]);
505
506 Assert.AreEqual("324", message[f("repeated_string_piece"), 1]);
507 Assert.AreEqual("325", message[f("repeated_cord"), 1]);
508
509 // -----------------------------------------------------------------
510
511 Assert.IsTrue(message.HasField(f("default_int32" )));
512 Assert.IsTrue(message.HasField(f("default_int64" )));
513 Assert.IsTrue(message.HasField(f("default_uint32" )));
514 Assert.IsTrue(message.HasField(f("default_uint64" )));
515 Assert.IsTrue(message.HasField(f("default_sint32" )));
516 Assert.IsTrue(message.HasField(f("default_sint64" )));
517 Assert.IsTrue(message.HasField(f("default_fixed32" )));
518 Assert.IsTrue(message.HasField(f("default_fixed64" )));
519 Assert.IsTrue(message.HasField(f("default_sfixed32")));
520 Assert.IsTrue(message.HasField(f("default_sfixed64")));
521 Assert.IsTrue(message.HasField(f("default_float" )));
522 Assert.IsTrue(message.HasField(f("default_double" )));
523 Assert.IsTrue(message.HasField(f("default_bool" )));
524 Assert.IsTrue(message.HasField(f("default_string" )));
525 Assert.IsTrue(message.HasField(f("default_bytes" )));
526
527 Assert.IsTrue(message.HasField(f("default_nested_enum" )));
528 Assert.IsTrue(message.HasField(f("default_foreign_enum")));
529 Assert.IsTrue(message.HasField(f("default_import_enum" )));
530
531 Assert.IsTrue(message.HasField(f("default_string_piece")));
532 Assert.IsTrue(message.HasField(f("default_cord")));
533
534 Assert.AreEqual(401 , message[f("default_int32" )]);
535 Assert.AreEqual(402L , message[f("default_int64" )]);
536 Assert.AreEqual(403U , message[f("default_uint32" )]);
537 Assert.AreEqual(404UL, message[f("default_uint64" )]);
538 Assert.AreEqual(405 , message[f("default_sint32" )]);
539 Assert.AreEqual(406L , message[f("default_sint64" )]);
540 Assert.AreEqual(407U , message[f("default_fixed32" )]);
541 Assert.AreEqual(408UL, message[f("default_fixed64" )]);
542 Assert.AreEqual(409 , message[f("default_sfixed32")]);
543 Assert.AreEqual(410L , message[f("default_sfixed64")]);
544 Assert.AreEqual(411F , message[f("default_float" )]);
545 Assert.AreEqual(412D , message[f("default_double" )]);
546 Assert.AreEqual(false, message[f("default_bool" )]);
547 Assert.AreEqual("415", message[f("default_string" )]);
548 Assert.AreEqual(TestUtil.ToBytes("416"), message[f("default_bytes")]);
549
550 Assert.AreEqual( nestedFoo, message[f("default_nested_enum" )]);
551 Assert.AreEqual(foreignFoo, message[f("default_foreign_enum")]);
552 Assert.AreEqual( importFoo, message[f("default_import_enum" )]);
553
554 Assert.AreEqual("424", message[f("default_string_piece")]);
555 Assert.AreEqual("425", message[f("default_cord")]);
556 }
557
558 /// <summary>
559 /// Assert that all fields of the message are cleared, and that
560 /// getting the fields returns their default values, using the reflection interface.
561 /// </summary>
562 public void AssertClearViaReflection(IMessage message) {
563 // has_blah() should initially be false for all optional fields.
564 Assert.IsFalse(message.HasField(f("optional_int32" )));
565 Assert.IsFalse(message.HasField(f("optional_int64" )));
566 Assert.IsFalse(message.HasField(f("optional_uint32" )));
567 Assert.IsFalse(message.HasField(f("optional_uint64" )));
568 Assert.IsFalse(message.HasField(f("optional_sint32" )));
569 Assert.IsFalse(message.HasField(f("optional_sint64" )));
570 Assert.IsFalse(message.HasField(f("optional_fixed32" )));
571 Assert.IsFalse(message.HasField(f("optional_fixed64" )));
572 Assert.IsFalse(message.HasField(f("optional_sfixed32")));
573 Assert.IsFalse(message.HasField(f("optional_sfixed64")));
574 Assert.IsFalse(message.HasField(f("optional_float" )));
575 Assert.IsFalse(message.HasField(f("optional_double" )));
576 Assert.IsFalse(message.HasField(f("optional_bool" )));
577 Assert.IsFalse(message.HasField(f("optional_string" )));
578 Assert.IsFalse(message.HasField(f("optional_bytes" )));
579
580 Assert.IsFalse(message.HasField(f("optionalgroup" )));
581 Assert.IsFalse(message.HasField(f("optional_nested_message" )));
582 Assert.IsFalse(message.HasField(f("optional_foreign_message")));
583 Assert.IsFalse(message.HasField(f("optional_import_message" )));
584
585 Assert.IsFalse(message.HasField(f("optional_nested_enum" )));
586 Assert.IsFalse(message.HasField(f("optional_foreign_enum")));
587 Assert.IsFalse(message.HasField(f("optional_import_enum" )));
588
589 Assert.IsFalse(message.HasField(f("optional_string_piece")));
590 Assert.IsFalse(message.HasField(f("optional_cord")));
591
592 // Optional fields without defaults are set to zero or something like it.
593 Assert.AreEqual(0 , message[f("optional_int32" )]);
594 Assert.AreEqual(0L , message[f("optional_int64" )]);
595 Assert.AreEqual(0U , message[f("optional_uint32" )]);
596 Assert.AreEqual(0UL , message[f("optional_uint64" )]);
597 Assert.AreEqual(0 , message[f("optional_sint32" )]);
598 Assert.AreEqual(0L , message[f("optional_sint64" )]);
599 Assert.AreEqual(0U , message[f("optional_fixed32" )]);
600 Assert.AreEqual(0UL , message[f("optional_fixed64" )]);
601 Assert.AreEqual(0 , message[f("optional_sfixed32")]);
602 Assert.AreEqual(0L , message[f("optional_sfixed64")]);
603 Assert.AreEqual(0F , message[f("optional_float" )]);
604 Assert.AreEqual(0D , message[f("optional_double" )]);
605 Assert.AreEqual(false, message[f("optional_bool" )]);
606 Assert.AreEqual("" , message[f("optional_string" )]);
607 Assert.AreEqual(ByteString.Empty, message[f("optional_bytes")]);
608
609 // Embedded messages should also be clear.
610 Assert.IsFalse(((IMessage)message[f("optionalgroup")]).HasField(groupA));
611 Assert.IsFalse(((IMessage)message[f("optional_nested_message")])
612 .HasField(nestedB));
613 Assert.IsFalse(((IMessage)message[f("optional_foreign_message")])
614 .HasField(foreignC));
615 Assert.IsFalse(((IMessage)message[f("optional_import_message")])
616 .HasField(importD));
617
618 Assert.AreEqual(0,((IMessage)message[f("optionalgroup")])[groupA]);
619 Assert.AreEqual(0,((IMessage)message[f("optional_nested_message")])[nestedB]);
620 Assert.AreEqual(0,((IMessage)message[f("optional_foreign_message")])[foreignC]);
621 Assert.AreEqual(0,((IMessage)message[f("optional_import_message")])[importD]);
622
623 // Enums without defaults are set to the first value in the enum.
624 Assert.AreEqual( nestedFoo, message[f("optional_nested_enum" )]);
625 Assert.AreEqual(foreignFoo, message[f("optional_foreign_enum")]);
626 Assert.AreEqual( importFoo, message[f("optional_import_enum" )]);
627
628 Assert.AreEqual("", message[f("optional_string_piece")]);
629 Assert.AreEqual("", message[f("optional_cord")]);
630
631 // Repeated fields are empty.
632 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_int32" )));
633 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_int64" )));
634 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_uint32" )));
635 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_uint64" )));
636 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_sint32" )));
637 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_sint64" )));
638 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_fixed32" )));
639 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_fixed64" )));
640 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_sfixed32")));
641 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_sfixed64")));
642 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_float" )));
643 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_double" )));
644 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_bool" )));
645 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_string" )));
646 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_bytes" )));
647
648 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeatedgroup" )));
649 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_nested_message" )));
650 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_foreign_message")));
651 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_import_message" )));
652 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_nested_enum" )));
653 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_foreign_enum" )));
654 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_import_enum" )));
655
656 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_string_piece")));
657 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_cord")));
658
659 // has_blah() should also be false for all default fields.
660 Assert.IsFalse(message.HasField(f("default_int32" )));
661 Assert.IsFalse(message.HasField(f("default_int64" )));
662 Assert.IsFalse(message.HasField(f("default_uint32" )));
663 Assert.IsFalse(message.HasField(f("default_uint64" )));
664 Assert.IsFalse(message.HasField(f("default_sint32" )));
665 Assert.IsFalse(message.HasField(f("default_sint64" )));
666 Assert.IsFalse(message.HasField(f("default_fixed32" )));
667 Assert.IsFalse(message.HasField(f("default_fixed64" )));
668 Assert.IsFalse(message.HasField(f("default_sfixed32")));
669 Assert.IsFalse(message.HasField(f("default_sfixed64")));
670 Assert.IsFalse(message.HasField(f("default_float" )));
671 Assert.IsFalse(message.HasField(f("default_double" )));
672 Assert.IsFalse(message.HasField(f("default_bool" )));
673 Assert.IsFalse(message.HasField(f("default_string" )));
674 Assert.IsFalse(message.HasField(f("default_bytes" )));
675
676 Assert.IsFalse(message.HasField(f("default_nested_enum" )));
677 Assert.IsFalse(message.HasField(f("default_foreign_enum")));
678 Assert.IsFalse(message.HasField(f("default_import_enum" )));
679
680 Assert.IsFalse(message.HasField(f("default_string_piece" )));
681 Assert.IsFalse(message.HasField(f("default_cord" )));
682
683 // Fields with defaults have their default values (duh).
684 Assert.AreEqual( 41 , message[f("default_int32" )]);
685 Assert.AreEqual( 42L , message[f("default_int64" )]);
686 Assert.AreEqual( 43U , message[f("default_uint32" )]);
687 Assert.AreEqual( 44UL , message[f("default_uint64" )]);
688 Assert.AreEqual(-45 , message[f("default_sint32" )]);
689 Assert.AreEqual( 46L , message[f("default_sint64" )]);
690 Assert.AreEqual( 47U , message[f("default_fixed32" )]);
691 Assert.AreEqual( 48UL , message[f("default_fixed64" )]);
692 Assert.AreEqual( 49 , message[f("default_sfixed32")]);
693 Assert.AreEqual(-50L , message[f("default_sfixed64")]);
694 Assert.AreEqual( 51.5F , message[f("default_float" )]);
695 Assert.AreEqual( 52e3D , message[f("default_double" )]);
696 Assert.AreEqual(true , message[f("default_bool" )]);
697 Assert.AreEqual("hello", message[f("default_string" )]);
698 Assert.AreEqual(TestUtil.ToBytes("world"), message[f("default_bytes")]);
699
700 Assert.AreEqual( nestedBar, message[f("default_nested_enum" )]);
701 Assert.AreEqual(foreignBar, message[f("default_foreign_enum")]);
702 Assert.AreEqual( importBar, message[f("default_import_enum" )]);
703
704 Assert.AreEqual("abc", message[f("default_string_piece")]);
705 Assert.AreEqual("123", message[f("default_cord")]);
706 }
707
708 // ---------------------------------------------------------------
709
710 internal void AssertRepeatedFieldsModifiedViaReflection(IMessage message) {
711 // ModifyRepeatedFields only sets the second repeated element of each
712 // field. In addition to verifying this, we also verify that the first
713 // element and size were *not* modified.
714 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_int32" )));
715 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_int64" )));
716 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_uint32" )));
717 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_uint64" )));
718 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sint32" )));
719 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sint64" )));
720 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_fixed32" )));
721 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_fixed64" )));
722 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sfixed32")));
723 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sfixed64")));
724 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_float" )));
725 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_double" )));
726 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_bool" )));
727 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_string" )));
728 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_bytes" )));
729
730 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeatedgroup" )));
731 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_nested_message" )));
732 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_foreign_message")));
733 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_import_message" )));
734 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_nested_enum" )));
735 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_foreign_enum" )));
736 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_import_enum" )));
737
738 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_string_piece")));
739 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_cord")));
740
741 Assert.AreEqual(201 , message[f("repeated_int32" ), 0]);
742 Assert.AreEqual(202L , message[f("repeated_int64" ), 0]);
743 Assert.AreEqual(203U , message[f("repeated_uint32" ), 0]);
744 Assert.AreEqual(204UL, message[f("repeated_uint64" ), 0]);
745 Assert.AreEqual(205 , message[f("repeated_sint32" ), 0]);
746 Assert.AreEqual(206L , message[f("repeated_sint64" ), 0]);
747 Assert.AreEqual(207U , message[f("repeated_fixed32" ), 0]);
748 Assert.AreEqual(208UL, message[f("repeated_fixed64" ), 0]);
749 Assert.AreEqual(209 , message[f("repeated_sfixed32"), 0]);
750 Assert.AreEqual(210L , message[f("repeated_sfixed64"), 0]);
751 Assert.AreEqual(211F , message[f("repeated_float" ), 0]);
752 Assert.AreEqual(212D , message[f("repeated_double" ), 0]);
753 Assert.AreEqual(true , message[f("repeated_bool" ), 0]);
754 Assert.AreEqual("215", message[f("repeated_string" ), 0]);
755 Assert.AreEqual(TestUtil.ToBytes("216"), message[f("repeated_bytes"), 0]);
756
757 Assert.AreEqual(217,((IMessage)message[f("repeatedgroup"), 0])[repeatedGroupA]);
758 Assert.AreEqual(218,((IMessage)message[f("repeated_nested_message"), 0])[nestedB]);
759 Assert.AreEqual(219,((IMessage)message[f("repeated_foreign_message"), 0])[foreignC]);
760 Assert.AreEqual(220,((IMessage)message[f("repeated_import_message"), 0])[importD]);
761
762 Assert.AreEqual( nestedBar, message[f("repeated_nested_enum" ),0]);
763 Assert.AreEqual(foreignBar, message[f("repeated_foreign_enum"),0]);
764 Assert.AreEqual( importBar, message[f("repeated_import_enum" ),0]);
765
766 Assert.AreEqual("224", message[f("repeated_string_piece"), 0]);
767 Assert.AreEqual("225", message[f("repeated_cord"), 0]);
768
769 Assert.AreEqual(501 , message[f("repeated_int32" ), 1]);
770 Assert.AreEqual(502L , message[f("repeated_int64" ), 1]);
771 Assert.AreEqual(503U , message[f("repeated_uint32" ), 1]);
772 Assert.AreEqual(504UL, message[f("repeated_uint64" ), 1]);
773 Assert.AreEqual(505 , message[f("repeated_sint32" ), 1]);
774 Assert.AreEqual(506L , message[f("repeated_sint64" ), 1]);
775 Assert.AreEqual(507U , message[f("repeated_fixed32" ), 1]);
776 Assert.AreEqual(508UL, message[f("repeated_fixed64" ), 1]);
777 Assert.AreEqual(509 , message[f("repeated_sfixed32"), 1]);
778 Assert.AreEqual(510L , message[f("repeated_sfixed64"), 1]);
779 Assert.AreEqual(511F , message[f("repeated_float" ), 1]);
780 Assert.AreEqual(512D , message[f("repeated_double" ), 1]);
781 Assert.AreEqual(true , message[f("repeated_bool" ), 1]);
782 Assert.AreEqual("515", message[f("repeated_string" ), 1]);
783 Assert.AreEqual(TestUtil.ToBytes("516"), message[f("repeated_bytes"), 1]);
784
785 Assert.AreEqual(517,((IMessage)message[f("repeatedgroup"), 1])[repeatedGroupA]);
786 Assert.AreEqual(518,((IMessage)message[f("repeated_nested_message"), 1])[nestedB]);
787 Assert.AreEqual(519,((IMessage)message[f("repeated_foreign_message"), 1])[foreignC]);
788 Assert.AreEqual(520,((IMessage)message[f("repeated_import_message"), 1])[importD]);
789
790 Assert.AreEqual( nestedFoo, message[f("repeated_nested_enum" ),1]);
791 Assert.AreEqual(foreignFoo, message[f("repeated_foreign_enum"),1]);
792 Assert.AreEqual( importFoo, message[f("repeated_import_enum" ),1]);
793
794 Assert.AreEqual("524", message[f("repeated_string_piece"), 1]);
795 Assert.AreEqual("525", message[f("repeated_cord"), 1]);
796 }
797 }
798}