| Jon Skeet | 6803686 | 2008-10-22 13:30:34 +0100 | [diff] [blame] | 1 | // Protocol Buffers - Google's data interchange format |
| 2 | // Copyright 2008 Google Inc. |
| 3 | // http://code.google.com/p/protobuf/ |
| 4 | // |
| 5 | // Licensed under the Apache License, Version 2.0 (the "License"); |
| 6 | // you may not use this file except in compliance with the License. |
| 7 | // You may obtain a copy of the License at |
| 8 | // |
| 9 | // http://www.apache.org/licenses/LICENSE-2.0 |
| 10 | // |
| 11 | // Unless required by applicable law or agreed to in writing, software |
| 12 | // distributed under the License is distributed on an "AS IS" BASIS, |
| 13 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 14 | // See the License for the specific language governing permissions and |
| 15 | // limitations under the License. |
| 16 | using System; |
| 17 | using System.Collections.Generic; |
| 18 | using System.IO; |
| 19 | using System.Text; |
| 20 | using Google.ProtocolBuffers.TestProtos; |
| 21 | using NUnit.Framework; |
| 22 | |
| 23 | namespace Google.ProtocolBuffers { |
| 24 | internal static class TestUtil { |
| 25 | |
| 26 | private static string testDataDirectory; |
| 27 | private static ByteString goldenMessage = null; |
| 28 | |
| 29 | internal static string TestDataDirectory { |
| 30 | get { |
| 31 | if (testDataDirectory != null) { |
| 32 | return testDataDirectory; |
| 33 | } |
| 34 | |
| 35 | DirectoryInfo ancestor = new DirectoryInfo("."); |
| 36 | // Search each parent directory looking for "testdata". |
| 37 | while (ancestor != null) { |
| 38 | string candidate = Path.Combine(ancestor.FullName, "testdata"); |
| 39 | if (Directory.Exists(candidate)) { |
| Jon Skeet | 52a035a | 2008-10-22 14:11:30 +0100 | [diff] [blame^] | 40 | testDataDirectory = candidate; |
| Jon Skeet | 6803686 | 2008-10-22 13:30:34 +0100 | [diff] [blame] | 41 | return candidate; |
| 42 | } |
| 43 | ancestor = ancestor.Parent; |
| 44 | } |
| 45 | // TODO(jonskeet): Come up with a better exception to throw |
| 46 | throw new Exception("Unable to find directory containing test files"); |
| 47 | } |
| 48 | } |
| 49 | |
| 50 | internal static ByteString GoldenMessage { |
| 51 | get { |
| 52 | if (goldenMessage == null) { |
| 53 | goldenMessage = ReadBytesFromFile("golden_message"); |
| 54 | } |
| 55 | return goldenMessage; |
| 56 | } |
| 57 | } |
| 58 | |
| 59 | /// <summary> |
| 60 | /// Creates an unmodifiable ExtensionRegistry containing all the extensions |
| 61 | /// of TestAllExtensions. |
| 62 | /// </summary> |
| 63 | /// <returns></returns> |
| 64 | internal static ExtensionRegistry CreateExtensionRegistry() { |
| 65 | ExtensionRegistry registry = ExtensionRegistry.CreateInstance(); |
| 66 | RegisterAllExtensions(registry); |
| 67 | return registry.AsReadOnly(); |
| 68 | } |
| 69 | |
| 70 | /// <summary> |
| 71 | /// Registers all of the extensions in TestAllExtensions with the given |
| 72 | /// ExtensionRegistry. |
| 73 | /// </summary> |
| 74 | internal static void RegisterAllExtensions(ExtensionRegistry registry) { |
| 75 | registry.Add(UnitTestProtoFile.OptionalInt32Extension); |
| 76 | registry.Add(UnitTestProtoFile.OptionalInt64Extension); |
| 77 | registry.Add(UnitTestProtoFile.OptionalUint32Extension); |
| 78 | registry.Add(UnitTestProtoFile.OptionalUint64Extension); |
| 79 | registry.Add(UnitTestProtoFile.OptionalSint32Extension); |
| 80 | registry.Add(UnitTestProtoFile.OptionalSint64Extension); |
| 81 | registry.Add(UnitTestProtoFile.OptionalFixed32Extension); |
| 82 | registry.Add(UnitTestProtoFile.OptionalFixed64Extension); |
| 83 | registry.Add(UnitTestProtoFile.OptionalSfixed32Extension); |
| 84 | registry.Add(UnitTestProtoFile.OptionalSfixed64Extension); |
| 85 | registry.Add(UnitTestProtoFile.OptionalFloatExtension); |
| 86 | registry.Add(UnitTestProtoFile.OptionalDoubleExtension); |
| 87 | registry.Add(UnitTestProtoFile.OptionalBoolExtension); |
| 88 | registry.Add(UnitTestProtoFile.OptionalStringExtension); |
| 89 | registry.Add(UnitTestProtoFile.OptionalBytesExtension); |
| 90 | registry.Add(UnitTestProtoFile.OptionalGroupExtension); |
| 91 | registry.Add(UnitTestProtoFile.OptionalNestedMessageExtension); |
| 92 | registry.Add(UnitTestProtoFile.OptionalForeignMessageExtension); |
| 93 | registry.Add(UnitTestProtoFile.OptionalImportMessageExtension); |
| 94 | registry.Add(UnitTestProtoFile.OptionalNestedEnumExtension); |
| 95 | registry.Add(UnitTestProtoFile.OptionalForeignEnumExtension); |
| 96 | registry.Add(UnitTestProtoFile.OptionalImportEnumExtension); |
| 97 | registry.Add(UnitTestProtoFile.OptionalStringPieceExtension); |
| 98 | registry.Add(UnitTestProtoFile.OptionalCordExtension); |
| 99 | |
| 100 | registry.Add(UnitTestProtoFile.RepeatedInt32Extension); |
| 101 | registry.Add(UnitTestProtoFile.RepeatedInt64Extension); |
| 102 | registry.Add(UnitTestProtoFile.RepeatedUint32Extension); |
| 103 | registry.Add(UnitTestProtoFile.RepeatedUint64Extension); |
| 104 | registry.Add(UnitTestProtoFile.RepeatedSint32Extension); |
| 105 | registry.Add(UnitTestProtoFile.RepeatedSint64Extension); |
| 106 | registry.Add(UnitTestProtoFile.RepeatedFixed32Extension); |
| 107 | registry.Add(UnitTestProtoFile.RepeatedFixed64Extension); |
| 108 | registry.Add(UnitTestProtoFile.RepeatedSfixed32Extension); |
| 109 | registry.Add(UnitTestProtoFile.RepeatedSfixed64Extension); |
| 110 | registry.Add(UnitTestProtoFile.RepeatedFloatExtension); |
| 111 | registry.Add(UnitTestProtoFile.RepeatedDoubleExtension); |
| 112 | registry.Add(UnitTestProtoFile.RepeatedBoolExtension); |
| 113 | registry.Add(UnitTestProtoFile.RepeatedStringExtension); |
| 114 | registry.Add(UnitTestProtoFile.RepeatedBytesExtension); |
| 115 | registry.Add(UnitTestProtoFile.RepeatedGroupExtension); |
| 116 | registry.Add(UnitTestProtoFile.RepeatedNestedMessageExtension); |
| 117 | registry.Add(UnitTestProtoFile.RepeatedForeignMessageExtension); |
| 118 | registry.Add(UnitTestProtoFile.RepeatedImportMessageExtension); |
| 119 | registry.Add(UnitTestProtoFile.RepeatedNestedEnumExtension); |
| 120 | registry.Add(UnitTestProtoFile.RepeatedForeignEnumExtension); |
| 121 | registry.Add(UnitTestProtoFile.RepeatedImportEnumExtension); |
| 122 | registry.Add(UnitTestProtoFile.RepeatedStringPieceExtension); |
| 123 | registry.Add(UnitTestProtoFile.RepeatedCordExtension); |
| 124 | |
| 125 | registry.Add(UnitTestProtoFile.DefaultInt32Extension); |
| 126 | registry.Add(UnitTestProtoFile.DefaultInt64Extension); |
| 127 | registry.Add(UnitTestProtoFile.DefaultUint32Extension); |
| 128 | registry.Add(UnitTestProtoFile.DefaultUint64Extension); |
| 129 | registry.Add(UnitTestProtoFile.DefaultSint32Extension); |
| 130 | registry.Add(UnitTestProtoFile.DefaultSint64Extension); |
| 131 | registry.Add(UnitTestProtoFile.DefaultFixed32Extension); |
| 132 | registry.Add(UnitTestProtoFile.DefaultFixed64Extension); |
| 133 | registry.Add(UnitTestProtoFile.DefaultSfixed32Extension); |
| 134 | registry.Add(UnitTestProtoFile.DefaultSfixed64Extension); |
| 135 | registry.Add(UnitTestProtoFile.DefaultFloatExtension); |
| 136 | registry.Add(UnitTestProtoFile.DefaultDoubleExtension); |
| 137 | registry.Add(UnitTestProtoFile.DefaultBoolExtension); |
| 138 | registry.Add(UnitTestProtoFile.DefaultStringExtension); |
| 139 | registry.Add(UnitTestProtoFile.DefaultBytesExtension); |
| 140 | registry.Add(UnitTestProtoFile.DefaultNestedEnumExtension); |
| 141 | registry.Add(UnitTestProtoFile.DefaultForeignEnumExtension); |
| 142 | registry.Add(UnitTestProtoFile.DefaultImportEnumExtension); |
| 143 | registry.Add(UnitTestProtoFile.DefaultStringPieceExtension); |
| 144 | registry.Add(UnitTestProtoFile.DefaultCordExtension); |
| 145 | } |
| 146 | |
| 147 | internal static string ReadTextFromFile(string filePath) { |
| 148 | return ReadBytesFromFile(filePath).ToStringUtf8(); |
| 149 | } |
| 150 | |
| 151 | internal static ByteString ReadBytesFromFile(String filename) { |
| 152 | byte[] data = File.ReadAllBytes(Path.Combine(TestDataDirectory, filename)); |
| 153 | return ByteString.CopyFrom(data); |
| 154 | } |
| 155 | |
| 156 | /// <summary> |
| 157 | /// Helper to convert a String to ByteString. |
| 158 | /// </summary> |
| 159 | internal static ByteString ToBytes(String str) { |
| 160 | return ByteString.CopyFrom(Encoding.UTF8.GetBytes(str)); |
| 161 | } |
| 162 | |
| 163 | internal static TestAllTypes GetAllSet() { |
| 164 | TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); |
| 165 | SetAllFields(builder); |
| 166 | return builder.Build(); |
| 167 | } |
| 168 | |
| 169 | /// <summary> |
| 170 | /// Sets every field of the specified message to the values expected by |
| 171 | /// AssertAllFieldsSet. |
| 172 | /// </summary> |
| 173 | internal static void SetAllFields(TestAllTypes.Builder message) { |
| 174 | message.SetOptionalInt32(101); |
| 175 | message.SetOptionalInt64(102); |
| 176 | message.SetOptionalUint32(103); |
| 177 | message.SetOptionalUint64(104); |
| 178 | message.SetOptionalSint32(105); |
| 179 | message.SetOptionalSint64(106); |
| 180 | message.SetOptionalFixed32(107); |
| 181 | message.SetOptionalFixed64(108); |
| 182 | message.SetOptionalSfixed32(109); |
| 183 | message.SetOptionalSfixed64(110); |
| 184 | message.SetOptionalFloat(111); |
| 185 | message.SetOptionalDouble(112); |
| 186 | message.SetOptionalBool(true); |
| 187 | message.SetOptionalString("115"); |
| 188 | message.SetOptionalBytes(ToBytes("116")); |
| 189 | |
| 190 | message.SetOptionalGroup(TestAllTypes.Types.OptionalGroup.CreateBuilder().SetA(117).Build()); |
| 191 | message.SetOptionalNestedMessage(TestAllTypes.Types.NestedMessage.CreateBuilder().SetBb(118).Build()); |
| 192 | message.SetOptionalForeignMessage(ForeignMessage.CreateBuilder().SetC(119).Build()); |
| 193 | message.SetOptionalImportMessage(ImportMessage.CreateBuilder().SetD(120).Build()); |
| 194 | |
| 195 | message.SetOptionalNestedEnum(TestAllTypes.Types.NestedEnum.BAZ); |
| 196 | message.SetOptionalForeignEnum(ForeignEnum.FOREIGN_BAZ); |
| 197 | message.SetOptionalImportEnum(ImportEnum.IMPORT_BAZ); |
| 198 | |
| 199 | message.SetOptionalStringPiece("124"); |
| 200 | message.SetOptionalCord("125"); |
| 201 | |
| 202 | // ----------------------------------------------------------------- |
| 203 | |
| 204 | message.AddRepeatedInt32(201); |
| 205 | message.AddRepeatedInt64(202); |
| 206 | message.AddRepeatedUint32(203); |
| 207 | message.AddRepeatedUint64(204); |
| 208 | message.AddRepeatedSint32(205); |
| 209 | message.AddRepeatedSint64(206); |
| 210 | message.AddRepeatedFixed32(207); |
| 211 | message.AddRepeatedFixed64(208); |
| 212 | message.AddRepeatedSfixed32(209); |
| 213 | message.AddRepeatedSfixed64(210); |
| 214 | message.AddRepeatedFloat(211); |
| 215 | message.AddRepeatedDouble(212); |
| 216 | message.AddRepeatedBool(true); |
| 217 | message.AddRepeatedString("215"); |
| 218 | message.AddRepeatedBytes(ToBytes("216")); |
| 219 | |
| 220 | message.AddRepeatedGroup(TestAllTypes.Types.RepeatedGroup.CreateBuilder().SetA(217).Build()); |
| 221 | message.AddRepeatedNestedMessage(TestAllTypes.Types.NestedMessage.CreateBuilder().SetBb(218).Build()); |
| 222 | message.AddRepeatedForeignMessage(ForeignMessage.CreateBuilder().SetC(219).Build()); |
| 223 | message.AddRepeatedImportMessage(ImportMessage.CreateBuilder().SetD(220).Build()); |
| 224 | |
| 225 | message.AddRepeatedNestedEnum(TestAllTypes.Types.NestedEnum.BAR); |
| 226 | message.AddRepeatedForeignEnum(ForeignEnum.FOREIGN_BAR); |
| 227 | message.AddRepeatedImportEnum(ImportEnum.IMPORT_BAR); |
| 228 | |
| 229 | message.AddRepeatedStringPiece("224"); |
| 230 | message.AddRepeatedCord("225"); |
| 231 | |
| 232 | // Add a second one of each field. |
| 233 | message.AddRepeatedInt32(301); |
| 234 | message.AddRepeatedInt64(302); |
| 235 | message.AddRepeatedUint32(303); |
| 236 | message.AddRepeatedUint64(304); |
| 237 | message.AddRepeatedSint32(305); |
| 238 | message.AddRepeatedSint64(306); |
| 239 | message.AddRepeatedFixed32(307); |
| 240 | message.AddRepeatedFixed64(308); |
| 241 | message.AddRepeatedSfixed32(309); |
| 242 | message.AddRepeatedSfixed64(310); |
| 243 | message.AddRepeatedFloat(311); |
| 244 | message.AddRepeatedDouble(312); |
| 245 | message.AddRepeatedBool(false); |
| 246 | message.AddRepeatedString("315"); |
| 247 | message.AddRepeatedBytes(ToBytes("316")); |
| 248 | |
| 249 | message.AddRepeatedGroup(TestAllTypes.Types.RepeatedGroup.CreateBuilder().SetA(317).Build()); |
| 250 | message.AddRepeatedNestedMessage(TestAllTypes.Types.NestedMessage.CreateBuilder().SetBb(318).Build()); |
| 251 | message.AddRepeatedForeignMessage(ForeignMessage.CreateBuilder().SetC(319).Build()); |
| 252 | message.AddRepeatedImportMessage(ImportMessage.CreateBuilder().SetD(320).Build()); |
| 253 | |
| 254 | message.AddRepeatedNestedEnum(TestAllTypes.Types.NestedEnum.BAZ); |
| 255 | message.AddRepeatedForeignEnum(ForeignEnum.FOREIGN_BAZ); |
| 256 | message.AddRepeatedImportEnum(ImportEnum.IMPORT_BAZ); |
| 257 | |
| 258 | message.AddRepeatedStringPiece("324"); |
| 259 | message.AddRepeatedCord("325"); |
| 260 | |
| 261 | // ----------------------------------------------------------------- |
| 262 | |
| 263 | message.SetDefaultInt32(401); |
| 264 | message.SetDefaultInt64(402); |
| 265 | message.SetDefaultUint32(403); |
| 266 | message.SetDefaultUint64(404); |
| 267 | message.SetDefaultSint32(405); |
| 268 | message.SetDefaultSint64(406); |
| 269 | message.SetDefaultFixed32(407); |
| 270 | message.SetDefaultFixed64(408); |
| 271 | message.SetDefaultSfixed32(409); |
| 272 | message.SetDefaultSfixed64(410); |
| 273 | message.SetDefaultFloat(411); |
| 274 | message.SetDefaultDouble(412); |
| 275 | message.SetDefaultBool(false); |
| 276 | message.SetDefaultString("415"); |
| 277 | message.SetDefaultBytes(ToBytes("416")); |
| 278 | |
| 279 | message.SetDefaultNestedEnum(TestAllTypes.Types.NestedEnum.FOO); |
| 280 | message.SetDefaultForeignEnum(ForeignEnum.FOREIGN_FOO); |
| 281 | message.SetDefaultImportEnum(ImportEnum.IMPORT_FOO); |
| 282 | |
| 283 | message.SetDefaultStringPiece("424"); |
| 284 | message.SetDefaultCord("425"); |
| 285 | } |
| 286 | |
| 287 | /// <summary> |
| 288 | /// Asserts that all fields of the specified message are set to the values |
| 289 | /// assigned by SetAllFields. |
| 290 | /// </summary> |
| 291 | internal static void AssertAllFieldsSet(TestAllTypes message) { |
| 292 | Assert.IsTrue(message.HasOptionalInt32); |
| 293 | Assert.IsTrue(message.HasOptionalInt64); |
| 294 | Assert.IsTrue(message.HasOptionalUint32); |
| 295 | Assert.IsTrue(message.HasOptionalUint64); |
| 296 | Assert.IsTrue(message.HasOptionalSint32); |
| 297 | Assert.IsTrue(message.HasOptionalSint64); |
| 298 | Assert.IsTrue(message.HasOptionalFixed32); |
| 299 | Assert.IsTrue(message.HasOptionalFixed64); |
| 300 | Assert.IsTrue(message.HasOptionalSfixed32); |
| 301 | Assert.IsTrue(message.HasOptionalSfixed64); |
| 302 | Assert.IsTrue(message.HasOptionalFloat); |
| 303 | Assert.IsTrue(message.HasOptionalDouble); |
| 304 | Assert.IsTrue(message.HasOptionalBool); |
| 305 | Assert.IsTrue(message.HasOptionalString); |
| 306 | Assert.IsTrue(message.HasOptionalBytes); |
| 307 | |
| 308 | Assert.IsTrue(message.HasOptionalGroup); |
| 309 | Assert.IsTrue(message.HasOptionalNestedMessage); |
| 310 | Assert.IsTrue(message.HasOptionalForeignMessage); |
| 311 | Assert.IsTrue(message.HasOptionalImportMessage); |
| 312 | |
| 313 | Assert.IsTrue(message.OptionalGroup.HasA); |
| 314 | Assert.IsTrue(message.OptionalNestedMessage.HasBb); |
| 315 | Assert.IsTrue(message.OptionalForeignMessage.HasC); |
| 316 | Assert.IsTrue(message.OptionalImportMessage.HasD); |
| 317 | |
| 318 | Assert.IsTrue(message.HasOptionalNestedEnum); |
| 319 | Assert.IsTrue(message.HasOptionalForeignEnum); |
| 320 | Assert.IsTrue(message.HasOptionalImportEnum); |
| 321 | |
| 322 | Assert.IsTrue(message.HasOptionalStringPiece); |
| 323 | Assert.IsTrue(message.HasOptionalCord); |
| 324 | |
| 325 | Assert.AreEqual(101, message.OptionalInt32); |
| 326 | Assert.AreEqual(102, message.OptionalInt64); |
| 327 | Assert.AreEqual(103, message.OptionalUint32); |
| 328 | Assert.AreEqual(104, message.OptionalUint64); |
| 329 | Assert.AreEqual(105, message.OptionalSint32); |
| 330 | Assert.AreEqual(106, message.OptionalSint64); |
| 331 | Assert.AreEqual(107, message.OptionalFixed32); |
| 332 | Assert.AreEqual(108, message.OptionalFixed64); |
| 333 | Assert.AreEqual(109, message.OptionalSfixed32); |
| 334 | Assert.AreEqual(110, message.OptionalSfixed64); |
| 335 | Assert.AreEqual(111, message.OptionalFloat); |
| 336 | Assert.AreEqual(112, message.OptionalDouble); |
| 337 | Assert.AreEqual(true, message.OptionalBool); |
| 338 | Assert.AreEqual("115", message.OptionalString); |
| 339 | Assert.AreEqual(ToBytes("116"), message.OptionalBytes); |
| 340 | |
| 341 | Assert.AreEqual(117, message.OptionalGroup.A); |
| 342 | Assert.AreEqual(118, message.OptionalNestedMessage.Bb); |
| 343 | Assert.AreEqual(119, message.OptionalForeignMessage.C); |
| 344 | Assert.AreEqual(120, message.OptionalImportMessage.D); |
| 345 | |
| 346 | Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAZ, message.OptionalNestedEnum); |
| 347 | Assert.AreEqual(ForeignEnum.FOREIGN_BAZ, message.OptionalForeignEnum); |
| 348 | Assert.AreEqual(ImportEnum.IMPORT_BAZ, message.OptionalImportEnum); |
| 349 | |
| 350 | Assert.AreEqual("124", message.OptionalStringPiece); |
| 351 | Assert.AreEqual("125", message.OptionalCord); |
| 352 | |
| 353 | // ----------------------------------------------------------------- |
| 354 | |
| 355 | Assert.AreEqual(2, message.RepeatedInt32Count); |
| 356 | Assert.AreEqual(2, message.RepeatedInt64Count); |
| 357 | Assert.AreEqual(2, message.RepeatedUint32Count); |
| 358 | Assert.AreEqual(2, message.RepeatedUint64Count); |
| 359 | Assert.AreEqual(2, message.RepeatedSint32Count); |
| 360 | Assert.AreEqual(2, message.RepeatedSint64Count); |
| 361 | Assert.AreEqual(2, message.RepeatedFixed32Count); |
| 362 | Assert.AreEqual(2, message.RepeatedFixed64Count); |
| 363 | Assert.AreEqual(2, message.RepeatedSfixed32Count); |
| 364 | Assert.AreEqual(2, message.RepeatedSfixed64Count); |
| 365 | Assert.AreEqual(2, message.RepeatedFloatCount); |
| 366 | Assert.AreEqual(2, message.RepeatedDoubleCount); |
| 367 | Assert.AreEqual(2, message.RepeatedBoolCount); |
| 368 | Assert.AreEqual(2, message.RepeatedStringCount); |
| 369 | Assert.AreEqual(2, message.RepeatedBytesCount); |
| 370 | |
| 371 | Assert.AreEqual(2, message.RepeatedGroupCount ); |
| 372 | Assert.AreEqual(2, message.RepeatedNestedMessageCount ); |
| 373 | Assert.AreEqual(2, message.RepeatedForeignMessageCount); |
| 374 | Assert.AreEqual(2, message.RepeatedImportMessageCount ); |
| 375 | Assert.AreEqual(2, message.RepeatedNestedEnumCount ); |
| 376 | Assert.AreEqual(2, message.RepeatedForeignEnumCount ); |
| 377 | Assert.AreEqual(2, message.RepeatedImportEnumCount ); |
| 378 | |
| 379 | Assert.AreEqual(2, message.RepeatedStringPieceCount); |
| 380 | Assert.AreEqual(2, message.RepeatedCordCount); |
| 381 | |
| 382 | Assert.AreEqual(201, message.GetRepeatedInt32(0)); |
| 383 | Assert.AreEqual(202, message.GetRepeatedInt64(0)); |
| 384 | Assert.AreEqual(203, message.GetRepeatedUint32(0)); |
| 385 | Assert.AreEqual(204, message.GetRepeatedUint64(0)); |
| 386 | Assert.AreEqual(205, message.GetRepeatedSint32(0)); |
| 387 | Assert.AreEqual(206, message.GetRepeatedSint64(0)); |
| 388 | Assert.AreEqual(207, message.GetRepeatedFixed32(0)); |
| 389 | Assert.AreEqual(208, message.GetRepeatedFixed64(0)); |
| 390 | Assert.AreEqual(209, message.GetRepeatedSfixed32(0)); |
| 391 | Assert.AreEqual(210, message.GetRepeatedSfixed64(0)); |
| 392 | Assert.AreEqual(211, message.GetRepeatedFloat(0)); |
| 393 | Assert.AreEqual(212, message.GetRepeatedDouble(0)); |
| 394 | Assert.AreEqual(true , message.GetRepeatedBool(0)); |
| 395 | Assert.AreEqual("215", message.GetRepeatedString(0)); |
| 396 | Assert.AreEqual(ToBytes("216"), message.GetRepeatedBytes(0)); |
| 397 | |
| 398 | Assert.AreEqual(217, message.GetRepeatedGroup(0).A); |
| 399 | Assert.AreEqual(218, message.GetRepeatedNestedMessage (0).Bb); |
| 400 | Assert.AreEqual(219, message.GetRepeatedForeignMessage(0).C); |
| 401 | Assert.AreEqual(220, message.GetRepeatedImportMessage (0).D); |
| 402 | |
| 403 | Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, message.GetRepeatedNestedEnum (0)); |
| 404 | Assert.AreEqual(ForeignEnum.FOREIGN_BAR, message.GetRepeatedForeignEnum(0)); |
| 405 | Assert.AreEqual(ImportEnum.IMPORT_BAR, message.GetRepeatedImportEnum(0)); |
| 406 | |
| 407 | Assert.AreEqual("224", message.GetRepeatedStringPiece(0)); |
| 408 | Assert.AreEqual("225", message.GetRepeatedCord(0)); |
| 409 | |
| 410 | Assert.AreEqual(301, message.GetRepeatedInt32 (1)); |
| 411 | Assert.AreEqual(302, message.GetRepeatedInt64 (1)); |
| 412 | Assert.AreEqual(303, message.GetRepeatedUint32 (1)); |
| 413 | Assert.AreEqual(304, message.GetRepeatedUint64 (1)); |
| 414 | Assert.AreEqual(305, message.GetRepeatedSint32 (1)); |
| 415 | Assert.AreEqual(306, message.GetRepeatedSint64 (1)); |
| 416 | Assert.AreEqual(307, message.GetRepeatedFixed32 (1)); |
| 417 | Assert.AreEqual(308, message.GetRepeatedFixed64 (1)); |
| 418 | Assert.AreEqual(309, message.GetRepeatedSfixed32(1)); |
| 419 | Assert.AreEqual(310, message.GetRepeatedSfixed64(1)); |
| 420 | Assert.AreEqual(311, message.GetRepeatedFloat (1), 0.0); |
| 421 | Assert.AreEqual(312, message.GetRepeatedDouble (1), 0.0); |
| 422 | Assert.AreEqual(false, message.GetRepeatedBool (1)); |
| 423 | Assert.AreEqual("315", message.GetRepeatedString (1)); |
| 424 | Assert.AreEqual(ToBytes("316"), message.GetRepeatedBytes(1)); |
| 425 | |
| 426 | Assert.AreEqual(317, message.GetRepeatedGroup (1).A); |
| 427 | Assert.AreEqual(318, message.GetRepeatedNestedMessage (1).Bb); |
| 428 | Assert.AreEqual(319, message.GetRepeatedForeignMessage(1).C); |
| 429 | Assert.AreEqual(320, message.GetRepeatedImportMessage (1).D); |
| 430 | |
| 431 | Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAZ, message.GetRepeatedNestedEnum (1)); |
| 432 | Assert.AreEqual(ForeignEnum.FOREIGN_BAZ, message.GetRepeatedForeignEnum(1)); |
| 433 | Assert.AreEqual(ImportEnum.IMPORT_BAZ, message.GetRepeatedImportEnum(1)); |
| 434 | |
| 435 | Assert.AreEqual("324", message.GetRepeatedStringPiece(1)); |
| 436 | Assert.AreEqual("325", message.GetRepeatedCord(1)); |
| 437 | |
| 438 | // ----------------------------------------------------------------- |
| 439 | |
| 440 | Assert.IsTrue(message.HasDefaultInt32 ); |
| 441 | Assert.IsTrue(message.HasDefaultInt64 ); |
| 442 | Assert.IsTrue(message.HasDefaultUint32 ); |
| 443 | Assert.IsTrue(message.HasDefaultUint64 ); |
| 444 | Assert.IsTrue(message.HasDefaultSint32 ); |
| 445 | Assert.IsTrue(message.HasDefaultSint64 ); |
| 446 | Assert.IsTrue(message.HasDefaultFixed32 ); |
| 447 | Assert.IsTrue(message.HasDefaultFixed64 ); |
| 448 | Assert.IsTrue(message.HasDefaultSfixed32); |
| 449 | Assert.IsTrue(message.HasDefaultSfixed64); |
| 450 | Assert.IsTrue(message.HasDefaultFloat ); |
| 451 | Assert.IsTrue(message.HasDefaultDouble ); |
| 452 | Assert.IsTrue(message.HasDefaultBool ); |
| 453 | Assert.IsTrue(message.HasDefaultString ); |
| 454 | Assert.IsTrue(message.HasDefaultBytes ); |
| 455 | |
| 456 | Assert.IsTrue(message.HasDefaultNestedEnum ); |
| 457 | Assert.IsTrue(message.HasDefaultForeignEnum); |
| 458 | Assert.IsTrue(message.HasDefaultImportEnum ); |
| 459 | |
| 460 | Assert.IsTrue(message.HasDefaultStringPiece); |
| 461 | Assert.IsTrue(message.HasDefaultCord); |
| 462 | |
| 463 | Assert.AreEqual(401, message.DefaultInt32); |
| 464 | Assert.AreEqual(402, message.DefaultInt64); |
| 465 | Assert.AreEqual(403, message.DefaultUint32); |
| 466 | Assert.AreEqual(404, message.DefaultUint64); |
| 467 | Assert.AreEqual(405, message.DefaultSint32); |
| 468 | Assert.AreEqual(406, message.DefaultSint64); |
| 469 | Assert.AreEqual(407, message.DefaultFixed32); |
| 470 | Assert.AreEqual(408, message.DefaultFixed64); |
| 471 | Assert.AreEqual(409, message.DefaultSfixed32); |
| 472 | Assert.AreEqual(410, message.DefaultSfixed64); |
| 473 | Assert.AreEqual(411, message.DefaultFloat); |
| 474 | Assert.AreEqual(412, message.DefaultDouble); |
| 475 | Assert.AreEqual(false, message.DefaultBool ); |
| 476 | Assert.AreEqual("415", message.DefaultString ); |
| 477 | Assert.AreEqual(ToBytes("416"), message.DefaultBytes); |
| 478 | |
| 479 | Assert.AreEqual(TestAllTypes.Types.NestedEnum.FOO, message.DefaultNestedEnum); |
| 480 | Assert.AreEqual(ForeignEnum.FOREIGN_FOO, message.DefaultForeignEnum); |
| 481 | Assert.AreEqual(ImportEnum.IMPORT_FOO, message.DefaultImportEnum); |
| 482 | |
| 483 | Assert.AreEqual("424", message.DefaultStringPiece); |
| 484 | Assert.AreEqual("425", message.DefaultCord); |
| 485 | } |
| 486 | |
| 487 | internal static void AssertClear(TestAllTypes message) { |
| 488 | // HasBlah() should initially be false for all optional fields. |
| 489 | Assert.IsFalse(message.HasOptionalInt32); |
| 490 | Assert.IsFalse(message.HasOptionalInt64); |
| 491 | Assert.IsFalse(message.HasOptionalUint32); |
| 492 | Assert.IsFalse(message.HasOptionalUint64); |
| 493 | Assert.IsFalse(message.HasOptionalSint32); |
| 494 | Assert.IsFalse(message.HasOptionalSint64); |
| 495 | Assert.IsFalse(message.HasOptionalFixed32); |
| 496 | Assert.IsFalse(message.HasOptionalFixed64); |
| 497 | Assert.IsFalse(message.HasOptionalSfixed32); |
| 498 | Assert.IsFalse(message.HasOptionalSfixed64); |
| 499 | Assert.IsFalse(message.HasOptionalFloat); |
| 500 | Assert.IsFalse(message.HasOptionalDouble); |
| 501 | Assert.IsFalse(message.HasOptionalBool); |
| 502 | Assert.IsFalse(message.HasOptionalString); |
| 503 | Assert.IsFalse(message.HasOptionalBytes); |
| 504 | |
| 505 | Assert.IsFalse(message.HasOptionalGroup); |
| 506 | Assert.IsFalse(message.HasOptionalNestedMessage); |
| 507 | Assert.IsFalse(message.HasOptionalForeignMessage); |
| 508 | Assert.IsFalse(message.HasOptionalImportMessage); |
| 509 | |
| 510 | Assert.IsFalse(message.HasOptionalNestedEnum); |
| 511 | Assert.IsFalse(message.HasOptionalForeignEnum); |
| 512 | Assert.IsFalse(message.HasOptionalImportEnum); |
| 513 | |
| 514 | Assert.IsFalse(message.HasOptionalStringPiece); |
| 515 | Assert.IsFalse(message.HasOptionalCord); |
| 516 | |
| 517 | // Optional fields without defaults are set to zero or something like it. |
| 518 | Assert.AreEqual(0, message.OptionalInt32); |
| 519 | Assert.AreEqual(0, message.OptionalInt64); |
| 520 | Assert.AreEqual(0, message.OptionalUint32); |
| 521 | Assert.AreEqual(0, message.OptionalUint64); |
| 522 | Assert.AreEqual(0, message.OptionalSint32); |
| 523 | Assert.AreEqual(0, message.OptionalSint64); |
| 524 | Assert.AreEqual(0, message.OptionalFixed32); |
| 525 | Assert.AreEqual(0, message.OptionalFixed64); |
| 526 | Assert.AreEqual(0, message.OptionalSfixed32); |
| 527 | Assert.AreEqual(0, message.OptionalSfixed64); |
| 528 | Assert.AreEqual(0, message.OptionalFloat); |
| 529 | Assert.AreEqual(0, message.OptionalDouble); |
| 530 | Assert.AreEqual(false, message.OptionalBool); |
| 531 | Assert.AreEqual("", message.OptionalString); |
| 532 | Assert.AreEqual(ByteString.Empty, message.OptionalBytes); |
| 533 | |
| 534 | // Embedded messages should also be clear. |
| 535 | Assert.IsFalse(message.OptionalGroup.HasA); |
| 536 | Assert.IsFalse(message.OptionalNestedMessage.HasBb); |
| 537 | Assert.IsFalse(message.OptionalForeignMessage.HasC); |
| 538 | Assert.IsFalse(message.OptionalImportMessage.HasD); |
| 539 | |
| 540 | Assert.AreEqual(0, message.OptionalGroup.A); |
| 541 | Assert.AreEqual(0, message.OptionalNestedMessage.Bb); |
| 542 | Assert.AreEqual(0, message.OptionalForeignMessage.C); |
| 543 | Assert.AreEqual(0, message.OptionalImportMessage.D); |
| 544 | |
| 545 | // Enums without defaults are set to the first value in the enum. |
| 546 | Assert.AreEqual(TestAllTypes.Types.NestedEnum.FOO, message.OptionalNestedEnum); |
| 547 | Assert.AreEqual(ForeignEnum.FOREIGN_FOO, message.OptionalForeignEnum); |
| 548 | Assert.AreEqual(ImportEnum.IMPORT_FOO, message.OptionalImportEnum); |
| 549 | |
| 550 | Assert.AreEqual("", message.OptionalStringPiece); |
| 551 | Assert.AreEqual("", message.OptionalCord); |
| 552 | |
| 553 | // Repeated fields are empty. |
| 554 | Assert.AreEqual(0, message.RepeatedInt32Count); |
| 555 | Assert.AreEqual(0, message.RepeatedInt64Count); |
| 556 | Assert.AreEqual(0, message.RepeatedUint32Count); |
| 557 | Assert.AreEqual(0, message.RepeatedUint64Count); |
| 558 | Assert.AreEqual(0, message.RepeatedSint32Count); |
| 559 | Assert.AreEqual(0, message.RepeatedSint64Count); |
| 560 | Assert.AreEqual(0, message.RepeatedFixed32Count); |
| 561 | Assert.AreEqual(0, message.RepeatedFixed64Count); |
| 562 | Assert.AreEqual(0, message.RepeatedSfixed32Count); |
| 563 | Assert.AreEqual(0, message.RepeatedSfixed64Count); |
| 564 | Assert.AreEqual(0, message.RepeatedFloatCount); |
| 565 | Assert.AreEqual(0, message.RepeatedDoubleCount); |
| 566 | Assert.AreEqual(0, message.RepeatedBoolCount); |
| 567 | Assert.AreEqual(0, message.RepeatedStringCount); |
| 568 | Assert.AreEqual(0, message.RepeatedBytesCount); |
| 569 | |
| 570 | Assert.AreEqual(0, message.RepeatedGroupCount); |
| 571 | Assert.AreEqual(0, message.RepeatedNestedMessageCount); |
| 572 | Assert.AreEqual(0, message.RepeatedForeignMessageCount); |
| 573 | Assert.AreEqual(0, message.RepeatedImportMessageCount); |
| 574 | Assert.AreEqual(0, message.RepeatedNestedEnumCount); |
| 575 | Assert.AreEqual(0, message.RepeatedForeignEnumCount); |
| 576 | Assert.AreEqual(0, message.RepeatedImportEnumCount); |
| 577 | |
| 578 | Assert.AreEqual(0, message.RepeatedStringPieceCount); |
| 579 | Assert.AreEqual(0, message.RepeatedCordCount); |
| 580 | |
| 581 | // HasBlah() should also be false for all default fields. |
| 582 | Assert.IsFalse(message.HasDefaultInt32); |
| 583 | Assert.IsFalse(message.HasDefaultInt64); |
| 584 | Assert.IsFalse(message.HasDefaultUint32); |
| 585 | Assert.IsFalse(message.HasDefaultUint64); |
| 586 | Assert.IsFalse(message.HasDefaultSint32); |
| 587 | Assert.IsFalse(message.HasDefaultSint64); |
| 588 | Assert.IsFalse(message.HasDefaultFixed32); |
| 589 | Assert.IsFalse(message.HasDefaultFixed64); |
| 590 | Assert.IsFalse(message.HasDefaultSfixed32); |
| 591 | Assert.IsFalse(message.HasDefaultSfixed64); |
| 592 | Assert.IsFalse(message.HasDefaultFloat); |
| 593 | Assert.IsFalse(message.HasDefaultDouble); |
| 594 | Assert.IsFalse(message.HasDefaultBool); |
| 595 | Assert.IsFalse(message.HasDefaultString); |
| 596 | Assert.IsFalse(message.HasDefaultBytes); |
| 597 | |
| 598 | Assert.IsFalse(message.HasDefaultNestedEnum); |
| 599 | Assert.IsFalse(message.HasDefaultForeignEnum); |
| 600 | Assert.IsFalse(message.HasDefaultImportEnum); |
| 601 | |
| 602 | Assert.IsFalse(message.HasDefaultStringPiece); |
| 603 | Assert.IsFalse(message.HasDefaultCord); |
| 604 | |
| 605 | // Fields with defaults have their default values (duh). |
| 606 | Assert.AreEqual(41, message.DefaultInt32); |
| 607 | Assert.AreEqual(42, message.DefaultInt64); |
| 608 | Assert.AreEqual(43, message.DefaultUint32); |
| 609 | Assert.AreEqual(44, message.DefaultUint64); |
| 610 | Assert.AreEqual(-45, message.DefaultSint32); |
| 611 | Assert.AreEqual(46, message.DefaultSint64); |
| 612 | Assert.AreEqual(47, message.DefaultFixed32); |
| 613 | Assert.AreEqual(48, message.DefaultFixed64); |
| 614 | Assert.AreEqual(49, message.DefaultSfixed32); |
| 615 | Assert.AreEqual(-50, message.DefaultSfixed64); |
| 616 | Assert.AreEqual(51.5, message.DefaultFloat, 0.0); |
| 617 | Assert.AreEqual(52e3, message.DefaultDouble, 0.0); |
| 618 | Assert.AreEqual(true, message.DefaultBool); |
| 619 | Assert.AreEqual("hello", message.DefaultString); |
| 620 | Assert.AreEqual(ToBytes("world"), message.DefaultBytes); |
| 621 | |
| 622 | Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, message.DefaultNestedEnum); |
| 623 | Assert.AreEqual(ForeignEnum.FOREIGN_BAR, message.DefaultForeignEnum); |
| 624 | Assert.AreEqual(ImportEnum.IMPORT_BAR, message.DefaultImportEnum); |
| 625 | |
| 626 | Assert.AreEqual("abc", message.DefaultStringPiece); |
| 627 | Assert.AreEqual("123", message.DefaultCord); |
| 628 | } |
| 629 | |
| 630 | /// <summary> |
| 631 | /// Get a TestAllExtensions with all fields set as they would be by |
| 632 | /// SetAllExtensions(TestAllExtensions.Builder). |
| 633 | /// </summary> |
| 634 | internal static TestAllExtensions GetAllExtensionsSet() { |
| 635 | TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder(); |
| 636 | SetAllExtensions(builder); |
| 637 | return builder.Build(); |
| 638 | } |
| 639 | |
| 640 | /// <summary> |
| 641 | /// Sets every field of the specified builder to the values expected by |
| 642 | /// AssertAllExtensionsSet. |
| 643 | /// </summary> |
| 644 | internal static void SetAllExtensions(TestAllExtensions.Builder message) { |
| 645 | message.SetExtension(UnitTestProtoFile.OptionalInt32Extension, 101); |
| 646 | message.SetExtension(UnitTestProtoFile.OptionalInt64Extension, 102L); |
| 647 | message.SetExtension(UnitTestProtoFile.OptionalUint32Extension, 103U); |
| 648 | message.SetExtension(UnitTestProtoFile.OptionalUint64Extension, 104UL); |
| 649 | message.SetExtension(UnitTestProtoFile.OptionalSint32Extension, 105); |
| 650 | message.SetExtension(UnitTestProtoFile.OptionalSint64Extension, 106L); |
| 651 | message.SetExtension(UnitTestProtoFile.OptionalFixed32Extension, 107U); |
| 652 | message.SetExtension(UnitTestProtoFile.OptionalFixed64Extension, 108UL); |
| 653 | message.SetExtension(UnitTestProtoFile.OptionalSfixed32Extension, 109); |
| 654 | message.SetExtension(UnitTestProtoFile.OptionalSfixed64Extension, 110L); |
| 655 | message.SetExtension(UnitTestProtoFile.OptionalFloatExtension, 111F); |
| 656 | message.SetExtension(UnitTestProtoFile.OptionalDoubleExtension, 112D); |
| 657 | message.SetExtension(UnitTestProtoFile.OptionalBoolExtension, true); |
| 658 | message.SetExtension(UnitTestProtoFile.OptionalStringExtension, "115"); |
| 659 | message.SetExtension(UnitTestProtoFile.OptionalBytesExtension, ToBytes("116")); |
| 660 | |
| 661 | message.SetExtension(UnitTestProtoFile.OptionalGroupExtension, OptionalGroup_extension.CreateBuilder().SetA(117).Build()); |
| 662 | message.SetExtension(UnitTestProtoFile.OptionalNestedMessageExtension, TestAllTypes.Types.NestedMessage.CreateBuilder().SetBb(118).Build()); |
| 663 | message.SetExtension(UnitTestProtoFile.OptionalForeignMessageExtension, ForeignMessage.CreateBuilder().SetC(119).Build()); |
| 664 | message.SetExtension(UnitTestProtoFile.OptionalImportMessageExtension, ImportMessage.CreateBuilder().SetD(120).Build()); |
| 665 | |
| 666 | message.SetExtension(UnitTestProtoFile.OptionalNestedEnumExtension, TestAllTypes.Types.NestedEnum.BAZ); |
| 667 | message.SetExtension(UnitTestProtoFile.OptionalForeignEnumExtension, ForeignEnum.FOREIGN_BAZ); |
| 668 | message.SetExtension(UnitTestProtoFile.OptionalImportEnumExtension, ImportEnum.IMPORT_BAZ); |
| 669 | |
| 670 | message.SetExtension(UnitTestProtoFile.OptionalStringPieceExtension, "124"); |
| 671 | message.SetExtension(UnitTestProtoFile.OptionalCordExtension, "125"); |
| 672 | |
| 673 | // ----------------------------------------------------------------- |
| 674 | |
| 675 | message.AddExtension(UnitTestProtoFile.RepeatedInt32Extension, 201); |
| 676 | message.AddExtension(UnitTestProtoFile.RepeatedInt64Extension, 202L); |
| 677 | message.AddExtension(UnitTestProtoFile.RepeatedUint32Extension, 203U); |
| 678 | message.AddExtension(UnitTestProtoFile.RepeatedUint64Extension, 204UL); |
| 679 | message.AddExtension(UnitTestProtoFile.RepeatedSint32Extension, 205); |
| 680 | message.AddExtension(UnitTestProtoFile.RepeatedSint64Extension, 206L); |
| 681 | message.AddExtension(UnitTestProtoFile.RepeatedFixed32Extension, 207U); |
| 682 | message.AddExtension(UnitTestProtoFile.RepeatedFixed64Extension, 208UL); |
| 683 | message.AddExtension(UnitTestProtoFile.RepeatedSfixed32Extension, 209); |
| 684 | message.AddExtension(UnitTestProtoFile.RepeatedSfixed64Extension, 210L); |
| 685 | message.AddExtension(UnitTestProtoFile.RepeatedFloatExtension, 211F); |
| 686 | message.AddExtension(UnitTestProtoFile.RepeatedDoubleExtension, 212D); |
| 687 | message.AddExtension(UnitTestProtoFile.RepeatedBoolExtension, true); |
| 688 | message.AddExtension(UnitTestProtoFile.RepeatedStringExtension, "215"); |
| 689 | message.AddExtension(UnitTestProtoFile.RepeatedBytesExtension, ToBytes("216")); |
| 690 | |
| 691 | message.AddExtension(UnitTestProtoFile.RepeatedGroupExtension, RepeatedGroup_extension.CreateBuilder().SetA(217).Build()); |
| 692 | message.AddExtension(UnitTestProtoFile.RepeatedNestedMessageExtension, TestAllTypes.Types.NestedMessage.CreateBuilder().SetBb(218).Build()); |
| 693 | message.AddExtension(UnitTestProtoFile.RepeatedForeignMessageExtension, ForeignMessage.CreateBuilder().SetC(219).Build()); |
| 694 | message.AddExtension(UnitTestProtoFile.RepeatedImportMessageExtension, ImportMessage.CreateBuilder().SetD(220).Build()); |
| 695 | |
| 696 | message.AddExtension(UnitTestProtoFile.RepeatedNestedEnumExtension, TestAllTypes.Types.NestedEnum.BAR); |
| 697 | message.AddExtension(UnitTestProtoFile.RepeatedForeignEnumExtension, ForeignEnum.FOREIGN_BAR); |
| 698 | message.AddExtension(UnitTestProtoFile.RepeatedImportEnumExtension, ImportEnum.IMPORT_BAR); |
| 699 | |
| 700 | message.AddExtension(UnitTestProtoFile.RepeatedStringPieceExtension, "224"); |
| 701 | message.AddExtension(UnitTestProtoFile.RepeatedCordExtension, "225"); |
| 702 | |
| 703 | // Add a second one of each field. |
| 704 | message.AddExtension(UnitTestProtoFile.RepeatedInt32Extension, 301); |
| 705 | message.AddExtension(UnitTestProtoFile.RepeatedInt64Extension, 302L); |
| 706 | message.AddExtension(UnitTestProtoFile.RepeatedUint32Extension, 303U); |
| 707 | message.AddExtension(UnitTestProtoFile.RepeatedUint64Extension, 304UL); |
| 708 | message.AddExtension(UnitTestProtoFile.RepeatedSint32Extension, 305); |
| 709 | message.AddExtension(UnitTestProtoFile.RepeatedSint64Extension, 306L); |
| 710 | message.AddExtension(UnitTestProtoFile.RepeatedFixed32Extension, 307U); |
| 711 | message.AddExtension(UnitTestProtoFile.RepeatedFixed64Extension, 308UL); |
| 712 | message.AddExtension(UnitTestProtoFile.RepeatedSfixed32Extension, 309); |
| 713 | message.AddExtension(UnitTestProtoFile.RepeatedSfixed64Extension, 310L); |
| 714 | message.AddExtension(UnitTestProtoFile.RepeatedFloatExtension, 311F); |
| 715 | message.AddExtension(UnitTestProtoFile.RepeatedDoubleExtension, 312D); |
| 716 | message.AddExtension(UnitTestProtoFile.RepeatedBoolExtension, false); |
| 717 | message.AddExtension(UnitTestProtoFile.RepeatedStringExtension, "315"); |
| 718 | message.AddExtension(UnitTestProtoFile.RepeatedBytesExtension, ToBytes("316")); |
| 719 | |
| 720 | message.AddExtension(UnitTestProtoFile.RepeatedGroupExtension, RepeatedGroup_extension.CreateBuilder().SetA(317).Build()); |
| 721 | message.AddExtension(UnitTestProtoFile.RepeatedNestedMessageExtension, TestAllTypes.Types.NestedMessage.CreateBuilder().SetBb(318).Build()); |
| 722 | message.AddExtension(UnitTestProtoFile.RepeatedForeignMessageExtension, ForeignMessage.CreateBuilder().SetC(319).Build()); |
| 723 | message.AddExtension(UnitTestProtoFile.RepeatedImportMessageExtension, ImportMessage.CreateBuilder().SetD(320).Build()); |
| 724 | |
| 725 | message.AddExtension(UnitTestProtoFile.RepeatedNestedEnumExtension, TestAllTypes.Types.NestedEnum.BAZ); |
| 726 | message.AddExtension(UnitTestProtoFile.RepeatedForeignEnumExtension, ForeignEnum.FOREIGN_BAZ); |
| 727 | message.AddExtension(UnitTestProtoFile.RepeatedImportEnumExtension, ImportEnum.IMPORT_BAZ); |
| 728 | |
| 729 | message.AddExtension(UnitTestProtoFile.RepeatedStringPieceExtension, "324"); |
| 730 | message.AddExtension(UnitTestProtoFile.RepeatedCordExtension, "325"); |
| 731 | |
| 732 | // ----------------------------------------------------------------- |
| 733 | |
| 734 | message.SetExtension(UnitTestProtoFile.DefaultInt32Extension, 401); |
| 735 | message.SetExtension(UnitTestProtoFile.DefaultInt64Extension, 402L); |
| 736 | message.SetExtension(UnitTestProtoFile.DefaultUint32Extension, 403U); |
| 737 | message.SetExtension(UnitTestProtoFile.DefaultUint64Extension, 404UL); |
| 738 | message.SetExtension(UnitTestProtoFile.DefaultSint32Extension, 405); |
| 739 | message.SetExtension(UnitTestProtoFile.DefaultSint64Extension, 406L); |
| 740 | message.SetExtension(UnitTestProtoFile.DefaultFixed32Extension, 407U); |
| 741 | message.SetExtension(UnitTestProtoFile.DefaultFixed64Extension, 408UL); |
| 742 | message.SetExtension(UnitTestProtoFile.DefaultSfixed32Extension, 409); |
| 743 | message.SetExtension(UnitTestProtoFile.DefaultSfixed64Extension, 410L); |
| 744 | message.SetExtension(UnitTestProtoFile.DefaultFloatExtension, 411F); |
| 745 | message.SetExtension(UnitTestProtoFile.DefaultDoubleExtension, 412D); |
| 746 | message.SetExtension(UnitTestProtoFile.DefaultBoolExtension, false); |
| 747 | message.SetExtension(UnitTestProtoFile.DefaultStringExtension, "415"); |
| 748 | message.SetExtension(UnitTestProtoFile.DefaultBytesExtension, ToBytes("416")); |
| 749 | |
| 750 | message.SetExtension(UnitTestProtoFile.DefaultNestedEnumExtension, TestAllTypes.Types.NestedEnum.FOO); |
| 751 | message.SetExtension(UnitTestProtoFile.DefaultForeignEnumExtension, ForeignEnum.FOREIGN_FOO); |
| 752 | message.SetExtension(UnitTestProtoFile.DefaultImportEnumExtension, ImportEnum.IMPORT_FOO); |
| 753 | |
| 754 | message.SetExtension(UnitTestProtoFile.DefaultStringPieceExtension, "424"); |
| 755 | message.SetExtension(UnitTestProtoFile.DefaultCordExtension, "425"); |
| 756 | } |
| 757 | |
| 758 | internal static void ModifyRepeatedFields(TestAllTypes.Builder message) { |
| 759 | message.SetRepeatedInt32(1, 501); |
| 760 | message.SetRepeatedInt64(1, 502); |
| 761 | message.SetRepeatedUint32(1, 503); |
| 762 | message.SetRepeatedUint64(1, 504); |
| 763 | message.SetRepeatedSint32(1, 505); |
| 764 | message.SetRepeatedSint64(1, 506); |
| 765 | message.SetRepeatedFixed32(1, 507); |
| 766 | message.SetRepeatedFixed64(1, 508); |
| 767 | message.SetRepeatedSfixed32(1, 509); |
| 768 | message.SetRepeatedSfixed64(1, 510); |
| 769 | message.SetRepeatedFloat(1, 511); |
| 770 | message.SetRepeatedDouble(1, 512); |
| 771 | message.SetRepeatedBool(1, true); |
| 772 | message.SetRepeatedString(1, "515"); |
| 773 | message.SetRepeatedBytes(1, ToBytes("516")); |
| 774 | |
| 775 | message.SetRepeatedGroup(1, TestAllTypes.Types.RepeatedGroup.CreateBuilder().SetA(517).Build()); |
| 776 | message.SetRepeatedNestedMessage(1, TestAllTypes.Types.NestedMessage.CreateBuilder().SetBb(518).Build()); |
| 777 | message.SetRepeatedForeignMessage(1, ForeignMessage.CreateBuilder().SetC(519).Build()); |
| 778 | message.SetRepeatedImportMessage(1, ImportMessage.CreateBuilder().SetD(520).Build()); |
| 779 | |
| 780 | message.SetRepeatedNestedEnum(1, TestAllTypes.Types.NestedEnum.FOO); |
| 781 | message.SetRepeatedForeignEnum(1, ForeignEnum.FOREIGN_FOO); |
| 782 | message.SetRepeatedImportEnum(1, ImportEnum.IMPORT_FOO); |
| 783 | |
| 784 | message.SetRepeatedStringPiece(1, "524"); |
| 785 | message.SetRepeatedCord(1, "525"); |
| 786 | } |
| 787 | |
| 788 | internal static void AssertRepeatedFieldsModified(TestAllTypes message) { |
| 789 | // ModifyRepeatedFields only sets the second repeated element of each |
| 790 | // field. In addition to verifying this, we also verify that the first |
| 791 | // element and size were *not* modified. |
| 792 | Assert.AreEqual(2, message.RepeatedInt32Count); |
| 793 | Assert.AreEqual(2, message.RepeatedInt64Count); |
| 794 | Assert.AreEqual(2, message.RepeatedUint32Count); |
| 795 | Assert.AreEqual(2, message.RepeatedUint64Count); |
| 796 | Assert.AreEqual(2, message.RepeatedSint32Count); |
| 797 | Assert.AreEqual(2, message.RepeatedSint64Count); |
| 798 | Assert.AreEqual(2, message.RepeatedFixed32Count); |
| 799 | Assert.AreEqual(2, message.RepeatedFixed64Count); |
| 800 | Assert.AreEqual(2, message.RepeatedSfixed32Count); |
| 801 | Assert.AreEqual(2, message.RepeatedSfixed64Count); |
| 802 | Assert.AreEqual(2, message.RepeatedFloatCount); |
| 803 | Assert.AreEqual(2, message.RepeatedDoubleCount); |
| 804 | Assert.AreEqual(2, message.RepeatedBoolCount); |
| 805 | Assert.AreEqual(2, message.RepeatedStringCount); |
| 806 | Assert.AreEqual(2, message.RepeatedBytesCount); |
| 807 | |
| 808 | Assert.AreEqual(2, message.RepeatedGroupCount); |
| 809 | Assert.AreEqual(2, message.RepeatedNestedMessageCount); |
| 810 | Assert.AreEqual(2, message.RepeatedForeignMessageCount); |
| 811 | Assert.AreEqual(2, message.RepeatedImportMessageCount); |
| 812 | Assert.AreEqual(2, message.RepeatedNestedEnumCount); |
| 813 | Assert.AreEqual(2, message.RepeatedForeignEnumCount); |
| 814 | Assert.AreEqual(2, message.RepeatedImportEnumCount); |
| 815 | |
| 816 | Assert.AreEqual(2, message.RepeatedStringPieceCount); |
| 817 | Assert.AreEqual(2, message.RepeatedCordCount); |
| 818 | |
| 819 | Assert.AreEqual(201, message.GetRepeatedInt32(0)); |
| 820 | Assert.AreEqual(202L, message.GetRepeatedInt64(0)); |
| 821 | Assert.AreEqual(203U, message.GetRepeatedUint32(0)); |
| 822 | Assert.AreEqual(204UL, message.GetRepeatedUint64(0)); |
| 823 | Assert.AreEqual(205, message.GetRepeatedSint32(0)); |
| 824 | Assert.AreEqual(206L, message.GetRepeatedSint64(0)); |
| 825 | Assert.AreEqual(207U, message.GetRepeatedFixed32(0)); |
| 826 | Assert.AreEqual(208UL, message.GetRepeatedFixed64(0)); |
| 827 | Assert.AreEqual(209, message.GetRepeatedSfixed32(0)); |
| 828 | Assert.AreEqual(210L, message.GetRepeatedSfixed64(0)); |
| 829 | Assert.AreEqual(211F, message.GetRepeatedFloat(0)); |
| 830 | Assert.AreEqual(212D, message.GetRepeatedDouble(0)); |
| 831 | Assert.AreEqual(true, message.GetRepeatedBool(0)); |
| 832 | Assert.AreEqual("215", message.GetRepeatedString(0)); |
| 833 | Assert.AreEqual(ToBytes("216"), message.GetRepeatedBytes(0)); |
| 834 | |
| 835 | Assert.AreEqual(217, message.GetRepeatedGroup(0).A); |
| 836 | Assert.AreEqual(218, message.GetRepeatedNestedMessage(0).Bb); |
| 837 | Assert.AreEqual(219, message.GetRepeatedForeignMessage(0).C); |
| 838 | Assert.AreEqual(220, message.GetRepeatedImportMessage(0).D); |
| 839 | |
| 840 | Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, message.GetRepeatedNestedEnum(0)); |
| 841 | Assert.AreEqual(ForeignEnum.FOREIGN_BAR, message.GetRepeatedForeignEnum(0)); |
| 842 | Assert.AreEqual(ImportEnum.IMPORT_BAR, message.GetRepeatedImportEnum(0)); |
| 843 | |
| 844 | Assert.AreEqual("224", message.GetRepeatedStringPiece(0)); |
| 845 | Assert.AreEqual("225", message.GetRepeatedCord(0)); |
| 846 | |
| 847 | // Actually verify the second (modified) elements now. |
| 848 | Assert.AreEqual(501, message.GetRepeatedInt32(1)); |
| 849 | Assert.AreEqual(502L, message.GetRepeatedInt64(1)); |
| 850 | Assert.AreEqual(503U, message.GetRepeatedUint32(1)); |
| 851 | Assert.AreEqual(504UL, message.GetRepeatedUint64(1)); |
| 852 | Assert.AreEqual(505, message.GetRepeatedSint32(1)); |
| 853 | Assert.AreEqual(506L, message.GetRepeatedSint64(1)); |
| 854 | Assert.AreEqual(507U, message.GetRepeatedFixed32(1)); |
| 855 | Assert.AreEqual(508UL, message.GetRepeatedFixed64(1)); |
| 856 | Assert.AreEqual(509, message.GetRepeatedSfixed32(1)); |
| 857 | Assert.AreEqual(510L, message.GetRepeatedSfixed64(1)); |
| 858 | Assert.AreEqual(511F, message.GetRepeatedFloat(1)); |
| 859 | Assert.AreEqual(512D, message.GetRepeatedDouble(1)); |
| 860 | Assert.AreEqual(true, message.GetRepeatedBool(1)); |
| 861 | Assert.AreEqual("515", message.GetRepeatedString(1)); |
| 862 | Assert.AreEqual(ToBytes("516"), message.GetRepeatedBytes(1)); |
| 863 | |
| 864 | Assert.AreEqual(517, message.GetRepeatedGroup(1).A); |
| 865 | Assert.AreEqual(518, message.GetRepeatedNestedMessage(1).Bb); |
| 866 | Assert.AreEqual(519, message.GetRepeatedForeignMessage(1).C); |
| 867 | Assert.AreEqual(520, message.GetRepeatedImportMessage(1).D); |
| 868 | |
| 869 | Assert.AreEqual(TestAllTypes.Types.NestedEnum.FOO, message.GetRepeatedNestedEnum(1)); |
| 870 | Assert.AreEqual(ForeignEnum.FOREIGN_FOO, message.GetRepeatedForeignEnum(1)); |
| 871 | Assert.AreEqual(ImportEnum.IMPORT_FOO, message.GetRepeatedImportEnum(1)); |
| 872 | |
| 873 | Assert.AreEqual("524", message.GetRepeatedStringPiece(1)); |
| 874 | Assert.AreEqual("525", message.GetRepeatedCord(1)); |
| 875 | } |
| 876 | |
| 877 | /// <summary> |
| 878 | /// Helper to assert that sequences are equal. |
| 879 | /// </summary> |
| 880 | internal static void AssertEqual<T>(IEnumerable<T> first, IEnumerable<T> second) { |
| 881 | using (IEnumerator<T> firstEnumerator = first.GetEnumerator()) { |
| 882 | foreach (T secondElement in second) { |
| 883 | Assert.IsTrue(firstEnumerator.MoveNext(), "First enumerator ran out of elements too early."); |
| 884 | Assert.AreEqual(firstEnumerator.Current, secondElement); |
| 885 | } |
| 886 | Assert.IsFalse(firstEnumerator.MoveNext(), "Second enumerator ran out of elements too early."); |
| 887 | } |
| 888 | } |
| 889 | |
| 890 | internal static void AssertEqualBytes(byte[] expected, byte[] actual) { |
| 891 | Assert.AreEqual(ByteString.CopyFrom(expected), ByteString.CopyFrom(actual)); |
| 892 | } |
| 893 | |
| 894 | internal static void AssertAllExtensionsSet(TestAllExtensions message) { |
| 895 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalInt32Extension )); |
| 896 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalInt64Extension )); |
| 897 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalUint32Extension )); |
| 898 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalUint64Extension )); |
| 899 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalSint32Extension )); |
| 900 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalSint64Extension )); |
| 901 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalFixed32Extension )); |
| 902 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalFixed64Extension )); |
| 903 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalSfixed32Extension)); |
| 904 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalSfixed64Extension)); |
| 905 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalFloatExtension )); |
| 906 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalDoubleExtension )); |
| 907 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalBoolExtension )); |
| 908 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalStringExtension )); |
| 909 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalBytesExtension )); |
| 910 | |
| 911 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalGroupExtension )); |
| 912 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalNestedMessageExtension )); |
| 913 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalForeignMessageExtension)); |
| 914 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalImportMessageExtension )); |
| 915 | |
| 916 | Assert.IsTrue(message.GetExtension(UnitTestProtoFile.OptionalGroupExtension ).HasA); |
| 917 | Assert.IsTrue(message.GetExtension(UnitTestProtoFile.OptionalNestedMessageExtension ).HasBb); |
| 918 | Assert.IsTrue(message.GetExtension(UnitTestProtoFile.OptionalForeignMessageExtension).HasC); |
| 919 | Assert.IsTrue(message.GetExtension(UnitTestProtoFile.OptionalImportMessageExtension ).HasD); |
| 920 | |
| 921 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalNestedEnumExtension )); |
| 922 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalForeignEnumExtension)); |
| 923 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalImportEnumExtension )); |
| 924 | |
| 925 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalStringPieceExtension)); |
| 926 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalCordExtension)); |
| 927 | |
| 928 | Assert.AreEqual(101 , message.GetExtension(UnitTestProtoFile.OptionalInt32Extension )); |
| 929 | Assert.AreEqual(102L , message.GetExtension(UnitTestProtoFile.OptionalInt64Extension )); |
| 930 | Assert.AreEqual(103U , message.GetExtension(UnitTestProtoFile.OptionalUint32Extension )); |
| 931 | Assert.AreEqual(104UL , message.GetExtension(UnitTestProtoFile.OptionalUint64Extension )); |
| 932 | Assert.AreEqual(105 , message.GetExtension(UnitTestProtoFile.OptionalSint32Extension )); |
| 933 | Assert.AreEqual(106L , message.GetExtension(UnitTestProtoFile.OptionalSint64Extension )); |
| 934 | Assert.AreEqual(107U , message.GetExtension(UnitTestProtoFile.OptionalFixed32Extension )); |
| 935 | Assert.AreEqual(108UL , message.GetExtension(UnitTestProtoFile.OptionalFixed64Extension )); |
| 936 | Assert.AreEqual(109 , message.GetExtension(UnitTestProtoFile.OptionalSfixed32Extension)); |
| 937 | Assert.AreEqual(110L , message.GetExtension(UnitTestProtoFile.OptionalSfixed64Extension)); |
| 938 | Assert.AreEqual(111F , message.GetExtension(UnitTestProtoFile.OptionalFloatExtension )); |
| 939 | Assert.AreEqual(112D , message.GetExtension(UnitTestProtoFile.OptionalDoubleExtension )); |
| 940 | Assert.AreEqual(true , message.GetExtension(UnitTestProtoFile.OptionalBoolExtension )); |
| 941 | Assert.AreEqual("115", message.GetExtension(UnitTestProtoFile.OptionalStringExtension )); |
| 942 | Assert.AreEqual(ToBytes("116"), message.GetExtension(UnitTestProtoFile.OptionalBytesExtension)); |
| 943 | |
| 944 | Assert.AreEqual(117, message.GetExtension(UnitTestProtoFile.OptionalGroupExtension ).A); |
| 945 | Assert.AreEqual(118, message.GetExtension(UnitTestProtoFile.OptionalNestedMessageExtension ).Bb); |
| 946 | Assert.AreEqual(119, message.GetExtension(UnitTestProtoFile.OptionalForeignMessageExtension).C); |
| 947 | Assert.AreEqual(120, message.GetExtension(UnitTestProtoFile.OptionalImportMessageExtension ).D); |
| 948 | |
| 949 | Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAZ, message.GetExtension(UnitTestProtoFile.OptionalNestedEnumExtension)); |
| 950 | Assert.AreEqual(ForeignEnum.FOREIGN_BAZ, message.GetExtension(UnitTestProtoFile.OptionalForeignEnumExtension)); |
| 951 | Assert.AreEqual(ImportEnum.IMPORT_BAZ, message.GetExtension(UnitTestProtoFile.OptionalImportEnumExtension)); |
| 952 | |
| 953 | Assert.AreEqual("124", message.GetExtension(UnitTestProtoFile.OptionalStringPieceExtension)); |
| 954 | Assert.AreEqual("125", message.GetExtension(UnitTestProtoFile.OptionalCordExtension)); |
| 955 | |
| 956 | // ----------------------------------------------------------------- |
| 957 | |
| 958 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedInt32Extension )); |
| 959 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedInt64Extension )); |
| 960 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedUint32Extension )); |
| 961 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedUint64Extension )); |
| 962 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedSint32Extension )); |
| 963 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedSint64Extension )); |
| 964 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedFixed32Extension )); |
| 965 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedFixed64Extension )); |
| 966 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedSfixed32Extension)); |
| 967 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedSfixed64Extension)); |
| 968 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedFloatExtension )); |
| 969 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedDoubleExtension )); |
| 970 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedBoolExtension )); |
| 971 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedStringExtension )); |
| 972 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedBytesExtension )); |
| 973 | |
| 974 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedGroupExtension )); |
| 975 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedNestedMessageExtension )); |
| 976 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedForeignMessageExtension)); |
| 977 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedImportMessageExtension )); |
| 978 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedNestedEnumExtension )); |
| 979 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedForeignEnumExtension )); |
| 980 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedImportEnumExtension )); |
| 981 | |
| 982 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedStringPieceExtension)); |
| 983 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedCordExtension)); |
| 984 | |
| 985 | Assert.AreEqual(201 , message.GetExtension(UnitTestProtoFile.RepeatedInt32Extension , 0)); |
| 986 | Assert.AreEqual(202L , message.GetExtension(UnitTestProtoFile.RepeatedInt64Extension , 0)); |
| 987 | Assert.AreEqual(203U , message.GetExtension(UnitTestProtoFile.RepeatedUint32Extension , 0)); |
| 988 | Assert.AreEqual(204UL , message.GetExtension(UnitTestProtoFile.RepeatedUint64Extension , 0)); |
| 989 | Assert.AreEqual(205 , message.GetExtension(UnitTestProtoFile.RepeatedSint32Extension , 0)); |
| 990 | Assert.AreEqual(206L , message.GetExtension(UnitTestProtoFile.RepeatedSint64Extension , 0)); |
| 991 | Assert.AreEqual(207U , message.GetExtension(UnitTestProtoFile.RepeatedFixed32Extension , 0)); |
| 992 | Assert.AreEqual(208UL , message.GetExtension(UnitTestProtoFile.RepeatedFixed64Extension , 0)); |
| 993 | Assert.AreEqual(209 , message.GetExtension(UnitTestProtoFile.RepeatedSfixed32Extension, 0)); |
| 994 | Assert.AreEqual(210L , message.GetExtension(UnitTestProtoFile.RepeatedSfixed64Extension, 0)); |
| 995 | Assert.AreEqual(211F , message.GetExtension(UnitTestProtoFile.RepeatedFloatExtension , 0)); |
| 996 | Assert.AreEqual(212D , message.GetExtension(UnitTestProtoFile.RepeatedDoubleExtension , 0)); |
| 997 | Assert.AreEqual(true , message.GetExtension(UnitTestProtoFile.RepeatedBoolExtension , 0)); |
| 998 | Assert.AreEqual("215", message.GetExtension(UnitTestProtoFile.RepeatedStringExtension , 0)); |
| 999 | Assert.AreEqual(ToBytes("216"), message.GetExtension(UnitTestProtoFile.RepeatedBytesExtension, 0)); |
| 1000 | |
| 1001 | Assert.AreEqual(217, message.GetExtension(UnitTestProtoFile.RepeatedGroupExtension , 0).A); |
| 1002 | Assert.AreEqual(218, message.GetExtension(UnitTestProtoFile.RepeatedNestedMessageExtension , 0).Bb); |
| 1003 | Assert.AreEqual(219, message.GetExtension(UnitTestProtoFile.RepeatedForeignMessageExtension, 0).C); |
| 1004 | Assert.AreEqual(220, message.GetExtension(UnitTestProtoFile.RepeatedImportMessageExtension , 0).D); |
| 1005 | |
| 1006 | Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, message.GetExtension(UnitTestProtoFile.RepeatedNestedEnumExtension, 0)); |
| 1007 | Assert.AreEqual(ForeignEnum.FOREIGN_BAR, message.GetExtension(UnitTestProtoFile.RepeatedForeignEnumExtension, 0)); |
| 1008 | Assert.AreEqual(ImportEnum.IMPORT_BAR, message.GetExtension(UnitTestProtoFile.RepeatedImportEnumExtension, 0)); |
| 1009 | |
| 1010 | Assert.AreEqual("224", message.GetExtension(UnitTestProtoFile.RepeatedStringPieceExtension, 0)); |
| 1011 | Assert.AreEqual("225", message.GetExtension(UnitTestProtoFile.RepeatedCordExtension, 0)); |
| 1012 | |
| 1013 | Assert.AreEqual(301 , message.GetExtension(UnitTestProtoFile.RepeatedInt32Extension , 1)); |
| 1014 | Assert.AreEqual(302L , message.GetExtension(UnitTestProtoFile.RepeatedInt64Extension , 1)); |
| 1015 | Assert.AreEqual(303U , message.GetExtension(UnitTestProtoFile.RepeatedUint32Extension , 1)); |
| 1016 | Assert.AreEqual(304UL , message.GetExtension(UnitTestProtoFile.RepeatedUint64Extension , 1)); |
| 1017 | Assert.AreEqual(305 , message.GetExtension(UnitTestProtoFile.RepeatedSint32Extension , 1)); |
| 1018 | Assert.AreEqual(306L , message.GetExtension(UnitTestProtoFile.RepeatedSint64Extension , 1)); |
| 1019 | Assert.AreEqual(307U , message.GetExtension(UnitTestProtoFile.RepeatedFixed32Extension , 1)); |
| 1020 | Assert.AreEqual(308UL , message.GetExtension(UnitTestProtoFile.RepeatedFixed64Extension , 1)); |
| 1021 | Assert.AreEqual(309 , message.GetExtension(UnitTestProtoFile.RepeatedSfixed32Extension, 1)); |
| 1022 | Assert.AreEqual(310L , message.GetExtension(UnitTestProtoFile.RepeatedSfixed64Extension, 1)); |
| 1023 | Assert.AreEqual(311F , message.GetExtension(UnitTestProtoFile.RepeatedFloatExtension , 1)); |
| 1024 | Assert.AreEqual(312D , message.GetExtension(UnitTestProtoFile.RepeatedDoubleExtension , 1)); |
| 1025 | Assert.AreEqual(false, message.GetExtension(UnitTestProtoFile.RepeatedBoolExtension , 1)); |
| 1026 | Assert.AreEqual("315", message.GetExtension(UnitTestProtoFile.RepeatedStringExtension , 1)); |
| 1027 | Assert.AreEqual(ToBytes("316"), message.GetExtension(UnitTestProtoFile.RepeatedBytesExtension, 1)); |
| 1028 | |
| 1029 | Assert.AreEqual(317, message.GetExtension(UnitTestProtoFile.RepeatedGroupExtension , 1).A); |
| 1030 | Assert.AreEqual(318, message.GetExtension(UnitTestProtoFile.RepeatedNestedMessageExtension , 1).Bb); |
| 1031 | Assert.AreEqual(319, message.GetExtension(UnitTestProtoFile.RepeatedForeignMessageExtension, 1).C); |
| 1032 | Assert.AreEqual(320, message.GetExtension(UnitTestProtoFile.RepeatedImportMessageExtension , 1).D); |
| 1033 | |
| 1034 | Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAZ, message.GetExtension(UnitTestProtoFile.RepeatedNestedEnumExtension, 1)); |
| 1035 | Assert.AreEqual(ForeignEnum.FOREIGN_BAZ, message.GetExtension(UnitTestProtoFile.RepeatedForeignEnumExtension, 1)); |
| 1036 | Assert.AreEqual(ImportEnum.IMPORT_BAZ, message.GetExtension(UnitTestProtoFile.RepeatedImportEnumExtension, 1)); |
| 1037 | |
| 1038 | Assert.AreEqual("324", message.GetExtension(UnitTestProtoFile.RepeatedStringPieceExtension, 1)); |
| 1039 | Assert.AreEqual("325", message.GetExtension(UnitTestProtoFile.RepeatedCordExtension, 1)); |
| 1040 | |
| 1041 | // ----------------------------------------------------------------- |
| 1042 | |
| 1043 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultInt32Extension )); |
| 1044 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultInt64Extension )); |
| 1045 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultUint32Extension )); |
| 1046 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultUint64Extension )); |
| 1047 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultSint32Extension )); |
| 1048 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultSint64Extension )); |
| 1049 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultFixed32Extension )); |
| 1050 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultFixed64Extension )); |
| 1051 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultSfixed32Extension)); |
| 1052 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultSfixed64Extension)); |
| 1053 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultFloatExtension )); |
| 1054 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultDoubleExtension )); |
| 1055 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultBoolExtension )); |
| 1056 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultStringExtension )); |
| 1057 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultBytesExtension )); |
| 1058 | |
| 1059 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultNestedEnumExtension )); |
| 1060 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultForeignEnumExtension)); |
| 1061 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultImportEnumExtension )); |
| 1062 | |
| 1063 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultStringPieceExtension)); |
| 1064 | Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultCordExtension)); |
| 1065 | |
| 1066 | Assert.AreEqual(401 , message.GetExtension(UnitTestProtoFile.DefaultInt32Extension )); |
| 1067 | Assert.AreEqual(402L , message.GetExtension(UnitTestProtoFile.DefaultInt64Extension )); |
| 1068 | Assert.AreEqual(403U , message.GetExtension(UnitTestProtoFile.DefaultUint32Extension )); |
| 1069 | Assert.AreEqual(404UL , message.GetExtension(UnitTestProtoFile.DefaultUint64Extension )); |
| 1070 | Assert.AreEqual(405 , message.GetExtension(UnitTestProtoFile.DefaultSint32Extension )); |
| 1071 | Assert.AreEqual(406L , message.GetExtension(UnitTestProtoFile.DefaultSint64Extension )); |
| 1072 | Assert.AreEqual(407U , message.GetExtension(UnitTestProtoFile.DefaultFixed32Extension )); |
| 1073 | Assert.AreEqual(408UL , message.GetExtension(UnitTestProtoFile.DefaultFixed64Extension )); |
| 1074 | Assert.AreEqual(409 , message.GetExtension(UnitTestProtoFile.DefaultSfixed32Extension)); |
| 1075 | Assert.AreEqual(410L , message.GetExtension(UnitTestProtoFile.DefaultSfixed64Extension)); |
| 1076 | Assert.AreEqual(411F , message.GetExtension(UnitTestProtoFile.DefaultFloatExtension )); |
| 1077 | Assert.AreEqual(412D , message.GetExtension(UnitTestProtoFile.DefaultDoubleExtension )); |
| 1078 | Assert.AreEqual(false, message.GetExtension(UnitTestProtoFile.DefaultBoolExtension )); |
| 1079 | Assert.AreEqual("415", message.GetExtension(UnitTestProtoFile.DefaultStringExtension )); |
| 1080 | Assert.AreEqual(ToBytes("416"), message.GetExtension(UnitTestProtoFile.DefaultBytesExtension)); |
| 1081 | |
| 1082 | Assert.AreEqual(TestAllTypes.Types.NestedEnum.FOO, message.GetExtension(UnitTestProtoFile.DefaultNestedEnumExtension )); |
| 1083 | Assert.AreEqual(ForeignEnum.FOREIGN_FOO, message.GetExtension(UnitTestProtoFile.DefaultForeignEnumExtension)); |
| 1084 | Assert.AreEqual(ImportEnum.IMPORT_FOO, message.GetExtension(UnitTestProtoFile.DefaultImportEnumExtension)); |
| 1085 | |
| 1086 | Assert.AreEqual("424", message.GetExtension(UnitTestProtoFile.DefaultStringPieceExtension)); |
| 1087 | Assert.AreEqual("425", message.GetExtension(UnitTestProtoFile.DefaultCordExtension)); |
| 1088 | } |
| 1089 | |
| 1090 | /// <summary> |
| 1091 | /// Modifies the repeated extensions of the given message to contain the values |
| 1092 | /// expected by AssertRepeatedExtensionsModified. |
| 1093 | /// </summary> |
| 1094 | internal static void ModifyRepeatedExtensions(TestAllExtensions.Builder message) { |
| 1095 | message.SetExtension(UnitTestProtoFile.RepeatedInt32Extension, 1, 501); |
| 1096 | message.SetExtension(UnitTestProtoFile.RepeatedInt64Extension, 1, 502L); |
| 1097 | message.SetExtension(UnitTestProtoFile.RepeatedUint32Extension, 1, 503U); |
| 1098 | message.SetExtension(UnitTestProtoFile.RepeatedUint64Extension, 1, 504UL); |
| 1099 | message.SetExtension(UnitTestProtoFile.RepeatedSint32Extension, 1, 505); |
| 1100 | message.SetExtension(UnitTestProtoFile.RepeatedSint64Extension, 1, 506L); |
| 1101 | message.SetExtension(UnitTestProtoFile.RepeatedFixed32Extension, 1, 507U); |
| 1102 | message.SetExtension(UnitTestProtoFile.RepeatedFixed64Extension, 1, 508UL); |
| 1103 | message.SetExtension(UnitTestProtoFile.RepeatedSfixed32Extension, 1, 509); |
| 1104 | message.SetExtension(UnitTestProtoFile.RepeatedSfixed64Extension, 1, 510L); |
| 1105 | message.SetExtension(UnitTestProtoFile.RepeatedFloatExtension, 1, 511F); |
| 1106 | message.SetExtension(UnitTestProtoFile.RepeatedDoubleExtension, 1, 512D); |
| 1107 | message.SetExtension(UnitTestProtoFile.RepeatedBoolExtension, 1, true); |
| 1108 | message.SetExtension(UnitTestProtoFile.RepeatedStringExtension, 1, "515"); |
| 1109 | message.SetExtension(UnitTestProtoFile.RepeatedBytesExtension, 1, ToBytes("516")); |
| 1110 | |
| 1111 | message.SetExtension(UnitTestProtoFile.RepeatedGroupExtension, 1, RepeatedGroup_extension.CreateBuilder().SetA(517).Build()); |
| 1112 | message.SetExtension(UnitTestProtoFile.RepeatedNestedMessageExtension, 1, TestAllTypes.Types.NestedMessage.CreateBuilder().SetBb(518).Build()); |
| 1113 | message.SetExtension(UnitTestProtoFile.RepeatedForeignMessageExtension, 1, ForeignMessage.CreateBuilder().SetC(519).Build()); |
| 1114 | message.SetExtension(UnitTestProtoFile.RepeatedImportMessageExtension, 1, ImportMessage.CreateBuilder().SetD(520).Build()); |
| 1115 | |
| 1116 | message.SetExtension(UnitTestProtoFile.RepeatedNestedEnumExtension, 1, TestAllTypes.Types.NestedEnum.FOO); |
| 1117 | message.SetExtension(UnitTestProtoFile.RepeatedForeignEnumExtension, 1, ForeignEnum.FOREIGN_FOO); |
| 1118 | message.SetExtension(UnitTestProtoFile.RepeatedImportEnumExtension, 1, ImportEnum.IMPORT_FOO); |
| 1119 | |
| 1120 | message.SetExtension(UnitTestProtoFile.RepeatedStringPieceExtension, 1, "524"); |
| 1121 | message.SetExtension(UnitTestProtoFile.RepeatedCordExtension, 1, "525"); |
| 1122 | } |
| 1123 | |
| 1124 | /// <summary> |
| 1125 | /// Asserts that all repeated extensions are set to the values assigned by |
| 1126 | /// SetAllExtensions follwed by ModifyRepeatedExtensions. |
| 1127 | /// </summary> |
| 1128 | internal static void AssertRepeatedExtensionsModified(TestAllExtensions message) { |
| 1129 | // ModifyRepeatedFields only sets the second repeated element of each |
| 1130 | // field. In addition to verifying this, we also verify that the first |
| 1131 | // element and size were *not* modified. |
| 1132 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedInt32Extension)); |
| 1133 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedInt64Extension)); |
| 1134 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedUint32Extension)); |
| 1135 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedUint64Extension)); |
| 1136 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedSint32Extension)); |
| 1137 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedSint64Extension)); |
| 1138 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedFixed32Extension)); |
| 1139 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedFixed64Extension)); |
| 1140 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedSfixed32Extension)); |
| 1141 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedSfixed64Extension)); |
| 1142 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedFloatExtension)); |
| 1143 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedDoubleExtension)); |
| 1144 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedBoolExtension)); |
| 1145 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedStringExtension)); |
| 1146 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedBytesExtension)); |
| 1147 | |
| 1148 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedGroupExtension)); |
| 1149 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedNestedMessageExtension)); |
| 1150 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedForeignMessageExtension)); |
| 1151 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedImportMessageExtension)); |
| 1152 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedNestedEnumExtension)); |
| 1153 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedForeignEnumExtension)); |
| 1154 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedImportEnumExtension)); |
| 1155 | |
| 1156 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedStringPieceExtension)); |
| 1157 | Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedCordExtension)); |
| 1158 | |
| 1159 | Assert.AreEqual(201, message.GetExtension(UnitTestProtoFile.RepeatedInt32Extension, 0)); |
| 1160 | Assert.AreEqual(202L, message.GetExtension(UnitTestProtoFile.RepeatedInt64Extension, 0)); |
| 1161 | Assert.AreEqual(203U, message.GetExtension(UnitTestProtoFile.RepeatedUint32Extension, 0)); |
| 1162 | Assert.AreEqual(204UL, message.GetExtension(UnitTestProtoFile.RepeatedUint64Extension, 0)); |
| 1163 | Assert.AreEqual(205, message.GetExtension(UnitTestProtoFile.RepeatedSint32Extension, 0)); |
| 1164 | Assert.AreEqual(206L, message.GetExtension(UnitTestProtoFile.RepeatedSint64Extension, 0)); |
| 1165 | Assert.AreEqual(207U, message.GetExtension(UnitTestProtoFile.RepeatedFixed32Extension, 0)); |
| 1166 | Assert.AreEqual(208UL, message.GetExtension(UnitTestProtoFile.RepeatedFixed64Extension, 0)); |
| 1167 | Assert.AreEqual(209, message.GetExtension(UnitTestProtoFile.RepeatedSfixed32Extension, 0)); |
| 1168 | Assert.AreEqual(210L, message.GetExtension(UnitTestProtoFile.RepeatedSfixed64Extension, 0)); |
| 1169 | Assert.AreEqual(211F, message.GetExtension(UnitTestProtoFile.RepeatedFloatExtension, 0)); |
| 1170 | Assert.AreEqual(212D, message.GetExtension(UnitTestProtoFile.RepeatedDoubleExtension, 0)); |
| 1171 | Assert.AreEqual(true, message.GetExtension(UnitTestProtoFile.RepeatedBoolExtension, 0)); |
| 1172 | Assert.AreEqual("215", message.GetExtension(UnitTestProtoFile.RepeatedStringExtension, 0)); |
| 1173 | Assert.AreEqual(ToBytes("216"), message.GetExtension(UnitTestProtoFile.RepeatedBytesExtension, 0)); |
| 1174 | |
| 1175 | Assert.AreEqual(217, message.GetExtension(UnitTestProtoFile.RepeatedGroupExtension, 0).A); |
| 1176 | Assert.AreEqual(218, message.GetExtension(UnitTestProtoFile.RepeatedNestedMessageExtension, 0).Bb); |
| 1177 | Assert.AreEqual(219, message.GetExtension(UnitTestProtoFile.RepeatedForeignMessageExtension, 0).C); |
| 1178 | Assert.AreEqual(220, message.GetExtension(UnitTestProtoFile.RepeatedImportMessageExtension, 0).D); |
| 1179 | |
| 1180 | Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, message.GetExtension(UnitTestProtoFile.RepeatedNestedEnumExtension, 0)); |
| 1181 | Assert.AreEqual(ForeignEnum.FOREIGN_BAR, message.GetExtension(UnitTestProtoFile.RepeatedForeignEnumExtension, 0)); |
| 1182 | Assert.AreEqual(ImportEnum.IMPORT_BAR, message.GetExtension(UnitTestProtoFile.RepeatedImportEnumExtension, 0)); |
| 1183 | |
| 1184 | Assert.AreEqual("224", message.GetExtension(UnitTestProtoFile.RepeatedStringPieceExtension, 0)); |
| 1185 | Assert.AreEqual("225", message.GetExtension(UnitTestProtoFile.RepeatedCordExtension, 0)); |
| 1186 | |
| 1187 | // Actually verify the second (modified) elements now. |
| 1188 | Assert.AreEqual(501, message.GetExtension(UnitTestProtoFile.RepeatedInt32Extension, 1)); |
| 1189 | Assert.AreEqual(502L, message.GetExtension(UnitTestProtoFile.RepeatedInt64Extension, 1)); |
| 1190 | Assert.AreEqual(503U, message.GetExtension(UnitTestProtoFile.RepeatedUint32Extension, 1)); |
| 1191 | Assert.AreEqual(504UL, message.GetExtension(UnitTestProtoFile.RepeatedUint64Extension, 1)); |
| 1192 | Assert.AreEqual(505, message.GetExtension(UnitTestProtoFile.RepeatedSint32Extension, 1)); |
| 1193 | Assert.AreEqual(506L, message.GetExtension(UnitTestProtoFile.RepeatedSint64Extension, 1)); |
| 1194 | Assert.AreEqual(507U, message.GetExtension(UnitTestProtoFile.RepeatedFixed32Extension, 1)); |
| 1195 | Assert.AreEqual(508UL, message.GetExtension(UnitTestProtoFile.RepeatedFixed64Extension, 1)); |
| 1196 | Assert.AreEqual(509, message.GetExtension(UnitTestProtoFile.RepeatedSfixed32Extension, 1)); |
| 1197 | Assert.AreEqual(510L, message.GetExtension(UnitTestProtoFile.RepeatedSfixed64Extension, 1)); |
| 1198 | Assert.AreEqual(511F, message.GetExtension(UnitTestProtoFile.RepeatedFloatExtension, 1)); |
| 1199 | Assert.AreEqual(512D, message.GetExtension(UnitTestProtoFile.RepeatedDoubleExtension, 1)); |
| 1200 | Assert.AreEqual(true, message.GetExtension(UnitTestProtoFile.RepeatedBoolExtension, 1)); |
| 1201 | Assert.AreEqual("515", message.GetExtension(UnitTestProtoFile.RepeatedStringExtension, 1)); |
| 1202 | Assert.AreEqual(ToBytes("516"), message.GetExtension(UnitTestProtoFile.RepeatedBytesExtension, 1)); |
| 1203 | |
| 1204 | Assert.AreEqual(517, message.GetExtension(UnitTestProtoFile.RepeatedGroupExtension, 1).A); |
| 1205 | Assert.AreEqual(518, message.GetExtension(UnitTestProtoFile.RepeatedNestedMessageExtension, 1).Bb); |
| 1206 | Assert.AreEqual(519, message.GetExtension(UnitTestProtoFile.RepeatedForeignMessageExtension, 1).C); |
| 1207 | Assert.AreEqual(520, message.GetExtension(UnitTestProtoFile.RepeatedImportMessageExtension, 1).D); |
| 1208 | |
| 1209 | Assert.AreEqual(TestAllTypes.Types.NestedEnum.FOO, message.GetExtension(UnitTestProtoFile.RepeatedNestedEnumExtension, 1)); |
| 1210 | Assert.AreEqual(ForeignEnum.FOREIGN_FOO, message.GetExtension(UnitTestProtoFile.RepeatedForeignEnumExtension, 1)); |
| 1211 | Assert.AreEqual(ImportEnum.IMPORT_FOO, message.GetExtension(UnitTestProtoFile.RepeatedImportEnumExtension, 1)); |
| 1212 | |
| 1213 | Assert.AreEqual("524", message.GetExtension(UnitTestProtoFile.RepeatedStringPieceExtension, 1)); |
| 1214 | Assert.AreEqual("525", message.GetExtension(UnitTestProtoFile.RepeatedCordExtension, 1)); |
| 1215 | } |
| 1216 | |
| 1217 | internal static void AssertExtensionsClear(TestAllExtensions message) { |
| 1218 | // HasBlah() should initially be false for all optional fields. |
| 1219 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalInt32Extension)); |
| 1220 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalInt64Extension)); |
| 1221 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalUint32Extension)); |
| 1222 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalUint64Extension)); |
| 1223 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalSint32Extension)); |
| 1224 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalSint64Extension)); |
| 1225 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalFixed32Extension)); |
| 1226 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalFixed64Extension)); |
| 1227 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalSfixed32Extension)); |
| 1228 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalSfixed64Extension)); |
| 1229 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalFloatExtension)); |
| 1230 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalDoubleExtension)); |
| 1231 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalBoolExtension)); |
| 1232 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalStringExtension)); |
| 1233 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalBytesExtension)); |
| 1234 | |
| 1235 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalGroupExtension)); |
| 1236 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalNestedMessageExtension)); |
| 1237 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalForeignMessageExtension)); |
| 1238 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalImportMessageExtension)); |
| 1239 | |
| 1240 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalNestedEnumExtension)); |
| 1241 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalForeignEnumExtension)); |
| 1242 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalImportEnumExtension)); |
| 1243 | |
| 1244 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalStringPieceExtension)); |
| 1245 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalCordExtension)); |
| 1246 | |
| 1247 | // Optional fields without defaults are set to zero or something like it. |
| 1248 | Assert.AreEqual(0, message.GetExtension(UnitTestProtoFile.OptionalInt32Extension)); |
| 1249 | Assert.AreEqual(0L, message.GetExtension(UnitTestProtoFile.OptionalInt64Extension)); |
| 1250 | Assert.AreEqual(0U, message.GetExtension(UnitTestProtoFile.OptionalUint32Extension)); |
| 1251 | Assert.AreEqual(0UL, message.GetExtension(UnitTestProtoFile.OptionalUint64Extension)); |
| 1252 | Assert.AreEqual(0, message.GetExtension(UnitTestProtoFile.OptionalSint32Extension)); |
| 1253 | Assert.AreEqual(0L, message.GetExtension(UnitTestProtoFile.OptionalSint64Extension)); |
| 1254 | Assert.AreEqual(0U, message.GetExtension(UnitTestProtoFile.OptionalFixed32Extension)); |
| 1255 | Assert.AreEqual(0UL, message.GetExtension(UnitTestProtoFile.OptionalFixed64Extension)); |
| 1256 | Assert.AreEqual(0, message.GetExtension(UnitTestProtoFile.OptionalSfixed32Extension)); |
| 1257 | Assert.AreEqual(0L, message.GetExtension(UnitTestProtoFile.OptionalSfixed64Extension)); |
| 1258 | Assert.AreEqual(0F, message.GetExtension(UnitTestProtoFile.OptionalFloatExtension)); |
| 1259 | Assert.AreEqual(0D, message.GetExtension(UnitTestProtoFile.OptionalDoubleExtension)); |
| 1260 | Assert.AreEqual(false, message.GetExtension(UnitTestProtoFile.OptionalBoolExtension)); |
| 1261 | Assert.AreEqual("", message.GetExtension(UnitTestProtoFile.OptionalStringExtension)); |
| 1262 | Assert.AreEqual(ByteString.Empty, message.GetExtension(UnitTestProtoFile.OptionalBytesExtension)); |
| 1263 | |
| 1264 | // Embedded messages should also be clear. |
| 1265 | Assert.IsFalse(message.GetExtension(UnitTestProtoFile.OptionalGroupExtension).HasA); |
| 1266 | Assert.IsFalse(message.GetExtension(UnitTestProtoFile.OptionalNestedMessageExtension).HasBb); |
| 1267 | Assert.IsFalse(message.GetExtension(UnitTestProtoFile.OptionalForeignMessageExtension).HasC); |
| 1268 | Assert.IsFalse(message.GetExtension(UnitTestProtoFile.OptionalImportMessageExtension).HasD); |
| 1269 | |
| 1270 | Assert.AreEqual(0, message.GetExtension(UnitTestProtoFile.OptionalGroupExtension).A); |
| 1271 | Assert.AreEqual(0, message.GetExtension(UnitTestProtoFile.OptionalNestedMessageExtension).Bb); |
| 1272 | Assert.AreEqual(0, message.GetExtension(UnitTestProtoFile.OptionalForeignMessageExtension).C); |
| 1273 | Assert.AreEqual(0, message.GetExtension(UnitTestProtoFile.OptionalImportMessageExtension).D); |
| 1274 | |
| 1275 | // Enums without defaults are set to the first value in the enum. |
| 1276 | Assert.AreEqual(TestAllTypes.Types.NestedEnum.FOO, message.GetExtension(UnitTestProtoFile.OptionalNestedEnumExtension)); |
| 1277 | Assert.AreEqual(ForeignEnum.FOREIGN_FOO, message.GetExtension(UnitTestProtoFile.OptionalForeignEnumExtension)); |
| 1278 | Assert.AreEqual(ImportEnum.IMPORT_FOO, message.GetExtension(UnitTestProtoFile.OptionalImportEnumExtension)); |
| 1279 | |
| 1280 | Assert.AreEqual("", message.GetExtension(UnitTestProtoFile.OptionalStringPieceExtension)); |
| 1281 | Assert.AreEqual("", message.GetExtension(UnitTestProtoFile.OptionalCordExtension)); |
| 1282 | |
| 1283 | // Repeated fields are empty. |
| 1284 | Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedInt32Extension)); |
| 1285 | Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedInt64Extension)); |
| 1286 | Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedUint32Extension)); |
| 1287 | Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedUint64Extension)); |
| 1288 | Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedSint32Extension)); |
| 1289 | Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedSint64Extension)); |
| 1290 | Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedFixed32Extension)); |
| 1291 | Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedFixed64Extension)); |
| 1292 | Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedSfixed32Extension)); |
| 1293 | Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedSfixed64Extension)); |
| 1294 | Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedFloatExtension)); |
| 1295 | Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedDoubleExtension)); |
| 1296 | Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedBoolExtension)); |
| 1297 | Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedStringExtension)); |
| 1298 | Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedBytesExtension)); |
| 1299 | |
| 1300 | Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedGroupExtension)); |
| 1301 | Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedNestedMessageExtension)); |
| 1302 | Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedForeignMessageExtension)); |
| 1303 | Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedImportMessageExtension)); |
| 1304 | Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedNestedEnumExtension)); |
| 1305 | Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedForeignEnumExtension)); |
| 1306 | Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedImportEnumExtension)); |
| 1307 | |
| 1308 | Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedStringPieceExtension)); |
| 1309 | Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedCordExtension)); |
| 1310 | |
| 1311 | // HasBlah() should also be false for all default fields. |
| 1312 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultInt32Extension)); |
| 1313 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultInt64Extension)); |
| 1314 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultUint32Extension)); |
| 1315 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultUint64Extension)); |
| 1316 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultSint32Extension)); |
| 1317 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultSint64Extension)); |
| 1318 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultFixed32Extension)); |
| 1319 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultFixed64Extension)); |
| 1320 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultSfixed32Extension)); |
| 1321 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultSfixed64Extension)); |
| 1322 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultFloatExtension)); |
| 1323 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultDoubleExtension)); |
| 1324 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultBoolExtension)); |
| 1325 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultStringExtension)); |
| 1326 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultBytesExtension)); |
| 1327 | |
| 1328 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultNestedEnumExtension)); |
| 1329 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultForeignEnumExtension)); |
| 1330 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultImportEnumExtension)); |
| 1331 | |
| 1332 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultStringPieceExtension)); |
| 1333 | Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultCordExtension)); |
| 1334 | |
| 1335 | // Fields with defaults have their default values (duh). |
| 1336 | Assert.AreEqual(41, message.GetExtension(UnitTestProtoFile.DefaultInt32Extension)); |
| 1337 | Assert.AreEqual(42L, message.GetExtension(UnitTestProtoFile.DefaultInt64Extension)); |
| 1338 | Assert.AreEqual(43U, message.GetExtension(UnitTestProtoFile.DefaultUint32Extension)); |
| 1339 | Assert.AreEqual(44UL, message.GetExtension(UnitTestProtoFile.DefaultUint64Extension)); |
| 1340 | Assert.AreEqual(-45, message.GetExtension(UnitTestProtoFile.DefaultSint32Extension)); |
| 1341 | Assert.AreEqual(46L, message.GetExtension(UnitTestProtoFile.DefaultSint64Extension)); |
| 1342 | Assert.AreEqual(47U, message.GetExtension(UnitTestProtoFile.DefaultFixed32Extension)); |
| 1343 | Assert.AreEqual(48UL, message.GetExtension(UnitTestProtoFile.DefaultFixed64Extension)); |
| 1344 | Assert.AreEqual(49, message.GetExtension(UnitTestProtoFile.DefaultSfixed32Extension)); |
| 1345 | Assert.AreEqual(-50L, message.GetExtension(UnitTestProtoFile.DefaultSfixed64Extension)); |
| 1346 | Assert.AreEqual(51.5F, message.GetExtension(UnitTestProtoFile.DefaultFloatExtension)); |
| 1347 | Assert.AreEqual(52e3D, message.GetExtension(UnitTestProtoFile.DefaultDoubleExtension)); |
| 1348 | Assert.AreEqual(true, message.GetExtension(UnitTestProtoFile.DefaultBoolExtension)); |
| 1349 | Assert.AreEqual("hello", message.GetExtension(UnitTestProtoFile.DefaultStringExtension)); |
| 1350 | Assert.AreEqual(ToBytes("world"), message.GetExtension(UnitTestProtoFile.DefaultBytesExtension)); |
| 1351 | |
| 1352 | Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, message.GetExtension(UnitTestProtoFile.DefaultNestedEnumExtension)); |
| 1353 | Assert.AreEqual(ForeignEnum.FOREIGN_BAR, message.GetExtension(UnitTestProtoFile.DefaultForeignEnumExtension)); |
| 1354 | Assert.AreEqual(ImportEnum.IMPORT_BAR, message.GetExtension(UnitTestProtoFile.DefaultImportEnumExtension)); |
| 1355 | |
| 1356 | Assert.AreEqual("abc", message.GetExtension(UnitTestProtoFile.DefaultStringPieceExtension)); |
| 1357 | Assert.AreEqual("123", message.GetExtension(UnitTestProtoFile.DefaultCordExtension)); |
| 1358 | } |
| 1359 | |
| 1360 | /// <summary> |
| 1361 | /// Helper to construct a byte array from a bunch of bytes. |
| 1362 | /// </summary> |
| 1363 | internal static byte[] Bytes(params byte[] bytesAsInts) { |
| 1364 | byte[] bytes = new byte[bytesAsInts.Length]; |
| 1365 | for (int i = 0; i < bytesAsInts.Length; i++) { |
| 1366 | bytes[i] = (byte)bytesAsInts[i]; |
| 1367 | } |
| 1368 | return bytes; |
| 1369 | } |
| 1370 | } |
| 1371 | } |