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