Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / protobuf-javalite / eac64a5f7afdfca32476534fd8d0bf69d77002ca / . / src / ProtocolBuffers.Test / ReflectionTester.cs
blob: 9565a167f0ec4770fb71b018fbb6f2c46693a5d7 [file] [log] [blame]
csharptest71f662c2011-05-20 15:15:34 -0500[diff] [blame]1#region Copyright notice and license
2
3// Protocol Buffers - Google's data interchange format
4// Copyright 2008 Google Inc. All rights reserved.
5// http://github.com/jskeet/dotnet-protobufs/
6// Original C++/Java/Python code:
7// http://code.google.com/p/protobuf/
8//
9// Redistribution and use in source and binary forms, with or without
10// modification, are permitted provided that the following conditions are
11// met:
12//
13// * Redistributions of source code must retain the above copyright
14// notice, this list of conditions and the following disclaimer.
15// * Redistributions in binary form must reproduce the above
16// copyright notice, this list of conditions and the following disclaimer
17// in the documentation and/or other materials provided with the
18// distribution.
19// * Neither the name of Google Inc. nor the names of its
20// contributors may be used to endorse or promote products derived from
21// this software without specific prior written permission.
22//
23// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
26// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
27// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
28// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
29// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
30// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
31// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
32// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
33// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34
35#endregion
36
37using System;
38using Google.ProtocolBuffers.Descriptors;
39using Google.ProtocolBuffers.TestProtos;
csharptesteac64a52011-10-04 13:43:26 -0500[diff] [blame^]40using Microsoft.VisualStudio.TestTools.UnitTesting;
41
42#pragma warning disable 618 // Disable warning about obsolete use miss-matched assert arguments
csharptest71f662c2011-05-20 15:15:34 -0500[diff] [blame]43
44namespace Google.ProtocolBuffers
45{
46 /// <summary>
47 /// Performs the same things that the methods of TestUtil do, but
48 /// via the reflection interface. This is its own class because it needs
49 /// to know what descriptor to use.
50 /// </summary>
51 internal class ReflectionTester
52 {
53 private readonly MessageDescriptor baseDescriptor;
54 private readonly ExtensionRegistry extensionRegistry;
55
56 private readonly FileDescriptor file;
57 private readonly FileDescriptor importFile;
58
59 private readonly MessageDescriptor optionalGroup;
60 private readonly MessageDescriptor repeatedGroup;
61 private readonly MessageDescriptor nestedMessage;
62 private readonly MessageDescriptor foreignMessage;
63 private readonly MessageDescriptor importMessage;
64
65 private readonly FieldDescriptor groupA;
66 private readonly FieldDescriptor repeatedGroupA;
67 private readonly FieldDescriptor nestedB;
68 private readonly FieldDescriptor foreignC;
69 private readonly FieldDescriptor importD;
70
71 private readonly EnumDescriptor nestedEnum;
72 private readonly EnumDescriptor foreignEnum;
73 private readonly EnumDescriptor importEnum;
74
75 private readonly EnumValueDescriptor nestedFoo;
76 private readonly EnumValueDescriptor nestedBar;
77 private readonly EnumValueDescriptor nestedBaz;
78 private readonly EnumValueDescriptor foreignFoo;
79 private readonly EnumValueDescriptor foreignBar;
80 private readonly EnumValueDescriptor foreignBaz;
81 private readonly EnumValueDescriptor importFoo;
82 private readonly EnumValueDescriptor importBar;
83 private readonly EnumValueDescriptor importBaz;
84
85 /// <summary>
86 /// Constructs an instance that will expect messages using the given
87 /// descriptor. Normally <paramref name="baseDescriptor"/> should be
88 /// a descriptor for TestAllTypes. However, if extensionRegistry is non-null,
89 /// then baseDescriptor should be for TestAllExtensions instead, and instead of
90 /// reading and writing normal fields, the tester will read and write extensions.
91 /// All of the TestAllExtensions extensions must be registered in the registry.
92 /// </summary>
93 private ReflectionTester(MessageDescriptor baseDescriptor,
94 ExtensionRegistry extensionRegistry)
95 {
96 this.baseDescriptor = baseDescriptor;
97 this.extensionRegistry = extensionRegistry;
98
99 this.file = baseDescriptor.File;
100 // TODO(jonskeet): We've got 2 dependencies, not 1 - because of the C# options. Hmm.
101 // Assert.AreEqual(1, file.Dependencies.Count);
102 // TODO(jonskeet): Find dependency by name instead of number?
103 this.importFile = file.Dependencies[1];
104
105 MessageDescriptor testAllTypes;
106 if (baseDescriptor.Name == "TestAllTypes")
107 {
108 testAllTypes = baseDescriptor;
109 }
110 else
111 {
112 testAllTypes = file.FindTypeByName<MessageDescriptor>("TestAllTypes");
113 Assert.IsNotNull(testAllTypes);
114 }
115
116 if (extensionRegistry == null)
117 {
118 // Use testAllTypes, rather than baseDescriptor, to allow
119 // initialization using TestPackedTypes descriptors. These objects
120 // won't be used by the methods for packed fields.
121 this.optionalGroup =
122 testAllTypes.FindDescriptor<MessageDescriptor>("OptionalGroup");
123 this.repeatedGroup =
124 testAllTypes.FindDescriptor<MessageDescriptor>("RepeatedGroup");
125 }
126 else
127 {
128 this.optionalGroup =
129 file.FindTypeByName<MessageDescriptor>("OptionalGroup_extension");
130 this.repeatedGroup =
131 file.FindTypeByName<MessageDescriptor>("RepeatedGroup_extension");
132 }
133 this.nestedMessage = testAllTypes.FindDescriptor<MessageDescriptor>("NestedMessage");
134 this.foreignMessage = file.FindTypeByName<MessageDescriptor>("ForeignMessage");
135 this.importMessage = importFile.FindTypeByName<MessageDescriptor>("ImportMessage");
136
137 this.nestedEnum = testAllTypes.FindDescriptor<EnumDescriptor>("NestedEnum");
138 this.foreignEnum = file.FindTypeByName<EnumDescriptor>("ForeignEnum");
139 this.importEnum = importFile.FindTypeByName<EnumDescriptor>("ImportEnum");
140
141 Assert.IsNotNull(optionalGroup);
142 Assert.IsNotNull(repeatedGroup);
143 Assert.IsNotNull(nestedMessage);
144 Assert.IsNotNull(foreignMessage);
145 Assert.IsNotNull(importMessage);
146 Assert.IsNotNull(nestedEnum);
147 Assert.IsNotNull(foreignEnum);
148 Assert.IsNotNull(importEnum);
149
150 this.nestedB = nestedMessage.FindDescriptor<FieldDescriptor>("bb");
151 this.foreignC = foreignMessage.FindDescriptor<FieldDescriptor>("c");
152 this.importD = importMessage.FindDescriptor<FieldDescriptor>("d");
153 this.nestedFoo = nestedEnum.FindValueByName("FOO");
154 this.nestedBar = nestedEnum.FindValueByName("BAR");
155 this.nestedBaz = nestedEnum.FindValueByName("BAZ");
156 this.foreignFoo = foreignEnum.FindValueByName("FOREIGN_FOO");
157 this.foreignBar = foreignEnum.FindValueByName("FOREIGN_BAR");
158 this.foreignBaz = foreignEnum.FindValueByName("FOREIGN_BAZ");
159 this.importFoo = importEnum.FindValueByName("IMPORT_FOO");
160 this.importBar = importEnum.FindValueByName("IMPORT_BAR");
161 this.importBaz = importEnum.FindValueByName("IMPORT_BAZ");
162
163 this.groupA = optionalGroup.FindDescriptor<FieldDescriptor>("a");
164 this.repeatedGroupA = repeatedGroup.FindDescriptor<FieldDescriptor>("a");
165
166 Assert.IsNotNull(groupA);
167 Assert.IsNotNull(repeatedGroupA);
168 Assert.IsNotNull(nestedB);
169 Assert.IsNotNull(foreignC);
170 Assert.IsNotNull(importD);
171 Assert.IsNotNull(nestedFoo);
172 Assert.IsNotNull(nestedBar);
173 Assert.IsNotNull(nestedBaz);
174 Assert.IsNotNull(foreignFoo);
175 Assert.IsNotNull(foreignBar);
176 Assert.IsNotNull(foreignBaz);
177 Assert.IsNotNull(importFoo);
178 Assert.IsNotNull(importBar);
179 Assert.IsNotNull(importBaz);
180 }
181
182 /// <summary>
183 /// Creates an instance for the TestAllTypes message, with no extension registry.
184 /// </summary>
185 public static ReflectionTester CreateTestAllTypesInstance()
186 {
187 return new ReflectionTester(TestAllTypes.Descriptor, null);
188 }
189
190 /// <summary>
191 /// Creates an instance for the TestAllExtensions message, with an
192 /// extension registry from TestUtil.CreateExtensionRegistry.
193 /// </summary>
194 public static ReflectionTester CreateTestAllExtensionsInstance()
195 {
196 return new ReflectionTester(TestAllExtensions.Descriptor, TestUtil.CreateExtensionRegistry());
197 }
198
199 /// <summary>
200 /// Creates an instance for the TestPackedTypes message, with no extensions.
201 /// </summary>
202 public static ReflectionTester CreateTestPackedTypesInstance()
203 {
204 return new ReflectionTester(TestPackedTypes.Descriptor, null);
205 }
206
207 /// <summary>
208 /// Shorthand to get a FieldDescriptor for a field of unittest::TestAllTypes.
209 /// </summary>
210 private FieldDescriptor f(String name)
211 {
212 FieldDescriptor result;
213 if (extensionRegistry == null)
214 {
215 result = baseDescriptor.FindDescriptor<FieldDescriptor>(name);
216 }
217 else
218 {
219 result = file.FindTypeByName<FieldDescriptor>(name + "_extension");
220 }
221 Assert.IsNotNull(result);
222 return result;
223 }
224
225 /// <summary>
226 /// Calls parent.CreateBuilderForField() or uses the extension registry
227 /// to find an appropriate builder, depending on what type is being tested.
228 /// </summary>
229 private IBuilder CreateBuilderForField(IBuilder parent, FieldDescriptor field)
230 {
231 if (extensionRegistry == null)
232 {
233 return parent.CreateBuilderForField(field);
234 }
235 else
236 {
237 ExtensionInfo extension = extensionRegistry[field.ContainingType, field.FieldNumber];
238 Assert.IsNotNull(extension);
239 Assert.IsNotNull(extension.DefaultInstance);
240 return (IBuilder) extension.DefaultInstance.WeakCreateBuilderForType();
241 }
242 }
243
244 /// <summary>
245 /// Sets every field of the message to the values expected by
246 /// AssertAllFieldsSet, using the reflection interface.
247 /// </summary>
248 /// <param name="message"></param>
249 internal void SetAllFieldsViaReflection(IBuilder message)
250 {
251 message[f("optional_int32")] = 101;
252 message[f("optional_int64")] = 102L;
253 message[f("optional_uint32")] = 103U;
254 message[f("optional_uint64")] = 104UL;
255 message[f("optional_sint32")] = 105;
256 message[f("optional_sint64")] = 106L;
257 message[f("optional_fixed32")] = 107U;
258 message[f("optional_fixed64")] = 108UL;
259 message[f("optional_sfixed32")] = 109;
260 message[f("optional_sfixed64")] = 110L;
261 message[f("optional_float")] = 111F;
262 message[f("optional_double")] = 112D;
263 message[f("optional_bool")] = true;
264 message[f("optional_string")] = "115";
265 message[f("optional_bytes")] = TestUtil.ToBytes("116");
266
267 message[f("optionalgroup")] =
268 CreateBuilderForField(message, f("optionalgroup")).SetField(groupA, 117).WeakBuild();
269 message[f("optional_nested_message")] =
270 CreateBuilderForField(message, f("optional_nested_message")).SetField(nestedB, 118).WeakBuild();
271 message[f("optional_foreign_message")] =
272 CreateBuilderForField(message, f("optional_foreign_message")).SetField(foreignC, 119).WeakBuild();
273 message[f("optional_import_message")] =
274 CreateBuilderForField(message, f("optional_import_message")).SetField(importD, 120).WeakBuild();
275
276 message[f("optional_nested_enum")] = nestedBaz;
277 message[f("optional_foreign_enum")] = foreignBaz;
278 message[f("optional_import_enum")] = importBaz;
279
280 message[f("optional_string_piece")] = "124";
281 message[f("optional_cord")] = "125";
282
283 // -----------------------------------------------------------------
284
285 message.WeakAddRepeatedField(f("repeated_int32"), 201);
286 message.WeakAddRepeatedField(f("repeated_int64"), 202L);
287 message.WeakAddRepeatedField(f("repeated_uint32"), 203U);
288 message.WeakAddRepeatedField(f("repeated_uint64"), 204UL);
289 message.WeakAddRepeatedField(f("repeated_sint32"), 205);
290 message.WeakAddRepeatedField(f("repeated_sint64"), 206L);
291 message.WeakAddRepeatedField(f("repeated_fixed32"), 207U);
292 message.WeakAddRepeatedField(f("repeated_fixed64"), 208UL);
293 message.WeakAddRepeatedField(f("repeated_sfixed32"), 209);
294 message.WeakAddRepeatedField(f("repeated_sfixed64"), 210L);
295 message.WeakAddRepeatedField(f("repeated_float"), 211F);
296 message.WeakAddRepeatedField(f("repeated_double"), 212D);
297 message.WeakAddRepeatedField(f("repeated_bool"), true);
298 message.WeakAddRepeatedField(f("repeated_string"), "215");
299 message.WeakAddRepeatedField(f("repeated_bytes"), TestUtil.ToBytes("216"));
300
301
302 message.WeakAddRepeatedField(f("repeatedgroup"),
303 CreateBuilderForField(message, f("repeatedgroup")).SetField(repeatedGroupA, 217)
304 .WeakBuild());
305 message.WeakAddRepeatedField(f("repeated_nested_message"),
306 CreateBuilderForField(message, f("repeated_nested_message")).SetField(nestedB,
307 218).
308 WeakBuild());
309 message.WeakAddRepeatedField(f("repeated_foreign_message"),
310 CreateBuilderForField(message, f("repeated_foreign_message")).SetField(
311 foreignC, 219).WeakBuild());
312 message.WeakAddRepeatedField(f("repeated_import_message"),
313 CreateBuilderForField(message, f("repeated_import_message")).SetField(importD,
314 220).
315 WeakBuild());
316
317 message.WeakAddRepeatedField(f("repeated_nested_enum"), nestedBar);
318 message.WeakAddRepeatedField(f("repeated_foreign_enum"), foreignBar);
319 message.WeakAddRepeatedField(f("repeated_import_enum"), importBar);
320
321 message.WeakAddRepeatedField(f("repeated_string_piece"), "224");
322 message.WeakAddRepeatedField(f("repeated_cord"), "225");
323
324 // Add a second one of each field.
325 message.WeakAddRepeatedField(f("repeated_int32"), 301);
326 message.WeakAddRepeatedField(f("repeated_int64"), 302L);
327 message.WeakAddRepeatedField(f("repeated_uint32"), 303U);
328 message.WeakAddRepeatedField(f("repeated_uint64"), 304UL);
329 message.WeakAddRepeatedField(f("repeated_sint32"), 305);
330 message.WeakAddRepeatedField(f("repeated_sint64"), 306L);
331 message.WeakAddRepeatedField(f("repeated_fixed32"), 307U);
332 message.WeakAddRepeatedField(f("repeated_fixed64"), 308UL);
333 message.WeakAddRepeatedField(f("repeated_sfixed32"), 309);
334 message.WeakAddRepeatedField(f("repeated_sfixed64"), 310L);
335 message.WeakAddRepeatedField(f("repeated_float"), 311F);
336 message.WeakAddRepeatedField(f("repeated_double"), 312D);
337 message.WeakAddRepeatedField(f("repeated_bool"), false);
338 message.WeakAddRepeatedField(f("repeated_string"), "315");
339 message.WeakAddRepeatedField(f("repeated_bytes"), TestUtil.ToBytes("316"));
340
341 message.WeakAddRepeatedField(f("repeatedgroup"),
342 CreateBuilderForField(message, f("repeatedgroup"))
343 .SetField(repeatedGroupA, 317).WeakBuild());
344 message.WeakAddRepeatedField(f("repeated_nested_message"),
345 CreateBuilderForField(message, f("repeated_nested_message"))
346 .SetField(nestedB, 318).WeakBuild());
347 message.WeakAddRepeatedField(f("repeated_foreign_message"),
348 CreateBuilderForField(message, f("repeated_foreign_message"))
349 .SetField(foreignC, 319).WeakBuild());
350 message.WeakAddRepeatedField(f("repeated_import_message"),
351 CreateBuilderForField(message, f("repeated_import_message"))
352 .SetField(importD, 320).WeakBuild());
353
354 message.WeakAddRepeatedField(f("repeated_nested_enum"), nestedBaz);
355 message.WeakAddRepeatedField(f("repeated_foreign_enum"), foreignBaz);
356 message.WeakAddRepeatedField(f("repeated_import_enum"), importBaz);
357
358 message.WeakAddRepeatedField(f("repeated_string_piece"), "324");
359 message.WeakAddRepeatedField(f("repeated_cord"), "325");
360
361 // -----------------------------------------------------------------
362
363 message[f("default_int32")] = 401;
364 message[f("default_int64")] = 402L;
365 message[f("default_uint32")] = 403U;
366 message[f("default_uint64")] = 404UL;
367 message[f("default_sint32")] = 405;
368 message[f("default_sint64")] = 406L;
369 message[f("default_fixed32")] = 407U;
370 message[f("default_fixed64")] = 408UL;
371 message[f("default_sfixed32")] = 409;
372 message[f("default_sfixed64")] = 410L;
373 message[f("default_float")] = 411F;
374 message[f("default_double")] = 412D;
375 message[f("default_bool")] = false;
376 message[f("default_string")] = "415";
377 message[f("default_bytes")] = TestUtil.ToBytes("416");
378
379 message[f("default_nested_enum")] = nestedFoo;
380 message[f("default_foreign_enum")] = foreignFoo;
381 message[f("default_import_enum")] = importFoo;
382
383 message[f("default_string_piece")] = "424";
384 message[f("default_cord")] = "425";
385 }
386
387 // -------------------------------------------------------------------
388
389 /// <summary>
390 /// Modify the repeated fields of the specified message to contain the
391 /// values expected by AssertRepeatedFieldsModified, using the IBuilder
392 /// reflection interface.
393 /// </summary>
394 internal void ModifyRepeatedFieldsViaReflection(IBuilder message)
395 {
396 message[f("repeated_int32"), 1] = 501;
397 message[f("repeated_int64"), 1] = 502L;
398 message[f("repeated_uint32"), 1] = 503U;
399 message[f("repeated_uint64"), 1] = 504UL;
400 message[f("repeated_sint32"), 1] = 505;
401 message[f("repeated_sint64"), 1] = 506L;
402 message[f("repeated_fixed32"), 1] = 507U;
403 message[f("repeated_fixed64"), 1] = 508UL;
404 message[f("repeated_sfixed32"), 1] = 509;
405 message[f("repeated_sfixed64"), 1] = 510L;
406 message[f("repeated_float"), 1] = 511F;
407 message[f("repeated_double"), 1] = 512D;
408 message[f("repeated_bool"), 1] = true;
409 message[f("repeated_string"), 1] = "515";
410 message.SetRepeatedField(f("repeated_bytes"), 1, TestUtil.ToBytes("516"));
411
412 message.SetRepeatedField(f("repeatedgroup"), 1,
413 CreateBuilderForField(message, f("repeatedgroup")).SetField(repeatedGroupA, 517).
414 WeakBuild());
415 message.SetRepeatedField(f("repeated_nested_message"), 1,
416 CreateBuilderForField(message, f("repeated_nested_message")).SetField(nestedB, 518)
417 .WeakBuild());
418 message.SetRepeatedField(f("repeated_foreign_message"), 1,
419 CreateBuilderForField(message, f("repeated_foreign_message")).SetField(foreignC,
420 519).
421 WeakBuild());
422 message.SetRepeatedField(f("repeated_import_message"), 1,
423 CreateBuilderForField(message, f("repeated_import_message")).SetField(importD, 520)
424 .WeakBuild());
425
426 message[f("repeated_nested_enum"), 1] = nestedFoo;
427 message[f("repeated_foreign_enum"), 1] = foreignFoo;
428 message[f("repeated_import_enum"), 1] = importFoo;
429
430 message[f("repeated_string_piece"), 1] = "524";
431 message[f("repeated_cord"), 1] = "525";
432 }
433
434 // -------------------------------------------------------------------
435
436 /// <summary>
437 /// Asserts that all fields of the specified message are set to the values
438 /// assigned by SetAllFields, using the IMessage reflection interface.
439 /// </summary>
440 public void AssertAllFieldsSetViaReflection(IMessage message)
441 {
442 Assert.IsTrue(message.HasField(f("optional_int32")));
443 Assert.IsTrue(message.HasField(f("optional_int64")));
444 Assert.IsTrue(message.HasField(f("optional_uint32")));
445 Assert.IsTrue(message.HasField(f("optional_uint64")));
446 Assert.IsTrue(message.HasField(f("optional_sint32")));
447 Assert.IsTrue(message.HasField(f("optional_sint64")));
448 Assert.IsTrue(message.HasField(f("optional_fixed32")));
449 Assert.IsTrue(message.HasField(f("optional_fixed64")));
450 Assert.IsTrue(message.HasField(f("optional_sfixed32")));
451 Assert.IsTrue(message.HasField(f("optional_sfixed64")));
452 Assert.IsTrue(message.HasField(f("optional_float")));
453 Assert.IsTrue(message.HasField(f("optional_double")));
454 Assert.IsTrue(message.HasField(f("optional_bool")));
455 Assert.IsTrue(message.HasField(f("optional_string")));
456 Assert.IsTrue(message.HasField(f("optional_bytes")));
457
458 Assert.IsTrue(message.HasField(f("optionalgroup")));
459 Assert.IsTrue(message.HasField(f("optional_nested_message")));
460 Assert.IsTrue(message.HasField(f("optional_foreign_message")));
461 Assert.IsTrue(message.HasField(f("optional_import_message")));
462
463 Assert.IsTrue(((IMessage) message[f("optionalgroup")]).HasField(groupA));
464 Assert.IsTrue(((IMessage) message[f("optional_nested_message")]).HasField(nestedB));
465 Assert.IsTrue(((IMessage) message[f("optional_foreign_message")]).HasField(foreignC));
466 Assert.IsTrue(((IMessage) message[f("optional_import_message")]).HasField(importD));
467
468 Assert.IsTrue(message.HasField(f("optional_nested_enum")));
469 Assert.IsTrue(message.HasField(f("optional_foreign_enum")));
470 Assert.IsTrue(message.HasField(f("optional_import_enum")));
471
472 Assert.IsTrue(message.HasField(f("optional_string_piece")));
473 Assert.IsTrue(message.HasField(f("optional_cord")));
474
475 Assert.AreEqual(101, message[f("optional_int32")]);
476 Assert.AreEqual(102L, message[f("optional_int64")]);
csharptesteac64a52011-10-04 13:43:26 -0500[diff] [blame^]477 Assert.AreEqual(103u, message[f("optional_uint32")]);
csharptest71f662c2011-05-20 15:15:34 -0500[diff] [blame]478 Assert.AreEqual(104UL, message[f("optional_uint64")]);
479 Assert.AreEqual(105, message[f("optional_sint32")]);
480 Assert.AreEqual(106L, message[f("optional_sint64")]);
481 Assert.AreEqual(107U, message[f("optional_fixed32")]);
482 Assert.AreEqual(108UL, message[f("optional_fixed64")]);
483 Assert.AreEqual(109, message[f("optional_sfixed32")]);
484 Assert.AreEqual(110L, message[f("optional_sfixed64")]);
485 Assert.AreEqual(111F, message[f("optional_float")]);
486 Assert.AreEqual(112D, message[f("optional_double")]);
487 Assert.AreEqual(true, message[f("optional_bool")]);
488 Assert.AreEqual("115", message[f("optional_string")]);
489 Assert.AreEqual(TestUtil.ToBytes("116"), message[f("optional_bytes")]);
490
491 Assert.AreEqual(117, ((IMessage) message[f("optionalgroup")])[groupA]);
492 Assert.AreEqual(118, ((IMessage) message[f("optional_nested_message")])[nestedB]);
493 Assert.AreEqual(119, ((IMessage) message[f("optional_foreign_message")])[foreignC]);
494 Assert.AreEqual(120, ((IMessage) message[f("optional_import_message")])[importD]);
495
496 Assert.AreEqual(nestedBaz, message[f("optional_nested_enum")]);
497 Assert.AreEqual(foreignBaz, message[f("optional_foreign_enum")]);
498 Assert.AreEqual(importBaz, message[f("optional_import_enum")]);
499
500 Assert.AreEqual("124", message[f("optional_string_piece")]);
501 Assert.AreEqual("125", message[f("optional_cord")]);
502
503 // -----------------------------------------------------------------
504
505 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_int32")));
506 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_int64")));
507 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_uint32")));
508 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_uint64")));
509 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sint32")));
510 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sint64")));
511 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_fixed32")));
512 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_fixed64")));
513 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sfixed32")));
514 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sfixed64")));
515 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_float")));
516 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_double")));
517 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_bool")));
518 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_string")));
519 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_bytes")));
520
521 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeatedgroup")));
522 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_nested_message")));
523 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_foreign_message")));
524 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_import_message")));
525 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_nested_enum")));
526 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_foreign_enum")));
527 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_import_enum")));
528
529 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_string_piece")));
530 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_cord")));
531
532 Assert.AreEqual(201, message[f("repeated_int32"), 0]);
533 Assert.AreEqual(202L, message[f("repeated_int64"), 0]);
534 Assert.AreEqual(203U, message[f("repeated_uint32"), 0]);
535 Assert.AreEqual(204UL, message[f("repeated_uint64"), 0]);
536 Assert.AreEqual(205, message[f("repeated_sint32"), 0]);
537 Assert.AreEqual(206L, message[f("repeated_sint64"), 0]);
538 Assert.AreEqual(207U, message[f("repeated_fixed32"), 0]);
539 Assert.AreEqual(208UL, message[f("repeated_fixed64"), 0]);
540 Assert.AreEqual(209, message[f("repeated_sfixed32"), 0]);
541 Assert.AreEqual(210L, message[f("repeated_sfixed64"), 0]);
542 Assert.AreEqual(211F, message[f("repeated_float"), 0]);
543 Assert.AreEqual(212D, message[f("repeated_double"), 0]);
544 Assert.AreEqual(true, message[f("repeated_bool"), 0]);
545 Assert.AreEqual("215", message[f("repeated_string"), 0]);
546 Assert.AreEqual(TestUtil.ToBytes("216"), message[f("repeated_bytes"), 0]);
547
548 Assert.AreEqual(217, ((IMessage) message[f("repeatedgroup"), 0])[repeatedGroupA]);
549 Assert.AreEqual(218, ((IMessage) message[f("repeated_nested_message"), 0])[nestedB]);
550 Assert.AreEqual(219, ((IMessage) message[f("repeated_foreign_message"), 0])[foreignC]);
551 Assert.AreEqual(220, ((IMessage) message[f("repeated_import_message"), 0])[importD]);
552
553 Assert.AreEqual(nestedBar, message[f("repeated_nested_enum"), 0]);
554 Assert.AreEqual(foreignBar, message[f("repeated_foreign_enum"), 0]);
555 Assert.AreEqual(importBar, message[f("repeated_import_enum"), 0]);
556
557 Assert.AreEqual("224", message[f("repeated_string_piece"), 0]);
558 Assert.AreEqual("225", message[f("repeated_cord"), 0]);
559
560 Assert.AreEqual(301, message[f("repeated_int32"), 1]);
561 Assert.AreEqual(302L, message[f("repeated_int64"), 1]);
562 Assert.AreEqual(303U, message[f("repeated_uint32"), 1]);
563 Assert.AreEqual(304UL, message[f("repeated_uint64"), 1]);
564 Assert.AreEqual(305, message[f("repeated_sint32"), 1]);
565 Assert.AreEqual(306L, message[f("repeated_sint64"), 1]);
566 Assert.AreEqual(307U, message[f("repeated_fixed32"), 1]);
567 Assert.AreEqual(308UL, message[f("repeated_fixed64"), 1]);
568 Assert.AreEqual(309, message[f("repeated_sfixed32"), 1]);
569 Assert.AreEqual(310L, message[f("repeated_sfixed64"), 1]);
570 Assert.AreEqual(311F, message[f("repeated_float"), 1]);
571 Assert.AreEqual(312D, message[f("repeated_double"), 1]);
572 Assert.AreEqual(false, message[f("repeated_bool"), 1]);
573 Assert.AreEqual("315", message[f("repeated_string"), 1]);
574 Assert.AreEqual(TestUtil.ToBytes("316"), message[f("repeated_bytes"), 1]);
575
576 Assert.AreEqual(317, ((IMessage) message[f("repeatedgroup"), 1])[repeatedGroupA]);
577 Assert.AreEqual(318, ((IMessage) message[f("repeated_nested_message"), 1])[nestedB]);
578 Assert.AreEqual(319, ((IMessage) message[f("repeated_foreign_message"), 1])[foreignC]);
579 Assert.AreEqual(320, ((IMessage) message[f("repeated_import_message"), 1])[importD]);
580
581 Assert.AreEqual(nestedBaz, message[f("repeated_nested_enum"), 1]);
582 Assert.AreEqual(foreignBaz, message[f("repeated_foreign_enum"), 1]);
583 Assert.AreEqual(importBaz, message[f("repeated_import_enum"), 1]);
584
585 Assert.AreEqual("324", message[f("repeated_string_piece"), 1]);
586 Assert.AreEqual("325", message[f("repeated_cord"), 1]);
587
588 // -----------------------------------------------------------------
589
590 Assert.IsTrue(message.HasField(f("default_int32")));
591 Assert.IsTrue(message.HasField(f("default_int64")));
592 Assert.IsTrue(message.HasField(f("default_uint32")));
593 Assert.IsTrue(message.HasField(f("default_uint64")));
594 Assert.IsTrue(message.HasField(f("default_sint32")));
595 Assert.IsTrue(message.HasField(f("default_sint64")));
596 Assert.IsTrue(message.HasField(f("default_fixed32")));
597 Assert.IsTrue(message.HasField(f("default_fixed64")));
598 Assert.IsTrue(message.HasField(f("default_sfixed32")));
599 Assert.IsTrue(message.HasField(f("default_sfixed64")));
600 Assert.IsTrue(message.HasField(f("default_float")));
601 Assert.IsTrue(message.HasField(f("default_double")));
602 Assert.IsTrue(message.HasField(f("default_bool")));
603 Assert.IsTrue(message.HasField(f("default_string")));
604 Assert.IsTrue(message.HasField(f("default_bytes")));
605
606 Assert.IsTrue(message.HasField(f("default_nested_enum")));
607 Assert.IsTrue(message.HasField(f("default_foreign_enum")));
608 Assert.IsTrue(message.HasField(f("default_import_enum")));
609
610 Assert.IsTrue(message.HasField(f("default_string_piece")));
611 Assert.IsTrue(message.HasField(f("default_cord")));
612
613 Assert.AreEqual(401, message[f("default_int32")]);
614 Assert.AreEqual(402L, message[f("default_int64")]);
615 Assert.AreEqual(403U, message[f("default_uint32")]);
616 Assert.AreEqual(404UL, message[f("default_uint64")]);
617 Assert.AreEqual(405, message[f("default_sint32")]);
618 Assert.AreEqual(406L, message[f("default_sint64")]);
619 Assert.AreEqual(407U, message[f("default_fixed32")]);
620 Assert.AreEqual(408UL, message[f("default_fixed64")]);
621 Assert.AreEqual(409, message[f("default_sfixed32")]);
622 Assert.AreEqual(410L, message[f("default_sfixed64")]);
623 Assert.AreEqual(411F, message[f("default_float")]);
624 Assert.AreEqual(412D, message[f("default_double")]);
625 Assert.AreEqual(false, message[f("default_bool")]);
626 Assert.AreEqual("415", message[f("default_string")]);
627 Assert.AreEqual(TestUtil.ToBytes("416"), message[f("default_bytes")]);
628
629 Assert.AreEqual(nestedFoo, message[f("default_nested_enum")]);
630 Assert.AreEqual(foreignFoo, message[f("default_foreign_enum")]);
631 Assert.AreEqual(importFoo, message[f("default_import_enum")]);
632
633 Assert.AreEqual("424", message[f("default_string_piece")]);
634 Assert.AreEqual("425", message[f("default_cord")]);
635 }
636
637 /// <summary>
638 /// Assert that all fields of the message are cleared, and that
639 /// getting the fields returns their default values, using the reflection interface.
640 /// </summary>
641 public void AssertClearViaReflection(IMessage message)
642 {
643 // has_blah() should initially be false for all optional fields.
644 Assert.IsFalse(message.HasField(f("optional_int32")));
645 Assert.IsFalse(message.HasField(f("optional_int64")));
646 Assert.IsFalse(message.HasField(f("optional_uint32")));
647 Assert.IsFalse(message.HasField(f("optional_uint64")));
648 Assert.IsFalse(message.HasField(f("optional_sint32")));
649 Assert.IsFalse(message.HasField(f("optional_sint64")));
650 Assert.IsFalse(message.HasField(f("optional_fixed32")));
651 Assert.IsFalse(message.HasField(f("optional_fixed64")));
652 Assert.IsFalse(message.HasField(f("optional_sfixed32")));
653 Assert.IsFalse(message.HasField(f("optional_sfixed64")));
654 Assert.IsFalse(message.HasField(f("optional_float")));
655 Assert.IsFalse(message.HasField(f("optional_double")));
656 Assert.IsFalse(message.HasField(f("optional_bool")));
657 Assert.IsFalse(message.HasField(f("optional_string")));
658 Assert.IsFalse(message.HasField(f("optional_bytes")));
659
660 Assert.IsFalse(message.HasField(f("optionalgroup")));
661 Assert.IsFalse(message.HasField(f("optional_nested_message")));
662 Assert.IsFalse(message.HasField(f("optional_foreign_message")));
663 Assert.IsFalse(message.HasField(f("optional_import_message")));
664
665 Assert.IsFalse(message.HasField(f("optional_nested_enum")));
666 Assert.IsFalse(message.HasField(f("optional_foreign_enum")));
667 Assert.IsFalse(message.HasField(f("optional_import_enum")));
668
669 Assert.IsFalse(message.HasField(f("optional_string_piece")));
670 Assert.IsFalse(message.HasField(f("optional_cord")));
671
672 // Optional fields without defaults are set to zero or something like it.
673 Assert.AreEqual(0, message[f("optional_int32")]);
674 Assert.AreEqual(0L, message[f("optional_int64")]);
675 Assert.AreEqual(0U, message[f("optional_uint32")]);
676 Assert.AreEqual(0UL, message[f("optional_uint64")]);
677 Assert.AreEqual(0, message[f("optional_sint32")]);
678 Assert.AreEqual(0L, message[f("optional_sint64")]);
679 Assert.AreEqual(0U, message[f("optional_fixed32")]);
680 Assert.AreEqual(0UL, message[f("optional_fixed64")]);
681 Assert.AreEqual(0, message[f("optional_sfixed32")]);
682 Assert.AreEqual(0L, message[f("optional_sfixed64")]);
683 Assert.AreEqual(0F, message[f("optional_float")]);
684 Assert.AreEqual(0D, message[f("optional_double")]);
685 Assert.AreEqual(false, message[f("optional_bool")]);
686 Assert.AreEqual("", message[f("optional_string")]);
687 Assert.AreEqual(ByteString.Empty, message[f("optional_bytes")]);
688
689 // Embedded messages should also be clear.
690 Assert.IsFalse(((IMessage) message[f("optionalgroup")]).HasField(groupA));
691 Assert.IsFalse(((IMessage) message[f("optional_nested_message")])
692 .HasField(nestedB));
693 Assert.IsFalse(((IMessage) message[f("optional_foreign_message")])
694 .HasField(foreignC));
695 Assert.IsFalse(((IMessage) message[f("optional_import_message")])
696 .HasField(importD));
697
698 Assert.AreEqual(0, ((IMessage) message[f("optionalgroup")])[groupA]);
699 Assert.AreEqual(0, ((IMessage) message[f("optional_nested_message")])[nestedB]);
700 Assert.AreEqual(0, ((IMessage) message[f("optional_foreign_message")])[foreignC]);
701 Assert.AreEqual(0, ((IMessage) message[f("optional_import_message")])[importD]);
702
703 // Enums without defaults are set to the first value in the enum.
704 Assert.AreEqual(nestedFoo, message[f("optional_nested_enum")]);
705 Assert.AreEqual(foreignFoo, message[f("optional_foreign_enum")]);
706 Assert.AreEqual(importFoo, message[f("optional_import_enum")]);
707
708 Assert.AreEqual("", message[f("optional_string_piece")]);
709 Assert.AreEqual("", message[f("optional_cord")]);
710
711 // Repeated fields are empty.
712 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_int32")));
713 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_int64")));
714 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_uint32")));
715 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_uint64")));
716 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_sint32")));
717 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_sint64")));
718 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_fixed32")));
719 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_fixed64")));
720 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_sfixed32")));
721 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_sfixed64")));
722 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_float")));
723 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_double")));
724 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_bool")));
725 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_string")));
726 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_bytes")));
727
728 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeatedgroup")));
729 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_nested_message")));
730 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_foreign_message")));
731 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_import_message")));
732 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_nested_enum")));
733 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_foreign_enum")));
734 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_import_enum")));
735
736 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_string_piece")));
737 Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_cord")));
738
739 // has_blah() should also be false for all default fields.
740 Assert.IsFalse(message.HasField(f("default_int32")));
741 Assert.IsFalse(message.HasField(f("default_int64")));
742 Assert.IsFalse(message.HasField(f("default_uint32")));
743 Assert.IsFalse(message.HasField(f("default_uint64")));
744 Assert.IsFalse(message.HasField(f("default_sint32")));
745 Assert.IsFalse(message.HasField(f("default_sint64")));
746 Assert.IsFalse(message.HasField(f("default_fixed32")));
747 Assert.IsFalse(message.HasField(f("default_fixed64")));
748 Assert.IsFalse(message.HasField(f("default_sfixed32")));
749 Assert.IsFalse(message.HasField(f("default_sfixed64")));
750 Assert.IsFalse(message.HasField(f("default_float")));
751 Assert.IsFalse(message.HasField(f("default_double")));
752 Assert.IsFalse(message.HasField(f("default_bool")));
753 Assert.IsFalse(message.HasField(f("default_string")));
754 Assert.IsFalse(message.HasField(f("default_bytes")));
755
756 Assert.IsFalse(message.HasField(f("default_nested_enum")));
757 Assert.IsFalse(message.HasField(f("default_foreign_enum")));
758 Assert.IsFalse(message.HasField(f("default_import_enum")));
759
760 Assert.IsFalse(message.HasField(f("default_string_piece")));
761 Assert.IsFalse(message.HasField(f("default_cord")));
762
763 // Fields with defaults have their default values (duh).
764 Assert.AreEqual(41, message[f("default_int32")]);
765 Assert.AreEqual(42L, message[f("default_int64")]);
766 Assert.AreEqual(43U, message[f("default_uint32")]);
767 Assert.AreEqual(44UL, message[f("default_uint64")]);
768 Assert.AreEqual(-45, message[f("default_sint32")]);
769 Assert.AreEqual(46L, message[f("default_sint64")]);
770 Assert.AreEqual(47U, message[f("default_fixed32")]);
771 Assert.AreEqual(48UL, message[f("default_fixed64")]);
772 Assert.AreEqual(49, message[f("default_sfixed32")]);
773 Assert.AreEqual(-50L, message[f("default_sfixed64")]);
774 Assert.AreEqual(51.5F, message[f("default_float")]);
775 Assert.AreEqual(52e3D, message[f("default_double")]);
776 Assert.AreEqual(true, message[f("default_bool")]);
777 Assert.AreEqual("hello", message[f("default_string")]);
778 Assert.AreEqual(TestUtil.ToBytes("world"), message[f("default_bytes")]);
779
780 Assert.AreEqual(nestedBar, message[f("default_nested_enum")]);
781 Assert.AreEqual(foreignBar, message[f("default_foreign_enum")]);
782 Assert.AreEqual(importBar, message[f("default_import_enum")]);
783
784 Assert.AreEqual("abc", message[f("default_string_piece")]);
785 Assert.AreEqual("123", message[f("default_cord")]);
786 }
787
788 // ---------------------------------------------------------------
789
790 internal void AssertRepeatedFieldsModifiedViaReflection(IMessage message)
791 {
792 // ModifyRepeatedFields only sets the second repeated element of each
793 // field. In addition to verifying this, we also verify that the first
794 // element and size were *not* modified.
795 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_int32")));
796 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_int64")));
797 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_uint32")));
798 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_uint64")));
799 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sint32")));
800 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sint64")));
801 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_fixed32")));
802 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_fixed64")));
803 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sfixed32")));
804 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sfixed64")));
805 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_float")));
806 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_double")));
807 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_bool")));
808 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_string")));
809 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_bytes")));
810
811 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeatedgroup")));
812 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_nested_message")));
813 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_foreign_message")));
814 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_import_message")));
815 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_nested_enum")));
816 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_foreign_enum")));
817 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_import_enum")));
818
819 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_string_piece")));
820 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_cord")));
821
822 Assert.AreEqual(201, message[f("repeated_int32"), 0]);
823 Assert.AreEqual(202L, message[f("repeated_int64"), 0]);
824 Assert.AreEqual(203U, message[f("repeated_uint32"), 0]);
825 Assert.AreEqual(204UL, message[f("repeated_uint64"), 0]);
826 Assert.AreEqual(205, message[f("repeated_sint32"), 0]);
827 Assert.AreEqual(206L, message[f("repeated_sint64"), 0]);
828 Assert.AreEqual(207U, message[f("repeated_fixed32"), 0]);
829 Assert.AreEqual(208UL, message[f("repeated_fixed64"), 0]);
830 Assert.AreEqual(209, message[f("repeated_sfixed32"), 0]);
831 Assert.AreEqual(210L, message[f("repeated_sfixed64"), 0]);
832 Assert.AreEqual(211F, message[f("repeated_float"), 0]);
833 Assert.AreEqual(212D, message[f("repeated_double"), 0]);
834 Assert.AreEqual(true, message[f("repeated_bool"), 0]);
835 Assert.AreEqual("215", message[f("repeated_string"), 0]);
836 Assert.AreEqual(TestUtil.ToBytes("216"), message[f("repeated_bytes"), 0]);
837
838 Assert.AreEqual(217, ((IMessage) message[f("repeatedgroup"), 0])[repeatedGroupA]);
839 Assert.AreEqual(218, ((IMessage) message[f("repeated_nested_message"), 0])[nestedB]);
840 Assert.AreEqual(219, ((IMessage) message[f("repeated_foreign_message"), 0])[foreignC]);
841 Assert.AreEqual(220, ((IMessage) message[f("repeated_import_message"), 0])[importD]);
842
843 Assert.AreEqual(nestedBar, message[f("repeated_nested_enum"), 0]);
844 Assert.AreEqual(foreignBar, message[f("repeated_foreign_enum"), 0]);
845 Assert.AreEqual(importBar, message[f("repeated_import_enum"), 0]);
846
847 Assert.AreEqual("224", message[f("repeated_string_piece"), 0]);
848 Assert.AreEqual("225", message[f("repeated_cord"), 0]);
849
850 Assert.AreEqual(501, message[f("repeated_int32"), 1]);
851 Assert.AreEqual(502L, message[f("repeated_int64"), 1]);
852 Assert.AreEqual(503U, message[f("repeated_uint32"), 1]);
853 Assert.AreEqual(504UL, message[f("repeated_uint64"), 1]);
854 Assert.AreEqual(505, message[f("repeated_sint32"), 1]);
855 Assert.AreEqual(506L, message[f("repeated_sint64"), 1]);
856 Assert.AreEqual(507U, message[f("repeated_fixed32"), 1]);
857 Assert.AreEqual(508UL, message[f("repeated_fixed64"), 1]);
858 Assert.AreEqual(509, message[f("repeated_sfixed32"), 1]);
859 Assert.AreEqual(510L, message[f("repeated_sfixed64"), 1]);
860 Assert.AreEqual(511F, message[f("repeated_float"), 1]);
861 Assert.AreEqual(512D, message[f("repeated_double"), 1]);
862 Assert.AreEqual(true, message[f("repeated_bool"), 1]);
863 Assert.AreEqual("515", message[f("repeated_string"), 1]);
864 Assert.AreEqual(TestUtil.ToBytes("516"), message[f("repeated_bytes"), 1]);
865
866 Assert.AreEqual(517, ((IMessage) message[f("repeatedgroup"), 1])[repeatedGroupA]);
867 Assert.AreEqual(518, ((IMessage) message[f("repeated_nested_message"), 1])[nestedB]);
868 Assert.AreEqual(519, ((IMessage) message[f("repeated_foreign_message"), 1])[foreignC]);
869 Assert.AreEqual(520, ((IMessage) message[f("repeated_import_message"), 1])[importD]);
870
871 Assert.AreEqual(nestedFoo, message[f("repeated_nested_enum"), 1]);
872 Assert.AreEqual(foreignFoo, message[f("repeated_foreign_enum"), 1]);
873 Assert.AreEqual(importFoo, message[f("repeated_import_enum"), 1]);
874
875 Assert.AreEqual("524", message[f("repeated_string_piece"), 1]);
876 Assert.AreEqual("525", message[f("repeated_cord"), 1]);
877 }
878
879 /// <summary>
880 /// Verifies that the reflection setters for the given Builder object throw an
881 /// ArgumentNullException if they are passed a null value.
882 /// </summary>
883 public void AssertReflectionSettersRejectNull(IBuilder builder)
884 {
885 TestUtil.AssertArgumentNullException(() => builder[f("optional_string")] = null);
886 TestUtil.AssertArgumentNullException(() => builder[f("optional_bytes")] = null);
887 TestUtil.AssertArgumentNullException(() => builder[f("optional_nested_enum")] = null);
888 TestUtil.AssertArgumentNullException(() => builder[f("optional_nested_message")] = null);
889 TestUtil.AssertArgumentNullException(() => builder[f("optional_nested_message")] = null);
890 TestUtil.AssertArgumentNullException(() => builder.WeakAddRepeatedField(f("repeated_string"), null));
891 TestUtil.AssertArgumentNullException(() => builder.WeakAddRepeatedField(f("repeated_bytes"), null));
892 TestUtil.AssertArgumentNullException(() => builder.WeakAddRepeatedField(f("repeated_nested_enum"), null));
893 TestUtil.AssertArgumentNullException(() => builder.WeakAddRepeatedField(f("repeated_nested_message"), null));
894 }
895
896 /// <summary>
897 /// Verifies that the reflection repeated setters for the given Builder object throw an
898 /// ArgumentNullException if they are passed a null value.
899 /// </summary>
900 public void AssertReflectionRepeatedSettersRejectNull(IBuilder builder)
901 {
902 builder.WeakAddRepeatedField(f("repeated_string"), "one");
903 TestUtil.AssertArgumentNullException(() => builder.SetRepeatedField(f("repeated_string"), 0, null));
904 builder.WeakAddRepeatedField(f("repeated_bytes"), TestUtil.ToBytes("one"));
905 TestUtil.AssertArgumentNullException(() => builder.SetRepeatedField(f("repeated_bytes"), 0, null));
906 builder.WeakAddRepeatedField(f("repeated_nested_enum"), nestedBaz);
907 TestUtil.AssertArgumentNullException(() => builder.SetRepeatedField(f("repeated_nested_enum"), 0, null));
908 builder.WeakAddRepeatedField(f("repeated_nested_message"),
909 new TestAllTypes.Types.NestedMessage.Builder {Bb = 218}.Build());
910 TestUtil.AssertArgumentNullException(() => builder.SetRepeatedField(f("repeated_nested_message"), 0, null));
911 }
912
913 public void SetPackedFieldsViaReflection(IBuilder message)
914 {
915 message.WeakAddRepeatedField(f("packed_int32"), 601);
916 message.WeakAddRepeatedField(f("packed_int64"), 602L);
917 message.WeakAddRepeatedField(f("packed_uint32"), 603U);
918 message.WeakAddRepeatedField(f("packed_uint64"), 604UL);
919 message.WeakAddRepeatedField(f("packed_sint32"), 605);
920 message.WeakAddRepeatedField(f("packed_sint64"), 606L);
921 message.WeakAddRepeatedField(f("packed_fixed32"), 607U);
922 message.WeakAddRepeatedField(f("packed_fixed64"), 608UL);
923 message.WeakAddRepeatedField(f("packed_sfixed32"), 609);
924 message.WeakAddRepeatedField(f("packed_sfixed64"), 610L);
925 message.WeakAddRepeatedField(f("packed_float"), 611F);
926 message.WeakAddRepeatedField(f("packed_double"), 612D);
927 message.WeakAddRepeatedField(f("packed_bool"), true);
928 message.WeakAddRepeatedField(f("packed_enum"), foreignBar);
929 // Add a second one of each field.
930 message.WeakAddRepeatedField(f("packed_int32"), 701);
931 message.WeakAddRepeatedField(f("packed_int64"), 702L);
932 message.WeakAddRepeatedField(f("packed_uint32"), 703U);
933 message.WeakAddRepeatedField(f("packed_uint64"), 704UL);
934 message.WeakAddRepeatedField(f("packed_sint32"), 705);
935 message.WeakAddRepeatedField(f("packed_sint64"), 706L);
936 message.WeakAddRepeatedField(f("packed_fixed32"), 707U);
937 message.WeakAddRepeatedField(f("packed_fixed64"), 708UL);
938 message.WeakAddRepeatedField(f("packed_sfixed32"), 709);
939 message.WeakAddRepeatedField(f("packed_sfixed64"), 710L);
940 message.WeakAddRepeatedField(f("packed_float"), 711F);
941 message.WeakAddRepeatedField(f("packed_double"), 712D);
942 message.WeakAddRepeatedField(f("packed_bool"), false);
943 message.WeakAddRepeatedField(f("packed_enum"), foreignBaz);
944 }
945
946 public void AssertPackedFieldsSetViaReflection(IMessage message)
947 {
948 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_int32")));
949 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_int64")));
950 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_uint32")));
951 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_uint64")));
952 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_sint32")));
953 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_sint64")));
954 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_fixed32")));
955 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_fixed64")));
956 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_sfixed32")));
957 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_sfixed64")));
958 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_float")));
959 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_double")));
960 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_bool")));
961 Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_enum")));
csharptesteac64a52011-10-04 13:43:26 -0500[diff] [blame^]962
csharptest71f662c2011-05-20 15:15:34 -0500[diff] [blame]963 Assert.AreEqual(601, message[f("packed_int32"), 0]);
964 Assert.AreEqual(602L, message[f("packed_int64"), 0]);
csharptesteac64a52011-10-04 13:43:26 -0500[diff] [blame^]965 Assert.AreEqual(603u, message[f("packed_uint32"), 0]);
966 Assert.AreEqual(604uL, message[f("packed_uint64"), 0]);
csharptest71f662c2011-05-20 15:15:34 -0500[diff] [blame]967 Assert.AreEqual(605, message[f("packed_sint32"), 0]);
968 Assert.AreEqual(606L, message[f("packed_sint64"), 0]);
csharptesteac64a52011-10-04 13:43:26 -0500[diff] [blame^]969 Assert.AreEqual(607u, message[f("packed_fixed32"), 0]);
970 Assert.AreEqual(608uL, message[f("packed_fixed64"), 0]);
csharptest71f662c2011-05-20 15:15:34 -0500[diff] [blame]971 Assert.AreEqual(609, message[f("packed_sfixed32"), 0]);
972 Assert.AreEqual(610L, message[f("packed_sfixed64"), 0]);
973 Assert.AreEqual(611F, message[f("packed_float"), 0]);
974 Assert.AreEqual(612D, message[f("packed_double"), 0]);
975 Assert.AreEqual(true, message[f("packed_bool"), 0]);
976 Assert.AreEqual(foreignBar, message[f("packed_enum"), 0]);
csharptesteac64a52011-10-04 13:43:26 -0500[diff] [blame^]977
csharptest71f662c2011-05-20 15:15:34 -0500[diff] [blame]978 Assert.AreEqual(701, message[f("packed_int32"), 1]);
979 Assert.AreEqual(702L, message[f("packed_int64"), 1]);
csharptesteac64a52011-10-04 13:43:26 -0500[diff] [blame^]980 Assert.AreEqual(703u, message[f("packed_uint32"), 1]);
981 Assert.AreEqual(704uL, message[f("packed_uint64"), 1]);
csharptest71f662c2011-05-20 15:15:34 -0500[diff] [blame]982 Assert.AreEqual(705, message[f("packed_sint32"), 1]);
983 Assert.AreEqual(706L, message[f("packed_sint64"), 1]);
csharptesteac64a52011-10-04 13:43:26 -0500[diff] [blame^]984 Assert.AreEqual(707u, message[f("packed_fixed32"), 1]);
985 Assert.AreEqual(708uL, message[f("packed_fixed64"), 1]);
csharptest71f662c2011-05-20 15:15:34 -0500[diff] [blame]986 Assert.AreEqual(709, message[f("packed_sfixed32"), 1]);
987 Assert.AreEqual(710L, message[f("packed_sfixed64"), 1]);
988 Assert.AreEqual(711F, message[f("packed_float"), 1]);
989 Assert.AreEqual(712D, message[f("packed_double"), 1]);
990 Assert.AreEqual(false, message[f("packed_bool"), 1]);
991 Assert.AreEqual(foreignBaz, message[f("packed_enum"), 1]);
992 }
993 }
994}