From ce97e686826147e2a071fd2321555f7d40ec5d93 Mon Sep 17 00:00:00 2001 From: Jon Skeet Date: Wed, 29 Apr 2015 15:27:14 +0100 Subject: Convert both the full and lite runtimes (and json/xml serialization assemblies) to be Portable Class Libraries. All referring projects are now .NET 4 client rather than .NET 3.5. This commit also fixes up the ProtoBench app, which I'd neglected in previous commits. (Disentangling the two sets of changes would be time-consuming.) --- csharp/src/AddressBook/AddressBook.csproj | 13 +- csharp/src/AddressBook/app.config | 2 +- csharp/src/ProtoBench/GoogleSize.cs | 4569 +++ csharp/src/ProtoBench/GoogleSpeed.cs | 6634 ++++ csharp/src/ProtoBench/Properties/AssemblyInfo.cs | 1 - csharp/src/ProtoBench/ProtoBench.csproj | 28 +- .../ProtoBench/TestProtos/GoogleSizeProtoFile.cs | 4572 --- .../ProtoBench/TestProtos/GoogleSpeedProtoFile.cs | 6637 ---- .../TestProtos/UnitTestImportProtoFile.cs | 346 - .../src/ProtoBench/TestProtos/UnitTestProtoFile.cs | 21602 ------------ csharp/src/ProtoBench/Unittest.cs | 33516 +++++++++++++++++++ csharp/src/ProtoBench/UnittestImport.cs | 347 + csharp/src/ProtoBench/UnittestImportPublic.cs | 333 + csharp/src/ProtoBench/app.config | 3 + csharp/src/ProtoDump/ProtoDump.csproj | 14 +- csharp/src/ProtoDump/app.config | 3 + csharp/src/ProtoMunge/ProtoMunge.csproj | 14 +- csharp/src/ProtoMunge/app.config | 3 + .../ProtocolBuffers.Serialization.csproj | 16 +- .../ProtocolBuffersLite.Serialization.csproj | 16 +- .../ProtocolBuffers.Test.CF20.csproj | 190 - .../ProtocolBuffers.Test.CF35.csproj | 191 - .../ProtocolBuffers.Test.NET20.csproj | 178 - .../ProtocolBuffers.Test.NET35.csproj | 179 - .../ProtocolBuffers.Test.NET40.csproj | 179 - .../ProtocolBuffers.Test.PL40.csproj | 213 - .../ProtocolBuffers.Test.SL20.csproj | 214 - .../ProtocolBuffers.Test.SL30.csproj | 215 - .../ProtocolBuffers.Test.SL40.csproj | 215 - .../ProtocolBuffers.Test.csproj | 11 +- csharp/src/ProtocolBuffers.sln | 6 + csharp/src/ProtocolBuffers/FieldSet.cs | 8 +- csharp/src/ProtocolBuffers/GeneratedMessage.cs | 4 +- .../src/ProtocolBuffers/Properties/AssemblyInfo.cs | 3 - csharp/src/ProtocolBuffers/ProtocolBuffers.csproj | 17 +- .../src/ProtocolBuffers/ProtocolBuffersLite.csproj | 17 +- csharp/src/ProtocolBuffers/TextFormat.cs | 4 - csharp/src/ProtocolBuffers/UnknownFieldSet.cs | 4 +- .../ProtocolBuffersLite.Test.CF20.csproj | 133 - .../ProtocolBuffersLite.Test.CF35.csproj | 134 - .../ProtocolBuffersLite.Test.NET20.csproj | 121 - .../ProtocolBuffersLite.Test.NET35.csproj | 122 - .../ProtocolBuffersLite.Test.NET40.csproj | 122 - .../ProtocolBuffersLite.Test.PL40.csproj | 156 - .../ProtocolBuffersLite.Test.SL20.csproj | 157 - .../ProtocolBuffersLite.Test.SL30.csproj | 158 - .../ProtocolBuffersLite.Test.SL40.csproj | 158 - .../ProtocolBuffersLite.Test.csproj | 11 +- .../ProtocolBuffersLiteMixed.Test.CF20.csproj | 126 - .../ProtocolBuffersLiteMixed.Test.CF35.csproj | 127 - .../ProtocolBuffersLiteMixed.Test.NET20.csproj | 114 - .../ProtocolBuffersLiteMixed.Test.NET35.csproj | 115 - .../ProtocolBuffersLiteMixed.Test.NET40.csproj | 115 - .../ProtocolBuffersLiteMixed.Test.PL40.csproj | 149 - .../ProtocolBuffersLiteMixed.Test.SL20.csproj | 150 - .../ProtocolBuffersLiteMixed.Test.SL30.csproj | 151 - .../ProtocolBuffersLiteMixed.Test.SL40.csproj | 151 - .../ProtocolBuffersLiteMixed.Test.csproj | 11 +- 58 files changed, 45514 insertions(+), 37484 deletions(-) create mode 100644 csharp/src/ProtoBench/GoogleSize.cs create mode 100644 csharp/src/ProtoBench/GoogleSpeed.cs delete mode 100644 csharp/src/ProtoBench/TestProtos/GoogleSizeProtoFile.cs delete mode 100644 csharp/src/ProtoBench/TestProtos/GoogleSpeedProtoFile.cs delete mode 100644 csharp/src/ProtoBench/TestProtos/UnitTestImportProtoFile.cs delete mode 100644 csharp/src/ProtoBench/TestProtos/UnitTestProtoFile.cs create mode 100644 csharp/src/ProtoBench/Unittest.cs create mode 100644 csharp/src/ProtoBench/UnittestImport.cs create mode 100644 csharp/src/ProtoBench/UnittestImportPublic.cs create mode 100644 csharp/src/ProtoBench/app.config create mode 100644 csharp/src/ProtoDump/app.config create mode 100644 csharp/src/ProtoMunge/app.config delete mode 100644 csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.CF20.csproj delete mode 100644 csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.CF35.csproj delete mode 100644 csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.NET20.csproj delete mode 100644 csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.NET35.csproj delete mode 100644 csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.NET40.csproj delete mode 100644 csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.PL40.csproj delete mode 100644 csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.SL20.csproj delete mode 100644 csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.SL30.csproj delete mode 100644 csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.SL40.csproj delete mode 100644 csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.CF20.csproj delete mode 100644 csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.CF35.csproj delete mode 100644 csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.NET20.csproj delete mode 100644 csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.NET35.csproj delete mode 100644 csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.NET40.csproj delete mode 100644 csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.PL40.csproj delete mode 100644 csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.SL20.csproj delete mode 100644 csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.SL30.csproj delete mode 100644 csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.SL40.csproj delete mode 100644 csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.CF20.csproj delete mode 100644 csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.CF35.csproj delete mode 100644 csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.NET20.csproj delete mode 100644 csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.NET35.csproj delete mode 100644 csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.NET40.csproj delete mode 100644 csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.PL40.csproj delete mode 100644 csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.SL20.csproj delete mode 100644 csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.SL30.csproj delete mode 100644 csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.SL40.csproj diff --git a/csharp/src/AddressBook/AddressBook.csproj b/csharp/src/AddressBook/AddressBook.csproj index fe05ad6c..52b82a8f 100644 --- a/csharp/src/AddressBook/AddressBook.csproj +++ b/csharp/src/AddressBook/AddressBook.csproj @@ -1,8 +1,6 @@  - CLIENTPROFILE - NET35 Debug AnyCPU 9.0.30729 @@ -12,16 +10,17 @@ Properties Google.ProtocolBuffers.Examples.AddressBook AddressBook - v3.5 + v4.0 512 Google.ProtocolBuffers.Examples.AddressBook.Program + Client true full false - bin\NET35\Debug - obj\NET35\Debug\ + bin\Debug + obj\Debug\ DEBUG;TRACE prompt 4 @@ -32,8 +31,8 @@ pdbonly true - bin\NET35\Release - obj\NET35\Release\ + bin\Release + obj\Release\ TRACE prompt 4 diff --git a/csharp/src/AddressBook/app.config b/csharp/src/AddressBook/app.config index 0df7832f..19fac17a 100644 --- a/csharp/src/AddressBook/app.config +++ b/csharp/src/AddressBook/app.config @@ -1,3 +1,3 @@ - + diff --git a/csharp/src/ProtoBench/GoogleSize.cs b/csharp/src/ProtoBench/GoogleSize.cs new file mode 100644 index 00000000..06f2c0ca --- /dev/null +++ b/csharp/src/ProtoBench/GoogleSize.cs @@ -0,0 +1,4569 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: google_size.proto +#pragma warning disable 1591, 0612, 3021 +#region Designer generated code + +using pb = global::Google.ProtocolBuffers; +using pbc = global::Google.ProtocolBuffers.Collections; +using pbd = global::Google.ProtocolBuffers.Descriptors; +using scg = global::System.Collections.Generic; +namespace Google.ProtocolBuffers.TestProtos { + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public static partial class GoogleSize { + + #region Extension registration + public static void RegisterAllExtensions(pb::ExtensionRegistry registry) { + } + #endregion + #region Static variables + internal static pbd::MessageDescriptor internal__static_benchmarks_SizeMessage1__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_benchmarks_SizeMessage1__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_benchmarks_SizeMessage1SubMessage__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_benchmarks_SizeMessage1SubMessage__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_benchmarks_SizeMessage2__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_benchmarks_SizeMessage2__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_benchmarks_SizeMessage2_Group1__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_benchmarks_SizeMessage2_Group1__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_benchmarks_SizeMessage2GroupedMessage__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_benchmarks_SizeMessage2GroupedMessage__FieldAccessorTable; + #endregion + #region Descriptor + public static pbd::FileDescriptor Descriptor { + get { return descriptor; } + } + private static pbd::FileDescriptor descriptor; + + static GoogleSize() { + byte[] descriptorData = global::System.Convert.FromBase64String( + string.Concat( + "ChFnb29nbGVfc2l6ZS5wcm90bxIKYmVuY2htYXJrcyL2BgoMU2l6ZU1lc3Nh", + "Z2UxEg4KBmZpZWxkMRgBIAIoCRIOCgZmaWVsZDkYCSABKAkSDwoHZmllbGQx", + "OBgSIAEoCRIWCgdmaWVsZDgwGFAgASgIOgVmYWxzZRIVCgdmaWVsZDgxGFEg", + "ASgIOgR0cnVlEg4KBmZpZWxkMhgCIAIoBRIOCgZmaWVsZDMYAyACKAUSEQoI", + "ZmllbGQyODAYmAIgASgFEhEKBmZpZWxkNhgGIAEoBToBMBIPCgdmaWVsZDIy", + "GBYgASgDEg4KBmZpZWxkNBgEIAEoCRIOCgZmaWVsZDUYBSADKAYSFgoHZmll", + "bGQ1ORg7IAEoCDoFZmFsc2USDgoGZmllbGQ3GAcgASgJEg8KB2ZpZWxkMTYY", + "ECABKAUSFAoIZmllbGQxMzAYggEgASgFOgEwEhUKB2ZpZWxkMTIYDCABKAg6", + "BHRydWUSFQoHZmllbGQxNxgRIAEoCDoEdHJ1ZRIVCgdmaWVsZDEzGA0gASgI", + "OgR0cnVlEhUKB2ZpZWxkMTQYDiABKAg6BHRydWUSEwoIZmllbGQxMDQYaCAB", + "KAU6ATASEwoIZmllbGQxMDAYZCABKAU6ATASEwoIZmllbGQxMDEYZSABKAU6", + "ATASEAoIZmllbGQxMDIYZiABKAkSEAoIZmllbGQxMDMYZyABKAkSEgoHZmll", + "bGQyORgdIAEoBToBMBIWCgdmaWVsZDMwGB4gASgIOgVmYWxzZRITCgdmaWVs", + "ZDYwGDwgASgFOgItMRIVCghmaWVsZDI3MRiPAiABKAU6Ai0xEhUKCGZpZWxk", + "MjcyGJACIAEoBToCLTESEQoIZmllbGQxNTAYlgEgASgFEhIKB2ZpZWxkMjMY", + "FyABKAU6ATASFgoHZmllbGQyNBgYIAEoCDoFZmFsc2USEgoHZmllbGQyNRgZ", + "IAEoBToBMBIzCgdmaWVsZDE1GA8gASgLMiIuYmVuY2htYXJrcy5TaXplTWVz", + "c2FnZTFTdWJNZXNzYWdlEg8KB2ZpZWxkNzgYTiABKAgSEgoHZmllbGQ2NxhD", + "IAEoBToBMBIPCgdmaWVsZDY4GEQgASgFEhQKCGZpZWxkMTI4GIABIAEoBToB", + "MBIoCghmaWVsZDEyORiBASABKAk6FXh4eHh4eHh4eHh4eHh4eHh4eHh4eBIU", + "CghmaWVsZDEzMRiDASABKAU6ATAioQMKFlNpemVNZXNzYWdlMVN1Yk1lc3Nh", + "Z2USEQoGZmllbGQxGAEgASgFOgEwEhEKBmZpZWxkMhgCIAEoBToBMBIRCgZm", + "aWVsZDMYAyABKAU6ATASDwoHZmllbGQxNRgPIAEoCRIVCgdmaWVsZDEyGAwg", + "ASgIOgR0cnVlEg8KB2ZpZWxkMTMYDSABKAMSDwoHZmllbGQxNBgOIAEoAxIP", + "CgdmaWVsZDE2GBAgASgFEhIKB2ZpZWxkMTkYEyABKAU6ATISFQoHZmllbGQy", + "MBgUIAEoCDoEdHJ1ZRIVCgdmaWVsZDI4GBwgASgIOgR0cnVlEg8KB2ZpZWxk", + "MjEYFSABKAYSDwoHZmllbGQyMhgWIAEoBRIWCgdmaWVsZDIzGBcgASgIOgVm", + "YWxzZRIYCghmaWVsZDIwNhjOASABKAg6BWZhbHNlEhEKCGZpZWxkMjAzGMsB", + "IAEoBxIRCghmaWVsZDIwNBjMASABKAUSEQoIZmllbGQyMDUYzQEgASgJEhEK", + "CGZpZWxkMjA3GM8BIAEoBBIRCghmaWVsZDMwMBisAiABKAQixwcKDFNpemVN", + "ZXNzYWdlMhIOCgZmaWVsZDEYASABKAkSDgoGZmllbGQzGAMgASgDEg4KBmZp", + "ZWxkNBgEIAEoAxIPCgdmaWVsZDMwGB4gASgDEhYKB2ZpZWxkNzUYSyABKAg6", + "BWZhbHNlEg4KBmZpZWxkNhgGIAEoCRIOCgZmaWVsZDIYAiABKAwSEgoHZmll", + "bGQyMRgVIAEoBToBMBIPCgdmaWVsZDcxGEcgASgFEg8KB2ZpZWxkMjUYGSAB", + "KAISEwoIZmllbGQxMDkYbSABKAU6ATASFAoIZmllbGQyMTAY0gEgASgFOgEw", + "EhQKCGZpZWxkMjExGNMBIAEoBToBMBIUCghmaWVsZDIxMhjUASABKAU6ATAS", + "FAoIZmllbGQyMTMY1QEgASgFOgEwEhQKCGZpZWxkMjE2GNgBIAEoBToBMBIU", + "CghmaWVsZDIxNxjZASABKAU6ATASFAoIZmllbGQyMTgY2gEgASgFOgEwEhQK", + "CGZpZWxkMjIwGNwBIAEoBToBMBIUCghmaWVsZDIyMRjdASABKAU6ATASFAoI", + "ZmllbGQyMjIY3gEgASgCOgEwEg8KB2ZpZWxkNjMYPyABKAUSLwoGZ3JvdXAx", + "GAogAygKMh8uYmVuY2htYXJrcy5TaXplTWVzc2FnZTIuR3JvdXAxEhEKCGZp", + "ZWxkMTI4GIABIAMoCRIRCghmaWVsZDEzMRiDASABKAMSEAoIZmllbGQxMjcY", + "fyADKAkSEQoIZmllbGQxMjkYgQEgASgFEhEKCGZpZWxkMTMwGIIBIAMoAxIY", + "CghmaWVsZDIwNRjNASABKAg6BWZhbHNlEhgKCGZpZWxkMjA2GM4BIAEoCDoF", + "ZmFsc2UawgIKBkdyb3VwMRIPCgdmaWVsZDExGAsgAigCEg8KB2ZpZWxkMjYY", + "GiABKAISDwoHZmllbGQxMhgMIAEoCRIPCgdmaWVsZDEzGA0gASgJEg8KB2Zp", + "ZWxkMTQYDiADKAkSDwoHZmllbGQxNRgPIAIoBBIOCgZmaWVsZDUYBSABKAUS", + "DwoHZmllbGQyNxgbIAEoCRIPCgdmaWVsZDI4GBwgASgFEg8KB2ZpZWxkMjkY", + "HSABKAkSDwoHZmllbGQxNhgQIAEoCRIPCgdmaWVsZDIyGBYgAygJEg8KB2Zp", + "ZWxkNzMYSSADKAUSEgoHZmllbGQyMBgUIAEoBToBMBIPCgdmaWVsZDI0GBgg", + "ASgJEjcKB2ZpZWxkMzEYHyABKAsyJi5iZW5jaG1hcmtzLlNpemVNZXNzYWdl", + "Mkdyb3VwZWRNZXNzYWdlIt4BChpTaXplTWVzc2FnZTJHcm91cGVkTWVzc2Fn", + "ZRIOCgZmaWVsZDEYASABKAISDgoGZmllbGQyGAIgASgCEhEKBmZpZWxkMxgD", + "IAEoAjoBMBIOCgZmaWVsZDQYBCABKAgSDgoGZmllbGQ1GAUgASgIEhQKBmZp", + "ZWxkNhgGIAEoCDoEdHJ1ZRIVCgZmaWVsZDcYByABKAg6BWZhbHNlEg4KBmZp", + "ZWxkOBgIIAEoAhIOCgZmaWVsZDkYCSABKAgSDwoHZmllbGQxMBgKIAEoAhIP", + "CgdmaWVsZDExGAsgASgDQjJCCkdvb2dsZVNpemVIAqoCIUdvb2dsZS5Qcm90", + "b2NvbEJ1ZmZlcnMuVGVzdFByb3Rvcw==")); + pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) { + descriptor = root; + internal__static_benchmarks_SizeMessage1__Descriptor = Descriptor.MessageTypes[0]; + internal__static_benchmarks_SizeMessage1__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_benchmarks_SizeMessage1__Descriptor, + new string[] { "Field1", "Field9", "Field18", "Field80", "Field81", "Field2", "Field3", "Field280", "Field6", "Field22", "Field4", "Field5", "Field59", "Field7", "Field16", "Field130", "Field12", "Field17", "Field13", "Field14", "Field104", "Field100", "Field101", "Field102", "Field103", "Field29", "Field30", "Field60", "Field271", "Field272", "Field150", "Field23", "Field24", "Field25", "Field15", "Field78", "Field67", "Field68", "Field128", "Field129", "Field131", }); + internal__static_benchmarks_SizeMessage1SubMessage__Descriptor = Descriptor.MessageTypes[1]; + internal__static_benchmarks_SizeMessage1SubMessage__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_benchmarks_SizeMessage1SubMessage__Descriptor, + new string[] { "Field1", "Field2", "Field3", "Field15", "Field12", "Field13", "Field14", "Field16", "Field19", "Field20", "Field28", "Field21", "Field22", "Field23", "Field206", "Field203", "Field204", "Field205", "Field207", "Field300", }); + internal__static_benchmarks_SizeMessage2__Descriptor = Descriptor.MessageTypes[2]; + internal__static_benchmarks_SizeMessage2__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_benchmarks_SizeMessage2__Descriptor, + new string[] { "Field1", "Field3", "Field4", "Field30", "Field75", "Field6", "Field2", "Field21", "Field71", "Field25", "Field109", "Field210", "Field211", "Field212", "Field213", "Field216", "Field217", "Field218", "Field220", "Field221", "Field222", "Field63", "Group1", "Field128", "Field131", "Field127", "Field129", "Field130", "Field205", "Field206", }); + internal__static_benchmarks_SizeMessage2_Group1__Descriptor = internal__static_benchmarks_SizeMessage2__Descriptor.NestedTypes[0]; + internal__static_benchmarks_SizeMessage2_Group1__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_benchmarks_SizeMessage2_Group1__Descriptor, + new string[] { "Field11", "Field26", "Field12", "Field13", "Field14", "Field15", "Field5", "Field27", "Field28", "Field29", "Field16", "Field22", "Field73", "Field20", "Field24", "Field31", }); + internal__static_benchmarks_SizeMessage2GroupedMessage__Descriptor = Descriptor.MessageTypes[3]; + internal__static_benchmarks_SizeMessage2GroupedMessage__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_benchmarks_SizeMessage2GroupedMessage__Descriptor, + new string[] { "Field1", "Field2", "Field3", "Field4", "Field5", "Field6", "Field7", "Field8", "Field9", "Field10", "Field11", }); + pb::ExtensionRegistry registry = pb::ExtensionRegistry.CreateInstance(); + RegisterAllExtensions(registry); + return registry; + }; + pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData, + new pbd::FileDescriptor[] { + }, assigner); + } + #endregion + + } + #region Messages + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class SizeMessage1 : pb::GeneratedMessage { + private SizeMessage1() { } + private static readonly SizeMessage1 defaultInstance = new SizeMessage1().MakeReadOnly(); + public static SizeMessage1 DefaultInstance { + get { return defaultInstance; } + } + + public override SizeMessage1 DefaultInstanceForType { + get { return DefaultInstance; } + } + + protected override SizeMessage1 ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.GoogleSize.internal__static_benchmarks_SizeMessage1__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.GoogleSize.internal__static_benchmarks_SizeMessage1__FieldAccessorTable; } + } + + public const int Field1FieldNumber = 1; + private bool hasField1; + private string field1_ = ""; + public bool HasField1 { + get { return hasField1; } + } + public string Field1 { + get { return field1_; } + } + + public const int Field9FieldNumber = 9; + private bool hasField9; + private string field9_ = ""; + public bool HasField9 { + get { return hasField9; } + } + public string Field9 { + get { return field9_; } + } + + public const int Field18FieldNumber = 18; + private bool hasField18; + private string field18_ = ""; + public bool HasField18 { + get { return hasField18; } + } + public string Field18 { + get { return field18_; } + } + + public const int Field80FieldNumber = 80; + private bool hasField80; + private bool field80_; + public bool HasField80 { + get { return hasField80; } + } + public bool Field80 { + get { return field80_; } + } + + public const int Field81FieldNumber = 81; + private bool hasField81; + private bool field81_ = true; + public bool HasField81 { + get { return hasField81; } + } + public bool Field81 { + get { return field81_; } + } + + public const int Field2FieldNumber = 2; + private bool hasField2; + private int field2_; + public bool HasField2 { + get { return hasField2; } + } + public int Field2 { + get { return field2_; } + } + + public const int Field3FieldNumber = 3; + private bool hasField3; + private int field3_; + public bool HasField3 { + get { return hasField3; } + } + public int Field3 { + get { return field3_; } + } + + public const int Field280FieldNumber = 280; + private bool hasField280; + private int field280_; + public bool HasField280 { + get { return hasField280; } + } + public int Field280 { + get { return field280_; } + } + + public const int Field6FieldNumber = 6; + private bool hasField6; + private int field6_; + public bool HasField6 { + get { return hasField6; } + } + public int Field6 { + get { return field6_; } + } + + public const int Field22FieldNumber = 22; + private bool hasField22; + private long field22_; + public bool HasField22 { + get { return hasField22; } + } + public long Field22 { + get { return field22_; } + } + + public const int Field4FieldNumber = 4; + private bool hasField4; + private string field4_ = ""; + public bool HasField4 { + get { return hasField4; } + } + public string Field4 { + get { return field4_; } + } + + public const int Field5FieldNumber = 5; + private pbc::PopsicleList field5_ = new pbc::PopsicleList(); + [global::System.CLSCompliant(false)] + public scg::IList Field5List { + get { return pbc::Lists.AsReadOnly(field5_); } + } + public int Field5Count { + get { return field5_.Count; } + } + [global::System.CLSCompliant(false)] + public ulong GetField5(int index) { + return field5_[index]; + } + + public const int Field59FieldNumber = 59; + private bool hasField59; + private bool field59_; + public bool HasField59 { + get { return hasField59; } + } + public bool Field59 { + get { return field59_; } + } + + public const int Field7FieldNumber = 7; + private bool hasField7; + private string field7_ = ""; + public bool HasField7 { + get { return hasField7; } + } + public string Field7 { + get { return field7_; } + } + + public const int Field16FieldNumber = 16; + private bool hasField16; + private int field16_; + public bool HasField16 { + get { return hasField16; } + } + public int Field16 { + get { return field16_; } + } + + public const int Field130FieldNumber = 130; + private bool hasField130; + private int field130_; + public bool HasField130 { + get { return hasField130; } + } + public int Field130 { + get { return field130_; } + } + + public const int Field12FieldNumber = 12; + private bool hasField12; + private bool field12_ = true; + public bool HasField12 { + get { return hasField12; } + } + public bool Field12 { + get { return field12_; } + } + + public const int Field17FieldNumber = 17; + private bool hasField17; + private bool field17_ = true; + public bool HasField17 { + get { return hasField17; } + } + public bool Field17 { + get { return field17_; } + } + + public const int Field13FieldNumber = 13; + private bool hasField13; + private bool field13_ = true; + public bool HasField13 { + get { return hasField13; } + } + public bool Field13 { + get { return field13_; } + } + + public const int Field14FieldNumber = 14; + private bool hasField14; + private bool field14_ = true; + public bool HasField14 { + get { return hasField14; } + } + public bool Field14 { + get { return field14_; } + } + + public const int Field104FieldNumber = 104; + private bool hasField104; + private int field104_; + public bool HasField104 { + get { return hasField104; } + } + public int Field104 { + get { return field104_; } + } + + public const int Field100FieldNumber = 100; + private bool hasField100; + private int field100_; + public bool HasField100 { + get { return hasField100; } + } + public int Field100 { + get { return field100_; } + } + + public const int Field101FieldNumber = 101; + private bool hasField101; + private int field101_; + public bool HasField101 { + get { return hasField101; } + } + public int Field101 { + get { return field101_; } + } + + public const int Field102FieldNumber = 102; + private bool hasField102; + private string field102_ = ""; + public bool HasField102 { + get { return hasField102; } + } + public string Field102 { + get { return field102_; } + } + + public const int Field103FieldNumber = 103; + private bool hasField103; + private string field103_ = ""; + public bool HasField103 { + get { return hasField103; } + } + public string Field103 { + get { return field103_; } + } + + public const int Field29FieldNumber = 29; + private bool hasField29; + private int field29_; + public bool HasField29 { + get { return hasField29; } + } + public int Field29 { + get { return field29_; } + } + + public const int Field30FieldNumber = 30; + private bool hasField30; + private bool field30_; + public bool HasField30 { + get { return hasField30; } + } + public bool Field30 { + get { return field30_; } + } + + public const int Field60FieldNumber = 60; + private bool hasField60; + private int field60_ = -1; + public bool HasField60 { + get { return hasField60; } + } + public int Field60 { + get { return field60_; } + } + + public const int Field271FieldNumber = 271; + private bool hasField271; + private int field271_ = -1; + public bool HasField271 { + get { return hasField271; } + } + public int Field271 { + get { return field271_; } + } + + public const int Field272FieldNumber = 272; + private bool hasField272; + private int field272_ = -1; + public bool HasField272 { + get { return hasField272; } + } + public int Field272 { + get { return field272_; } + } + + public const int Field150FieldNumber = 150; + private bool hasField150; + private int field150_; + public bool HasField150 { + get { return hasField150; } + } + public int Field150 { + get { return field150_; } + } + + public const int Field23FieldNumber = 23; + private bool hasField23; + private int field23_; + public bool HasField23 { + get { return hasField23; } + } + public int Field23 { + get { return field23_; } + } + + public const int Field24FieldNumber = 24; + private bool hasField24; + private bool field24_; + public bool HasField24 { + get { return hasField24; } + } + public bool Field24 { + get { return field24_; } + } + + public const int Field25FieldNumber = 25; + private bool hasField25; + private int field25_; + public bool HasField25 { + get { return hasField25; } + } + public int Field25 { + get { return field25_; } + } + + public const int Field15FieldNumber = 15; + private bool hasField15; + private global::Google.ProtocolBuffers.TestProtos.SizeMessage1SubMessage field15_; + public bool HasField15 { + get { return hasField15; } + } + public global::Google.ProtocolBuffers.TestProtos.SizeMessage1SubMessage Field15 { + get { return field15_ ?? global::Google.ProtocolBuffers.TestProtos.SizeMessage1SubMessage.DefaultInstance; } + } + + public const int Field78FieldNumber = 78; + private bool hasField78; + private bool field78_; + public bool HasField78 { + get { return hasField78; } + } + public bool Field78 { + get { return field78_; } + } + + public const int Field67FieldNumber = 67; + private bool hasField67; + private int field67_; + public bool HasField67 { + get { return hasField67; } + } + public int Field67 { + get { return field67_; } + } + + public const int Field68FieldNumber = 68; + private bool hasField68; + private int field68_; + public bool HasField68 { + get { return hasField68; } + } + public int Field68 { + get { return field68_; } + } + + public const int Field128FieldNumber = 128; + private bool hasField128; + private int field128_; + public bool HasField128 { + get { return hasField128; } + } + public int Field128 { + get { return field128_; } + } + + public const int Field129FieldNumber = 129; + private bool hasField129; + private string field129_ = "xxxxxxxxxxxxxxxxxxxxx"; + public bool HasField129 { + get { return hasField129; } + } + public string Field129 { + get { return field129_; } + } + + public const int Field131FieldNumber = 131; + private bool hasField131; + private int field131_; + public bool HasField131 { + get { return hasField131; } + } + public int Field131 { + get { return field131_; } + } + + public static SizeMessage1 ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static SizeMessage1 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static SizeMessage1 ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static SizeMessage1 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static SizeMessage1 ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static SizeMessage1 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static SizeMessage1 ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static SizeMessage1 ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static SizeMessage1 ParseFrom(pb::ICodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static SizeMessage1 ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + private SizeMessage1 MakeReadOnly() { + field5_.MakeReadOnly(); + return this; + } + + public static Builder CreateBuilder() { return new Builder(); } + public override Builder ToBuilder() { return CreateBuilder(this); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(SizeMessage1 prototype) { + return new Builder(prototype); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() { + result = DefaultInstance; + resultIsReadOnly = true; + } + internal Builder(SizeMessage1 cloneFrom) { + result = cloneFrom; + resultIsReadOnly = true; + } + + private bool resultIsReadOnly; + private SizeMessage1 result; + + private SizeMessage1 PrepareBuilder() { + if (resultIsReadOnly) { + SizeMessage1 original = result; + result = new SizeMessage1(); + resultIsReadOnly = false; + MergeFrom(original); + } + return result; + } + + public override bool IsInitialized { + get { return result.IsInitialized; } + } + + protected override SizeMessage1 MessageBeingBuilt { + get { return PrepareBuilder(); } + } + + public override Builder Clear() { + result = DefaultInstance; + resultIsReadOnly = true; + return this; + } + + public override Builder Clone() { + if (resultIsReadOnly) { + return new Builder(result); + } else { + return new Builder().MergeFrom(result); + } + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Google.ProtocolBuffers.TestProtos.SizeMessage1.Descriptor; } + } + + public override SizeMessage1 DefaultInstanceForType { + get { return global::Google.ProtocolBuffers.TestProtos.SizeMessage1.DefaultInstance; } + } + + public override SizeMessage1 BuildPartial() { + if (resultIsReadOnly) { + return result; + } + resultIsReadOnly = true; + return result.MakeReadOnly(); + } + + + public bool HasField1 { + get { return result.hasField1; } + } + public string Field1 { + get { return result.Field1; } + set { SetField1(value); } + } + public Builder SetField1(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField1 = true; + result.field1_ = value; + return this; + } + public Builder ClearField1() { + PrepareBuilder(); + result.hasField1 = false; + result.field1_ = ""; + return this; + } + + public bool HasField9 { + get { return result.hasField9; } + } + public string Field9 { + get { return result.Field9; } + set { SetField9(value); } + } + public Builder SetField9(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField9 = true; + result.field9_ = value; + return this; + } + public Builder ClearField9() { + PrepareBuilder(); + result.hasField9 = false; + result.field9_ = ""; + return this; + } + + public bool HasField18 { + get { return result.hasField18; } + } + public string Field18 { + get { return result.Field18; } + set { SetField18(value); } + } + public Builder SetField18(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField18 = true; + result.field18_ = value; + return this; + } + public Builder ClearField18() { + PrepareBuilder(); + result.hasField18 = false; + result.field18_ = ""; + return this; + } + + public bool HasField80 { + get { return result.hasField80; } + } + public bool Field80 { + get { return result.Field80; } + set { SetField80(value); } + } + public Builder SetField80(bool value) { + PrepareBuilder(); + result.hasField80 = true; + result.field80_ = value; + return this; + } + public Builder ClearField80() { + PrepareBuilder(); + result.hasField80 = false; + result.field80_ = false; + return this; + } + + public bool HasField81 { + get { return result.hasField81; } + } + public bool Field81 { + get { return result.Field81; } + set { SetField81(value); } + } + public Builder SetField81(bool value) { + PrepareBuilder(); + result.hasField81 = true; + result.field81_ = value; + return this; + } + public Builder ClearField81() { + PrepareBuilder(); + result.hasField81 = false; + result.field81_ = true; + return this; + } + + public bool HasField2 { + get { return result.hasField2; } + } + public int Field2 { + get { return result.Field2; } + set { SetField2(value); } + } + public Builder SetField2(int value) { + PrepareBuilder(); + result.hasField2 = true; + result.field2_ = value; + return this; + } + public Builder ClearField2() { + PrepareBuilder(); + result.hasField2 = false; + result.field2_ = 0; + return this; + } + + public bool HasField3 { + get { return result.hasField3; } + } + public int Field3 { + get { return result.Field3; } + set { SetField3(value); } + } + public Builder SetField3(int value) { + PrepareBuilder(); + result.hasField3 = true; + result.field3_ = value; + return this; + } + public Builder ClearField3() { + PrepareBuilder(); + result.hasField3 = false; + result.field3_ = 0; + return this; + } + + public bool HasField280 { + get { return result.hasField280; } + } + public int Field280 { + get { return result.Field280; } + set { SetField280(value); } + } + public Builder SetField280(int value) { + PrepareBuilder(); + result.hasField280 = true; + result.field280_ = value; + return this; + } + public Builder ClearField280() { + PrepareBuilder(); + result.hasField280 = false; + result.field280_ = 0; + return this; + } + + public bool HasField6 { + get { return result.hasField6; } + } + public int Field6 { + get { return result.Field6; } + set { SetField6(value); } + } + public Builder SetField6(int value) { + PrepareBuilder(); + result.hasField6 = true; + result.field6_ = value; + return this; + } + public Builder ClearField6() { + PrepareBuilder(); + result.hasField6 = false; + result.field6_ = 0; + return this; + } + + public bool HasField22 { + get { return result.hasField22; } + } + public long Field22 { + get { return result.Field22; } + set { SetField22(value); } + } + public Builder SetField22(long value) { + PrepareBuilder(); + result.hasField22 = true; + result.field22_ = value; + return this; + } + public Builder ClearField22() { + PrepareBuilder(); + result.hasField22 = false; + result.field22_ = 0L; + return this; + } + + public bool HasField4 { + get { return result.hasField4; } + } + public string Field4 { + get { return result.Field4; } + set { SetField4(value); } + } + public Builder SetField4(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField4 = true; + result.field4_ = value; + return this; + } + public Builder ClearField4() { + PrepareBuilder(); + result.hasField4 = false; + result.field4_ = ""; + return this; + } + + [global::System.CLSCompliant(false)] + public pbc::IPopsicleList Field5List { + get { return PrepareBuilder().field5_; } + } + public int Field5Count { + get { return result.Field5Count; } + } + [global::System.CLSCompliant(false)] + public ulong GetField5(int index) { + return result.GetField5(index); + } + [global::System.CLSCompliant(false)] + public Builder SetField5(int index, ulong value) { + PrepareBuilder(); + result.field5_[index] = value; + return this; + } + [global::System.CLSCompliant(false)] + public Builder AddField5(ulong value) { + PrepareBuilder(); + result.field5_.Add(value); + return this; + } + [global::System.CLSCompliant(false)] + public Builder AddRangeField5(scg::IEnumerable values) { + PrepareBuilder(); + result.field5_.Add(values); + return this; + } + public Builder ClearField5() { + PrepareBuilder(); + result.field5_.Clear(); + return this; + } + + public bool HasField59 { + get { return result.hasField59; } + } + public bool Field59 { + get { return result.Field59; } + set { SetField59(value); } + } + public Builder SetField59(bool value) { + PrepareBuilder(); + result.hasField59 = true; + result.field59_ = value; + return this; + } + public Builder ClearField59() { + PrepareBuilder(); + result.hasField59 = false; + result.field59_ = false; + return this; + } + + public bool HasField7 { + get { return result.hasField7; } + } + public string Field7 { + get { return result.Field7; } + set { SetField7(value); } + } + public Builder SetField7(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField7 = true; + result.field7_ = value; + return this; + } + public Builder ClearField7() { + PrepareBuilder(); + result.hasField7 = false; + result.field7_ = ""; + return this; + } + + public bool HasField16 { + get { return result.hasField16; } + } + public int Field16 { + get { return result.Field16; } + set { SetField16(value); } + } + public Builder SetField16(int value) { + PrepareBuilder(); + result.hasField16 = true; + result.field16_ = value; + return this; + } + public Builder ClearField16() { + PrepareBuilder(); + result.hasField16 = false; + result.field16_ = 0; + return this; + } + + public bool HasField130 { + get { return result.hasField130; } + } + public int Field130 { + get { return result.Field130; } + set { SetField130(value); } + } + public Builder SetField130(int value) { + PrepareBuilder(); + result.hasField130 = true; + result.field130_ = value; + return this; + } + public Builder ClearField130() { + PrepareBuilder(); + result.hasField130 = false; + result.field130_ = 0; + return this; + } + + public bool HasField12 { + get { return result.hasField12; } + } + public bool Field12 { + get { return result.Field12; } + set { SetField12(value); } + } + public Builder SetField12(bool value) { + PrepareBuilder(); + result.hasField12 = true; + result.field12_ = value; + return this; + } + public Builder ClearField12() { + PrepareBuilder(); + result.hasField12 = false; + result.field12_ = true; + return this; + } + + public bool HasField17 { + get { return result.hasField17; } + } + public bool Field17 { + get { return result.Field17; } + set { SetField17(value); } + } + public Builder SetField17(bool value) { + PrepareBuilder(); + result.hasField17 = true; + result.field17_ = value; + return this; + } + public Builder ClearField17() { + PrepareBuilder(); + result.hasField17 = false; + result.field17_ = true; + return this; + } + + public bool HasField13 { + get { return result.hasField13; } + } + public bool Field13 { + get { return result.Field13; } + set { SetField13(value); } + } + public Builder SetField13(bool value) { + PrepareBuilder(); + result.hasField13 = true; + result.field13_ = value; + return this; + } + public Builder ClearField13() { + PrepareBuilder(); + result.hasField13 = false; + result.field13_ = true; + return this; + } + + public bool HasField14 { + get { return result.hasField14; } + } + public bool Field14 { + get { return result.Field14; } + set { SetField14(value); } + } + public Builder SetField14(bool value) { + PrepareBuilder(); + result.hasField14 = true; + result.field14_ = value; + return this; + } + public Builder ClearField14() { + PrepareBuilder(); + result.hasField14 = false; + result.field14_ = true; + return this; + } + + public bool HasField104 { + get { return result.hasField104; } + } + public int Field104 { + get { return result.Field104; } + set { SetField104(value); } + } + public Builder SetField104(int value) { + PrepareBuilder(); + result.hasField104 = true; + result.field104_ = value; + return this; + } + public Builder ClearField104() { + PrepareBuilder(); + result.hasField104 = false; + result.field104_ = 0; + return this; + } + + public bool HasField100 { + get { return result.hasField100; } + } + public int Field100 { + get { return result.Field100; } + set { SetField100(value); } + } + public Builder SetField100(int value) { + PrepareBuilder(); + result.hasField100 = true; + result.field100_ = value; + return this; + } + public Builder ClearField100() { + PrepareBuilder(); + result.hasField100 = false; + result.field100_ = 0; + return this; + } + + public bool HasField101 { + get { return result.hasField101; } + } + public int Field101 { + get { return result.Field101; } + set { SetField101(value); } + } + public Builder SetField101(int value) { + PrepareBuilder(); + result.hasField101 = true; + result.field101_ = value; + return this; + } + public Builder ClearField101() { + PrepareBuilder(); + result.hasField101 = false; + result.field101_ = 0; + return this; + } + + public bool HasField102 { + get { return result.hasField102; } + } + public string Field102 { + get { return result.Field102; } + set { SetField102(value); } + } + public Builder SetField102(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField102 = true; + result.field102_ = value; + return this; + } + public Builder ClearField102() { + PrepareBuilder(); + result.hasField102 = false; + result.field102_ = ""; + return this; + } + + public bool HasField103 { + get { return result.hasField103; } + } + public string Field103 { + get { return result.Field103; } + set { SetField103(value); } + } + public Builder SetField103(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField103 = true; + result.field103_ = value; + return this; + } + public Builder ClearField103() { + PrepareBuilder(); + result.hasField103 = false; + result.field103_ = ""; + return this; + } + + public bool HasField29 { + get { return result.hasField29; } + } + public int Field29 { + get { return result.Field29; } + set { SetField29(value); } + } + public Builder SetField29(int value) { + PrepareBuilder(); + result.hasField29 = true; + result.field29_ = value; + return this; + } + public Builder ClearField29() { + PrepareBuilder(); + result.hasField29 = false; + result.field29_ = 0; + return this; + } + + public bool HasField30 { + get { return result.hasField30; } + } + public bool Field30 { + get { return result.Field30; } + set { SetField30(value); } + } + public Builder SetField30(bool value) { + PrepareBuilder(); + result.hasField30 = true; + result.field30_ = value; + return this; + } + public Builder ClearField30() { + PrepareBuilder(); + result.hasField30 = false; + result.field30_ = false; + return this; + } + + public bool HasField60 { + get { return result.hasField60; } + } + public int Field60 { + get { return result.Field60; } + set { SetField60(value); } + } + public Builder SetField60(int value) { + PrepareBuilder(); + result.hasField60 = true; + result.field60_ = value; + return this; + } + public Builder ClearField60() { + PrepareBuilder(); + result.hasField60 = false; + result.field60_ = -1; + return this; + } + + public bool HasField271 { + get { return result.hasField271; } + } + public int Field271 { + get { return result.Field271; } + set { SetField271(value); } + } + public Builder SetField271(int value) { + PrepareBuilder(); + result.hasField271 = true; + result.field271_ = value; + return this; + } + public Builder ClearField271() { + PrepareBuilder(); + result.hasField271 = false; + result.field271_ = -1; + return this; + } + + public bool HasField272 { + get { return result.hasField272; } + } + public int Field272 { + get { return result.Field272; } + set { SetField272(value); } + } + public Builder SetField272(int value) { + PrepareBuilder(); + result.hasField272 = true; + result.field272_ = value; + return this; + } + public Builder ClearField272() { + PrepareBuilder(); + result.hasField272 = false; + result.field272_ = -1; + return this; + } + + public bool HasField150 { + get { return result.hasField150; } + } + public int Field150 { + get { return result.Field150; } + set { SetField150(value); } + } + public Builder SetField150(int value) { + PrepareBuilder(); + result.hasField150 = true; + result.field150_ = value; + return this; + } + public Builder ClearField150() { + PrepareBuilder(); + result.hasField150 = false; + result.field150_ = 0; + return this; + } + + public bool HasField23 { + get { return result.hasField23; } + } + public int Field23 { + get { return result.Field23; } + set { SetField23(value); } + } + public Builder SetField23(int value) { + PrepareBuilder(); + result.hasField23 = true; + result.field23_ = value; + return this; + } + public Builder ClearField23() { + PrepareBuilder(); + result.hasField23 = false; + result.field23_ = 0; + return this; + } + + public bool HasField24 { + get { return result.hasField24; } + } + public bool Field24 { + get { return result.Field24; } + set { SetField24(value); } + } + public Builder SetField24(bool value) { + PrepareBuilder(); + result.hasField24 = true; + result.field24_ = value; + return this; + } + public Builder ClearField24() { + PrepareBuilder(); + result.hasField24 = false; + result.field24_ = false; + return this; + } + + public bool HasField25 { + get { return result.hasField25; } + } + public int Field25 { + get { return result.Field25; } + set { SetField25(value); } + } + public Builder SetField25(int value) { + PrepareBuilder(); + result.hasField25 = true; + result.field25_ = value; + return this; + } + public Builder ClearField25() { + PrepareBuilder(); + result.hasField25 = false; + result.field25_ = 0; + return this; + } + + public bool HasField15 { + get { return result.hasField15; } + } + public global::Google.ProtocolBuffers.TestProtos.SizeMessage1SubMessage Field15 { + get { return result.Field15; } + set { SetField15(value); } + } + public Builder SetField15(global::Google.ProtocolBuffers.TestProtos.SizeMessage1SubMessage value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField15 = true; + result.field15_ = value; + return this; + } + public Builder SetField15(global::Google.ProtocolBuffers.TestProtos.SizeMessage1SubMessage.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + PrepareBuilder(); + result.hasField15 = true; + result.field15_ = builderForValue.Build(); + return this; + } + public Builder MergeField15(global::Google.ProtocolBuffers.TestProtos.SizeMessage1SubMessage value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + if (result.hasField15 && + result.field15_ != global::Google.ProtocolBuffers.TestProtos.SizeMessage1SubMessage.DefaultInstance) { + result.field15_ = global::Google.ProtocolBuffers.TestProtos.SizeMessage1SubMessage.CreateBuilder(result.field15_).MergeFrom(value).BuildPartial(); + } else { + result.field15_ = value; + } + result.hasField15 = true; + return this; + } + public Builder ClearField15() { + PrepareBuilder(); + result.hasField15 = false; + result.field15_ = null; + return this; + } + + public bool HasField78 { + get { return result.hasField78; } + } + public bool Field78 { + get { return result.Field78; } + set { SetField78(value); } + } + public Builder SetField78(bool value) { + PrepareBuilder(); + result.hasField78 = true; + result.field78_ = value; + return this; + } + public Builder ClearField78() { + PrepareBuilder(); + result.hasField78 = false; + result.field78_ = false; + return this; + } + + public bool HasField67 { + get { return result.hasField67; } + } + public int Field67 { + get { return result.Field67; } + set { SetField67(value); } + } + public Builder SetField67(int value) { + PrepareBuilder(); + result.hasField67 = true; + result.field67_ = value; + return this; + } + public Builder ClearField67() { + PrepareBuilder(); + result.hasField67 = false; + result.field67_ = 0; + return this; + } + + public bool HasField68 { + get { return result.hasField68; } + } + public int Field68 { + get { return result.Field68; } + set { SetField68(value); } + } + public Builder SetField68(int value) { + PrepareBuilder(); + result.hasField68 = true; + result.field68_ = value; + return this; + } + public Builder ClearField68() { + PrepareBuilder(); + result.hasField68 = false; + result.field68_ = 0; + return this; + } + + public bool HasField128 { + get { return result.hasField128; } + } + public int Field128 { + get { return result.Field128; } + set { SetField128(value); } + } + public Builder SetField128(int value) { + PrepareBuilder(); + result.hasField128 = true; + result.field128_ = value; + return this; + } + public Builder ClearField128() { + PrepareBuilder(); + result.hasField128 = false; + result.field128_ = 0; + return this; + } + + public bool HasField129 { + get { return result.hasField129; } + } + public string Field129 { + get { return result.Field129; } + set { SetField129(value); } + } + public Builder SetField129(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField129 = true; + result.field129_ = value; + return this; + } + public Builder ClearField129() { + PrepareBuilder(); + result.hasField129 = false; + result.field129_ = "xxxxxxxxxxxxxxxxxxxxx"; + return this; + } + + public bool HasField131 { + get { return result.hasField131; } + } + public int Field131 { + get { return result.Field131; } + set { SetField131(value); } + } + public Builder SetField131(int value) { + PrepareBuilder(); + result.hasField131 = true; + result.field131_ = value; + return this; + } + public Builder ClearField131() { + PrepareBuilder(); + result.hasField131 = false; + result.field131_ = 0; + return this; + } + } + static SizeMessage1() { + object.ReferenceEquals(global::Google.ProtocolBuffers.TestProtos.GoogleSize.Descriptor, null); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class SizeMessage1SubMessage : pb::GeneratedMessage { + private SizeMessage1SubMessage() { } + private static readonly SizeMessage1SubMessage defaultInstance = new SizeMessage1SubMessage().MakeReadOnly(); + public static SizeMessage1SubMessage DefaultInstance { + get { return defaultInstance; } + } + + public override SizeMessage1SubMessage DefaultInstanceForType { + get { return DefaultInstance; } + } + + protected override SizeMessage1SubMessage ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.GoogleSize.internal__static_benchmarks_SizeMessage1SubMessage__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.GoogleSize.internal__static_benchmarks_SizeMessage1SubMessage__FieldAccessorTable; } + } + + public const int Field1FieldNumber = 1; + private bool hasField1; + private int field1_; + public bool HasField1 { + get { return hasField1; } + } + public int Field1 { + get { return field1_; } + } + + public const int Field2FieldNumber = 2; + private bool hasField2; + private int field2_; + public bool HasField2 { + get { return hasField2; } + } + public int Field2 { + get { return field2_; } + } + + public const int Field3FieldNumber = 3; + private bool hasField3; + private int field3_; + public bool HasField3 { + get { return hasField3; } + } + public int Field3 { + get { return field3_; } + } + + public const int Field15FieldNumber = 15; + private bool hasField15; + private string field15_ = ""; + public bool HasField15 { + get { return hasField15; } + } + public string Field15 { + get { return field15_; } + } + + public const int Field12FieldNumber = 12; + private bool hasField12; + private bool field12_ = true; + public bool HasField12 { + get { return hasField12; } + } + public bool Field12 { + get { return field12_; } + } + + public const int Field13FieldNumber = 13; + private bool hasField13; + private long field13_; + public bool HasField13 { + get { return hasField13; } + } + public long Field13 { + get { return field13_; } + } + + public const int Field14FieldNumber = 14; + private bool hasField14; + private long field14_; + public bool HasField14 { + get { return hasField14; } + } + public long Field14 { + get { return field14_; } + } + + public const int Field16FieldNumber = 16; + private bool hasField16; + private int field16_; + public bool HasField16 { + get { return hasField16; } + } + public int Field16 { + get { return field16_; } + } + + public const int Field19FieldNumber = 19; + private bool hasField19; + private int field19_ = 2; + public bool HasField19 { + get { return hasField19; } + } + public int Field19 { + get { return field19_; } + } + + public const int Field20FieldNumber = 20; + private bool hasField20; + private bool field20_ = true; + public bool HasField20 { + get { return hasField20; } + } + public bool Field20 { + get { return field20_; } + } + + public const int Field28FieldNumber = 28; + private bool hasField28; + private bool field28_ = true; + public bool HasField28 { + get { return hasField28; } + } + public bool Field28 { + get { return field28_; } + } + + public const int Field21FieldNumber = 21; + private bool hasField21; + private ulong field21_; + public bool HasField21 { + get { return hasField21; } + } + [global::System.CLSCompliant(false)] + public ulong Field21 { + get { return field21_; } + } + + public const int Field22FieldNumber = 22; + private bool hasField22; + private int field22_; + public bool HasField22 { + get { return hasField22; } + } + public int Field22 { + get { return field22_; } + } + + public const int Field23FieldNumber = 23; + private bool hasField23; + private bool field23_; + public bool HasField23 { + get { return hasField23; } + } + public bool Field23 { + get { return field23_; } + } + + public const int Field206FieldNumber = 206; + private bool hasField206; + private bool field206_; + public bool HasField206 { + get { return hasField206; } + } + public bool Field206 { + get { return field206_; } + } + + public const int Field203FieldNumber = 203; + private bool hasField203; + private uint field203_; + public bool HasField203 { + get { return hasField203; } + } + [global::System.CLSCompliant(false)] + public uint Field203 { + get { return field203_; } + } + + public const int Field204FieldNumber = 204; + private bool hasField204; + private int field204_; + public bool HasField204 { + get { return hasField204; } + } + public int Field204 { + get { return field204_; } + } + + public const int Field205FieldNumber = 205; + private bool hasField205; + private string field205_ = ""; + public bool HasField205 { + get { return hasField205; } + } + public string Field205 { + get { return field205_; } + } + + public const int Field207FieldNumber = 207; + private bool hasField207; + private ulong field207_; + public bool HasField207 { + get { return hasField207; } + } + [global::System.CLSCompliant(false)] + public ulong Field207 { + get { return field207_; } + } + + public const int Field300FieldNumber = 300; + private bool hasField300; + private ulong field300_; + public bool HasField300 { + get { return hasField300; } + } + [global::System.CLSCompliant(false)] + public ulong Field300 { + get { return field300_; } + } + + public static SizeMessage1SubMessage ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static SizeMessage1SubMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static SizeMessage1SubMessage ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static SizeMessage1SubMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static SizeMessage1SubMessage ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static SizeMessage1SubMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static SizeMessage1SubMessage ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static SizeMessage1SubMessage ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static SizeMessage1SubMessage ParseFrom(pb::ICodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static SizeMessage1SubMessage ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + private SizeMessage1SubMessage MakeReadOnly() { + return this; + } + + public static Builder CreateBuilder() { return new Builder(); } + public override Builder ToBuilder() { return CreateBuilder(this); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(SizeMessage1SubMessage prototype) { + return new Builder(prototype); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() { + result = DefaultInstance; + resultIsReadOnly = true; + } + internal Builder(SizeMessage1SubMessage cloneFrom) { + result = cloneFrom; + resultIsReadOnly = true; + } + + private bool resultIsReadOnly; + private SizeMessage1SubMessage result; + + private SizeMessage1SubMessage PrepareBuilder() { + if (resultIsReadOnly) { + SizeMessage1SubMessage original = result; + result = new SizeMessage1SubMessage(); + resultIsReadOnly = false; + MergeFrom(original); + } + return result; + } + + public override bool IsInitialized { + get { return result.IsInitialized; } + } + + protected override SizeMessage1SubMessage MessageBeingBuilt { + get { return PrepareBuilder(); } + } + + public override Builder Clear() { + result = DefaultInstance; + resultIsReadOnly = true; + return this; + } + + public override Builder Clone() { + if (resultIsReadOnly) { + return new Builder(result); + } else { + return new Builder().MergeFrom(result); + } + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Google.ProtocolBuffers.TestProtos.SizeMessage1SubMessage.Descriptor; } + } + + public override SizeMessage1SubMessage DefaultInstanceForType { + get { return global::Google.ProtocolBuffers.TestProtos.SizeMessage1SubMessage.DefaultInstance; } + } + + public override SizeMessage1SubMessage BuildPartial() { + if (resultIsReadOnly) { + return result; + } + resultIsReadOnly = true; + return result.MakeReadOnly(); + } + + + public bool HasField1 { + get { return result.hasField1; } + } + public int Field1 { + get { return result.Field1; } + set { SetField1(value); } + } + public Builder SetField1(int value) { + PrepareBuilder(); + result.hasField1 = true; + result.field1_ = value; + return this; + } + public Builder ClearField1() { + PrepareBuilder(); + result.hasField1 = false; + result.field1_ = 0; + return this; + } + + public bool HasField2 { + get { return result.hasField2; } + } + public int Field2 { + get { return result.Field2; } + set { SetField2(value); } + } + public Builder SetField2(int value) { + PrepareBuilder(); + result.hasField2 = true; + result.field2_ = value; + return this; + } + public Builder ClearField2() { + PrepareBuilder(); + result.hasField2 = false; + result.field2_ = 0; + return this; + } + + public bool HasField3 { + get { return result.hasField3; } + } + public int Field3 { + get { return result.Field3; } + set { SetField3(value); } + } + public Builder SetField3(int value) { + PrepareBuilder(); + result.hasField3 = true; + result.field3_ = value; + return this; + } + public Builder ClearField3() { + PrepareBuilder(); + result.hasField3 = false; + result.field3_ = 0; + return this; + } + + public bool HasField15 { + get { return result.hasField15; } + } + public string Field15 { + get { return result.Field15; } + set { SetField15(value); } + } + public Builder SetField15(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField15 = true; + result.field15_ = value; + return this; + } + public Builder ClearField15() { + PrepareBuilder(); + result.hasField15 = false; + result.field15_ = ""; + return this; + } + + public bool HasField12 { + get { return result.hasField12; } + } + public bool Field12 { + get { return result.Field12; } + set { SetField12(value); } + } + public Builder SetField12(bool value) { + PrepareBuilder(); + result.hasField12 = true; + result.field12_ = value; + return this; + } + public Builder ClearField12() { + PrepareBuilder(); + result.hasField12 = false; + result.field12_ = true; + return this; + } + + public bool HasField13 { + get { return result.hasField13; } + } + public long Field13 { + get { return result.Field13; } + set { SetField13(value); } + } + public Builder SetField13(long value) { + PrepareBuilder(); + result.hasField13 = true; + result.field13_ = value; + return this; + } + public Builder ClearField13() { + PrepareBuilder(); + result.hasField13 = false; + result.field13_ = 0L; + return this; + } + + public bool HasField14 { + get { return result.hasField14; } + } + public long Field14 { + get { return result.Field14; } + set { SetField14(value); } + } + public Builder SetField14(long value) { + PrepareBuilder(); + result.hasField14 = true; + result.field14_ = value; + return this; + } + public Builder ClearField14() { + PrepareBuilder(); + result.hasField14 = false; + result.field14_ = 0L; + return this; + } + + public bool HasField16 { + get { return result.hasField16; } + } + public int Field16 { + get { return result.Field16; } + set { SetField16(value); } + } + public Builder SetField16(int value) { + PrepareBuilder(); + result.hasField16 = true; + result.field16_ = value; + return this; + } + public Builder ClearField16() { + PrepareBuilder(); + result.hasField16 = false; + result.field16_ = 0; + return this; + } + + public bool HasField19 { + get { return result.hasField19; } + } + public int Field19 { + get { return result.Field19; } + set { SetField19(value); } + } + public Builder SetField19(int value) { + PrepareBuilder(); + result.hasField19 = true; + result.field19_ = value; + return this; + } + public Builder ClearField19() { + PrepareBuilder(); + result.hasField19 = false; + result.field19_ = 2; + return this; + } + + public bool HasField20 { + get { return result.hasField20; } + } + public bool Field20 { + get { return result.Field20; } + set { SetField20(value); } + } + public Builder SetField20(bool value) { + PrepareBuilder(); + result.hasField20 = true; + result.field20_ = value; + return this; + } + public Builder ClearField20() { + PrepareBuilder(); + result.hasField20 = false; + result.field20_ = true; + return this; + } + + public bool HasField28 { + get { return result.hasField28; } + } + public bool Field28 { + get { return result.Field28; } + set { SetField28(value); } + } + public Builder SetField28(bool value) { + PrepareBuilder(); + result.hasField28 = true; + result.field28_ = value; + return this; + } + public Builder ClearField28() { + PrepareBuilder(); + result.hasField28 = false; + result.field28_ = true; + return this; + } + + public bool HasField21 { + get { return result.hasField21; } + } + [global::System.CLSCompliant(false)] + public ulong Field21 { + get { return result.Field21; } + set { SetField21(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetField21(ulong value) { + PrepareBuilder(); + result.hasField21 = true; + result.field21_ = value; + return this; + } + public Builder ClearField21() { + PrepareBuilder(); + result.hasField21 = false; + result.field21_ = 0UL; + return this; + } + + public bool HasField22 { + get { return result.hasField22; } + } + public int Field22 { + get { return result.Field22; } + set { SetField22(value); } + } + public Builder SetField22(int value) { + PrepareBuilder(); + result.hasField22 = true; + result.field22_ = value; + return this; + } + public Builder ClearField22() { + PrepareBuilder(); + result.hasField22 = false; + result.field22_ = 0; + return this; + } + + public bool HasField23 { + get { return result.hasField23; } + } + public bool Field23 { + get { return result.Field23; } + set { SetField23(value); } + } + public Builder SetField23(bool value) { + PrepareBuilder(); + result.hasField23 = true; + result.field23_ = value; + return this; + } + public Builder ClearField23() { + PrepareBuilder(); + result.hasField23 = false; + result.field23_ = false; + return this; + } + + public bool HasField206 { + get { return result.hasField206; } + } + public bool Field206 { + get { return result.Field206; } + set { SetField206(value); } + } + public Builder SetField206(bool value) { + PrepareBuilder(); + result.hasField206 = true; + result.field206_ = value; + return this; + } + public Builder ClearField206() { + PrepareBuilder(); + result.hasField206 = false; + result.field206_ = false; + return this; + } + + public bool HasField203 { + get { return result.hasField203; } + } + [global::System.CLSCompliant(false)] + public uint Field203 { + get { return result.Field203; } + set { SetField203(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetField203(uint value) { + PrepareBuilder(); + result.hasField203 = true; + result.field203_ = value; + return this; + } + public Builder ClearField203() { + PrepareBuilder(); + result.hasField203 = false; + result.field203_ = 0; + return this; + } + + public bool HasField204 { + get { return result.hasField204; } + } + public int Field204 { + get { return result.Field204; } + set { SetField204(value); } + } + public Builder SetField204(int value) { + PrepareBuilder(); + result.hasField204 = true; + result.field204_ = value; + return this; + } + public Builder ClearField204() { + PrepareBuilder(); + result.hasField204 = false; + result.field204_ = 0; + return this; + } + + public bool HasField205 { + get { return result.hasField205; } + } + public string Field205 { + get { return result.Field205; } + set { SetField205(value); } + } + public Builder SetField205(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField205 = true; + result.field205_ = value; + return this; + } + public Builder ClearField205() { + PrepareBuilder(); + result.hasField205 = false; + result.field205_ = ""; + return this; + } + + public bool HasField207 { + get { return result.hasField207; } + } + [global::System.CLSCompliant(false)] + public ulong Field207 { + get { return result.Field207; } + set { SetField207(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetField207(ulong value) { + PrepareBuilder(); + result.hasField207 = true; + result.field207_ = value; + return this; + } + public Builder ClearField207() { + PrepareBuilder(); + result.hasField207 = false; + result.field207_ = 0UL; + return this; + } + + public bool HasField300 { + get { return result.hasField300; } + } + [global::System.CLSCompliant(false)] + public ulong Field300 { + get { return result.Field300; } + set { SetField300(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetField300(ulong value) { + PrepareBuilder(); + result.hasField300 = true; + result.field300_ = value; + return this; + } + public Builder ClearField300() { + PrepareBuilder(); + result.hasField300 = false; + result.field300_ = 0UL; + return this; + } + } + static SizeMessage1SubMessage() { + object.ReferenceEquals(global::Google.ProtocolBuffers.TestProtos.GoogleSize.Descriptor, null); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class SizeMessage2 : pb::GeneratedMessage { + private SizeMessage2() { } + private static readonly SizeMessage2 defaultInstance = new SizeMessage2().MakeReadOnly(); + public static SizeMessage2 DefaultInstance { + get { return defaultInstance; } + } + + public override SizeMessage2 DefaultInstanceForType { + get { return DefaultInstance; } + } + + protected override SizeMessage2 ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.GoogleSize.internal__static_benchmarks_SizeMessage2__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.GoogleSize.internal__static_benchmarks_SizeMessage2__FieldAccessorTable; } + } + + #region Nested types + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public static partial class Types { + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class Group1 : pb::GeneratedMessage { + private Group1() { } + private static readonly Group1 defaultInstance = new Group1().MakeReadOnly(); + public static Group1 DefaultInstance { + get { return defaultInstance; } + } + + public override Group1 DefaultInstanceForType { + get { return DefaultInstance; } + } + + protected override Group1 ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.GoogleSize.internal__static_benchmarks_SizeMessage2_Group1__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.GoogleSize.internal__static_benchmarks_SizeMessage2_Group1__FieldAccessorTable; } + } + + public const int Field11FieldNumber = 11; + private bool hasField11; + private float field11_; + public bool HasField11 { + get { return hasField11; } + } + public float Field11 { + get { return field11_; } + } + + public const int Field26FieldNumber = 26; + private bool hasField26; + private float field26_; + public bool HasField26 { + get { return hasField26; } + } + public float Field26 { + get { return field26_; } + } + + public const int Field12FieldNumber = 12; + private bool hasField12; + private string field12_ = ""; + public bool HasField12 { + get { return hasField12; } + } + public string Field12 { + get { return field12_; } + } + + public const int Field13FieldNumber = 13; + private bool hasField13; + private string field13_ = ""; + public bool HasField13 { + get { return hasField13; } + } + public string Field13 { + get { return field13_; } + } + + public const int Field14FieldNumber = 14; + private pbc::PopsicleList field14_ = new pbc::PopsicleList(); + public scg::IList Field14List { + get { return pbc::Lists.AsReadOnly(field14_); } + } + public int Field14Count { + get { return field14_.Count; } + } + public string GetField14(int index) { + return field14_[index]; + } + + public const int Field15FieldNumber = 15; + private bool hasField15; + private ulong field15_; + public bool HasField15 { + get { return hasField15; } + } + [global::System.CLSCompliant(false)] + public ulong Field15 { + get { return field15_; } + } + + public const int Field5FieldNumber = 5; + private bool hasField5; + private int field5_; + public bool HasField5 { + get { return hasField5; } + } + public int Field5 { + get { return field5_; } + } + + public const int Field27FieldNumber = 27; + private bool hasField27; + private string field27_ = ""; + public bool HasField27 { + get { return hasField27; } + } + public string Field27 { + get { return field27_; } + } + + public const int Field28FieldNumber = 28; + private bool hasField28; + private int field28_; + public bool HasField28 { + get { return hasField28; } + } + public int Field28 { + get { return field28_; } + } + + public const int Field29FieldNumber = 29; + private bool hasField29; + private string field29_ = ""; + public bool HasField29 { + get { return hasField29; } + } + public string Field29 { + get { return field29_; } + } + + public const int Field16FieldNumber = 16; + private bool hasField16; + private string field16_ = ""; + public bool HasField16 { + get { return hasField16; } + } + public string Field16 { + get { return field16_; } + } + + public const int Field22FieldNumber = 22; + private pbc::PopsicleList field22_ = new pbc::PopsicleList(); + public scg::IList Field22List { + get { return pbc::Lists.AsReadOnly(field22_); } + } + public int Field22Count { + get { return field22_.Count; } + } + public string GetField22(int index) { + return field22_[index]; + } + + public const int Field73FieldNumber = 73; + private pbc::PopsicleList field73_ = new pbc::PopsicleList(); + public scg::IList Field73List { + get { return pbc::Lists.AsReadOnly(field73_); } + } + public int Field73Count { + get { return field73_.Count; } + } + public int GetField73(int index) { + return field73_[index]; + } + + public const int Field20FieldNumber = 20; + private bool hasField20; + private int field20_; + public bool HasField20 { + get { return hasField20; } + } + public int Field20 { + get { return field20_; } + } + + public const int Field24FieldNumber = 24; + private bool hasField24; + private string field24_ = ""; + public bool HasField24 { + get { return hasField24; } + } + public string Field24 { + get { return field24_; } + } + + public const int Field31FieldNumber = 31; + private bool hasField31; + private global::Google.ProtocolBuffers.TestProtos.SizeMessage2GroupedMessage field31_; + public bool HasField31 { + get { return hasField31; } + } + public global::Google.ProtocolBuffers.TestProtos.SizeMessage2GroupedMessage Field31 { + get { return field31_ ?? global::Google.ProtocolBuffers.TestProtos.SizeMessage2GroupedMessage.DefaultInstance; } + } + + public static Group1 ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Group1 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Group1 ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Group1 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Group1 ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Group1 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Group1 ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static Group1 ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static Group1 ParseFrom(pb::ICodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Group1 ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + private Group1 MakeReadOnly() { + field14_.MakeReadOnly(); + field22_.MakeReadOnly(); + field73_.MakeReadOnly(); + return this; + } + + public static Builder CreateBuilder() { return new Builder(); } + public override Builder ToBuilder() { return CreateBuilder(this); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(Group1 prototype) { + return new Builder(prototype); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() { + result = DefaultInstance; + resultIsReadOnly = true; + } + internal Builder(Group1 cloneFrom) { + result = cloneFrom; + resultIsReadOnly = true; + } + + private bool resultIsReadOnly; + private Group1 result; + + private Group1 PrepareBuilder() { + if (resultIsReadOnly) { + Group1 original = result; + result = new Group1(); + resultIsReadOnly = false; + MergeFrom(original); + } + return result; + } + + public override bool IsInitialized { + get { return result.IsInitialized; } + } + + protected override Group1 MessageBeingBuilt { + get { return PrepareBuilder(); } + } + + public override Builder Clear() { + result = DefaultInstance; + resultIsReadOnly = true; + return this; + } + + public override Builder Clone() { + if (resultIsReadOnly) { + return new Builder(result); + } else { + return new Builder().MergeFrom(result); + } + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Google.ProtocolBuffers.TestProtos.SizeMessage2.Types.Group1.Descriptor; } + } + + public override Group1 DefaultInstanceForType { + get { return global::Google.ProtocolBuffers.TestProtos.SizeMessage2.Types.Group1.DefaultInstance; } + } + + public override Group1 BuildPartial() { + if (resultIsReadOnly) { + return result; + } + resultIsReadOnly = true; + return result.MakeReadOnly(); + } + + + public bool HasField11 { + get { return result.hasField11; } + } + public float Field11 { + get { return result.Field11; } + set { SetField11(value); } + } + public Builder SetField11(float value) { + PrepareBuilder(); + result.hasField11 = true; + result.field11_ = value; + return this; + } + public Builder ClearField11() { + PrepareBuilder(); + result.hasField11 = false; + result.field11_ = 0F; + return this; + } + + public bool HasField26 { + get { return result.hasField26; } + } + public float Field26 { + get { return result.Field26; } + set { SetField26(value); } + } + public Builder SetField26(float value) { + PrepareBuilder(); + result.hasField26 = true; + result.field26_ = value; + return this; + } + public Builder ClearField26() { + PrepareBuilder(); + result.hasField26 = false; + result.field26_ = 0F; + return this; + } + + public bool HasField12 { + get { return result.hasField12; } + } + public string Field12 { + get { return result.Field12; } + set { SetField12(value); } + } + public Builder SetField12(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField12 = true; + result.field12_ = value; + return this; + } + public Builder ClearField12() { + PrepareBuilder(); + result.hasField12 = false; + result.field12_ = ""; + return this; + } + + public bool HasField13 { + get { return result.hasField13; } + } + public string Field13 { + get { return result.Field13; } + set { SetField13(value); } + } + public Builder SetField13(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField13 = true; + result.field13_ = value; + return this; + } + public Builder ClearField13() { + PrepareBuilder(); + result.hasField13 = false; + result.field13_ = ""; + return this; + } + + public pbc::IPopsicleList Field14List { + get { return PrepareBuilder().field14_; } + } + public int Field14Count { + get { return result.Field14Count; } + } + public string GetField14(int index) { + return result.GetField14(index); + } + public Builder SetField14(int index, string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.field14_[index] = value; + return this; + } + public Builder AddField14(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.field14_.Add(value); + return this; + } + public Builder AddRangeField14(scg::IEnumerable values) { + PrepareBuilder(); + result.field14_.Add(values); + return this; + } + public Builder ClearField14() { + PrepareBuilder(); + result.field14_.Clear(); + return this; + } + + public bool HasField15 { + get { return result.hasField15; } + } + [global::System.CLSCompliant(false)] + public ulong Field15 { + get { return result.Field15; } + set { SetField15(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetField15(ulong value) { + PrepareBuilder(); + result.hasField15 = true; + result.field15_ = value; + return this; + } + public Builder ClearField15() { + PrepareBuilder(); + result.hasField15 = false; + result.field15_ = 0UL; + return this; + } + + public bool HasField5 { + get { return result.hasField5; } + } + public int Field5 { + get { return result.Field5; } + set { SetField5(value); } + } + public Builder SetField5(int value) { + PrepareBuilder(); + result.hasField5 = true; + result.field5_ = value; + return this; + } + public Builder ClearField5() { + PrepareBuilder(); + result.hasField5 = false; + result.field5_ = 0; + return this; + } + + public bool HasField27 { + get { return result.hasField27; } + } + public string Field27 { + get { return result.Field27; } + set { SetField27(value); } + } + public Builder SetField27(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField27 = true; + result.field27_ = value; + return this; + } + public Builder ClearField27() { + PrepareBuilder(); + result.hasField27 = false; + result.field27_ = ""; + return this; + } + + public bool HasField28 { + get { return result.hasField28; } + } + public int Field28 { + get { return result.Field28; } + set { SetField28(value); } + } + public Builder SetField28(int value) { + PrepareBuilder(); + result.hasField28 = true; + result.field28_ = value; + return this; + } + public Builder ClearField28() { + PrepareBuilder(); + result.hasField28 = false; + result.field28_ = 0; + return this; + } + + public bool HasField29 { + get { return result.hasField29; } + } + public string Field29 { + get { return result.Field29; } + set { SetField29(value); } + } + public Builder SetField29(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField29 = true; + result.field29_ = value; + return this; + } + public Builder ClearField29() { + PrepareBuilder(); + result.hasField29 = false; + result.field29_ = ""; + return this; + } + + public bool HasField16 { + get { return result.hasField16; } + } + public string Field16 { + get { return result.Field16; } + set { SetField16(value); } + } + public Builder SetField16(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField16 = true; + result.field16_ = value; + return this; + } + public Builder ClearField16() { + PrepareBuilder(); + result.hasField16 = false; + result.field16_ = ""; + return this; + } + + public pbc::IPopsicleList Field22List { + get { return PrepareBuilder().field22_; } + } + public int Field22Count { + get { return result.Field22Count; } + } + public string GetField22(int index) { + return result.GetField22(index); + } + public Builder SetField22(int index, string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.field22_[index] = value; + return this; + } + public Builder AddField22(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.field22_.Add(value); + return this; + } + public Builder AddRangeField22(scg::IEnumerable values) { + PrepareBuilder(); + result.field22_.Add(values); + return this; + } + public Builder ClearField22() { + PrepareBuilder(); + result.field22_.Clear(); + return this; + } + + public pbc::IPopsicleList Field73List { + get { return PrepareBuilder().field73_; } + } + public int Field73Count { + get { return result.Field73Count; } + } + public int GetField73(int index) { + return result.GetField73(index); + } + public Builder SetField73(int index, int value) { + PrepareBuilder(); + result.field73_[index] = value; + return this; + } + public Builder AddField73(int value) { + PrepareBuilder(); + result.field73_.Add(value); + return this; + } + public Builder AddRangeField73(scg::IEnumerable values) { + PrepareBuilder(); + result.field73_.Add(values); + return this; + } + public Builder ClearField73() { + PrepareBuilder(); + result.field73_.Clear(); + return this; + } + + public bool HasField20 { + get { return result.hasField20; } + } + public int Field20 { + get { return result.Field20; } + set { SetField20(value); } + } + public Builder SetField20(int value) { + PrepareBuilder(); + result.hasField20 = true; + result.field20_ = value; + return this; + } + public Builder ClearField20() { + PrepareBuilder(); + result.hasField20 = false; + result.field20_ = 0; + return this; + } + + public bool HasField24 { + get { return result.hasField24; } + } + public string Field24 { + get { return result.Field24; } + set { SetField24(value); } + } + public Builder SetField24(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField24 = true; + result.field24_ = value; + return this; + } + public Builder ClearField24() { + PrepareBuilder(); + result.hasField24 = false; + result.field24_ = ""; + return this; + } + + public bool HasField31 { + get { return result.hasField31; } + } + public global::Google.ProtocolBuffers.TestProtos.SizeMessage2GroupedMessage Field31 { + get { return result.Field31; } + set { SetField31(value); } + } + public Builder SetField31(global::Google.ProtocolBuffers.TestProtos.SizeMessage2GroupedMessage value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField31 = true; + result.field31_ = value; + return this; + } + public Builder SetField31(global::Google.ProtocolBuffers.TestProtos.SizeMessage2GroupedMessage.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + PrepareBuilder(); + result.hasField31 = true; + result.field31_ = builderForValue.Build(); + return this; + } + public Builder MergeField31(global::Google.ProtocolBuffers.TestProtos.SizeMessage2GroupedMessage value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + if (result.hasField31 && + result.field31_ != global::Google.ProtocolBuffers.TestProtos.SizeMessage2GroupedMessage.DefaultInstance) { + result.field31_ = global::Google.ProtocolBuffers.TestProtos.SizeMessage2GroupedMessage.CreateBuilder(result.field31_).MergeFrom(value).BuildPartial(); + } else { + result.field31_ = value; + } + result.hasField31 = true; + return this; + } + public Builder ClearField31() { + PrepareBuilder(); + result.hasField31 = false; + result.field31_ = null; + return this; + } + } + static Group1() { + object.ReferenceEquals(global::Google.ProtocolBuffers.TestProtos.GoogleSize.Descriptor, null); + } + } + + } + #endregion + + public const int Field1FieldNumber = 1; + private bool hasField1; + private string field1_ = ""; + public bool HasField1 { + get { return hasField1; } + } + public string Field1 { + get { return field1_; } + } + + public const int Field3FieldNumber = 3; + private bool hasField3; + private long field3_; + public bool HasField3 { + get { return hasField3; } + } + public long Field3 { + get { return field3_; } + } + + public const int Field4FieldNumber = 4; + private bool hasField4; + private long field4_; + public bool HasField4 { + get { return hasField4; } + } + public long Field4 { + get { return field4_; } + } + + public const int Field30FieldNumber = 30; + private bool hasField30; + private long field30_; + public bool HasField30 { + get { return hasField30; } + } + public long Field30 { + get { return field30_; } + } + + public const int Field75FieldNumber = 75; + private bool hasField75; + private bool field75_; + public bool HasField75 { + get { return hasField75; } + } + public bool Field75 { + get { return field75_; } + } + + public const int Field6FieldNumber = 6; + private bool hasField6; + private string field6_ = ""; + public bool HasField6 { + get { return hasField6; } + } + public string Field6 { + get { return field6_; } + } + + public const int Field2FieldNumber = 2; + private bool hasField2; + private pb::ByteString field2_ = pb::ByteString.Empty; + public bool HasField2 { + get { return hasField2; } + } + public pb::ByteString Field2 { + get { return field2_; } + } + + public const int Field21FieldNumber = 21; + private bool hasField21; + private int field21_; + public bool HasField21 { + get { return hasField21; } + } + public int Field21 { + get { return field21_; } + } + + public const int Field71FieldNumber = 71; + private bool hasField71; + private int field71_; + public bool HasField71 { + get { return hasField71; } + } + public int Field71 { + get { return field71_; } + } + + public const int Field25FieldNumber = 25; + private bool hasField25; + private float field25_; + public bool HasField25 { + get { return hasField25; } + } + public float Field25 { + get { return field25_; } + } + + public const int Field109FieldNumber = 109; + private bool hasField109; + private int field109_; + public bool HasField109 { + get { return hasField109; } + } + public int Field109 { + get { return field109_; } + } + + public const int Field210FieldNumber = 210; + private bool hasField210; + private int field210_; + public bool HasField210 { + get { return hasField210; } + } + public int Field210 { + get { return field210_; } + } + + public const int Field211FieldNumber = 211; + private bool hasField211; + private int field211_; + public bool HasField211 { + get { return hasField211; } + } + public int Field211 { + get { return field211_; } + } + + public const int Field212FieldNumber = 212; + private bool hasField212; + private int field212_; + public bool HasField212 { + get { return hasField212; } + } + public int Field212 { + get { return field212_; } + } + + public const int Field213FieldNumber = 213; + private bool hasField213; + private int field213_; + public bool HasField213 { + get { return hasField213; } + } + public int Field213 { + get { return field213_; } + } + + public const int Field216FieldNumber = 216; + private bool hasField216; + private int field216_; + public bool HasField216 { + get { return hasField216; } + } + public int Field216 { + get { return field216_; } + } + + public const int Field217FieldNumber = 217; + private bool hasField217; + private int field217_; + public bool HasField217 { + get { return hasField217; } + } + public int Field217 { + get { return field217_; } + } + + public const int Field218FieldNumber = 218; + private bool hasField218; + private int field218_; + public bool HasField218 { + get { return hasField218; } + } + public int Field218 { + get { return field218_; } + } + + public const int Field220FieldNumber = 220; + private bool hasField220; + private int field220_; + public bool HasField220 { + get { return hasField220; } + } + public int Field220 { + get { return field220_; } + } + + public const int Field221FieldNumber = 221; + private bool hasField221; + private int field221_; + public bool HasField221 { + get { return hasField221; } + } + public int Field221 { + get { return field221_; } + } + + public const int Field222FieldNumber = 222; + private bool hasField222; + private float field222_; + public bool HasField222 { + get { return hasField222; } + } + public float Field222 { + get { return field222_; } + } + + public const int Field63FieldNumber = 63; + private bool hasField63; + private int field63_; + public bool HasField63 { + get { return hasField63; } + } + public int Field63 { + get { return field63_; } + } + + public const int Group1FieldNumber = 10; + private pbc::PopsicleList group1_ = new pbc::PopsicleList(); + public scg::IList Group1List { + get { return group1_; } + } + public int Group1Count { + get { return group1_.Count; } + } + public global::Google.ProtocolBuffers.TestProtos.SizeMessage2.Types.Group1 GetGroup1(int index) { + return group1_[index]; + } + + public const int Field128FieldNumber = 128; + private pbc::PopsicleList field128_ = new pbc::PopsicleList(); + public scg::IList Field128List { + get { return pbc::Lists.AsReadOnly(field128_); } + } + public int Field128Count { + get { return field128_.Count; } + } + public string GetField128(int index) { + return field128_[index]; + } + + public const int Field131FieldNumber = 131; + private bool hasField131; + private long field131_; + public bool HasField131 { + get { return hasField131; } + } + public long Field131 { + get { return field131_; } + } + + public const int Field127FieldNumber = 127; + private pbc::PopsicleList field127_ = new pbc::PopsicleList(); + public scg::IList Field127List { + get { return pbc::Lists.AsReadOnly(field127_); } + } + public int Field127Count { + get { return field127_.Count; } + } + public string GetField127(int index) { + return field127_[index]; + } + + public const int Field129FieldNumber = 129; + private bool hasField129; + private int field129_; + public bool HasField129 { + get { return hasField129; } + } + public int Field129 { + get { return field129_; } + } + + public const int Field130FieldNumber = 130; + private pbc::PopsicleList field130_ = new pbc::PopsicleList(); + public scg::IList Field130List { + get { return pbc::Lists.AsReadOnly(field130_); } + } + public int Field130Count { + get { return field130_.Count; } + } + public long GetField130(int index) { + return field130_[index]; + } + + public const int Field205FieldNumber = 205; + private bool hasField205; + private bool field205_; + public bool HasField205 { + get { return hasField205; } + } + public bool Field205 { + get { return field205_; } + } + + public const int Field206FieldNumber = 206; + private bool hasField206; + private bool field206_; + public bool HasField206 { + get { return hasField206; } + } + public bool Field206 { + get { return field206_; } + } + + public static SizeMessage2 ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static SizeMessage2 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static SizeMessage2 ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static SizeMessage2 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static SizeMessage2 ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static SizeMessage2 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static SizeMessage2 ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static SizeMessage2 ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static SizeMessage2 ParseFrom(pb::ICodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static SizeMessage2 ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + private SizeMessage2 MakeReadOnly() { + group1_.MakeReadOnly(); + field128_.MakeReadOnly(); + field127_.MakeReadOnly(); + field130_.MakeReadOnly(); + return this; + } + + public static Builder CreateBuilder() { return new Builder(); } + public override Builder ToBuilder() { return CreateBuilder(this); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(SizeMessage2 prototype) { + return new Builder(prototype); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() { + result = DefaultInstance; + resultIsReadOnly = true; + } + internal Builder(SizeMessage2 cloneFrom) { + result = cloneFrom; + resultIsReadOnly = true; + } + + private bool resultIsReadOnly; + private SizeMessage2 result; + + private SizeMessage2 PrepareBuilder() { + if (resultIsReadOnly) { + SizeMessage2 original = result; + result = new SizeMessage2(); + resultIsReadOnly = false; + MergeFrom(original); + } + return result; + } + + public override bool IsInitialized { + get { return result.IsInitialized; } + } + + protected override SizeMessage2 MessageBeingBuilt { + get { return PrepareBuilder(); } + } + + public override Builder Clear() { + result = DefaultInstance; + resultIsReadOnly = true; + return this; + } + + public override Builder Clone() { + if (resultIsReadOnly) { + return new Builder(result); + } else { + return new Builder().MergeFrom(result); + } + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Google.ProtocolBuffers.TestProtos.SizeMessage2.Descriptor; } + } + + public override SizeMessage2 DefaultInstanceForType { + get { return global::Google.ProtocolBuffers.TestProtos.SizeMessage2.DefaultInstance; } + } + + public override SizeMessage2 BuildPartial() { + if (resultIsReadOnly) { + return result; + } + resultIsReadOnly = true; + return result.MakeReadOnly(); + } + + + public bool HasField1 { + get { return result.hasField1; } + } + public string Field1 { + get { return result.Field1; } + set { SetField1(value); } + } + public Builder SetField1(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField1 = true; + result.field1_ = value; + return this; + } + public Builder ClearField1() { + PrepareBuilder(); + result.hasField1 = false; + result.field1_ = ""; + return this; + } + + public bool HasField3 { + get { return result.hasField3; } + } + public long Field3 { + get { return result.Field3; } + set { SetField3(value); } + } + public Builder SetField3(long value) { + PrepareBuilder(); + result.hasField3 = true; + result.field3_ = value; + return this; + } + public Builder ClearField3() { + PrepareBuilder(); + result.hasField3 = false; + result.field3_ = 0L; + return this; + } + + public bool HasField4 { + get { return result.hasField4; } + } + public long Field4 { + get { return result.Field4; } + set { SetField4(value); } + } + public Builder SetField4(long value) { + PrepareBuilder(); + result.hasField4 = true; + result.field4_ = value; + return this; + } + public Builder ClearField4() { + PrepareBuilder(); + result.hasField4 = false; + result.field4_ = 0L; + return this; + } + + public bool HasField30 { + get { return result.hasField30; } + } + public long Field30 { + get { return result.Field30; } + set { SetField30(value); } + } + public Builder SetField30(long value) { + PrepareBuilder(); + result.hasField30 = true; + result.field30_ = value; + return this; + } + public Builder ClearField30() { + PrepareBuilder(); + result.hasField30 = false; + result.field30_ = 0L; + return this; + } + + public bool HasField75 { + get { return result.hasField75; } + } + public bool Field75 { + get { return result.Field75; } + set { SetField75(value); } + } + public Builder SetField75(bool value) { + PrepareBuilder(); + result.hasField75 = true; + result.field75_ = value; + return this; + } + public Builder ClearField75() { + PrepareBuilder(); + result.hasField75 = false; + result.field75_ = false; + return this; + } + + public bool HasField6 { + get { return result.hasField6; } + } + public string Field6 { + get { return result.Field6; } + set { SetField6(value); } + } + public Builder SetField6(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField6 = true; + result.field6_ = value; + return this; + } + public Builder ClearField6() { + PrepareBuilder(); + result.hasField6 = false; + result.field6_ = ""; + return this; + } + + public bool HasField2 { + get { return result.hasField2; } + } + public pb::ByteString Field2 { + get { return result.Field2; } + set { SetField2(value); } + } + public Builder SetField2(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField2 = true; + result.field2_ = value; + return this; + } + public Builder ClearField2() { + PrepareBuilder(); + result.hasField2 = false; + result.field2_ = pb::ByteString.Empty; + return this; + } + + public bool HasField21 { + get { return result.hasField21; } + } + public int Field21 { + get { return result.Field21; } + set { SetField21(value); } + } + public Builder SetField21(int value) { + PrepareBuilder(); + result.hasField21 = true; + result.field21_ = value; + return this; + } + public Builder ClearField21() { + PrepareBuilder(); + result.hasField21 = false; + result.field21_ = 0; + return this; + } + + public bool HasField71 { + get { return result.hasField71; } + } + public int Field71 { + get { return result.Field71; } + set { SetField71(value); } + } + public Builder SetField71(int value) { + PrepareBuilder(); + result.hasField71 = true; + result.field71_ = value; + return this; + } + public Builder ClearField71() { + PrepareBuilder(); + result.hasField71 = false; + result.field71_ = 0; + return this; + } + + public bool HasField25 { + get { return result.hasField25; } + } + public float Field25 { + get { return result.Field25; } + set { SetField25(value); } + } + public Builder SetField25(float value) { + PrepareBuilder(); + result.hasField25 = true; + result.field25_ = value; + return this; + } + public Builder ClearField25() { + PrepareBuilder(); + result.hasField25 = false; + result.field25_ = 0F; + return this; + } + + public bool HasField109 { + get { return result.hasField109; } + } + public int Field109 { + get { return result.Field109; } + set { SetField109(value); } + } + public Builder SetField109(int value) { + PrepareBuilder(); + result.hasField109 = true; + result.field109_ = value; + return this; + } + public Builder ClearField109() { + PrepareBuilder(); + result.hasField109 = false; + result.field109_ = 0; + return this; + } + + public bool HasField210 { + get { return result.hasField210; } + } + public int Field210 { + get { return result.Field210; } + set { SetField210(value); } + } + public Builder SetField210(int value) { + PrepareBuilder(); + result.hasField210 = true; + result.field210_ = value; + return this; + } + public Builder ClearField210() { + PrepareBuilder(); + result.hasField210 = false; + result.field210_ = 0; + return this; + } + + public bool HasField211 { + get { return result.hasField211; } + } + public int Field211 { + get { return result.Field211; } + set { SetField211(value); } + } + public Builder SetField211(int value) { + PrepareBuilder(); + result.hasField211 = true; + result.field211_ = value; + return this; + } + public Builder ClearField211() { + PrepareBuilder(); + result.hasField211 = false; + result.field211_ = 0; + return this; + } + + public bool HasField212 { + get { return result.hasField212; } + } + public int Field212 { + get { return result.Field212; } + set { SetField212(value); } + } + public Builder SetField212(int value) { + PrepareBuilder(); + result.hasField212 = true; + result.field212_ = value; + return this; + } + public Builder ClearField212() { + PrepareBuilder(); + result.hasField212 = false; + result.field212_ = 0; + return this; + } + + public bool HasField213 { + get { return result.hasField213; } + } + public int Field213 { + get { return result.Field213; } + set { SetField213(value); } + } + public Builder SetField213(int value) { + PrepareBuilder(); + result.hasField213 = true; + result.field213_ = value; + return this; + } + public Builder ClearField213() { + PrepareBuilder(); + result.hasField213 = false; + result.field213_ = 0; + return this; + } + + public bool HasField216 { + get { return result.hasField216; } + } + public int Field216 { + get { return result.Field216; } + set { SetField216(value); } + } + public Builder SetField216(int value) { + PrepareBuilder(); + result.hasField216 = true; + result.field216_ = value; + return this; + } + public Builder ClearField216() { + PrepareBuilder(); + result.hasField216 = false; + result.field216_ = 0; + return this; + } + + public bool HasField217 { + get { return result.hasField217; } + } + public int Field217 { + get { return result.Field217; } + set { SetField217(value); } + } + public Builder SetField217(int value) { + PrepareBuilder(); + result.hasField217 = true; + result.field217_ = value; + return this; + } + public Builder ClearField217() { + PrepareBuilder(); + result.hasField217 = false; + result.field217_ = 0; + return this; + } + + public bool HasField218 { + get { return result.hasField218; } + } + public int Field218 { + get { return result.Field218; } + set { SetField218(value); } + } + public Builder SetField218(int value) { + PrepareBuilder(); + result.hasField218 = true; + result.field218_ = value; + return this; + } + public Builder ClearField218() { + PrepareBuilder(); + result.hasField218 = false; + result.field218_ = 0; + return this; + } + + public bool HasField220 { + get { return result.hasField220; } + } + public int Field220 { + get { return result.Field220; } + set { SetField220(value); } + } + public Builder SetField220(int value) { + PrepareBuilder(); + result.hasField220 = true; + result.field220_ = value; + return this; + } + public Builder ClearField220() { + PrepareBuilder(); + result.hasField220 = false; + result.field220_ = 0; + return this; + } + + public bool HasField221 { + get { return result.hasField221; } + } + public int Field221 { + get { return result.Field221; } + set { SetField221(value); } + } + public Builder SetField221(int value) { + PrepareBuilder(); + result.hasField221 = true; + result.field221_ = value; + return this; + } + public Builder ClearField221() { + PrepareBuilder(); + result.hasField221 = false; + result.field221_ = 0; + return this; + } + + public bool HasField222 { + get { return result.hasField222; } + } + public float Field222 { + get { return result.Field222; } + set { SetField222(value); } + } + public Builder SetField222(float value) { + PrepareBuilder(); + result.hasField222 = true; + result.field222_ = value; + return this; + } + public Builder ClearField222() { + PrepareBuilder(); + result.hasField222 = false; + result.field222_ = 0F; + return this; + } + + public bool HasField63 { + get { return result.hasField63; } + } + public int Field63 { + get { return result.Field63; } + set { SetField63(value); } + } + public Builder SetField63(int value) { + PrepareBuilder(); + result.hasField63 = true; + result.field63_ = value; + return this; + } + public Builder ClearField63() { + PrepareBuilder(); + result.hasField63 = false; + result.field63_ = 0; + return this; + } + + public pbc::IPopsicleList Group1List { + get { return PrepareBuilder().group1_; } + } + public int Group1Count { + get { return result.Group1Count; } + } + public global::Google.ProtocolBuffers.TestProtos.SizeMessage2.Types.Group1 GetGroup1(int index) { + return result.GetGroup1(index); + } + public Builder SetGroup1(int index, global::Google.ProtocolBuffers.TestProtos.SizeMessage2.Types.Group1 value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.group1_[index] = value; + return this; + } + public Builder SetGroup1(int index, global::Google.ProtocolBuffers.TestProtos.SizeMessage2.Types.Group1.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + PrepareBuilder(); + result.group1_[index] = builderForValue.Build(); + return this; + } + public Builder AddGroup1(global::Google.ProtocolBuffers.TestProtos.SizeMessage2.Types.Group1 value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.group1_.Add(value); + return this; + } + public Builder AddGroup1(global::Google.ProtocolBuffers.TestProtos.SizeMessage2.Types.Group1.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + PrepareBuilder(); + result.group1_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeGroup1(scg::IEnumerable values) { + PrepareBuilder(); + result.group1_.Add(values); + return this; + } + public Builder ClearGroup1() { + PrepareBuilder(); + result.group1_.Clear(); + return this; + } + + public pbc::IPopsicleList Field128List { + get { return PrepareBuilder().field128_; } + } + public int Field128Count { + get { return result.Field128Count; } + } + public string GetField128(int index) { + return result.GetField128(index); + } + public Builder SetField128(int index, string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.field128_[index] = value; + return this; + } + public Builder AddField128(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.field128_.Add(value); + return this; + } + public Builder AddRangeField128(scg::IEnumerable values) { + PrepareBuilder(); + result.field128_.Add(values); + return this; + } + public Builder ClearField128() { + PrepareBuilder(); + result.field128_.Clear(); + return this; + } + + public bool HasField131 { + get { return result.hasField131; } + } + public long Field131 { + get { return result.Field131; } + set { SetField131(value); } + } + public Builder SetField131(long value) { + PrepareBuilder(); + result.hasField131 = true; + result.field131_ = value; + return this; + } + public Builder ClearField131() { + PrepareBuilder(); + result.hasField131 = false; + result.field131_ = 0L; + return this; + } + + public pbc::IPopsicleList Field127List { + get { return PrepareBuilder().field127_; } + } + public int Field127Count { + get { return result.Field127Count; } + } + public string GetField127(int index) { + return result.GetField127(index); + } + public Builder SetField127(int index, string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.field127_[index] = value; + return this; + } + public Builder AddField127(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.field127_.Add(value); + return this; + } + public Builder AddRangeField127(scg::IEnumerable values) { + PrepareBuilder(); + result.field127_.Add(values); + return this; + } + public Builder ClearField127() { + PrepareBuilder(); + result.field127_.Clear(); + return this; + } + + public bool HasField129 { + get { return result.hasField129; } + } + public int Field129 { + get { return result.Field129; } + set { SetField129(value); } + } + public Builder SetField129(int value) { + PrepareBuilder(); + result.hasField129 = true; + result.field129_ = value; + return this; + } + public Builder ClearField129() { + PrepareBuilder(); + result.hasField129 = false; + result.field129_ = 0; + return this; + } + + public pbc::IPopsicleList Field130List { + get { return PrepareBuilder().field130_; } + } + public int Field130Count { + get { return result.Field130Count; } + } + public long GetField130(int index) { + return result.GetField130(index); + } + public Builder SetField130(int index, long value) { + PrepareBuilder(); + result.field130_[index] = value; + return this; + } + public Builder AddField130(long value) { + PrepareBuilder(); + result.field130_.Add(value); + return this; + } + public Builder AddRangeField130(scg::IEnumerable values) { + PrepareBuilder(); + result.field130_.Add(values); + return this; + } + public Builder ClearField130() { + PrepareBuilder(); + result.field130_.Clear(); + return this; + } + + public bool HasField205 { + get { return result.hasField205; } + } + public bool Field205 { + get { return result.Field205; } + set { SetField205(value); } + } + public Builder SetField205(bool value) { + PrepareBuilder(); + result.hasField205 = true; + result.field205_ = value; + return this; + } + public Builder ClearField205() { + PrepareBuilder(); + result.hasField205 = false; + result.field205_ = false; + return this; + } + + public bool HasField206 { + get { return result.hasField206; } + } + public bool Field206 { + get { return result.Field206; } + set { SetField206(value); } + } + public Builder SetField206(bool value) { + PrepareBuilder(); + result.hasField206 = true; + result.field206_ = value; + return this; + } + public Builder ClearField206() { + PrepareBuilder(); + result.hasField206 = false; + result.field206_ = false; + return this; + } + } + static SizeMessage2() { + object.ReferenceEquals(global::Google.ProtocolBuffers.TestProtos.GoogleSize.Descriptor, null); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class SizeMessage2GroupedMessage : pb::GeneratedMessage { + private SizeMessage2GroupedMessage() { } + private static readonly SizeMessage2GroupedMessage defaultInstance = new SizeMessage2GroupedMessage().MakeReadOnly(); + public static SizeMessage2GroupedMessage DefaultInstance { + get { return defaultInstance; } + } + + public override SizeMessage2GroupedMessage DefaultInstanceForType { + get { return DefaultInstance; } + } + + protected override SizeMessage2GroupedMessage ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.GoogleSize.internal__static_benchmarks_SizeMessage2GroupedMessage__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.GoogleSize.internal__static_benchmarks_SizeMessage2GroupedMessage__FieldAccessorTable; } + } + + public const int Field1FieldNumber = 1; + private bool hasField1; + private float field1_; + public bool HasField1 { + get { return hasField1; } + } + public float Field1 { + get { return field1_; } + } + + public const int Field2FieldNumber = 2; + private bool hasField2; + private float field2_; + public bool HasField2 { + get { return hasField2; } + } + public float Field2 { + get { return field2_; } + } + + public const int Field3FieldNumber = 3; + private bool hasField3; + private float field3_; + public bool HasField3 { + get { return hasField3; } + } + public float Field3 { + get { return field3_; } + } + + public const int Field4FieldNumber = 4; + private bool hasField4; + private bool field4_; + public bool HasField4 { + get { return hasField4; } + } + public bool Field4 { + get { return field4_; } + } + + public const int Field5FieldNumber = 5; + private bool hasField5; + private bool field5_; + public bool HasField5 { + get { return hasField5; } + } + public bool Field5 { + get { return field5_; } + } + + public const int Field6FieldNumber = 6; + private bool hasField6; + private bool field6_ = true; + public bool HasField6 { + get { return hasField6; } + } + public bool Field6 { + get { return field6_; } + } + + public const int Field7FieldNumber = 7; + private bool hasField7; + private bool field7_; + public bool HasField7 { + get { return hasField7; } + } + public bool Field7 { + get { return field7_; } + } + + public const int Field8FieldNumber = 8; + private bool hasField8; + private float field8_; + public bool HasField8 { + get { return hasField8; } + } + public float Field8 { + get { return field8_; } + } + + public const int Field9FieldNumber = 9; + private bool hasField9; + private bool field9_; + public bool HasField9 { + get { return hasField9; } + } + public bool Field9 { + get { return field9_; } + } + + public const int Field10FieldNumber = 10; + private bool hasField10; + private float field10_; + public bool HasField10 { + get { return hasField10; } + } + public float Field10 { + get { return field10_; } + } + + public const int Field11FieldNumber = 11; + private bool hasField11; + private long field11_; + public bool HasField11 { + get { return hasField11; } + } + public long Field11 { + get { return field11_; } + } + + public static SizeMessage2GroupedMessage ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static SizeMessage2GroupedMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static SizeMessage2GroupedMessage ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static SizeMessage2GroupedMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static SizeMessage2GroupedMessage ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static SizeMessage2GroupedMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static SizeMessage2GroupedMessage ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static SizeMessage2GroupedMessage ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static SizeMessage2GroupedMessage ParseFrom(pb::ICodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static SizeMessage2GroupedMessage ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + private SizeMessage2GroupedMessage MakeReadOnly() { + return this; + } + + public static Builder CreateBuilder() { return new Builder(); } + public override Builder ToBuilder() { return CreateBuilder(this); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(SizeMessage2GroupedMessage prototype) { + return new Builder(prototype); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() { + result = DefaultInstance; + resultIsReadOnly = true; + } + internal Builder(SizeMessage2GroupedMessage cloneFrom) { + result = cloneFrom; + resultIsReadOnly = true; + } + + private bool resultIsReadOnly; + private SizeMessage2GroupedMessage result; + + private SizeMessage2GroupedMessage PrepareBuilder() { + if (resultIsReadOnly) { + SizeMessage2GroupedMessage original = result; + result = new SizeMessage2GroupedMessage(); + resultIsReadOnly = false; + MergeFrom(original); + } + return result; + } + + public override bool IsInitialized { + get { return result.IsInitialized; } + } + + protected override SizeMessage2GroupedMessage MessageBeingBuilt { + get { return PrepareBuilder(); } + } + + public override Builder Clear() { + result = DefaultInstance; + resultIsReadOnly = true; + return this; + } + + public override Builder Clone() { + if (resultIsReadOnly) { + return new Builder(result); + } else { + return new Builder().MergeFrom(result); + } + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Google.ProtocolBuffers.TestProtos.SizeMessage2GroupedMessage.Descriptor; } + } + + public override SizeMessage2GroupedMessage DefaultInstanceForType { + get { return global::Google.ProtocolBuffers.TestProtos.SizeMessage2GroupedMessage.DefaultInstance; } + } + + public override SizeMessage2GroupedMessage BuildPartial() { + if (resultIsReadOnly) { + return result; + } + resultIsReadOnly = true; + return result.MakeReadOnly(); + } + + + public bool HasField1 { + get { return result.hasField1; } + } + public float Field1 { + get { return result.Field1; } + set { SetField1(value); } + } + public Builder SetField1(float value) { + PrepareBuilder(); + result.hasField1 = true; + result.field1_ = value; + return this; + } + public Builder ClearField1() { + PrepareBuilder(); + result.hasField1 = false; + result.field1_ = 0F; + return this; + } + + public bool HasField2 { + get { return result.hasField2; } + } + public float Field2 { + get { return result.Field2; } + set { SetField2(value); } + } + public Builder SetField2(float value) { + PrepareBuilder(); + result.hasField2 = true; + result.field2_ = value; + return this; + } + public Builder ClearField2() { + PrepareBuilder(); + result.hasField2 = false; + result.field2_ = 0F; + return this; + } + + public bool HasField3 { + get { return result.hasField3; } + } + public float Field3 { + get { return result.Field3; } + set { SetField3(value); } + } + public Builder SetField3(float value) { + PrepareBuilder(); + result.hasField3 = true; + result.field3_ = value; + return this; + } + public Builder ClearField3() { + PrepareBuilder(); + result.hasField3 = false; + result.field3_ = 0F; + return this; + } + + public bool HasField4 { + get { return result.hasField4; } + } + public bool Field4 { + get { return result.Field4; } + set { SetField4(value); } + } + public Builder SetField4(bool value) { + PrepareBuilder(); + result.hasField4 = true; + result.field4_ = value; + return this; + } + public Builder ClearField4() { + PrepareBuilder(); + result.hasField4 = false; + result.field4_ = false; + return this; + } + + public bool HasField5 { + get { return result.hasField5; } + } + public bool Field5 { + get { return result.Field5; } + set { SetField5(value); } + } + public Builder SetField5(bool value) { + PrepareBuilder(); + result.hasField5 = true; + result.field5_ = value; + return this; + } + public Builder ClearField5() { + PrepareBuilder(); + result.hasField5 = false; + result.field5_ = false; + return this; + } + + public bool HasField6 { + get { return result.hasField6; } + } + public bool Field6 { + get { return result.Field6; } + set { SetField6(value); } + } + public Builder SetField6(bool value) { + PrepareBuilder(); + result.hasField6 = true; + result.field6_ = value; + return this; + } + public Builder ClearField6() { + PrepareBuilder(); + result.hasField6 = false; + result.field6_ = true; + return this; + } + + public bool HasField7 { + get { return result.hasField7; } + } + public bool Field7 { + get { return result.Field7; } + set { SetField7(value); } + } + public Builder SetField7(bool value) { + PrepareBuilder(); + result.hasField7 = true; + result.field7_ = value; + return this; + } + public Builder ClearField7() { + PrepareBuilder(); + result.hasField7 = false; + result.field7_ = false; + return this; + } + + public bool HasField8 { + get { return result.hasField8; } + } + public float Field8 { + get { return result.Field8; } + set { SetField8(value); } + } + public Builder SetField8(float value) { + PrepareBuilder(); + result.hasField8 = true; + result.field8_ = value; + return this; + } + public Builder ClearField8() { + PrepareBuilder(); + result.hasField8 = false; + result.field8_ = 0F; + return this; + } + + public bool HasField9 { + get { return result.hasField9; } + } + public bool Field9 { + get { return result.Field9; } + set { SetField9(value); } + } + public Builder SetField9(bool value) { + PrepareBuilder(); + result.hasField9 = true; + result.field9_ = value; + return this; + } + public Builder ClearField9() { + PrepareBuilder(); + result.hasField9 = false; + result.field9_ = false; + return this; + } + + public bool HasField10 { + get { return result.hasField10; } + } + public float Field10 { + get { return result.Field10; } + set { SetField10(value); } + } + public Builder SetField10(float value) { + PrepareBuilder(); + result.hasField10 = true; + result.field10_ = value; + return this; + } + public Builder ClearField10() { + PrepareBuilder(); + result.hasField10 = false; + result.field10_ = 0F; + return this; + } + + public bool HasField11 { + get { return result.hasField11; } + } + public long Field11 { + get { return result.Field11; } + set { SetField11(value); } + } + public Builder SetField11(long value) { + PrepareBuilder(); + result.hasField11 = true; + result.field11_ = value; + return this; + } + public Builder ClearField11() { + PrepareBuilder(); + result.hasField11 = false; + result.field11_ = 0L; + return this; + } + } + static SizeMessage2GroupedMessage() { + object.ReferenceEquals(global::Google.ProtocolBuffers.TestProtos.GoogleSize.Descriptor, null); + } + } + + #endregion + +} + +#endregion Designer generated code diff --git a/csharp/src/ProtoBench/GoogleSpeed.cs b/csharp/src/ProtoBench/GoogleSpeed.cs new file mode 100644 index 00000000..13e684a5 --- /dev/null +++ b/csharp/src/ProtoBench/GoogleSpeed.cs @@ -0,0 +1,6634 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: google_speed.proto +#pragma warning disable 1591, 0612, 3021 +#region Designer generated code + +using pb = global::Google.ProtocolBuffers; +using pbc = global::Google.ProtocolBuffers.Collections; +using pbd = global::Google.ProtocolBuffers.Descriptors; +using scg = global::System.Collections.Generic; +namespace Google.ProtocolBuffers.TestProtos { + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public static partial class GoogleSpeed { + + #region Extension registration + public static void RegisterAllExtensions(pb::ExtensionRegistry registry) { + } + #endregion + #region Static variables + internal static pbd::MessageDescriptor internal__static_benchmarks_SpeedMessage1__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_benchmarks_SpeedMessage1__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_benchmarks_SpeedMessage1SubMessage__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_benchmarks_SpeedMessage1SubMessage__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_benchmarks_SpeedMessage2__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_benchmarks_SpeedMessage2__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_benchmarks_SpeedMessage2_Group1__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_benchmarks_SpeedMessage2_Group1__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_benchmarks_SpeedMessage2GroupedMessage__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_benchmarks_SpeedMessage2GroupedMessage__FieldAccessorTable; + #endregion + #region Descriptor + public static pbd::FileDescriptor Descriptor { + get { return descriptor; } + } + private static pbd::FileDescriptor descriptor; + + static GoogleSpeed() { + byte[] descriptorData = global::System.Convert.FromBase64String( + string.Concat( + "ChJnb29nbGVfc3BlZWQucHJvdG8SCmJlbmNobWFya3Mi+AYKDVNwZWVkTWVz", + "c2FnZTESDgoGZmllbGQxGAEgAigJEg4KBmZpZWxkORgJIAEoCRIPCgdmaWVs", + "ZDE4GBIgASgJEhYKB2ZpZWxkODAYUCABKAg6BWZhbHNlEhUKB2ZpZWxkODEY", + "USABKAg6BHRydWUSDgoGZmllbGQyGAIgAigFEg4KBmZpZWxkMxgDIAIoBRIR", + "CghmaWVsZDI4MBiYAiABKAUSEQoGZmllbGQ2GAYgASgFOgEwEg8KB2ZpZWxk", + "MjIYFiABKAMSDgoGZmllbGQ0GAQgASgJEg4KBmZpZWxkNRgFIAMoBhIWCgdm", + "aWVsZDU5GDsgASgIOgVmYWxzZRIOCgZmaWVsZDcYByABKAkSDwoHZmllbGQx", + "NhgQIAEoBRIUCghmaWVsZDEzMBiCASABKAU6ATASFQoHZmllbGQxMhgMIAEo", + "CDoEdHJ1ZRIVCgdmaWVsZDE3GBEgASgIOgR0cnVlEhUKB2ZpZWxkMTMYDSAB", + "KAg6BHRydWUSFQoHZmllbGQxNBgOIAEoCDoEdHJ1ZRITCghmaWVsZDEwNBho", + "IAEoBToBMBITCghmaWVsZDEwMBhkIAEoBToBMBITCghmaWVsZDEwMRhlIAEo", + "BToBMBIQCghmaWVsZDEwMhhmIAEoCRIQCghmaWVsZDEwMxhnIAEoCRISCgdm", + "aWVsZDI5GB0gASgFOgEwEhYKB2ZpZWxkMzAYHiABKAg6BWZhbHNlEhMKB2Zp", + "ZWxkNjAYPCABKAU6Ai0xEhUKCGZpZWxkMjcxGI8CIAEoBToCLTESFQoIZmll", + "bGQyNzIYkAIgASgFOgItMRIRCghmaWVsZDE1MBiWASABKAUSEgoHZmllbGQy", + "MxgXIAEoBToBMBIWCgdmaWVsZDI0GBggASgIOgVmYWxzZRISCgdmaWVsZDI1", + "GBkgASgFOgEwEjQKB2ZpZWxkMTUYDyABKAsyIy5iZW5jaG1hcmtzLlNwZWVk", + "TWVzc2FnZTFTdWJNZXNzYWdlEg8KB2ZpZWxkNzgYTiABKAgSEgoHZmllbGQ2", + "NxhDIAEoBToBMBIPCgdmaWVsZDY4GEQgASgFEhQKCGZpZWxkMTI4GIABIAEo", + "BToBMBIoCghmaWVsZDEyORiBASABKAk6FXh4eHh4eHh4eHh4eHh4eHh4eHh4", + "eBIUCghmaWVsZDEzMRiDASABKAU6ATAiogMKF1NwZWVkTWVzc2FnZTFTdWJN", + "ZXNzYWdlEhEKBmZpZWxkMRgBIAEoBToBMBIRCgZmaWVsZDIYAiABKAU6ATAS", + "EQoGZmllbGQzGAMgASgFOgEwEg8KB2ZpZWxkMTUYDyABKAkSFQoHZmllbGQx", + "MhgMIAEoCDoEdHJ1ZRIPCgdmaWVsZDEzGA0gASgDEg8KB2ZpZWxkMTQYDiAB", + "KAMSDwoHZmllbGQxNhgQIAEoBRISCgdmaWVsZDE5GBMgASgFOgEyEhUKB2Zp", + "ZWxkMjAYFCABKAg6BHRydWUSFQoHZmllbGQyOBgcIAEoCDoEdHJ1ZRIPCgdm", + "aWVsZDIxGBUgASgGEg8KB2ZpZWxkMjIYFiABKAUSFgoHZmllbGQyMxgXIAEo", + "CDoFZmFsc2USGAoIZmllbGQyMDYYzgEgASgIOgVmYWxzZRIRCghmaWVsZDIw", + "MxjLASABKAcSEQoIZmllbGQyMDQYzAEgASgFEhEKCGZpZWxkMjA1GM0BIAEo", + "CRIRCghmaWVsZDIwNxjPASABKAQSEQoIZmllbGQzMDAYrAIgASgEIsoHCg1T", + "cGVlZE1lc3NhZ2UyEg4KBmZpZWxkMRgBIAEoCRIOCgZmaWVsZDMYAyABKAMS", + "DgoGZmllbGQ0GAQgASgDEg8KB2ZpZWxkMzAYHiABKAMSFgoHZmllbGQ3NRhL", + "IAEoCDoFZmFsc2USDgoGZmllbGQ2GAYgASgJEg4KBmZpZWxkMhgCIAEoDBIS", + "CgdmaWVsZDIxGBUgASgFOgEwEg8KB2ZpZWxkNzEYRyABKAUSDwoHZmllbGQy", + "NRgZIAEoAhITCghmaWVsZDEwORhtIAEoBToBMBIUCghmaWVsZDIxMBjSASAB", + "KAU6ATASFAoIZmllbGQyMTEY0wEgASgFOgEwEhQKCGZpZWxkMjEyGNQBIAEo", + "BToBMBIUCghmaWVsZDIxMxjVASABKAU6ATASFAoIZmllbGQyMTYY2AEgASgF", + "OgEwEhQKCGZpZWxkMjE3GNkBIAEoBToBMBIUCghmaWVsZDIxOBjaASABKAU6", + "ATASFAoIZmllbGQyMjAY3AEgASgFOgEwEhQKCGZpZWxkMjIxGN0BIAEoBToB", + "MBIUCghmaWVsZDIyMhjeASABKAI6ATASDwoHZmllbGQ2Mxg/IAEoBRIwCgZn", + "cm91cDEYCiADKAoyIC5iZW5jaG1hcmtzLlNwZWVkTWVzc2FnZTIuR3JvdXAx", + "EhEKCGZpZWxkMTI4GIABIAMoCRIRCghmaWVsZDEzMRiDASABKAMSEAoIZmll", + "bGQxMjcYfyADKAkSEQoIZmllbGQxMjkYgQEgASgFEhEKCGZpZWxkMTMwGIIB", + "IAMoAxIYCghmaWVsZDIwNRjNASABKAg6BWZhbHNlEhgKCGZpZWxkMjA2GM4B", + "IAEoCDoFZmFsc2UawwIKBkdyb3VwMRIPCgdmaWVsZDExGAsgAigCEg8KB2Zp", + "ZWxkMjYYGiABKAISDwoHZmllbGQxMhgMIAEoCRIPCgdmaWVsZDEzGA0gASgJ", + "Eg8KB2ZpZWxkMTQYDiADKAkSDwoHZmllbGQxNRgPIAIoBBIOCgZmaWVsZDUY", + "BSABKAUSDwoHZmllbGQyNxgbIAEoCRIPCgdmaWVsZDI4GBwgASgFEg8KB2Zp", + "ZWxkMjkYHSABKAkSDwoHZmllbGQxNhgQIAEoCRIPCgdmaWVsZDIyGBYgAygJ", + "Eg8KB2ZpZWxkNzMYSSADKAUSEgoHZmllbGQyMBgUIAEoBToBMBIPCgdmaWVs", + "ZDI0GBggASgJEjgKB2ZpZWxkMzEYHyABKAsyJy5iZW5jaG1hcmtzLlNwZWVk", + "TWVzc2FnZTJHcm91cGVkTWVzc2FnZSLfAQobU3BlZWRNZXNzYWdlMkdyb3Vw", + "ZWRNZXNzYWdlEg4KBmZpZWxkMRgBIAEoAhIOCgZmaWVsZDIYAiABKAISEQoG", + "ZmllbGQzGAMgASgCOgEwEg4KBmZpZWxkNBgEIAEoCBIOCgZmaWVsZDUYBSAB", + "KAgSFAoGZmllbGQ2GAYgASgIOgR0cnVlEhUKBmZpZWxkNxgHIAEoCDoFZmFs", + "c2USDgoGZmllbGQ4GAggASgCEg4KBmZpZWxkORgJIAEoCBIPCgdmaWVsZDEw", + "GAogASgCEg8KB2ZpZWxkMTEYCyABKANCM0ILR29vZ2xlU3BlZWRIAaoCIUdv", + "b2dsZS5Qcm90b2NvbEJ1ZmZlcnMuVGVzdFByb3Rvcw==")); + pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) { + descriptor = root; + internal__static_benchmarks_SpeedMessage1__Descriptor = Descriptor.MessageTypes[0]; + internal__static_benchmarks_SpeedMessage1__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_benchmarks_SpeedMessage1__Descriptor, + new string[] { "Field1", "Field9", "Field18", "Field80", "Field81", "Field2", "Field3", "Field280", "Field6", "Field22", "Field4", "Field5", "Field59", "Field7", "Field16", "Field130", "Field12", "Field17", "Field13", "Field14", "Field104", "Field100", "Field101", "Field102", "Field103", "Field29", "Field30", "Field60", "Field271", "Field272", "Field150", "Field23", "Field24", "Field25", "Field15", "Field78", "Field67", "Field68", "Field128", "Field129", "Field131", }); + internal__static_benchmarks_SpeedMessage1SubMessage__Descriptor = Descriptor.MessageTypes[1]; + internal__static_benchmarks_SpeedMessage1SubMessage__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_benchmarks_SpeedMessage1SubMessage__Descriptor, + new string[] { "Field1", "Field2", "Field3", "Field15", "Field12", "Field13", "Field14", "Field16", "Field19", "Field20", "Field28", "Field21", "Field22", "Field23", "Field206", "Field203", "Field204", "Field205", "Field207", "Field300", }); + internal__static_benchmarks_SpeedMessage2__Descriptor = Descriptor.MessageTypes[2]; + internal__static_benchmarks_SpeedMessage2__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_benchmarks_SpeedMessage2__Descriptor, + new string[] { "Field1", "Field3", "Field4", "Field30", "Field75", "Field6", "Field2", "Field21", "Field71", "Field25", "Field109", "Field210", "Field211", "Field212", "Field213", "Field216", "Field217", "Field218", "Field220", "Field221", "Field222", "Field63", "Group1", "Field128", "Field131", "Field127", "Field129", "Field130", "Field205", "Field206", }); + internal__static_benchmarks_SpeedMessage2_Group1__Descriptor = internal__static_benchmarks_SpeedMessage2__Descriptor.NestedTypes[0]; + internal__static_benchmarks_SpeedMessage2_Group1__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_benchmarks_SpeedMessage2_Group1__Descriptor, + new string[] { "Field11", "Field26", "Field12", "Field13", "Field14", "Field15", "Field5", "Field27", "Field28", "Field29", "Field16", "Field22", "Field73", "Field20", "Field24", "Field31", }); + internal__static_benchmarks_SpeedMessage2GroupedMessage__Descriptor = Descriptor.MessageTypes[3]; + internal__static_benchmarks_SpeedMessage2GroupedMessage__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_benchmarks_SpeedMessage2GroupedMessage__Descriptor, + new string[] { "Field1", "Field2", "Field3", "Field4", "Field5", "Field6", "Field7", "Field8", "Field9", "Field10", "Field11", }); + pb::ExtensionRegistry registry = pb::ExtensionRegistry.CreateInstance(); + RegisterAllExtensions(registry); + return registry; + }; + pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData, + new pbd::FileDescriptor[] { + }, assigner); + } + #endregion + + } + #region Messages + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class SpeedMessage1 : pb::GeneratedMessage { + private SpeedMessage1() { } + private static readonly SpeedMessage1 defaultInstance = new SpeedMessage1().MakeReadOnly(); + private static readonly string[] _speedMessage1FieldNames = new string[] { "field1", "field100", "field101", "field102", "field103", "field104", "field12", "field128", "field129", "field13", "field130", "field131", "field14", "field15", "field150", "field16", "field17", "field18", "field2", "field22", "field23", "field24", "field25", "field271", "field272", "field280", "field29", "field3", "field30", "field4", "field5", "field59", "field6", "field60", "field67", "field68", "field7", "field78", "field80", "field81", "field9" }; + private static readonly uint[] _speedMessage1FieldTags = new uint[] { 10, 800, 808, 818, 826, 832, 96, 1024, 1034, 104, 1040, 1048, 112, 122, 1200, 128, 136, 146, 16, 176, 184, 192, 200, 2168, 2176, 2240, 232, 24, 240, 34, 41, 472, 48, 480, 536, 544, 58, 624, 640, 648, 74 }; + public static SpeedMessage1 DefaultInstance { + get { return defaultInstance; } + } + + public override SpeedMessage1 DefaultInstanceForType { + get { return DefaultInstance; } + } + + protected override SpeedMessage1 ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.GoogleSpeed.internal__static_benchmarks_SpeedMessage1__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.GoogleSpeed.internal__static_benchmarks_SpeedMessage1__FieldAccessorTable; } + } + + public const int Field1FieldNumber = 1; + private bool hasField1; + private string field1_ = ""; + public bool HasField1 { + get { return hasField1; } + } + public string Field1 { + get { return field1_; } + } + + public const int Field9FieldNumber = 9; + private bool hasField9; + private string field9_ = ""; + public bool HasField9 { + get { return hasField9; } + } + public string Field9 { + get { return field9_; } + } + + public const int Field18FieldNumber = 18; + private bool hasField18; + private string field18_ = ""; + public bool HasField18 { + get { return hasField18; } + } + public string Field18 { + get { return field18_; } + } + + public const int Field80FieldNumber = 80; + private bool hasField80; + private bool field80_; + public bool HasField80 { + get { return hasField80; } + } + public bool Field80 { + get { return field80_; } + } + + public const int Field81FieldNumber = 81; + private bool hasField81; + private bool field81_ = true; + public bool HasField81 { + get { return hasField81; } + } + public bool Field81 { + get { return field81_; } + } + + public const int Field2FieldNumber = 2; + private bool hasField2; + private int field2_; + public bool HasField2 { + get { return hasField2; } + } + public int Field2 { + get { return field2_; } + } + + public const int Field3FieldNumber = 3; + private bool hasField3; + private int field3_; + public bool HasField3 { + get { return hasField3; } + } + public int Field3 { + get { return field3_; } + } + + public const int Field280FieldNumber = 280; + private bool hasField280; + private int field280_; + public bool HasField280 { + get { return hasField280; } + } + public int Field280 { + get { return field280_; } + } + + public const int Field6FieldNumber = 6; + private bool hasField6; + private int field6_; + public bool HasField6 { + get { return hasField6; } + } + public int Field6 { + get { return field6_; } + } + + public const int Field22FieldNumber = 22; + private bool hasField22; + private long field22_; + public bool HasField22 { + get { return hasField22; } + } + public long Field22 { + get { return field22_; } + } + + public const int Field4FieldNumber = 4; + private bool hasField4; + private string field4_ = ""; + public bool HasField4 { + get { return hasField4; } + } + public string Field4 { + get { return field4_; } + } + + public const int Field5FieldNumber = 5; + private pbc::PopsicleList field5_ = new pbc::PopsicleList(); + [global::System.CLSCompliant(false)] + public scg::IList Field5List { + get { return pbc::Lists.AsReadOnly(field5_); } + } + public int Field5Count { + get { return field5_.Count; } + } + [global::System.CLSCompliant(false)] + public ulong GetField5(int index) { + return field5_[index]; + } + + public const int Field59FieldNumber = 59; + private bool hasField59; + private bool field59_; + public bool HasField59 { + get { return hasField59; } + } + public bool Field59 { + get { return field59_; } + } + + public const int Field7FieldNumber = 7; + private bool hasField7; + private string field7_ = ""; + public bool HasField7 { + get { return hasField7; } + } + public string Field7 { + get { return field7_; } + } + + public const int Field16FieldNumber = 16; + private bool hasField16; + private int field16_; + public bool HasField16 { + get { return hasField16; } + } + public int Field16 { + get { return field16_; } + } + + public const int Field130FieldNumber = 130; + private bool hasField130; + private int field130_; + public bool HasField130 { + get { return hasField130; } + } + public int Field130 { + get { return field130_; } + } + + public const int Field12FieldNumber = 12; + private bool hasField12; + private bool field12_ = true; + public bool HasField12 { + get { return hasField12; } + } + public bool Field12 { + get { return field12_; } + } + + public const int Field17FieldNumber = 17; + private bool hasField17; + private bool field17_ = true; + public bool HasField17 { + get { return hasField17; } + } + public bool Field17 { + get { return field17_; } + } + + public const int Field13FieldNumber = 13; + private bool hasField13; + private bool field13_ = true; + public bool HasField13 { + get { return hasField13; } + } + public bool Field13 { + get { return field13_; } + } + + public const int Field14FieldNumber = 14; + private bool hasField14; + private bool field14_ = true; + public bool HasField14 { + get { return hasField14; } + } + public bool Field14 { + get { return field14_; } + } + + public const int Field104FieldNumber = 104; + private bool hasField104; + private int field104_; + public bool HasField104 { + get { return hasField104; } + } + public int Field104 { + get { return field104_; } + } + + public const int Field100FieldNumber = 100; + private bool hasField100; + private int field100_; + public bool HasField100 { + get { return hasField100; } + } + public int Field100 { + get { return field100_; } + } + + public const int Field101FieldNumber = 101; + private bool hasField101; + private int field101_; + public bool HasField101 { + get { return hasField101; } + } + public int Field101 { + get { return field101_; } + } + + public const int Field102FieldNumber = 102; + private bool hasField102; + private string field102_ = ""; + public bool HasField102 { + get { return hasField102; } + } + public string Field102 { + get { return field102_; } + } + + public const int Field103FieldNumber = 103; + private bool hasField103; + private string field103_ = ""; + public bool HasField103 { + get { return hasField103; } + } + public string Field103 { + get { return field103_; } + } + + public const int Field29FieldNumber = 29; + private bool hasField29; + private int field29_; + public bool HasField29 { + get { return hasField29; } + } + public int Field29 { + get { return field29_; } + } + + public const int Field30FieldNumber = 30; + private bool hasField30; + private bool field30_; + public bool HasField30 { + get { return hasField30; } + } + public bool Field30 { + get { return field30_; } + } + + public const int Field60FieldNumber = 60; + private bool hasField60; + private int field60_ = -1; + public bool HasField60 { + get { return hasField60; } + } + public int Field60 { + get { return field60_; } + } + + public const int Field271FieldNumber = 271; + private bool hasField271; + private int field271_ = -1; + public bool HasField271 { + get { return hasField271; } + } + public int Field271 { + get { return field271_; } + } + + public const int Field272FieldNumber = 272; + private bool hasField272; + private int field272_ = -1; + public bool HasField272 { + get { return hasField272; } + } + public int Field272 { + get { return field272_; } + } + + public const int Field150FieldNumber = 150; + private bool hasField150; + private int field150_; + public bool HasField150 { + get { return hasField150; } + } + public int Field150 { + get { return field150_; } + } + + public const int Field23FieldNumber = 23; + private bool hasField23; + private int field23_; + public bool HasField23 { + get { return hasField23; } + } + public int Field23 { + get { return field23_; } + } + + public const int Field24FieldNumber = 24; + private bool hasField24; + private bool field24_; + public bool HasField24 { + get { return hasField24; } + } + public bool Field24 { + get { return field24_; } + } + + public const int Field25FieldNumber = 25; + private bool hasField25; + private int field25_; + public bool HasField25 { + get { return hasField25; } + } + public int Field25 { + get { return field25_; } + } + + public const int Field15FieldNumber = 15; + private bool hasField15; + private global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage field15_; + public bool HasField15 { + get { return hasField15; } + } + public global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage Field15 { + get { return field15_ ?? global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage.DefaultInstance; } + } + + public const int Field78FieldNumber = 78; + private bool hasField78; + private bool field78_; + public bool HasField78 { + get { return hasField78; } + } + public bool Field78 { + get { return field78_; } + } + + public const int Field67FieldNumber = 67; + private bool hasField67; + private int field67_; + public bool HasField67 { + get { return hasField67; } + } + public int Field67 { + get { return field67_; } + } + + public const int Field68FieldNumber = 68; + private bool hasField68; + private int field68_; + public bool HasField68 { + get { return hasField68; } + } + public int Field68 { + get { return field68_; } + } + + public const int Field128FieldNumber = 128; + private bool hasField128; + private int field128_; + public bool HasField128 { + get { return hasField128; } + } + public int Field128 { + get { return field128_; } + } + + public const int Field129FieldNumber = 129; + private bool hasField129; + private string field129_ = "xxxxxxxxxxxxxxxxxxxxx"; + public bool HasField129 { + get { return hasField129; } + } + public string Field129 { + get { return field129_; } + } + + public const int Field131FieldNumber = 131; + private bool hasField131; + private int field131_; + public bool HasField131 { + get { return hasField131; } + } + public int Field131 { + get { return field131_; } + } + + public override bool IsInitialized { + get { + if (!hasField1) return false; + if (!hasField2) return false; + if (!hasField3) return false; + return true; + } + } + + public override void WriteTo(pb::ICodedOutputStream output) { + CalcSerializedSize(); + string[] field_names = _speedMessage1FieldNames; + if (hasField1) { + output.WriteString(1, field_names[0], Field1); + } + if (hasField2) { + output.WriteInt32(2, field_names[18], Field2); + } + if (hasField3) { + output.WriteInt32(3, field_names[27], Field3); + } + if (hasField4) { + output.WriteString(4, field_names[29], Field4); + } + if (field5_.Count > 0) { + output.WriteFixed64Array(5, field_names[30], field5_); + } + if (hasField6) { + output.WriteInt32(6, field_names[32], Field6); + } + if (hasField7) { + output.WriteString(7, field_names[36], Field7); + } + if (hasField9) { + output.WriteString(9, field_names[40], Field9); + } + if (hasField12) { + output.WriteBool(12, field_names[6], Field12); + } + if (hasField13) { + output.WriteBool(13, field_names[9], Field13); + } + if (hasField14) { + output.WriteBool(14, field_names[12], Field14); + } + if (hasField15) { + output.WriteMessage(15, field_names[13], Field15); + } + if (hasField16) { + output.WriteInt32(16, field_names[15], Field16); + } + if (hasField17) { + output.WriteBool(17, field_names[16], Field17); + } + if (hasField18) { + output.WriteString(18, field_names[17], Field18); + } + if (hasField22) { + output.WriteInt64(22, field_names[19], Field22); + } + if (hasField23) { + output.WriteInt32(23, field_names[20], Field23); + } + if (hasField24) { + output.WriteBool(24, field_names[21], Field24); + } + if (hasField25) { + output.WriteInt32(25, field_names[22], Field25); + } + if (hasField29) { + output.WriteInt32(29, field_names[26], Field29); + } + if (hasField30) { + output.WriteBool(30, field_names[28], Field30); + } + if (hasField59) { + output.WriteBool(59, field_names[31], Field59); + } + if (hasField60) { + output.WriteInt32(60, field_names[33], Field60); + } + if (hasField67) { + output.WriteInt32(67, field_names[34], Field67); + } + if (hasField68) { + output.WriteInt32(68, field_names[35], Field68); + } + if (hasField78) { + output.WriteBool(78, field_names[37], Field78); + } + if (hasField80) { + output.WriteBool(80, field_names[38], Field80); + } + if (hasField81) { + output.WriteBool(81, field_names[39], Field81); + } + if (hasField100) { + output.WriteInt32(100, field_names[1], Field100); + } + if (hasField101) { + output.WriteInt32(101, field_names[2], Field101); + } + if (hasField102) { + output.WriteString(102, field_names[3], Field102); + } + if (hasField103) { + output.WriteString(103, field_names[4], Field103); + } + if (hasField104) { + output.WriteInt32(104, field_names[5], Field104); + } + if (hasField128) { + output.WriteInt32(128, field_names[7], Field128); + } + if (hasField129) { + output.WriteString(129, field_names[8], Field129); + } + if (hasField130) { + output.WriteInt32(130, field_names[10], Field130); + } + if (hasField131) { + output.WriteInt32(131, field_names[11], Field131); + } + if (hasField150) { + output.WriteInt32(150, field_names[14], Field150); + } + if (hasField271) { + output.WriteInt32(271, field_names[23], Field271); + } + if (hasField272) { + output.WriteInt32(272, field_names[24], Field272); + } + if (hasField280) { + output.WriteInt32(280, field_names[25], Field280); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + return CalcSerializedSize(); + } + } + + private int CalcSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (hasField1) { + size += pb::CodedOutputStream.ComputeStringSize(1, Field1); + } + if (hasField9) { + size += pb::CodedOutputStream.ComputeStringSize(9, Field9); + } + if (hasField18) { + size += pb::CodedOutputStream.ComputeStringSize(18, Field18); + } + if (hasField80) { + size += pb::CodedOutputStream.ComputeBoolSize(80, Field80); + } + if (hasField81) { + size += pb::CodedOutputStream.ComputeBoolSize(81, Field81); + } + if (hasField2) { + size += pb::CodedOutputStream.ComputeInt32Size(2, Field2); + } + if (hasField3) { + size += pb::CodedOutputStream.ComputeInt32Size(3, Field3); + } + if (hasField280) { + size += pb::CodedOutputStream.ComputeInt32Size(280, Field280); + } + if (hasField6) { + size += pb::CodedOutputStream.ComputeInt32Size(6, Field6); + } + if (hasField22) { + size += pb::CodedOutputStream.ComputeInt64Size(22, Field22); + } + if (hasField4) { + size += pb::CodedOutputStream.ComputeStringSize(4, Field4); + } + { + int dataSize = 0; + dataSize = 8 * field5_.Count; + size += dataSize; + size += 1 * field5_.Count; + } + if (hasField59) { + size += pb::CodedOutputStream.ComputeBoolSize(59, Field59); + } + if (hasField7) { + size += pb::CodedOutputStream.ComputeStringSize(7, Field7); + } + if (hasField16) { + size += pb::CodedOutputStream.ComputeInt32Size(16, Field16); + } + if (hasField130) { + size += pb::CodedOutputStream.ComputeInt32Size(130, Field130); + } + if (hasField12) { + size += pb::CodedOutputStream.ComputeBoolSize(12, Field12); + } + if (hasField17) { + size += pb::CodedOutputStream.ComputeBoolSize(17, Field17); + } + if (hasField13) { + size += pb::CodedOutputStream.ComputeBoolSize(13, Field13); + } + if (hasField14) { + size += pb::CodedOutputStream.ComputeBoolSize(14, Field14); + } + if (hasField104) { + size += pb::CodedOutputStream.ComputeInt32Size(104, Field104); + } + if (hasField100) { + size += pb::CodedOutputStream.ComputeInt32Size(100, Field100); + } + if (hasField101) { + size += pb::CodedOutputStream.ComputeInt32Size(101, Field101); + } + if (hasField102) { + size += pb::CodedOutputStream.ComputeStringSize(102, Field102); + } + if (hasField103) { + size += pb::CodedOutputStream.ComputeStringSize(103, Field103); + } + if (hasField29) { + size += pb::CodedOutputStream.ComputeInt32Size(29, Field29); + } + if (hasField30) { + size += pb::CodedOutputStream.ComputeBoolSize(30, Field30); + } + if (hasField60) { + size += pb::CodedOutputStream.ComputeInt32Size(60, Field60); + } + if (hasField271) { + size += pb::CodedOutputStream.ComputeInt32Size(271, Field271); + } + if (hasField272) { + size += pb::CodedOutputStream.ComputeInt32Size(272, Field272); + } + if (hasField150) { + size += pb::CodedOutputStream.ComputeInt32Size(150, Field150); + } + if (hasField23) { + size += pb::CodedOutputStream.ComputeInt32Size(23, Field23); + } + if (hasField24) { + size += pb::CodedOutputStream.ComputeBoolSize(24, Field24); + } + if (hasField25) { + size += pb::CodedOutputStream.ComputeInt32Size(25, Field25); + } + if (hasField15) { + size += pb::CodedOutputStream.ComputeMessageSize(15, Field15); + } + if (hasField78) { + size += pb::CodedOutputStream.ComputeBoolSize(78, Field78); + } + if (hasField67) { + size += pb::CodedOutputStream.ComputeInt32Size(67, Field67); + } + if (hasField68) { + size += pb::CodedOutputStream.ComputeInt32Size(68, Field68); + } + if (hasField128) { + size += pb::CodedOutputStream.ComputeInt32Size(128, Field128); + } + if (hasField129) { + size += pb::CodedOutputStream.ComputeStringSize(129, Field129); + } + if (hasField131) { + size += pb::CodedOutputStream.ComputeInt32Size(131, Field131); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + public static SpeedMessage1 ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static SpeedMessage1 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static SpeedMessage1 ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static SpeedMessage1 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static SpeedMessage1 ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static SpeedMessage1 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static SpeedMessage1 ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static SpeedMessage1 ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static SpeedMessage1 ParseFrom(pb::ICodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static SpeedMessage1 ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + private SpeedMessage1 MakeReadOnly() { + field5_.MakeReadOnly(); + return this; + } + + public static Builder CreateBuilder() { return new Builder(); } + public override Builder ToBuilder() { return CreateBuilder(this); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(SpeedMessage1 prototype) { + return new Builder(prototype); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() { + result = DefaultInstance; + resultIsReadOnly = true; + } + internal Builder(SpeedMessage1 cloneFrom) { + result = cloneFrom; + resultIsReadOnly = true; + } + + private bool resultIsReadOnly; + private SpeedMessage1 result; + + private SpeedMessage1 PrepareBuilder() { + if (resultIsReadOnly) { + SpeedMessage1 original = result; + result = new SpeedMessage1(); + resultIsReadOnly = false; + MergeFrom(original); + } + return result; + } + + public override bool IsInitialized { + get { return result.IsInitialized; } + } + + protected override SpeedMessage1 MessageBeingBuilt { + get { return PrepareBuilder(); } + } + + public override Builder Clear() { + result = DefaultInstance; + resultIsReadOnly = true; + return this; + } + + public override Builder Clone() { + if (resultIsReadOnly) { + return new Builder(result); + } else { + return new Builder().MergeFrom(result); + } + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Google.ProtocolBuffers.TestProtos.SpeedMessage1.Descriptor; } + } + + public override SpeedMessage1 DefaultInstanceForType { + get { return global::Google.ProtocolBuffers.TestProtos.SpeedMessage1.DefaultInstance; } + } + + public override SpeedMessage1 BuildPartial() { + if (resultIsReadOnly) { + return result; + } + resultIsReadOnly = true; + return result.MakeReadOnly(); + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is SpeedMessage1) { + return MergeFrom((SpeedMessage1) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(SpeedMessage1 other) { + if (other == global::Google.ProtocolBuffers.TestProtos.SpeedMessage1.DefaultInstance) return this; + PrepareBuilder(); + if (other.HasField1) { + Field1 = other.Field1; + } + if (other.HasField9) { + Field9 = other.Field9; + } + if (other.HasField18) { + Field18 = other.Field18; + } + if (other.HasField80) { + Field80 = other.Field80; + } + if (other.HasField81) { + Field81 = other.Field81; + } + if (other.HasField2) { + Field2 = other.Field2; + } + if (other.HasField3) { + Field3 = other.Field3; + } + if (other.HasField280) { + Field280 = other.Field280; + } + if (other.HasField6) { + Field6 = other.Field6; + } + if (other.HasField22) { + Field22 = other.Field22; + } + if (other.HasField4) { + Field4 = other.Field4; + } + if (other.field5_.Count != 0) { + result.field5_.Add(other.field5_); + } + if (other.HasField59) { + Field59 = other.Field59; + } + if (other.HasField7) { + Field7 = other.Field7; + } + if (other.HasField16) { + Field16 = other.Field16; + } + if (other.HasField130) { + Field130 = other.Field130; + } + if (other.HasField12) { + Field12 = other.Field12; + } + if (other.HasField17) { + Field17 = other.Field17; + } + if (other.HasField13) { + Field13 = other.Field13; + } + if (other.HasField14) { + Field14 = other.Field14; + } + if (other.HasField104) { + Field104 = other.Field104; + } + if (other.HasField100) { + Field100 = other.Field100; + } + if (other.HasField101) { + Field101 = other.Field101; + } + if (other.HasField102) { + Field102 = other.Field102; + } + if (other.HasField103) { + Field103 = other.Field103; + } + if (other.HasField29) { + Field29 = other.Field29; + } + if (other.HasField30) { + Field30 = other.Field30; + } + if (other.HasField60) { + Field60 = other.Field60; + } + if (other.HasField271) { + Field271 = other.Field271; + } + if (other.HasField272) { + Field272 = other.Field272; + } + if (other.HasField150) { + Field150 = other.Field150; + } + if (other.HasField23) { + Field23 = other.Field23; + } + if (other.HasField24) { + Field24 = other.Field24; + } + if (other.HasField25) { + Field25 = other.Field25; + } + if (other.HasField15) { + MergeField15(other.Field15); + } + if (other.HasField78) { + Field78 = other.Field78; + } + if (other.HasField67) { + Field67 = other.Field67; + } + if (other.HasField68) { + Field68 = other.Field68; + } + if (other.HasField128) { + Field128 = other.Field128; + } + if (other.HasField129) { + Field129 = other.Field129; + } + if (other.HasField131) { + Field131 = other.Field131; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::ICodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + PrepareBuilder(); + pb::UnknownFieldSet.Builder unknownFields = null; + uint tag; + string field_name; + while (input.ReadTag(out tag, out field_name)) { + if(tag == 0 && field_name != null) { + int field_ordinal = global::System.Array.BinarySearch(_speedMessage1FieldNames, field_name, global::System.StringComparer.Ordinal); + if(field_ordinal >= 0) + tag = _speedMessage1FieldTags[field_ordinal]; + else { + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name); + continue; + } + } + switch (tag) { + case 0: { + throw pb::InvalidProtocolBufferException.InvalidTag(); + } + default: { + if (pb::WireFormat.IsEndGroupTag(tag)) { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name); + break; + } + case 10: { + result.hasField1 = input.ReadString(ref result.field1_); + break; + } + case 16: { + result.hasField2 = input.ReadInt32(ref result.field2_); + break; + } + case 24: { + result.hasField3 = input.ReadInt32(ref result.field3_); + break; + } + case 34: { + result.hasField4 = input.ReadString(ref result.field4_); + break; + } + case 42: + case 41: { + input.ReadFixed64Array(tag, field_name, result.field5_); + break; + } + case 48: { + result.hasField6 = input.ReadInt32(ref result.field6_); + break; + } + case 58: { + result.hasField7 = input.ReadString(ref result.field7_); + break; + } + case 74: { + result.hasField9 = input.ReadString(ref result.field9_); + break; + } + case 96: { + result.hasField12 = input.ReadBool(ref result.field12_); + break; + } + case 104: { + result.hasField13 = input.ReadBool(ref result.field13_); + break; + } + case 112: { + result.hasField14 = input.ReadBool(ref result.field14_); + break; + } + case 122: { + global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage.CreateBuilder(); + if (result.hasField15) { + subBuilder.MergeFrom(Field15); + } + input.ReadMessage(subBuilder, extensionRegistry); + Field15 = subBuilder.BuildPartial(); + break; + } + case 128: { + result.hasField16 = input.ReadInt32(ref result.field16_); + break; + } + case 136: { + result.hasField17 = input.ReadBool(ref result.field17_); + break; + } + case 146: { + result.hasField18 = input.ReadString(ref result.field18_); + break; + } + case 176: { + result.hasField22 = input.ReadInt64(ref result.field22_); + break; + } + case 184: { + result.hasField23 = input.ReadInt32(ref result.field23_); + break; + } + case 192: { + result.hasField24 = input.ReadBool(ref result.field24_); + break; + } + case 200: { + result.hasField25 = input.ReadInt32(ref result.field25_); + break; + } + case 232: { + result.hasField29 = input.ReadInt32(ref result.field29_); + break; + } + case 240: { + result.hasField30 = input.ReadBool(ref result.field30_); + break; + } + case 472: { + result.hasField59 = input.ReadBool(ref result.field59_); + break; + } + case 480: { + result.hasField60 = input.ReadInt32(ref result.field60_); + break; + } + case 536: { + result.hasField67 = input.ReadInt32(ref result.field67_); + break; + } + case 544: { + result.hasField68 = input.ReadInt32(ref result.field68_); + break; + } + case 624: { + result.hasField78 = input.ReadBool(ref result.field78_); + break; + } + case 640: { + result.hasField80 = input.ReadBool(ref result.field80_); + break; + } + case 648: { + result.hasField81 = input.ReadBool(ref result.field81_); + break; + } + case 800: { + result.hasField100 = input.ReadInt32(ref result.field100_); + break; + } + case 808: { + result.hasField101 = input.ReadInt32(ref result.field101_); + break; + } + case 818: { + result.hasField102 = input.ReadString(ref result.field102_); + break; + } + case 826: { + result.hasField103 = input.ReadString(ref result.field103_); + break; + } + case 832: { + result.hasField104 = input.ReadInt32(ref result.field104_); + break; + } + case 1024: { + result.hasField128 = input.ReadInt32(ref result.field128_); + break; + } + case 1034: { + result.hasField129 = input.ReadString(ref result.field129_); + break; + } + case 1040: { + result.hasField130 = input.ReadInt32(ref result.field130_); + break; + } + case 1048: { + result.hasField131 = input.ReadInt32(ref result.field131_); + break; + } + case 1200: { + result.hasField150 = input.ReadInt32(ref result.field150_); + break; + } + case 2168: { + result.hasField271 = input.ReadInt32(ref result.field271_); + break; + } + case 2176: { + result.hasField272 = input.ReadInt32(ref result.field272_); + break; + } + case 2240: { + result.hasField280 = input.ReadInt32(ref result.field280_); + break; + } + } + } + + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + + + public bool HasField1 { + get { return result.hasField1; } + } + public string Field1 { + get { return result.Field1; } + set { SetField1(value); } + } + public Builder SetField1(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField1 = true; + result.field1_ = value; + return this; + } + public Builder ClearField1() { + PrepareBuilder(); + result.hasField1 = false; + result.field1_ = ""; + return this; + } + + public bool HasField9 { + get { return result.hasField9; } + } + public string Field9 { + get { return result.Field9; } + set { SetField9(value); } + } + public Builder SetField9(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField9 = true; + result.field9_ = value; + return this; + } + public Builder ClearField9() { + PrepareBuilder(); + result.hasField9 = false; + result.field9_ = ""; + return this; + } + + public bool HasField18 { + get { return result.hasField18; } + } + public string Field18 { + get { return result.Field18; } + set { SetField18(value); } + } + public Builder SetField18(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField18 = true; + result.field18_ = value; + return this; + } + public Builder ClearField18() { + PrepareBuilder(); + result.hasField18 = false; + result.field18_ = ""; + return this; + } + + public bool HasField80 { + get { return result.hasField80; } + } + public bool Field80 { + get { return result.Field80; } + set { SetField80(value); } + } + public Builder SetField80(bool value) { + PrepareBuilder(); + result.hasField80 = true; + result.field80_ = value; + return this; + } + public Builder ClearField80() { + PrepareBuilder(); + result.hasField80 = false; + result.field80_ = false; + return this; + } + + public bool HasField81 { + get { return result.hasField81; } + } + public bool Field81 { + get { return result.Field81; } + set { SetField81(value); } + } + public Builder SetField81(bool value) { + PrepareBuilder(); + result.hasField81 = true; + result.field81_ = value; + return this; + } + public Builder ClearField81() { + PrepareBuilder(); + result.hasField81 = false; + result.field81_ = true; + return this; + } + + public bool HasField2 { + get { return result.hasField2; } + } + public int Field2 { + get { return result.Field2; } + set { SetField2(value); } + } + public Builder SetField2(int value) { + PrepareBuilder(); + result.hasField2 = true; + result.field2_ = value; + return this; + } + public Builder ClearField2() { + PrepareBuilder(); + result.hasField2 = false; + result.field2_ = 0; + return this; + } + + public bool HasField3 { + get { return result.hasField3; } + } + public int Field3 { + get { return result.Field3; } + set { SetField3(value); } + } + public Builder SetField3(int value) { + PrepareBuilder(); + result.hasField3 = true; + result.field3_ = value; + return this; + } + public Builder ClearField3() { + PrepareBuilder(); + result.hasField3 = false; + result.field3_ = 0; + return this; + } + + public bool HasField280 { + get { return result.hasField280; } + } + public int Field280 { + get { return result.Field280; } + set { SetField280(value); } + } + public Builder SetField280(int value) { + PrepareBuilder(); + result.hasField280 = true; + result.field280_ = value; + return this; + } + public Builder ClearField280() { + PrepareBuilder(); + result.hasField280 = false; + result.field280_ = 0; + return this; + } + + public bool HasField6 { + get { return result.hasField6; } + } + public int Field6 { + get { return result.Field6; } + set { SetField6(value); } + } + public Builder SetField6(int value) { + PrepareBuilder(); + result.hasField6 = true; + result.field6_ = value; + return this; + } + public Builder ClearField6() { + PrepareBuilder(); + result.hasField6 = false; + result.field6_ = 0; + return this; + } + + public bool HasField22 { + get { return result.hasField22; } + } + public long Field22 { + get { return result.Field22; } + set { SetField22(value); } + } + public Builder SetField22(long value) { + PrepareBuilder(); + result.hasField22 = true; + result.field22_ = value; + return this; + } + public Builder ClearField22() { + PrepareBuilder(); + result.hasField22 = false; + result.field22_ = 0L; + return this; + } + + public bool HasField4 { + get { return result.hasField4; } + } + public string Field4 { + get { return result.Field4; } + set { SetField4(value); } + } + public Builder SetField4(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField4 = true; + result.field4_ = value; + return this; + } + public Builder ClearField4() { + PrepareBuilder(); + result.hasField4 = false; + result.field4_ = ""; + return this; + } + + [global::System.CLSCompliant(false)] + public pbc::IPopsicleList Field5List { + get { return PrepareBuilder().field5_; } + } + public int Field5Count { + get { return result.Field5Count; } + } + [global::System.CLSCompliant(false)] + public ulong GetField5(int index) { + return result.GetField5(index); + } + [global::System.CLSCompliant(false)] + public Builder SetField5(int index, ulong value) { + PrepareBuilder(); + result.field5_[index] = value; + return this; + } + [global::System.CLSCompliant(false)] + public Builder AddField5(ulong value) { + PrepareBuilder(); + result.field5_.Add(value); + return this; + } + [global::System.CLSCompliant(false)] + public Builder AddRangeField5(scg::IEnumerable values) { + PrepareBuilder(); + result.field5_.Add(values); + return this; + } + public Builder ClearField5() { + PrepareBuilder(); + result.field5_.Clear(); + return this; + } + + public bool HasField59 { + get { return result.hasField59; } + } + public bool Field59 { + get { return result.Field59; } + set { SetField59(value); } + } + public Builder SetField59(bool value) { + PrepareBuilder(); + result.hasField59 = true; + result.field59_ = value; + return this; + } + public Builder ClearField59() { + PrepareBuilder(); + result.hasField59 = false; + result.field59_ = false; + return this; + } + + public bool HasField7 { + get { return result.hasField7; } + } + public string Field7 { + get { return result.Field7; } + set { SetField7(value); } + } + public Builder SetField7(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField7 = true; + result.field7_ = value; + return this; + } + public Builder ClearField7() { + PrepareBuilder(); + result.hasField7 = false; + result.field7_ = ""; + return this; + } + + public bool HasField16 { + get { return result.hasField16; } + } + public int Field16 { + get { return result.Field16; } + set { SetField16(value); } + } + public Builder SetField16(int value) { + PrepareBuilder(); + result.hasField16 = true; + result.field16_ = value; + return this; + } + public Builder ClearField16() { + PrepareBuilder(); + result.hasField16 = false; + result.field16_ = 0; + return this; + } + + public bool HasField130 { + get { return result.hasField130; } + } + public int Field130 { + get { return result.Field130; } + set { SetField130(value); } + } + public Builder SetField130(int value) { + PrepareBuilder(); + result.hasField130 = true; + result.field130_ = value; + return this; + } + public Builder ClearField130() { + PrepareBuilder(); + result.hasField130 = false; + result.field130_ = 0; + return this; + } + + public bool HasField12 { + get { return result.hasField12; } + } + public bool Field12 { + get { return result.Field12; } + set { SetField12(value); } + } + public Builder SetField12(bool value) { + PrepareBuilder(); + result.hasField12 = true; + result.field12_ = value; + return this; + } + public Builder ClearField12() { + PrepareBuilder(); + result.hasField12 = false; + result.field12_ = true; + return this; + } + + public bool HasField17 { + get { return result.hasField17; } + } + public bool Field17 { + get { return result.Field17; } + set { SetField17(value); } + } + public Builder SetField17(bool value) { + PrepareBuilder(); + result.hasField17 = true; + result.field17_ = value; + return this; + } + public Builder ClearField17() { + PrepareBuilder(); + result.hasField17 = false; + result.field17_ = true; + return this; + } + + public bool HasField13 { + get { return result.hasField13; } + } + public bool Field13 { + get { return result.Field13; } + set { SetField13(value); } + } + public Builder SetField13(bool value) { + PrepareBuilder(); + result.hasField13 = true; + result.field13_ = value; + return this; + } + public Builder ClearField13() { + PrepareBuilder(); + result.hasField13 = false; + result.field13_ = true; + return this; + } + + public bool HasField14 { + get { return result.hasField14; } + } + public bool Field14 { + get { return result.Field14; } + set { SetField14(value); } + } + public Builder SetField14(bool value) { + PrepareBuilder(); + result.hasField14 = true; + result.field14_ = value; + return this; + } + public Builder ClearField14() { + PrepareBuilder(); + result.hasField14 = false; + result.field14_ = true; + return this; + } + + public bool HasField104 { + get { return result.hasField104; } + } + public int Field104 { + get { return result.Field104; } + set { SetField104(value); } + } + public Builder SetField104(int value) { + PrepareBuilder(); + result.hasField104 = true; + result.field104_ = value; + return this; + } + public Builder ClearField104() { + PrepareBuilder(); + result.hasField104 = false; + result.field104_ = 0; + return this; + } + + public bool HasField100 { + get { return result.hasField100; } + } + public int Field100 { + get { return result.Field100; } + set { SetField100(value); } + } + public Builder SetField100(int value) { + PrepareBuilder(); + result.hasField100 = true; + result.field100_ = value; + return this; + } + public Builder ClearField100() { + PrepareBuilder(); + result.hasField100 = false; + result.field100_ = 0; + return this; + } + + public bool HasField101 { + get { return result.hasField101; } + } + public int Field101 { + get { return result.Field101; } + set { SetField101(value); } + } + public Builder SetField101(int value) { + PrepareBuilder(); + result.hasField101 = true; + result.field101_ = value; + return this; + } + public Builder ClearField101() { + PrepareBuilder(); + result.hasField101 = false; + result.field101_ = 0; + return this; + } + + public bool HasField102 { + get { return result.hasField102; } + } + public string Field102 { + get { return result.Field102; } + set { SetField102(value); } + } + public Builder SetField102(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField102 = true; + result.field102_ = value; + return this; + } + public Builder ClearField102() { + PrepareBuilder(); + result.hasField102 = false; + result.field102_ = ""; + return this; + } + + public bool HasField103 { + get { return result.hasField103; } + } + public string Field103 { + get { return result.Field103; } + set { SetField103(value); } + } + public Builder SetField103(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField103 = true; + result.field103_ = value; + return this; + } + public Builder ClearField103() { + PrepareBuilder(); + result.hasField103 = false; + result.field103_ = ""; + return this; + } + + public bool HasField29 { + get { return result.hasField29; } + } + public int Field29 { + get { return result.Field29; } + set { SetField29(value); } + } + public Builder SetField29(int value) { + PrepareBuilder(); + result.hasField29 = true; + result.field29_ = value; + return this; + } + public Builder ClearField29() { + PrepareBuilder(); + result.hasField29 = false; + result.field29_ = 0; + return this; + } + + public bool HasField30 { + get { return result.hasField30; } + } + public bool Field30 { + get { return result.Field30; } + set { SetField30(value); } + } + public Builder SetField30(bool value) { + PrepareBuilder(); + result.hasField30 = true; + result.field30_ = value; + return this; + } + public Builder ClearField30() { + PrepareBuilder(); + result.hasField30 = false; + result.field30_ = false; + return this; + } + + public bool HasField60 { + get { return result.hasField60; } + } + public int Field60 { + get { return result.Field60; } + set { SetField60(value); } + } + public Builder SetField60(int value) { + PrepareBuilder(); + result.hasField60 = true; + result.field60_ = value; + return this; + } + public Builder ClearField60() { + PrepareBuilder(); + result.hasField60 = false; + result.field60_ = -1; + return this; + } + + public bool HasField271 { + get { return result.hasField271; } + } + public int Field271 { + get { return result.Field271; } + set { SetField271(value); } + } + public Builder SetField271(int value) { + PrepareBuilder(); + result.hasField271 = true; + result.field271_ = value; + return this; + } + public Builder ClearField271() { + PrepareBuilder(); + result.hasField271 = false; + result.field271_ = -1; + return this; + } + + public bool HasField272 { + get { return result.hasField272; } + } + public int Field272 { + get { return result.Field272; } + set { SetField272(value); } + } + public Builder SetField272(int value) { + PrepareBuilder(); + result.hasField272 = true; + result.field272_ = value; + return this; + } + public Builder ClearField272() { + PrepareBuilder(); + result.hasField272 = false; + result.field272_ = -1; + return this; + } + + public bool HasField150 { + get { return result.hasField150; } + } + public int Field150 { + get { return result.Field150; } + set { SetField150(value); } + } + public Builder SetField150(int value) { + PrepareBuilder(); + result.hasField150 = true; + result.field150_ = value; + return this; + } + public Builder ClearField150() { + PrepareBuilder(); + result.hasField150 = false; + result.field150_ = 0; + return this; + } + + public bool HasField23 { + get { return result.hasField23; } + } + public int Field23 { + get { return result.Field23; } + set { SetField23(value); } + } + public Builder SetField23(int value) { + PrepareBuilder(); + result.hasField23 = true; + result.field23_ = value; + return this; + } + public Builder ClearField23() { + PrepareBuilder(); + result.hasField23 = false; + result.field23_ = 0; + return this; + } + + public bool HasField24 { + get { return result.hasField24; } + } + public bool Field24 { + get { return result.Field24; } + set { SetField24(value); } + } + public Builder SetField24(bool value) { + PrepareBuilder(); + result.hasField24 = true; + result.field24_ = value; + return this; + } + public Builder ClearField24() { + PrepareBuilder(); + result.hasField24 = false; + result.field24_ = false; + return this; + } + + public bool HasField25 { + get { return result.hasField25; } + } + public int Field25 { + get { return result.Field25; } + set { SetField25(value); } + } + public Builder SetField25(int value) { + PrepareBuilder(); + result.hasField25 = true; + result.field25_ = value; + return this; + } + public Builder ClearField25() { + PrepareBuilder(); + result.hasField25 = false; + result.field25_ = 0; + return this; + } + + public bool HasField15 { + get { return result.hasField15; } + } + public global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage Field15 { + get { return result.Field15; } + set { SetField15(value); } + } + public Builder SetField15(global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField15 = true; + result.field15_ = value; + return this; + } + public Builder SetField15(global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + PrepareBuilder(); + result.hasField15 = true; + result.field15_ = builderForValue.Build(); + return this; + } + public Builder MergeField15(global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + if (result.hasField15 && + result.field15_ != global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage.DefaultInstance) { + result.field15_ = global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage.CreateBuilder(result.field15_).MergeFrom(value).BuildPartial(); + } else { + result.field15_ = value; + } + result.hasField15 = true; + return this; + } + public Builder ClearField15() { + PrepareBuilder(); + result.hasField15 = false; + result.field15_ = null; + return this; + } + + public bool HasField78 { + get { return result.hasField78; } + } + public bool Field78 { + get { return result.Field78; } + set { SetField78(value); } + } + public Builder SetField78(bool value) { + PrepareBuilder(); + result.hasField78 = true; + result.field78_ = value; + return this; + } + public Builder ClearField78() { + PrepareBuilder(); + result.hasField78 = false; + result.field78_ = false; + return this; + } + + public bool HasField67 { + get { return result.hasField67; } + } + public int Field67 { + get { return result.Field67; } + set { SetField67(value); } + } + public Builder SetField67(int value) { + PrepareBuilder(); + result.hasField67 = true; + result.field67_ = value; + return this; + } + public Builder ClearField67() { + PrepareBuilder(); + result.hasField67 = false; + result.field67_ = 0; + return this; + } + + public bool HasField68 { + get { return result.hasField68; } + } + public int Field68 { + get { return result.Field68; } + set { SetField68(value); } + } + public Builder SetField68(int value) { + PrepareBuilder(); + result.hasField68 = true; + result.field68_ = value; + return this; + } + public Builder ClearField68() { + PrepareBuilder(); + result.hasField68 = false; + result.field68_ = 0; + return this; + } + + public bool HasField128 { + get { return result.hasField128; } + } + public int Field128 { + get { return result.Field128; } + set { SetField128(value); } + } + public Builder SetField128(int value) { + PrepareBuilder(); + result.hasField128 = true; + result.field128_ = value; + return this; + } + public Builder ClearField128() { + PrepareBuilder(); + result.hasField128 = false; + result.field128_ = 0; + return this; + } + + public bool HasField129 { + get { return result.hasField129; } + } + public string Field129 { + get { return result.Field129; } + set { SetField129(value); } + } + public Builder SetField129(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField129 = true; + result.field129_ = value; + return this; + } + public Builder ClearField129() { + PrepareBuilder(); + result.hasField129 = false; + result.field129_ = "xxxxxxxxxxxxxxxxxxxxx"; + return this; + } + + public bool HasField131 { + get { return result.hasField131; } + } + public int Field131 { + get { return result.Field131; } + set { SetField131(value); } + } + public Builder SetField131(int value) { + PrepareBuilder(); + result.hasField131 = true; + result.field131_ = value; + return this; + } + public Builder ClearField131() { + PrepareBuilder(); + result.hasField131 = false; + result.field131_ = 0; + return this; + } + } + static SpeedMessage1() { + object.ReferenceEquals(global::Google.ProtocolBuffers.TestProtos.GoogleSpeed.Descriptor, null); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class SpeedMessage1SubMessage : pb::GeneratedMessage { + private SpeedMessage1SubMessage() { } + private static readonly SpeedMessage1SubMessage defaultInstance = new SpeedMessage1SubMessage().MakeReadOnly(); + private static readonly string[] _speedMessage1SubMessageFieldNames = new string[] { "field1", "field12", "field13", "field14", "field15", "field16", "field19", "field2", "field20", "field203", "field204", "field205", "field206", "field207", "field21", "field22", "field23", "field28", "field3", "field300" }; + private static readonly uint[] _speedMessage1SubMessageFieldTags = new uint[] { 8, 96, 104, 112, 122, 128, 152, 16, 160, 1629, 1632, 1642, 1648, 1656, 169, 176, 184, 224, 24, 2400 }; + public static SpeedMessage1SubMessage DefaultInstance { + get { return defaultInstance; } + } + + public override SpeedMessage1SubMessage DefaultInstanceForType { + get { return DefaultInstance; } + } + + protected override SpeedMessage1SubMessage ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.GoogleSpeed.internal__static_benchmarks_SpeedMessage1SubMessage__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.GoogleSpeed.internal__static_benchmarks_SpeedMessage1SubMessage__FieldAccessorTable; } + } + + public const int Field1FieldNumber = 1; + private bool hasField1; + private int field1_; + public bool HasField1 { + get { return hasField1; } + } + public int Field1 { + get { return field1_; } + } + + public const int Field2FieldNumber = 2; + private bool hasField2; + private int field2_; + public bool HasField2 { + get { return hasField2; } + } + public int Field2 { + get { return field2_; } + } + + public const int Field3FieldNumber = 3; + private bool hasField3; + private int field3_; + public bool HasField3 { + get { return hasField3; } + } + public int Field3 { + get { return field3_; } + } + + public const int Field15FieldNumber = 15; + private bool hasField15; + private string field15_ = ""; + public bool HasField15 { + get { return hasField15; } + } + public string Field15 { + get { return field15_; } + } + + public const int Field12FieldNumber = 12; + private bool hasField12; + private bool field12_ = true; + public bool HasField12 { + get { return hasField12; } + } + public bool Field12 { + get { return field12_; } + } + + public const int Field13FieldNumber = 13; + private bool hasField13; + private long field13_; + public bool HasField13 { + get { return hasField13; } + } + public long Field13 { + get { return field13_; } + } + + public const int Field14FieldNumber = 14; + private bool hasField14; + private long field14_; + public bool HasField14 { + get { return hasField14; } + } + public long Field14 { + get { return field14_; } + } + + public const int Field16FieldNumber = 16; + private bool hasField16; + private int field16_; + public bool HasField16 { + get { return hasField16; } + } + public int Field16 { + get { return field16_; } + } + + public const int Field19FieldNumber = 19; + private bool hasField19; + private int field19_ = 2; + public bool HasField19 { + get { return hasField19; } + } + public int Field19 { + get { return field19_; } + } + + public const int Field20FieldNumber = 20; + private bool hasField20; + private bool field20_ = true; + public bool HasField20 { + get { return hasField20; } + } + public bool Field20 { + get { return field20_; } + } + + public const int Field28FieldNumber = 28; + private bool hasField28; + private bool field28_ = true; + public bool HasField28 { + get { return hasField28; } + } + public bool Field28 { + get { return field28_; } + } + + public const int Field21FieldNumber = 21; + private bool hasField21; + private ulong field21_; + public bool HasField21 { + get { return hasField21; } + } + [global::System.CLSCompliant(false)] + public ulong Field21 { + get { return field21_; } + } + + public const int Field22FieldNumber = 22; + private bool hasField22; + private int field22_; + public bool HasField22 { + get { return hasField22; } + } + public int Field22 { + get { return field22_; } + } + + public const int Field23FieldNumber = 23; + private bool hasField23; + private bool field23_; + public bool HasField23 { + get { return hasField23; } + } + public bool Field23 { + get { return field23_; } + } + + public const int Field206FieldNumber = 206; + private bool hasField206; + private bool field206_; + public bool HasField206 { + get { return hasField206; } + } + public bool Field206 { + get { return field206_; } + } + + public const int Field203FieldNumber = 203; + private bool hasField203; + private uint field203_; + public bool HasField203 { + get { return hasField203; } + } + [global::System.CLSCompliant(false)] + public uint Field203 { + get { return field203_; } + } + + public const int Field204FieldNumber = 204; + private bool hasField204; + private int field204_; + public bool HasField204 { + get { return hasField204; } + } + public int Field204 { + get { return field204_; } + } + + public const int Field205FieldNumber = 205; + private bool hasField205; + private string field205_ = ""; + public bool HasField205 { + get { return hasField205; } + } + public string Field205 { + get { return field205_; } + } + + public const int Field207FieldNumber = 207; + private bool hasField207; + private ulong field207_; + public bool HasField207 { + get { return hasField207; } + } + [global::System.CLSCompliant(false)] + public ulong Field207 { + get { return field207_; } + } + + public const int Field300FieldNumber = 300; + private bool hasField300; + private ulong field300_; + public bool HasField300 { + get { return hasField300; } + } + [global::System.CLSCompliant(false)] + public ulong Field300 { + get { return field300_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::ICodedOutputStream output) { + CalcSerializedSize(); + string[] field_names = _speedMessage1SubMessageFieldNames; + if (hasField1) { + output.WriteInt32(1, field_names[0], Field1); + } + if (hasField2) { + output.WriteInt32(2, field_names[7], Field2); + } + if (hasField3) { + output.WriteInt32(3, field_names[18], Field3); + } + if (hasField12) { + output.WriteBool(12, field_names[1], Field12); + } + if (hasField13) { + output.WriteInt64(13, field_names[2], Field13); + } + if (hasField14) { + output.WriteInt64(14, field_names[3], Field14); + } + if (hasField15) { + output.WriteString(15, field_names[4], Field15); + } + if (hasField16) { + output.WriteInt32(16, field_names[5], Field16); + } + if (hasField19) { + output.WriteInt32(19, field_names[6], Field19); + } + if (hasField20) { + output.WriteBool(20, field_names[8], Field20); + } + if (hasField21) { + output.WriteFixed64(21, field_names[14], Field21); + } + if (hasField22) { + output.WriteInt32(22, field_names[15], Field22); + } + if (hasField23) { + output.WriteBool(23, field_names[16], Field23); + } + if (hasField28) { + output.WriteBool(28, field_names[17], Field28); + } + if (hasField203) { + output.WriteFixed32(203, field_names[9], Field203); + } + if (hasField204) { + output.WriteInt32(204, field_names[10], Field204); + } + if (hasField205) { + output.WriteString(205, field_names[11], Field205); + } + if (hasField206) { + output.WriteBool(206, field_names[12], Field206); + } + if (hasField207) { + output.WriteUInt64(207, field_names[13], Field207); + } + if (hasField300) { + output.WriteUInt64(300, field_names[19], Field300); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + return CalcSerializedSize(); + } + } + + private int CalcSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (hasField1) { + size += pb::CodedOutputStream.ComputeInt32Size(1, Field1); + } + if (hasField2) { + size += pb::CodedOutputStream.ComputeInt32Size(2, Field2); + } + if (hasField3) { + size += pb::CodedOutputStream.ComputeInt32Size(3, Field3); + } + if (hasField15) { + size += pb::CodedOutputStream.ComputeStringSize(15, Field15); + } + if (hasField12) { + size += pb::CodedOutputStream.ComputeBoolSize(12, Field12); + } + if (hasField13) { + size += pb::CodedOutputStream.ComputeInt64Size(13, Field13); + } + if (hasField14) { + size += pb::CodedOutputStream.ComputeInt64Size(14, Field14); + } + if (hasField16) { + size += pb::CodedOutputStream.ComputeInt32Size(16, Field16); + } + if (hasField19) { + size += pb::CodedOutputStream.ComputeInt32Size(19, Field19); + } + if (hasField20) { + size += pb::CodedOutputStream.ComputeBoolSize(20, Field20); + } + if (hasField28) { + size += pb::CodedOutputStream.ComputeBoolSize(28, Field28); + } + if (hasField21) { + size += pb::CodedOutputStream.ComputeFixed64Size(21, Field21); + } + if (hasField22) { + size += pb::CodedOutputStream.ComputeInt32Size(22, Field22); + } + if (hasField23) { + size += pb::CodedOutputStream.ComputeBoolSize(23, Field23); + } + if (hasField206) { + size += pb::CodedOutputStream.ComputeBoolSize(206, Field206); + } + if (hasField203) { + size += pb::CodedOutputStream.ComputeFixed32Size(203, Field203); + } + if (hasField204) { + size += pb::CodedOutputStream.ComputeInt32Size(204, Field204); + } + if (hasField205) { + size += pb::CodedOutputStream.ComputeStringSize(205, Field205); + } + if (hasField207) { + size += pb::CodedOutputStream.ComputeUInt64Size(207, Field207); + } + if (hasField300) { + size += pb::CodedOutputStream.ComputeUInt64Size(300, Field300); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + public static SpeedMessage1SubMessage ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static SpeedMessage1SubMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static SpeedMessage1SubMessage ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static SpeedMessage1SubMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static SpeedMessage1SubMessage ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static SpeedMessage1SubMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static SpeedMessage1SubMessage ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static SpeedMessage1SubMessage ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static SpeedMessage1SubMessage ParseFrom(pb::ICodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static SpeedMessage1SubMessage ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + private SpeedMessage1SubMessage MakeReadOnly() { + return this; + } + + public static Builder CreateBuilder() { return new Builder(); } + public override Builder ToBuilder() { return CreateBuilder(this); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(SpeedMessage1SubMessage prototype) { + return new Builder(prototype); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() { + result = DefaultInstance; + resultIsReadOnly = true; + } + internal Builder(SpeedMessage1SubMessage cloneFrom) { + result = cloneFrom; + resultIsReadOnly = true; + } + + private bool resultIsReadOnly; + private SpeedMessage1SubMessage result; + + private SpeedMessage1SubMessage PrepareBuilder() { + if (resultIsReadOnly) { + SpeedMessage1SubMessage original = result; + result = new SpeedMessage1SubMessage(); + resultIsReadOnly = false; + MergeFrom(original); + } + return result; + } + + public override bool IsInitialized { + get { return result.IsInitialized; } + } + + protected override SpeedMessage1SubMessage MessageBeingBuilt { + get { return PrepareBuilder(); } + } + + public override Builder Clear() { + result = DefaultInstance; + resultIsReadOnly = true; + return this; + } + + public override Builder Clone() { + if (resultIsReadOnly) { + return new Builder(result); + } else { + return new Builder().MergeFrom(result); + } + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage.Descriptor; } + } + + public override SpeedMessage1SubMessage DefaultInstanceForType { + get { return global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage.DefaultInstance; } + } + + public override SpeedMessage1SubMessage BuildPartial() { + if (resultIsReadOnly) { + return result; + } + resultIsReadOnly = true; + return result.MakeReadOnly(); + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is SpeedMessage1SubMessage) { + return MergeFrom((SpeedMessage1SubMessage) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(SpeedMessage1SubMessage other) { + if (other == global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage.DefaultInstance) return this; + PrepareBuilder(); + if (other.HasField1) { + Field1 = other.Field1; + } + if (other.HasField2) { + Field2 = other.Field2; + } + if (other.HasField3) { + Field3 = other.Field3; + } + if (other.HasField15) { + Field15 = other.Field15; + } + if (other.HasField12) { + Field12 = other.Field12; + } + if (other.HasField13) { + Field13 = other.Field13; + } + if (other.HasField14) { + Field14 = other.Field14; + } + if (other.HasField16) { + Field16 = other.Field16; + } + if (other.HasField19) { + Field19 = other.Field19; + } + if (other.HasField20) { + Field20 = other.Field20; + } + if (other.HasField28) { + Field28 = other.Field28; + } + if (other.HasField21) { + Field21 = other.Field21; + } + if (other.HasField22) { + Field22 = other.Field22; + } + if (other.HasField23) { + Field23 = other.Field23; + } + if (other.HasField206) { + Field206 = other.Field206; + } + if (other.HasField203) { + Field203 = other.Field203; + } + if (other.HasField204) { + Field204 = other.Field204; + } + if (other.HasField205) { + Field205 = other.Field205; + } + if (other.HasField207) { + Field207 = other.Field207; + } + if (other.HasField300) { + Field300 = other.Field300; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::ICodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + PrepareBuilder(); + pb::UnknownFieldSet.Builder unknownFields = null; + uint tag; + string field_name; + while (input.ReadTag(out tag, out field_name)) { + if(tag == 0 && field_name != null) { + int field_ordinal = global::System.Array.BinarySearch(_speedMessage1SubMessageFieldNames, field_name, global::System.StringComparer.Ordinal); + if(field_ordinal >= 0) + tag = _speedMessage1SubMessageFieldTags[field_ordinal]; + else { + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name); + continue; + } + } + switch (tag) { + case 0: { + throw pb::InvalidProtocolBufferException.InvalidTag(); + } + default: { + if (pb::WireFormat.IsEndGroupTag(tag)) { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name); + break; + } + case 8: { + result.hasField1 = input.ReadInt32(ref result.field1_); + break; + } + case 16: { + result.hasField2 = input.ReadInt32(ref result.field2_); + break; + } + case 24: { + result.hasField3 = input.ReadInt32(ref result.field3_); + break; + } + case 96: { + result.hasField12 = input.ReadBool(ref result.field12_); + break; + } + case 104: { + result.hasField13 = input.ReadInt64(ref result.field13_); + break; + } + case 112: { + result.hasField14 = input.ReadInt64(ref result.field14_); + break; + } + case 122: { + result.hasField15 = input.ReadString(ref result.field15_); + break; + } + case 128: { + result.hasField16 = input.ReadInt32(ref result.field16_); + break; + } + case 152: { + result.hasField19 = input.ReadInt32(ref result.field19_); + break; + } + case 160: { + result.hasField20 = input.ReadBool(ref result.field20_); + break; + } + case 169: { + result.hasField21 = input.ReadFixed64(ref result.field21_); + break; + } + case 176: { + result.hasField22 = input.ReadInt32(ref result.field22_); + break; + } + case 184: { + result.hasField23 = input.ReadBool(ref result.field23_); + break; + } + case 224: { + result.hasField28 = input.ReadBool(ref result.field28_); + break; + } + case 1629: { + result.hasField203 = input.ReadFixed32(ref result.field203_); + break; + } + case 1632: { + result.hasField204 = input.ReadInt32(ref result.field204_); + break; + } + case 1642: { + result.hasField205 = input.ReadString(ref result.field205_); + break; + } + case 1648: { + result.hasField206 = input.ReadBool(ref result.field206_); + break; + } + case 1656: { + result.hasField207 = input.ReadUInt64(ref result.field207_); + break; + } + case 2400: { + result.hasField300 = input.ReadUInt64(ref result.field300_); + break; + } + } + } + + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + + + public bool HasField1 { + get { return result.hasField1; } + } + public int Field1 { + get { return result.Field1; } + set { SetField1(value); } + } + public Builder SetField1(int value) { + PrepareBuilder(); + result.hasField1 = true; + result.field1_ = value; + return this; + } + public Builder ClearField1() { + PrepareBuilder(); + result.hasField1 = false; + result.field1_ = 0; + return this; + } + + public bool HasField2 { + get { return result.hasField2; } + } + public int Field2 { + get { return result.Field2; } + set { SetField2(value); } + } + public Builder SetField2(int value) { + PrepareBuilder(); + result.hasField2 = true; + result.field2_ = value; + return this; + } + public Builder ClearField2() { + PrepareBuilder(); + result.hasField2 = false; + result.field2_ = 0; + return this; + } + + public bool HasField3 { + get { return result.hasField3; } + } + public int Field3 { + get { return result.Field3; } + set { SetField3(value); } + } + public Builder SetField3(int value) { + PrepareBuilder(); + result.hasField3 = true; + result.field3_ = value; + return this; + } + public Builder ClearField3() { + PrepareBuilder(); + result.hasField3 = false; + result.field3_ = 0; + return this; + } + + public bool HasField15 { + get { return result.hasField15; } + } + public string Field15 { + get { return result.Field15; } + set { SetField15(value); } + } + public Builder SetField15(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField15 = true; + result.field15_ = value; + return this; + } + public Builder ClearField15() { + PrepareBuilder(); + result.hasField15 = false; + result.field15_ = ""; + return this; + } + + public bool HasField12 { + get { return result.hasField12; } + } + public bool Field12 { + get { return result.Field12; } + set { SetField12(value); } + } + public Builder SetField12(bool value) { + PrepareBuilder(); + result.hasField12 = true; + result.field12_ = value; + return this; + } + public Builder ClearField12() { + PrepareBuilder(); + result.hasField12 = false; + result.field12_ = true; + return this; + } + + public bool HasField13 { + get { return result.hasField13; } + } + public long Field13 { + get { return result.Field13; } + set { SetField13(value); } + } + public Builder SetField13(long value) { + PrepareBuilder(); + result.hasField13 = true; + result.field13_ = value; + return this; + } + public Builder ClearField13() { + PrepareBuilder(); + result.hasField13 = false; + result.field13_ = 0L; + return this; + } + + public bool HasField14 { + get { return result.hasField14; } + } + public long Field14 { + get { return result.Field14; } + set { SetField14(value); } + } + public Builder SetField14(long value) { + PrepareBuilder(); + result.hasField14 = true; + result.field14_ = value; + return this; + } + public Builder ClearField14() { + PrepareBuilder(); + result.hasField14 = false; + result.field14_ = 0L; + return this; + } + + public bool HasField16 { + get { return result.hasField16; } + } + public int Field16 { + get { return result.Field16; } + set { SetField16(value); } + } + public Builder SetField16(int value) { + PrepareBuilder(); + result.hasField16 = true; + result.field16_ = value; + return this; + } + public Builder ClearField16() { + PrepareBuilder(); + result.hasField16 = false; + result.field16_ = 0; + return this; + } + + public bool HasField19 { + get { return result.hasField19; } + } + public int Field19 { + get { return result.Field19; } + set { SetField19(value); } + } + public Builder SetField19(int value) { + PrepareBuilder(); + result.hasField19 = true; + result.field19_ = value; + return this; + } + public Builder ClearField19() { + PrepareBuilder(); + result.hasField19 = false; + result.field19_ = 2; + return this; + } + + public bool HasField20 { + get { return result.hasField20; } + } + public bool Field20 { + get { return result.Field20; } + set { SetField20(value); } + } + public Builder SetField20(bool value) { + PrepareBuilder(); + result.hasField20 = true; + result.field20_ = value; + return this; + } + public Builder ClearField20() { + PrepareBuilder(); + result.hasField20 = false; + result.field20_ = true; + return this; + } + + public bool HasField28 { + get { return result.hasField28; } + } + public bool Field28 { + get { return result.Field28; } + set { SetField28(value); } + } + public Builder SetField28(bool value) { + PrepareBuilder(); + result.hasField28 = true; + result.field28_ = value; + return this; + } + public Builder ClearField28() { + PrepareBuilder(); + result.hasField28 = false; + result.field28_ = true; + return this; + } + + public bool HasField21 { + get { return result.hasField21; } + } + [global::System.CLSCompliant(false)] + public ulong Field21 { + get { return result.Field21; } + set { SetField21(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetField21(ulong value) { + PrepareBuilder(); + result.hasField21 = true; + result.field21_ = value; + return this; + } + public Builder ClearField21() { + PrepareBuilder(); + result.hasField21 = false; + result.field21_ = 0UL; + return this; + } + + public bool HasField22 { + get { return result.hasField22; } + } + public int Field22 { + get { return result.Field22; } + set { SetField22(value); } + } + public Builder SetField22(int value) { + PrepareBuilder(); + result.hasField22 = true; + result.field22_ = value; + return this; + } + public Builder ClearField22() { + PrepareBuilder(); + result.hasField22 = false; + result.field22_ = 0; + return this; + } + + public bool HasField23 { + get { return result.hasField23; } + } + public bool Field23 { + get { return result.Field23; } + set { SetField23(value); } + } + public Builder SetField23(bool value) { + PrepareBuilder(); + result.hasField23 = true; + result.field23_ = value; + return this; + } + public Builder ClearField23() { + PrepareBuilder(); + result.hasField23 = false; + result.field23_ = false; + return this; + } + + public bool HasField206 { + get { return result.hasField206; } + } + public bool Field206 { + get { return result.Field206; } + set { SetField206(value); } + } + public Builder SetField206(bool value) { + PrepareBuilder(); + result.hasField206 = true; + result.field206_ = value; + return this; + } + public Builder ClearField206() { + PrepareBuilder(); + result.hasField206 = false; + result.field206_ = false; + return this; + } + + public bool HasField203 { + get { return result.hasField203; } + } + [global::System.CLSCompliant(false)] + public uint Field203 { + get { return result.Field203; } + set { SetField203(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetField203(uint value) { + PrepareBuilder(); + result.hasField203 = true; + result.field203_ = value; + return this; + } + public Builder ClearField203() { + PrepareBuilder(); + result.hasField203 = false; + result.field203_ = 0; + return this; + } + + public bool HasField204 { + get { return result.hasField204; } + } + public int Field204 { + get { return result.Field204; } + set { SetField204(value); } + } + public Builder SetField204(int value) { + PrepareBuilder(); + result.hasField204 = true; + result.field204_ = value; + return this; + } + public Builder ClearField204() { + PrepareBuilder(); + result.hasField204 = false; + result.field204_ = 0; + return this; + } + + public bool HasField205 { + get { return result.hasField205; } + } + public string Field205 { + get { return result.Field205; } + set { SetField205(value); } + } + public Builder SetField205(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField205 = true; + result.field205_ = value; + return this; + } + public Builder ClearField205() { + PrepareBuilder(); + result.hasField205 = false; + result.field205_ = ""; + return this; + } + + public bool HasField207 { + get { return result.hasField207; } + } + [global::System.CLSCompliant(false)] + public ulong Field207 { + get { return result.Field207; } + set { SetField207(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetField207(ulong value) { + PrepareBuilder(); + result.hasField207 = true; + result.field207_ = value; + return this; + } + public Builder ClearField207() { + PrepareBuilder(); + result.hasField207 = false; + result.field207_ = 0UL; + return this; + } + + public bool HasField300 { + get { return result.hasField300; } + } + [global::System.CLSCompliant(false)] + public ulong Field300 { + get { return result.Field300; } + set { SetField300(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetField300(ulong value) { + PrepareBuilder(); + result.hasField300 = true; + result.field300_ = value; + return this; + } + public Builder ClearField300() { + PrepareBuilder(); + result.hasField300 = false; + result.field300_ = 0UL; + return this; + } + } + static SpeedMessage1SubMessage() { + object.ReferenceEquals(global::Google.ProtocolBuffers.TestProtos.GoogleSpeed.Descriptor, null); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class SpeedMessage2 : pb::GeneratedMessage { + private SpeedMessage2() { } + private static readonly SpeedMessage2 defaultInstance = new SpeedMessage2().MakeReadOnly(); + private static readonly string[] _speedMessage2FieldNames = new string[] { "field1", "field109", "field127", "field128", "field129", "field130", "field131", "field2", "field205", "field206", "field21", "field210", "field211", "field212", "field213", "field216", "field217", "field218", "field220", "field221", "field222", "field25", "field3", "field30", "field4", "field6", "field63", "field71", "field75", "group1" }; + private static readonly uint[] _speedMessage2FieldTags = new uint[] { 10, 872, 1018, 1026, 1032, 1040, 1048, 18, 1640, 1648, 168, 1680, 1688, 1696, 1704, 1728, 1736, 1744, 1760, 1768, 1781, 205, 24, 240, 32, 50, 504, 568, 600, 83 }; + public static SpeedMessage2 DefaultInstance { + get { return defaultInstance; } + } + + public override SpeedMessage2 DefaultInstanceForType { + get { return DefaultInstance; } + } + + protected override SpeedMessage2 ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.GoogleSpeed.internal__static_benchmarks_SpeedMessage2__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.GoogleSpeed.internal__static_benchmarks_SpeedMessage2__FieldAccessorTable; } + } + + #region Nested types + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public static partial class Types { + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class Group1 : pb::GeneratedMessage { + private Group1() { } + private static readonly Group1 defaultInstance = new Group1().MakeReadOnly(); + private static readonly string[] _group1FieldNames = new string[] { "field11", "field12", "field13", "field14", "field15", "field16", "field20", "field22", "field24", "field26", "field27", "field28", "field29", "field31", "field5", "field73" }; + private static readonly uint[] _group1FieldTags = new uint[] { 93, 98, 106, 114, 120, 130, 160, 178, 194, 213, 218, 224, 234, 250, 40, 584 }; + public static Group1 DefaultInstance { + get { return defaultInstance; } + } + + public override Group1 DefaultInstanceForType { + get { return DefaultInstance; } + } + + protected override Group1 ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.GoogleSpeed.internal__static_benchmarks_SpeedMessage2_Group1__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.GoogleSpeed.internal__static_benchmarks_SpeedMessage2_Group1__FieldAccessorTable; } + } + + public const int Field11FieldNumber = 11; + private bool hasField11; + private float field11_; + public bool HasField11 { + get { return hasField11; } + } + public float Field11 { + get { return field11_; } + } + + public const int Field26FieldNumber = 26; + private bool hasField26; + private float field26_; + public bool HasField26 { + get { return hasField26; } + } + public float Field26 { + get { return field26_; } + } + + public const int Field12FieldNumber = 12; + private bool hasField12; + private string field12_ = ""; + public bool HasField12 { + get { return hasField12; } + } + public string Field12 { + get { return field12_; } + } + + public const int Field13FieldNumber = 13; + private bool hasField13; + private string field13_ = ""; + public bool HasField13 { + get { return hasField13; } + } + public string Field13 { + get { return field13_; } + } + + public const int Field14FieldNumber = 14; + private pbc::PopsicleList field14_ = new pbc::PopsicleList(); + public scg::IList Field14List { + get { return pbc::Lists.AsReadOnly(field14_); } + } + public int Field14Count { + get { return field14_.Count; } + } + public string GetField14(int index) { + return field14_[index]; + } + + public const int Field15FieldNumber = 15; + private bool hasField15; + private ulong field15_; + public bool HasField15 { + get { return hasField15; } + } + [global::System.CLSCompliant(false)] + public ulong Field15 { + get { return field15_; } + } + + public const int Field5FieldNumber = 5; + private bool hasField5; + private int field5_; + public bool HasField5 { + get { return hasField5; } + } + public int Field5 { + get { return field5_; } + } + + public const int Field27FieldNumber = 27; + private bool hasField27; + private string field27_ = ""; + public bool HasField27 { + get { return hasField27; } + } + public string Field27 { + get { return field27_; } + } + + public const int Field28FieldNumber = 28; + private bool hasField28; + private int field28_; + public bool HasField28 { + get { return hasField28; } + } + public int Field28 { + get { return field28_; } + } + + public const int Field29FieldNumber = 29; + private bool hasField29; + private string field29_ = ""; + public bool HasField29 { + get { return hasField29; } + } + public string Field29 { + get { return field29_; } + } + + public const int Field16FieldNumber = 16; + private bool hasField16; + private string field16_ = ""; + public bool HasField16 { + get { return hasField16; } + } + public string Field16 { + get { return field16_; } + } + + public const int Field22FieldNumber = 22; + private pbc::PopsicleList field22_ = new pbc::PopsicleList(); + public scg::IList Field22List { + get { return pbc::Lists.AsReadOnly(field22_); } + } + public int Field22Count { + get { return field22_.Count; } + } + public string GetField22(int index) { + return field22_[index]; + } + + public const int Field73FieldNumber = 73; + private pbc::PopsicleList field73_ = new pbc::PopsicleList(); + public scg::IList Field73List { + get { return pbc::Lists.AsReadOnly(field73_); } + } + public int Field73Count { + get { return field73_.Count; } + } + public int GetField73(int index) { + return field73_[index]; + } + + public const int Field20FieldNumber = 20; + private bool hasField20; + private int field20_; + public bool HasField20 { + get { return hasField20; } + } + public int Field20 { + get { return field20_; } + } + + public const int Field24FieldNumber = 24; + private bool hasField24; + private string field24_ = ""; + public bool HasField24 { + get { return hasField24; } + } + public string Field24 { + get { return field24_; } + } + + public const int Field31FieldNumber = 31; + private bool hasField31; + private global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage field31_; + public bool HasField31 { + get { return hasField31; } + } + public global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage Field31 { + get { return field31_ ?? global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage.DefaultInstance; } + } + + public override bool IsInitialized { + get { + if (!hasField11) return false; + if (!hasField15) return false; + return true; + } + } + + public override void WriteTo(pb::ICodedOutputStream output) { + CalcSerializedSize(); + string[] field_names = _group1FieldNames; + if (hasField5) { + output.WriteInt32(5, field_names[14], Field5); + } + if (hasField11) { + output.WriteFloat(11, field_names[0], Field11); + } + if (hasField12) { + output.WriteString(12, field_names[1], Field12); + } + if (hasField13) { + output.WriteString(13, field_names[2], Field13); + } + if (field14_.Count > 0) { + output.WriteStringArray(14, field_names[3], field14_); + } + if (hasField15) { + output.WriteUInt64(15, field_names[4], Field15); + } + if (hasField16) { + output.WriteString(16, field_names[5], Field16); + } + if (hasField20) { + output.WriteInt32(20, field_names[6], Field20); + } + if (field22_.Count > 0) { + output.WriteStringArray(22, field_names[7], field22_); + } + if (hasField24) { + output.WriteString(24, field_names[8], Field24); + } + if (hasField26) { + output.WriteFloat(26, field_names[9], Field26); + } + if (hasField27) { + output.WriteString(27, field_names[10], Field27); + } + if (hasField28) { + output.WriteInt32(28, field_names[11], Field28); + } + if (hasField29) { + output.WriteString(29, field_names[12], Field29); + } + if (hasField31) { + output.WriteMessage(31, field_names[13], Field31); + } + if (field73_.Count > 0) { + output.WriteInt32Array(73, field_names[15], field73_); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + return CalcSerializedSize(); + } + } + + private int CalcSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (hasField11) { + size += pb::CodedOutputStream.ComputeFloatSize(11, Field11); + } + if (hasField26) { + size += pb::CodedOutputStream.ComputeFloatSize(26, Field26); + } + if (hasField12) { + size += pb::CodedOutputStream.ComputeStringSize(12, Field12); + } + if (hasField13) { + size += pb::CodedOutputStream.ComputeStringSize(13, Field13); + } + { + int dataSize = 0; + foreach (string element in Field14List) { + dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element); + } + size += dataSize; + size += 1 * field14_.Count; + } + if (hasField15) { + size += pb::CodedOutputStream.ComputeUInt64Size(15, Field15); + } + if (hasField5) { + size += pb::CodedOutputStream.ComputeInt32Size(5, Field5); + } + if (hasField27) { + size += pb::CodedOutputStream.ComputeStringSize(27, Field27); + } + if (hasField28) { + size += pb::CodedOutputStream.ComputeInt32Size(28, Field28); + } + if (hasField29) { + size += pb::CodedOutputStream.ComputeStringSize(29, Field29); + } + if (hasField16) { + size += pb::CodedOutputStream.ComputeStringSize(16, Field16); + } + { + int dataSize = 0; + foreach (string element in Field22List) { + dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element); + } + size += dataSize; + size += 2 * field22_.Count; + } + { + int dataSize = 0; + foreach (int element in Field73List) { + dataSize += pb::CodedOutputStream.ComputeInt32SizeNoTag(element); + } + size += dataSize; + size += 2 * field73_.Count; + } + if (hasField20) { + size += pb::CodedOutputStream.ComputeInt32Size(20, Field20); + } + if (hasField24) { + size += pb::CodedOutputStream.ComputeStringSize(24, Field24); + } + if (hasField31) { + size += pb::CodedOutputStream.ComputeMessageSize(31, Field31); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + public static Group1 ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Group1 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Group1 ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Group1 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Group1 ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Group1 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Group1 ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static Group1 ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static Group1 ParseFrom(pb::ICodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Group1 ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + private Group1 MakeReadOnly() { + field14_.MakeReadOnly(); + field22_.MakeReadOnly(); + field73_.MakeReadOnly(); + return this; + } + + public static Builder CreateBuilder() { return new Builder(); } + public override Builder ToBuilder() { return CreateBuilder(this); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(Group1 prototype) { + return new Builder(prototype); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() { + result = DefaultInstance; + resultIsReadOnly = true; + } + internal Builder(Group1 cloneFrom) { + result = cloneFrom; + resultIsReadOnly = true; + } + + private bool resultIsReadOnly; + private Group1 result; + + private Group1 PrepareBuilder() { + if (resultIsReadOnly) { + Group1 original = result; + result = new Group1(); + resultIsReadOnly = false; + MergeFrom(original); + } + return result; + } + + public override bool IsInitialized { + get { return result.IsInitialized; } + } + + protected override Group1 MessageBeingBuilt { + get { return PrepareBuilder(); } + } + + public override Builder Clear() { + result = DefaultInstance; + resultIsReadOnly = true; + return this; + } + + public override Builder Clone() { + if (resultIsReadOnly) { + return new Builder(result); + } else { + return new Builder().MergeFrom(result); + } + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1.Descriptor; } + } + + public override Group1 DefaultInstanceForType { + get { return global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1.DefaultInstance; } + } + + public override Group1 BuildPartial() { + if (resultIsReadOnly) { + return result; + } + resultIsReadOnly = true; + return result.MakeReadOnly(); + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is Group1) { + return MergeFrom((Group1) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(Group1 other) { + if (other == global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1.DefaultInstance) return this; + PrepareBuilder(); + if (other.HasField11) { + Field11 = other.Field11; + } + if (other.HasField26) { + Field26 = other.Field26; + } + if (other.HasField12) { + Field12 = other.Field12; + } + if (other.HasField13) { + Field13 = other.Field13; + } + if (other.field14_.Count != 0) { + result.field14_.Add(other.field14_); + } + if (other.HasField15) { + Field15 = other.Field15; + } + if (other.HasField5) { + Field5 = other.Field5; + } + if (other.HasField27) { + Field27 = other.Field27; + } + if (other.HasField28) { + Field28 = other.Field28; + } + if (other.HasField29) { + Field29 = other.Field29; + } + if (other.HasField16) { + Field16 = other.Field16; + } + if (other.field22_.Count != 0) { + result.field22_.Add(other.field22_); + } + if (other.field73_.Count != 0) { + result.field73_.Add(other.field73_); + } + if (other.HasField20) { + Field20 = other.Field20; + } + if (other.HasField24) { + Field24 = other.Field24; + } + if (other.HasField31) { + MergeField31(other.Field31); + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::ICodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + PrepareBuilder(); + pb::UnknownFieldSet.Builder unknownFields = null; + uint tag; + string field_name; + while (input.ReadTag(out tag, out field_name)) { + if(tag == 0 && field_name != null) { + int field_ordinal = global::System.Array.BinarySearch(_group1FieldNames, field_name, global::System.StringComparer.Ordinal); + if(field_ordinal >= 0) + tag = _group1FieldTags[field_ordinal]; + else { + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name); + continue; + } + } + switch (tag) { + case 0: { + throw pb::InvalidProtocolBufferException.InvalidTag(); + } + default: { + if (pb::WireFormat.IsEndGroupTag(tag)) { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name); + break; + } + case 40: { + result.hasField5 = input.ReadInt32(ref result.field5_); + break; + } + case 93: { + result.hasField11 = input.ReadFloat(ref result.field11_); + break; + } + case 98: { + result.hasField12 = input.ReadString(ref result.field12_); + break; + } + case 106: { + result.hasField13 = input.ReadString(ref result.field13_); + break; + } + case 114: { + input.ReadStringArray(tag, field_name, result.field14_); + break; + } + case 120: { + result.hasField15 = input.ReadUInt64(ref result.field15_); + break; + } + case 130: { + result.hasField16 = input.ReadString(ref result.field16_); + break; + } + case 160: { + result.hasField20 = input.ReadInt32(ref result.field20_); + break; + } + case 178: { + input.ReadStringArray(tag, field_name, result.field22_); + break; + } + case 194: { + result.hasField24 = input.ReadString(ref result.field24_); + break; + } + case 213: { + result.hasField26 = input.ReadFloat(ref result.field26_); + break; + } + case 218: { + result.hasField27 = input.ReadString(ref result.field27_); + break; + } + case 224: { + result.hasField28 = input.ReadInt32(ref result.field28_); + break; + } + case 234: { + result.hasField29 = input.ReadString(ref result.field29_); + break; + } + case 250: { + global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage.CreateBuilder(); + if (result.hasField31) { + subBuilder.MergeFrom(Field31); + } + input.ReadMessage(subBuilder, extensionRegistry); + Field31 = subBuilder.BuildPartial(); + break; + } + case 586: + case 584: { + input.ReadInt32Array(tag, field_name, result.field73_); + break; + } + } + } + + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + + + public bool HasField11 { + get { return result.hasField11; } + } + public float Field11 { + get { return result.Field11; } + set { SetField11(value); } + } + public Builder SetField11(float value) { + PrepareBuilder(); + result.hasField11 = true; + result.field11_ = value; + return this; + } + public Builder ClearField11() { + PrepareBuilder(); + result.hasField11 = false; + result.field11_ = 0F; + return this; + } + + public bool HasField26 { + get { return result.hasField26; } + } + public float Field26 { + get { return result.Field26; } + set { SetField26(value); } + } + public Builder SetField26(float value) { + PrepareBuilder(); + result.hasField26 = true; + result.field26_ = value; + return this; + } + public Builder ClearField26() { + PrepareBuilder(); + result.hasField26 = false; + result.field26_ = 0F; + return this; + } + + public bool HasField12 { + get { return result.hasField12; } + } + public string Field12 { + get { return result.Field12; } + set { SetField12(value); } + } + public Builder SetField12(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField12 = true; + result.field12_ = value; + return this; + } + public Builder ClearField12() { + PrepareBuilder(); + result.hasField12 = false; + result.field12_ = ""; + return this; + } + + public bool HasField13 { + get { return result.hasField13; } + } + public string Field13 { + get { return result.Field13; } + set { SetField13(value); } + } + public Builder SetField13(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField13 = true; + result.field13_ = value; + return this; + } + public Builder ClearField13() { + PrepareBuilder(); + result.hasField13 = false; + result.field13_ = ""; + return this; + } + + public pbc::IPopsicleList Field14List { + get { return PrepareBuilder().field14_; } + } + public int Field14Count { + get { return result.Field14Count; } + } + public string GetField14(int index) { + return result.GetField14(index); + } + public Builder SetField14(int index, string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.field14_[index] = value; + return this; + } + public Builder AddField14(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.field14_.Add(value); + return this; + } + public Builder AddRangeField14(scg::IEnumerable values) { + PrepareBuilder(); + result.field14_.Add(values); + return this; + } + public Builder ClearField14() { + PrepareBuilder(); + result.field14_.Clear(); + return this; + } + + public bool HasField15 { + get { return result.hasField15; } + } + [global::System.CLSCompliant(false)] + public ulong Field15 { + get { return result.Field15; } + set { SetField15(value); } + } + [global::System.CLSCompliant(false)] + public Builder SetField15(ulong value) { + PrepareBuilder(); + result.hasField15 = true; + result.field15_ = value; + return this; + } + public Builder ClearField15() { + PrepareBuilder(); + result.hasField15 = false; + result.field15_ = 0UL; + return this; + } + + public bool HasField5 { + get { return result.hasField5; } + } + public int Field5 { + get { return result.Field5; } + set { SetField5(value); } + } + public Builder SetField5(int value) { + PrepareBuilder(); + result.hasField5 = true; + result.field5_ = value; + return this; + } + public Builder ClearField5() { + PrepareBuilder(); + result.hasField5 = false; + result.field5_ = 0; + return this; + } + + public bool HasField27 { + get { return result.hasField27; } + } + public string Field27 { + get { return result.Field27; } + set { SetField27(value); } + } + public Builder SetField27(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField27 = true; + result.field27_ = value; + return this; + } + public Builder ClearField27() { + PrepareBuilder(); + result.hasField27 = false; + result.field27_ = ""; + return this; + } + + public bool HasField28 { + get { return result.hasField28; } + } + public int Field28 { + get { return result.Field28; } + set { SetField28(value); } + } + public Builder SetField28(int value) { + PrepareBuilder(); + result.hasField28 = true; + result.field28_ = value; + return this; + } + public Builder ClearField28() { + PrepareBuilder(); + result.hasField28 = false; + result.field28_ = 0; + return this; + } + + public bool HasField29 { + get { return result.hasField29; } + } + public string Field29 { + get { return result.Field29; } + set { SetField29(value); } + } + public Builder SetField29(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField29 = true; + result.field29_ = value; + return this; + } + public Builder ClearField29() { + PrepareBuilder(); + result.hasField29 = false; + result.field29_ = ""; + return this; + } + + public bool HasField16 { + get { return result.hasField16; } + } + public string Field16 { + get { return result.Field16; } + set { SetField16(value); } + } + public Builder SetField16(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField16 = true; + result.field16_ = value; + return this; + } + public Builder ClearField16() { + PrepareBuilder(); + result.hasField16 = false; + result.field16_ = ""; + return this; + } + + public pbc::IPopsicleList Field22List { + get { return PrepareBuilder().field22_; } + } + public int Field22Count { + get { return result.Field22Count; } + } + public string GetField22(int index) { + return result.GetField22(index); + } + public Builder SetField22(int index, string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.field22_[index] = value; + return this; + } + public Builder AddField22(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.field22_.Add(value); + return this; + } + public Builder AddRangeField22(scg::IEnumerable values) { + PrepareBuilder(); + result.field22_.Add(values); + return this; + } + public Builder ClearField22() { + PrepareBuilder(); + result.field22_.Clear(); + return this; + } + + public pbc::IPopsicleList Field73List { + get { return PrepareBuilder().field73_; } + } + public int Field73Count { + get { return result.Field73Count; } + } + public int GetField73(int index) { + return result.GetField73(index); + } + public Builder SetField73(int index, int value) { + PrepareBuilder(); + result.field73_[index] = value; + return this; + } + public Builder AddField73(int value) { + PrepareBuilder(); + result.field73_.Add(value); + return this; + } + public Builder AddRangeField73(scg::IEnumerable values) { + PrepareBuilder(); + result.field73_.Add(values); + return this; + } + public Builder ClearField73() { + PrepareBuilder(); + result.field73_.Clear(); + return this; + } + + public bool HasField20 { + get { return result.hasField20; } + } + public int Field20 { + get { return result.Field20; } + set { SetField20(value); } + } + public Builder SetField20(int value) { + PrepareBuilder(); + result.hasField20 = true; + result.field20_ = value; + return this; + } + public Builder ClearField20() { + PrepareBuilder(); + result.hasField20 = false; + result.field20_ = 0; + return this; + } + + public bool HasField24 { + get { return result.hasField24; } + } + public string Field24 { + get { return result.Field24; } + set { SetField24(value); } + } + public Builder SetField24(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField24 = true; + result.field24_ = value; + return this; + } + public Builder ClearField24() { + PrepareBuilder(); + result.hasField24 = false; + result.field24_ = ""; + return this; + } + + public bool HasField31 { + get { return result.hasField31; } + } + public global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage Field31 { + get { return result.Field31; } + set { SetField31(value); } + } + public Builder SetField31(global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField31 = true; + result.field31_ = value; + return this; + } + public Builder SetField31(global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + PrepareBuilder(); + result.hasField31 = true; + result.field31_ = builderForValue.Build(); + return this; + } + public Builder MergeField31(global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + if (result.hasField31 && + result.field31_ != global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage.DefaultInstance) { + result.field31_ = global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage.CreateBuilder(result.field31_).MergeFrom(value).BuildPartial(); + } else { + result.field31_ = value; + } + result.hasField31 = true; + return this; + } + public Builder ClearField31() { + PrepareBuilder(); + result.hasField31 = false; + result.field31_ = null; + return this; + } + } + static Group1() { + object.ReferenceEquals(global::Google.ProtocolBuffers.TestProtos.GoogleSpeed.Descriptor, null); + } + } + + } + #endregion + + public const int Field1FieldNumber = 1; + private bool hasField1; + private string field1_ = ""; + public bool HasField1 { + get { return hasField1; } + } + public string Field1 { + get { return field1_; } + } + + public const int Field3FieldNumber = 3; + private bool hasField3; + private long field3_; + public bool HasField3 { + get { return hasField3; } + } + public long Field3 { + get { return field3_; } + } + + public const int Field4FieldNumber = 4; + private bool hasField4; + private long field4_; + public bool HasField4 { + get { return hasField4; } + } + public long Field4 { + get { return field4_; } + } + + public const int Field30FieldNumber = 30; + private bool hasField30; + private long field30_; + public bool HasField30 { + get { return hasField30; } + } + public long Field30 { + get { return field30_; } + } + + public const int Field75FieldNumber = 75; + private bool hasField75; + private bool field75_; + public bool HasField75 { + get { return hasField75; } + } + public bool Field75 { + get { return field75_; } + } + + public const int Field6FieldNumber = 6; + private bool hasField6; + private string field6_ = ""; + public bool HasField6 { + get { return hasField6; } + } + public string Field6 { + get { return field6_; } + } + + public const int Field2FieldNumber = 2; + private bool hasField2; + private pb::ByteString field2_ = pb::ByteString.Empty; + public bool HasField2 { + get { return hasField2; } + } + public pb::ByteString Field2 { + get { return field2_; } + } + + public const int Field21FieldNumber = 21; + private bool hasField21; + private int field21_; + public bool HasField21 { + get { return hasField21; } + } + public int Field21 { + get { return field21_; } + } + + public const int Field71FieldNumber = 71; + private bool hasField71; + private int field71_; + public bool HasField71 { + get { return hasField71; } + } + public int Field71 { + get { return field71_; } + } + + public const int Field25FieldNumber = 25; + private bool hasField25; + private float field25_; + public bool HasField25 { + get { return hasField25; } + } + public float Field25 { + get { return field25_; } + } + + public const int Field109FieldNumber = 109; + private bool hasField109; + private int field109_; + public bool HasField109 { + get { return hasField109; } + } + public int Field109 { + get { return field109_; } + } + + public const int Field210FieldNumber = 210; + private bool hasField210; + private int field210_; + public bool HasField210 { + get { return hasField210; } + } + public int Field210 { + get { return field210_; } + } + + public const int Field211FieldNumber = 211; + private bool hasField211; + private int field211_; + public bool HasField211 { + get { return hasField211; } + } + public int Field211 { + get { return field211_; } + } + + public const int Field212FieldNumber = 212; + private bool hasField212; + private int field212_; + public bool HasField212 { + get { return hasField212; } + } + public int Field212 { + get { return field212_; } + } + + public const int Field213FieldNumber = 213; + private bool hasField213; + private int field213_; + public bool HasField213 { + get { return hasField213; } + } + public int Field213 { + get { return field213_; } + } + + public const int Field216FieldNumber = 216; + private bool hasField216; + private int field216_; + public bool HasField216 { + get { return hasField216; } + } + public int Field216 { + get { return field216_; } + } + + public const int Field217FieldNumber = 217; + private bool hasField217; + private int field217_; + public bool HasField217 { + get { return hasField217; } + } + public int Field217 { + get { return field217_; } + } + + public const int Field218FieldNumber = 218; + private bool hasField218; + private int field218_; + public bool HasField218 { + get { return hasField218; } + } + public int Field218 { + get { return field218_; } + } + + public const int Field220FieldNumber = 220; + private bool hasField220; + private int field220_; + public bool HasField220 { + get { return hasField220; } + } + public int Field220 { + get { return field220_; } + } + + public const int Field221FieldNumber = 221; + private bool hasField221; + private int field221_; + public bool HasField221 { + get { return hasField221; } + } + public int Field221 { + get { return field221_; } + } + + public const int Field222FieldNumber = 222; + private bool hasField222; + private float field222_; + public bool HasField222 { + get { return hasField222; } + } + public float Field222 { + get { return field222_; } + } + + public const int Field63FieldNumber = 63; + private bool hasField63; + private int field63_; + public bool HasField63 { + get { return hasField63; } + } + public int Field63 { + get { return field63_; } + } + + public const int Group1FieldNumber = 10; + private pbc::PopsicleList group1_ = new pbc::PopsicleList(); + public scg::IList Group1List { + get { return group1_; } + } + public int Group1Count { + get { return group1_.Count; } + } + public global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1 GetGroup1(int index) { + return group1_[index]; + } + + public const int Field128FieldNumber = 128; + private pbc::PopsicleList field128_ = new pbc::PopsicleList(); + public scg::IList Field128List { + get { return pbc::Lists.AsReadOnly(field128_); } + } + public int Field128Count { + get { return field128_.Count; } + } + public string GetField128(int index) { + return field128_[index]; + } + + public const int Field131FieldNumber = 131; + private bool hasField131; + private long field131_; + public bool HasField131 { + get { return hasField131; } + } + public long Field131 { + get { return field131_; } + } + + public const int Field127FieldNumber = 127; + private pbc::PopsicleList field127_ = new pbc::PopsicleList(); + public scg::IList Field127List { + get { return pbc::Lists.AsReadOnly(field127_); } + } + public int Field127Count { + get { return field127_.Count; } + } + public string GetField127(int index) { + return field127_[index]; + } + + public const int Field129FieldNumber = 129; + private bool hasField129; + private int field129_; + public bool HasField129 { + get { return hasField129; } + } + public int Field129 { + get { return field129_; } + } + + public const int Field130FieldNumber = 130; + private pbc::PopsicleList field130_ = new pbc::PopsicleList(); + public scg::IList Field130List { + get { return pbc::Lists.AsReadOnly(field130_); } + } + public int Field130Count { + get { return field130_.Count; } + } + public long GetField130(int index) { + return field130_[index]; + } + + public const int Field205FieldNumber = 205; + private bool hasField205; + private bool field205_; + public bool HasField205 { + get { return hasField205; } + } + public bool Field205 { + get { return field205_; } + } + + public const int Field206FieldNumber = 206; + private bool hasField206; + private bool field206_; + public bool HasField206 { + get { return hasField206; } + } + public bool Field206 { + get { return field206_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::ICodedOutputStream output) { + CalcSerializedSize(); + string[] field_names = _speedMessage2FieldNames; + if (hasField1) { + output.WriteString(1, field_names[0], Field1); + } + if (hasField2) { + output.WriteBytes(2, field_names[7], Field2); + } + if (hasField3) { + output.WriteInt64(3, field_names[22], Field3); + } + if (hasField4) { + output.WriteInt64(4, field_names[24], Field4); + } + if (hasField6) { + output.WriteString(6, field_names[25], Field6); + } + if (group1_.Count > 0) { + output.WriteGroupArray(10, field_names[29], group1_); + } + if (hasField21) { + output.WriteInt32(21, field_names[10], Field21); + } + if (hasField25) { + output.WriteFloat(25, field_names[21], Field25); + } + if (hasField30) { + output.WriteInt64(30, field_names[23], Field30); + } + if (hasField63) { + output.WriteInt32(63, field_names[26], Field63); + } + if (hasField71) { + output.WriteInt32(71, field_names[27], Field71); + } + if (hasField75) { + output.WriteBool(75, field_names[28], Field75); + } + if (hasField109) { + output.WriteInt32(109, field_names[1], Field109); + } + if (field127_.Count > 0) { + output.WriteStringArray(127, field_names[2], field127_); + } + if (field128_.Count > 0) { + output.WriteStringArray(128, field_names[3], field128_); + } + if (hasField129) { + output.WriteInt32(129, field_names[4], Field129); + } + if (field130_.Count > 0) { + output.WriteInt64Array(130, field_names[5], field130_); + } + if (hasField131) { + output.WriteInt64(131, field_names[6], Field131); + } + if (hasField205) { + output.WriteBool(205, field_names[8], Field205); + } + if (hasField206) { + output.WriteBool(206, field_names[9], Field206); + } + if (hasField210) { + output.WriteInt32(210, field_names[11], Field210); + } + if (hasField211) { + output.WriteInt32(211, field_names[12], Field211); + } + if (hasField212) { + output.WriteInt32(212, field_names[13], Field212); + } + if (hasField213) { + output.WriteInt32(213, field_names[14], Field213); + } + if (hasField216) { + output.WriteInt32(216, field_names[15], Field216); + } + if (hasField217) { + output.WriteInt32(217, field_names[16], Field217); + } + if (hasField218) { + output.WriteInt32(218, field_names[17], Field218); + } + if (hasField220) { + output.WriteInt32(220, field_names[18], Field220); + } + if (hasField221) { + output.WriteInt32(221, field_names[19], Field221); + } + if (hasField222) { + output.WriteFloat(222, field_names[20], Field222); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + return CalcSerializedSize(); + } + } + + private int CalcSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (hasField1) { + size += pb::CodedOutputStream.ComputeStringSize(1, Field1); + } + if (hasField3) { + size += pb::CodedOutputStream.ComputeInt64Size(3, Field3); + } + if (hasField4) { + size += pb::CodedOutputStream.ComputeInt64Size(4, Field4); + } + if (hasField30) { + size += pb::CodedOutputStream.ComputeInt64Size(30, Field30); + } + if (hasField75) { + size += pb::CodedOutputStream.ComputeBoolSize(75, Field75); + } + if (hasField6) { + size += pb::CodedOutputStream.ComputeStringSize(6, Field6); + } + if (hasField2) { + size += pb::CodedOutputStream.ComputeBytesSize(2, Field2); + } + if (hasField21) { + size += pb::CodedOutputStream.ComputeInt32Size(21, Field21); + } + if (hasField71) { + size += pb::CodedOutputStream.ComputeInt32Size(71, Field71); + } + if (hasField25) { + size += pb::CodedOutputStream.ComputeFloatSize(25, Field25); + } + if (hasField109) { + size += pb::CodedOutputStream.ComputeInt32Size(109, Field109); + } + if (hasField210) { + size += pb::CodedOutputStream.ComputeInt32Size(210, Field210); + } + if (hasField211) { + size += pb::CodedOutputStream.ComputeInt32Size(211, Field211); + } + if (hasField212) { + size += pb::CodedOutputStream.ComputeInt32Size(212, Field212); + } + if (hasField213) { + size += pb::CodedOutputStream.ComputeInt32Size(213, Field213); + } + if (hasField216) { + size += pb::CodedOutputStream.ComputeInt32Size(216, Field216); + } + if (hasField217) { + size += pb::CodedOutputStream.ComputeInt32Size(217, Field217); + } + if (hasField218) { + size += pb::CodedOutputStream.ComputeInt32Size(218, Field218); + } + if (hasField220) { + size += pb::CodedOutputStream.ComputeInt32Size(220, Field220); + } + if (hasField221) { + size += pb::CodedOutputStream.ComputeInt32Size(221, Field221); + } + if (hasField222) { + size += pb::CodedOutputStream.ComputeFloatSize(222, Field222); + } + if (hasField63) { + size += pb::CodedOutputStream.ComputeInt32Size(63, Field63); + } + foreach (global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1 element in Group1List) { + size += pb::CodedOutputStream.ComputeGroupSize(10, element); + } + { + int dataSize = 0; + foreach (string element in Field128List) { + dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element); + } + size += dataSize; + size += 2 * field128_.Count; + } + if (hasField131) { + size += pb::CodedOutputStream.ComputeInt64Size(131, Field131); + } + { + int dataSize = 0; + foreach (string element in Field127List) { + dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element); + } + size += dataSize; + size += 2 * field127_.Count; + } + if (hasField129) { + size += pb::CodedOutputStream.ComputeInt32Size(129, Field129); + } + { + int dataSize = 0; + foreach (long element in Field130List) { + dataSize += pb::CodedOutputStream.ComputeInt64SizeNoTag(element); + } + size += dataSize; + size += 2 * field130_.Count; + } + if (hasField205) { + size += pb::CodedOutputStream.ComputeBoolSize(205, Field205); + } + if (hasField206) { + size += pb::CodedOutputStream.ComputeBoolSize(206, Field206); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + public static SpeedMessage2 ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static SpeedMessage2 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static SpeedMessage2 ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static SpeedMessage2 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static SpeedMessage2 ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static SpeedMessage2 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static SpeedMessage2 ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static SpeedMessage2 ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static SpeedMessage2 ParseFrom(pb::ICodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static SpeedMessage2 ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + private SpeedMessage2 MakeReadOnly() { + group1_.MakeReadOnly(); + field128_.MakeReadOnly(); + field127_.MakeReadOnly(); + field130_.MakeReadOnly(); + return this; + } + + public static Builder CreateBuilder() { return new Builder(); } + public override Builder ToBuilder() { return CreateBuilder(this); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(SpeedMessage2 prototype) { + return new Builder(prototype); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() { + result = DefaultInstance; + resultIsReadOnly = true; + } + internal Builder(SpeedMessage2 cloneFrom) { + result = cloneFrom; + resultIsReadOnly = true; + } + + private bool resultIsReadOnly; + private SpeedMessage2 result; + + private SpeedMessage2 PrepareBuilder() { + if (resultIsReadOnly) { + SpeedMessage2 original = result; + result = new SpeedMessage2(); + resultIsReadOnly = false; + MergeFrom(original); + } + return result; + } + + public override bool IsInitialized { + get { return result.IsInitialized; } + } + + protected override SpeedMessage2 MessageBeingBuilt { + get { return PrepareBuilder(); } + } + + public override Builder Clear() { + result = DefaultInstance; + resultIsReadOnly = true; + return this; + } + + public override Builder Clone() { + if (resultIsReadOnly) { + return new Builder(result); + } else { + return new Builder().MergeFrom(result); + } + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Descriptor; } + } + + public override SpeedMessage2 DefaultInstanceForType { + get { return global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.DefaultInstance; } + } + + public override SpeedMessage2 BuildPartial() { + if (resultIsReadOnly) { + return result; + } + resultIsReadOnly = true; + return result.MakeReadOnly(); + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is SpeedMessage2) { + return MergeFrom((SpeedMessage2) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(SpeedMessage2 other) { + if (other == global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.DefaultInstance) return this; + PrepareBuilder(); + if (other.HasField1) { + Field1 = other.Field1; + } + if (other.HasField3) { + Field3 = other.Field3; + } + if (other.HasField4) { + Field4 = other.Field4; + } + if (other.HasField30) { + Field30 = other.Field30; + } + if (other.HasField75) { + Field75 = other.Field75; + } + if (other.HasField6) { + Field6 = other.Field6; + } + if (other.HasField2) { + Field2 = other.Field2; + } + if (other.HasField21) { + Field21 = other.Field21; + } + if (other.HasField71) { + Field71 = other.Field71; + } + if (other.HasField25) { + Field25 = other.Field25; + } + if (other.HasField109) { + Field109 = other.Field109; + } + if (other.HasField210) { + Field210 = other.Field210; + } + if (other.HasField211) { + Field211 = other.Field211; + } + if (other.HasField212) { + Field212 = other.Field212; + } + if (other.HasField213) { + Field213 = other.Field213; + } + if (other.HasField216) { + Field216 = other.Field216; + } + if (other.HasField217) { + Field217 = other.Field217; + } + if (other.HasField218) { + Field218 = other.Field218; + } + if (other.HasField220) { + Field220 = other.Field220; + } + if (other.HasField221) { + Field221 = other.Field221; + } + if (other.HasField222) { + Field222 = other.Field222; + } + if (other.HasField63) { + Field63 = other.Field63; + } + if (other.group1_.Count != 0) { + result.group1_.Add(other.group1_); + } + if (other.field128_.Count != 0) { + result.field128_.Add(other.field128_); + } + if (other.HasField131) { + Field131 = other.Field131; + } + if (other.field127_.Count != 0) { + result.field127_.Add(other.field127_); + } + if (other.HasField129) { + Field129 = other.Field129; + } + if (other.field130_.Count != 0) { + result.field130_.Add(other.field130_); + } + if (other.HasField205) { + Field205 = other.Field205; + } + if (other.HasField206) { + Field206 = other.Field206; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::ICodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + PrepareBuilder(); + pb::UnknownFieldSet.Builder unknownFields = null; + uint tag; + string field_name; + while (input.ReadTag(out tag, out field_name)) { + if(tag == 0 && field_name != null) { + int field_ordinal = global::System.Array.BinarySearch(_speedMessage2FieldNames, field_name, global::System.StringComparer.Ordinal); + if(field_ordinal >= 0) + tag = _speedMessage2FieldTags[field_ordinal]; + else { + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name); + continue; + } + } + switch (tag) { + case 0: { + throw pb::InvalidProtocolBufferException.InvalidTag(); + } + default: { + if (pb::WireFormat.IsEndGroupTag(tag)) { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name); + break; + } + case 10: { + result.hasField1 = input.ReadString(ref result.field1_); + break; + } + case 18: { + result.hasField2 = input.ReadBytes(ref result.field2_); + break; + } + case 24: { + result.hasField3 = input.ReadInt64(ref result.field3_); + break; + } + case 32: { + result.hasField4 = input.ReadInt64(ref result.field4_); + break; + } + case 50: { + result.hasField6 = input.ReadString(ref result.field6_); + break; + } + case 83: { + input.ReadGroupArray(tag, field_name, result.group1_, global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1.DefaultInstance, extensionRegistry); + break; + } + case 168: { + result.hasField21 = input.ReadInt32(ref result.field21_); + break; + } + case 205: { + result.hasField25 = input.ReadFloat(ref result.field25_); + break; + } + case 240: { + result.hasField30 = input.ReadInt64(ref result.field30_); + break; + } + case 504: { + result.hasField63 = input.ReadInt32(ref result.field63_); + break; + } + case 568: { + result.hasField71 = input.ReadInt32(ref result.field71_); + break; + } + case 600: { + result.hasField75 = input.ReadBool(ref result.field75_); + break; + } + case 872: { + result.hasField109 = input.ReadInt32(ref result.field109_); + break; + } + case 1018: { + input.ReadStringArray(tag, field_name, result.field127_); + break; + } + case 1026: { + input.ReadStringArray(tag, field_name, result.field128_); + break; + } + case 1032: { + result.hasField129 = input.ReadInt32(ref result.field129_); + break; + } + case 1042: + case 1040: { + input.ReadInt64Array(tag, field_name, result.field130_); + break; + } + case 1048: { + result.hasField131 = input.ReadInt64(ref result.field131_); + break; + } + case 1640: { + result.hasField205 = input.ReadBool(ref result.field205_); + break; + } + case 1648: { + result.hasField206 = input.ReadBool(ref result.field206_); + break; + } + case 1680: { + result.hasField210 = input.ReadInt32(ref result.field210_); + break; + } + case 1688: { + result.hasField211 = input.ReadInt32(ref result.field211_); + break; + } + case 1696: { + result.hasField212 = input.ReadInt32(ref result.field212_); + break; + } + case 1704: { + result.hasField213 = input.ReadInt32(ref result.field213_); + break; + } + case 1728: { + result.hasField216 = input.ReadInt32(ref result.field216_); + break; + } + case 1736: { + result.hasField217 = input.ReadInt32(ref result.field217_); + break; + } + case 1744: { + result.hasField218 = input.ReadInt32(ref result.field218_); + break; + } + case 1760: { + result.hasField220 = input.ReadInt32(ref result.field220_); + break; + } + case 1768: { + result.hasField221 = input.ReadInt32(ref result.field221_); + break; + } + case 1781: { + result.hasField222 = input.ReadFloat(ref result.field222_); + break; + } + } + } + + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + + + public bool HasField1 { + get { return result.hasField1; } + } + public string Field1 { + get { return result.Field1; } + set { SetField1(value); } + } + public Builder SetField1(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField1 = true; + result.field1_ = value; + return this; + } + public Builder ClearField1() { + PrepareBuilder(); + result.hasField1 = false; + result.field1_ = ""; + return this; + } + + public bool HasField3 { + get { return result.hasField3; } + } + public long Field3 { + get { return result.Field3; } + set { SetField3(value); } + } + public Builder SetField3(long value) { + PrepareBuilder(); + result.hasField3 = true; + result.field3_ = value; + return this; + } + public Builder ClearField3() { + PrepareBuilder(); + result.hasField3 = false; + result.field3_ = 0L; + return this; + } + + public bool HasField4 { + get { return result.hasField4; } + } + public long Field4 { + get { return result.Field4; } + set { SetField4(value); } + } + public Builder SetField4(long value) { + PrepareBuilder(); + result.hasField4 = true; + result.field4_ = value; + return this; + } + public Builder ClearField4() { + PrepareBuilder(); + result.hasField4 = false; + result.field4_ = 0L; + return this; + } + + public bool HasField30 { + get { return result.hasField30; } + } + public long Field30 { + get { return result.Field30; } + set { SetField30(value); } + } + public Builder SetField30(long value) { + PrepareBuilder(); + result.hasField30 = true; + result.field30_ = value; + return this; + } + public Builder ClearField30() { + PrepareBuilder(); + result.hasField30 = false; + result.field30_ = 0L; + return this; + } + + public bool HasField75 { + get { return result.hasField75; } + } + public bool Field75 { + get { return result.Field75; } + set { SetField75(value); } + } + public Builder SetField75(bool value) { + PrepareBuilder(); + result.hasField75 = true; + result.field75_ = value; + return this; + } + public Builder ClearField75() { + PrepareBuilder(); + result.hasField75 = false; + result.field75_ = false; + return this; + } + + public bool HasField6 { + get { return result.hasField6; } + } + public string Field6 { + get { return result.Field6; } + set { SetField6(value); } + } + public Builder SetField6(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField6 = true; + result.field6_ = value; + return this; + } + public Builder ClearField6() { + PrepareBuilder(); + result.hasField6 = false; + result.field6_ = ""; + return this; + } + + public bool HasField2 { + get { return result.hasField2; } + } + public pb::ByteString Field2 { + get { return result.Field2; } + set { SetField2(value); } + } + public Builder SetField2(pb::ByteString value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.hasField2 = true; + result.field2_ = value; + return this; + } + public Builder ClearField2() { + PrepareBuilder(); + result.hasField2 = false; + result.field2_ = pb::ByteString.Empty; + return this; + } + + public bool HasField21 { + get { return result.hasField21; } + } + public int Field21 { + get { return result.Field21; } + set { SetField21(value); } + } + public Builder SetField21(int value) { + PrepareBuilder(); + result.hasField21 = true; + result.field21_ = value; + return this; + } + public Builder ClearField21() { + PrepareBuilder(); + result.hasField21 = false; + result.field21_ = 0; + return this; + } + + public bool HasField71 { + get { return result.hasField71; } + } + public int Field71 { + get { return result.Field71; } + set { SetField71(value); } + } + public Builder SetField71(int value) { + PrepareBuilder(); + result.hasField71 = true; + result.field71_ = value; + return this; + } + public Builder ClearField71() { + PrepareBuilder(); + result.hasField71 = false; + result.field71_ = 0; + return this; + } + + public bool HasField25 { + get { return result.hasField25; } + } + public float Field25 { + get { return result.Field25; } + set { SetField25(value); } + } + public Builder SetField25(float value) { + PrepareBuilder(); + result.hasField25 = true; + result.field25_ = value; + return this; + } + public Builder ClearField25() { + PrepareBuilder(); + result.hasField25 = false; + result.field25_ = 0F; + return this; + } + + public bool HasField109 { + get { return result.hasField109; } + } + public int Field109 { + get { return result.Field109; } + set { SetField109(value); } + } + public Builder SetField109(int value) { + PrepareBuilder(); + result.hasField109 = true; + result.field109_ = value; + return this; + } + public Builder ClearField109() { + PrepareBuilder(); + result.hasField109 = false; + result.field109_ = 0; + return this; + } + + public bool HasField210 { + get { return result.hasField210; } + } + public int Field210 { + get { return result.Field210; } + set { SetField210(value); } + } + public Builder SetField210(int value) { + PrepareBuilder(); + result.hasField210 = true; + result.field210_ = value; + return this; + } + public Builder ClearField210() { + PrepareBuilder(); + result.hasField210 = false; + result.field210_ = 0; + return this; + } + + public bool HasField211 { + get { return result.hasField211; } + } + public int Field211 { + get { return result.Field211; } + set { SetField211(value); } + } + public Builder SetField211(int value) { + PrepareBuilder(); + result.hasField211 = true; + result.field211_ = value; + return this; + } + public Builder ClearField211() { + PrepareBuilder(); + result.hasField211 = false; + result.field211_ = 0; + return this; + } + + public bool HasField212 { + get { return result.hasField212; } + } + public int Field212 { + get { return result.Field212; } + set { SetField212(value); } + } + public Builder SetField212(int value) { + PrepareBuilder(); + result.hasField212 = true; + result.field212_ = value; + return this; + } + public Builder ClearField212() { + PrepareBuilder(); + result.hasField212 = false; + result.field212_ = 0; + return this; + } + + public bool HasField213 { + get { return result.hasField213; } + } + public int Field213 { + get { return result.Field213; } + set { SetField213(value); } + } + public Builder SetField213(int value) { + PrepareBuilder(); + result.hasField213 = true; + result.field213_ = value; + return this; + } + public Builder ClearField213() { + PrepareBuilder(); + result.hasField213 = false; + result.field213_ = 0; + return this; + } + + public bool HasField216 { + get { return result.hasField216; } + } + public int Field216 { + get { return result.Field216; } + set { SetField216(value); } + } + public Builder SetField216(int value) { + PrepareBuilder(); + result.hasField216 = true; + result.field216_ = value; + return this; + } + public Builder ClearField216() { + PrepareBuilder(); + result.hasField216 = false; + result.field216_ = 0; + return this; + } + + public bool HasField217 { + get { return result.hasField217; } + } + public int Field217 { + get { return result.Field217; } + set { SetField217(value); } + } + public Builder SetField217(int value) { + PrepareBuilder(); + result.hasField217 = true; + result.field217_ = value; + return this; + } + public Builder ClearField217() { + PrepareBuilder(); + result.hasField217 = false; + result.field217_ = 0; + return this; + } + + public bool HasField218 { + get { return result.hasField218; } + } + public int Field218 { + get { return result.Field218; } + set { SetField218(value); } + } + public Builder SetField218(int value) { + PrepareBuilder(); + result.hasField218 = true; + result.field218_ = value; + return this; + } + public Builder ClearField218() { + PrepareBuilder(); + result.hasField218 = false; + result.field218_ = 0; + return this; + } + + public bool HasField220 { + get { return result.hasField220; } + } + public int Field220 { + get { return result.Field220; } + set { SetField220(value); } + } + public Builder SetField220(int value) { + PrepareBuilder(); + result.hasField220 = true; + result.field220_ = value; + return this; + } + public Builder ClearField220() { + PrepareBuilder(); + result.hasField220 = false; + result.field220_ = 0; + return this; + } + + public bool HasField221 { + get { return result.hasField221; } + } + public int Field221 { + get { return result.Field221; } + set { SetField221(value); } + } + public Builder SetField221(int value) { + PrepareBuilder(); + result.hasField221 = true; + result.field221_ = value; + return this; + } + public Builder ClearField221() { + PrepareBuilder(); + result.hasField221 = false; + result.field221_ = 0; + return this; + } + + public bool HasField222 { + get { return result.hasField222; } + } + public float Field222 { + get { return result.Field222; } + set { SetField222(value); } + } + public Builder SetField222(float value) { + PrepareBuilder(); + result.hasField222 = true; + result.field222_ = value; + return this; + } + public Builder ClearField222() { + PrepareBuilder(); + result.hasField222 = false; + result.field222_ = 0F; + return this; + } + + public bool HasField63 { + get { return result.hasField63; } + } + public int Field63 { + get { return result.Field63; } + set { SetField63(value); } + } + public Builder SetField63(int value) { + PrepareBuilder(); + result.hasField63 = true; + result.field63_ = value; + return this; + } + public Builder ClearField63() { + PrepareBuilder(); + result.hasField63 = false; + result.field63_ = 0; + return this; + } + + public pbc::IPopsicleList Group1List { + get { return PrepareBuilder().group1_; } + } + public int Group1Count { + get { return result.Group1Count; } + } + public global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1 GetGroup1(int index) { + return result.GetGroup1(index); + } + public Builder SetGroup1(int index, global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1 value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.group1_[index] = value; + return this; + } + public Builder SetGroup1(int index, global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + PrepareBuilder(); + result.group1_[index] = builderForValue.Build(); + return this; + } + public Builder AddGroup1(global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1 value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.group1_.Add(value); + return this; + } + public Builder AddGroup1(global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1.Builder builderForValue) { + pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); + PrepareBuilder(); + result.group1_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeGroup1(scg::IEnumerable values) { + PrepareBuilder(); + result.group1_.Add(values); + return this; + } + public Builder ClearGroup1() { + PrepareBuilder(); + result.group1_.Clear(); + return this; + } + + public pbc::IPopsicleList Field128List { + get { return PrepareBuilder().field128_; } + } + public int Field128Count { + get { return result.Field128Count; } + } + public string GetField128(int index) { + return result.GetField128(index); + } + public Builder SetField128(int index, string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.field128_[index] = value; + return this; + } + public Builder AddField128(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.field128_.Add(value); + return this; + } + public Builder AddRangeField128(scg::IEnumerable values) { + PrepareBuilder(); + result.field128_.Add(values); + return this; + } + public Builder ClearField128() { + PrepareBuilder(); + result.field128_.Clear(); + return this; + } + + public bool HasField131 { + get { return result.hasField131; } + } + public long Field131 { + get { return result.Field131; } + set { SetField131(value); } + } + public Builder SetField131(long value) { + PrepareBuilder(); + result.hasField131 = true; + result.field131_ = value; + return this; + } + public Builder ClearField131() { + PrepareBuilder(); + result.hasField131 = false; + result.field131_ = 0L; + return this; + } + + public pbc::IPopsicleList Field127List { + get { return PrepareBuilder().field127_; } + } + public int Field127Count { + get { return result.Field127Count; } + } + public string GetField127(int index) { + return result.GetField127(index); + } + public Builder SetField127(int index, string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.field127_[index] = value; + return this; + } + public Builder AddField127(string value) { + pb::ThrowHelper.ThrowIfNull(value, "value"); + PrepareBuilder(); + result.field127_.Add(value); + return this; + } + public Builder AddRangeField127(scg::IEnumerable values) { + PrepareBuilder(); + result.field127_.Add(values); + return this; + } + public Builder ClearField127() { + PrepareBuilder(); + result.field127_.Clear(); + return this; + } + + public bool HasField129 { + get { return result.hasField129; } + } + public int Field129 { + get { return result.Field129; } + set { SetField129(value); } + } + public Builder SetField129(int value) { + PrepareBuilder(); + result.hasField129 = true; + result.field129_ = value; + return this; + } + public Builder ClearField129() { + PrepareBuilder(); + result.hasField129 = false; + result.field129_ = 0; + return this; + } + + public pbc::IPopsicleList Field130List { + get { return PrepareBuilder().field130_; } + } + public int Field130Count { + get { return result.Field130Count; } + } + public long GetField130(int index) { + return result.GetField130(index); + } + public Builder SetField130(int index, long value) { + PrepareBuilder(); + result.field130_[index] = value; + return this; + } + public Builder AddField130(long value) { + PrepareBuilder(); + result.field130_.Add(value); + return this; + } + public Builder AddRangeField130(scg::IEnumerable values) { + PrepareBuilder(); + result.field130_.Add(values); + return this; + } + public Builder ClearField130() { + PrepareBuilder(); + result.field130_.Clear(); + return this; + } + + public bool HasField205 { + get { return result.hasField205; } + } + public bool Field205 { + get { return result.Field205; } + set { SetField205(value); } + } + public Builder SetField205(bool value) { + PrepareBuilder(); + result.hasField205 = true; + result.field205_ = value; + return this; + } + public Builder ClearField205() { + PrepareBuilder(); + result.hasField205 = false; + result.field205_ = false; + return this; + } + + public bool HasField206 { + get { return result.hasField206; } + } + public bool Field206 { + get { return result.Field206; } + set { SetField206(value); } + } + public Builder SetField206(bool value) { + PrepareBuilder(); + result.hasField206 = true; + result.field206_ = value; + return this; + } + public Builder ClearField206() { + PrepareBuilder(); + result.hasField206 = false; + result.field206_ = false; + return this; + } + } + static SpeedMessage2() { + object.ReferenceEquals(global::Google.ProtocolBuffers.TestProtos.GoogleSpeed.Descriptor, null); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class SpeedMessage2GroupedMessage : pb::GeneratedMessage { + private SpeedMessage2GroupedMessage() { } + private static readonly SpeedMessage2GroupedMessage defaultInstance = new SpeedMessage2GroupedMessage().MakeReadOnly(); + private static readonly string[] _speedMessage2GroupedMessageFieldNames = new string[] { "field1", "field10", "field11", "field2", "field3", "field4", "field5", "field6", "field7", "field8", "field9" }; + private static readonly uint[] _speedMessage2GroupedMessageFieldTags = new uint[] { 13, 85, 88, 21, 29, 32, 40, 48, 56, 69, 72 }; + public static SpeedMessage2GroupedMessage DefaultInstance { + get { return defaultInstance; } + } + + public override SpeedMessage2GroupedMessage DefaultInstanceForType { + get { return DefaultInstance; } + } + + protected override SpeedMessage2GroupedMessage ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.GoogleSpeed.internal__static_benchmarks_SpeedMessage2GroupedMessage__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.GoogleSpeed.internal__static_benchmarks_SpeedMessage2GroupedMessage__FieldAccessorTable; } + } + + public const int Field1FieldNumber = 1; + private bool hasField1; + private float field1_; + public bool HasField1 { + get { return hasField1; } + } + public float Field1 { + get { return field1_; } + } + + public const int Field2FieldNumber = 2; + private bool hasField2; + private float field2_; + public bool HasField2 { + get { return hasField2; } + } + public float Field2 { + get { return field2_; } + } + + public const int Field3FieldNumber = 3; + private bool hasField3; + private float field3_; + public bool HasField3 { + get { return hasField3; } + } + public float Field3 { + get { return field3_; } + } + + public const int Field4FieldNumber = 4; + private bool hasField4; + private bool field4_; + public bool HasField4 { + get { return hasField4; } + } + public bool Field4 { + get { return field4_; } + } + + public const int Field5FieldNumber = 5; + private bool hasField5; + private bool field5_; + public bool HasField5 { + get { return hasField5; } + } + public bool Field5 { + get { return field5_; } + } + + public const int Field6FieldNumber = 6; + private bool hasField6; + private bool field6_ = true; + public bool HasField6 { + get { return hasField6; } + } + public bool Field6 { + get { return field6_; } + } + + public const int Field7FieldNumber = 7; + private bool hasField7; + private bool field7_; + public bool HasField7 { + get { return hasField7; } + } + public bool Field7 { + get { return field7_; } + } + + public const int Field8FieldNumber = 8; + private bool hasField8; + private float field8_; + public bool HasField8 { + get { return hasField8; } + } + public float Field8 { + get { return field8_; } + } + + public const int Field9FieldNumber = 9; + private bool hasField9; + private bool field9_; + public bool HasField9 { + get { return hasField9; } + } + public bool Field9 { + get { return field9_; } + } + + public const int Field10FieldNumber = 10; + private bool hasField10; + private float field10_; + public bool HasField10 { + get { return hasField10; } + } + public float Field10 { + get { return field10_; } + } + + public const int Field11FieldNumber = 11; + private bool hasField11; + private long field11_; + public bool HasField11 { + get { return hasField11; } + } + public long Field11 { + get { return field11_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::ICodedOutputStream output) { + CalcSerializedSize(); + string[] field_names = _speedMessage2GroupedMessageFieldNames; + if (hasField1) { + output.WriteFloat(1, field_names[0], Field1); + } + if (hasField2) { + output.WriteFloat(2, field_names[3], Field2); + } + if (hasField3) { + output.WriteFloat(3, field_names[4], Field3); + } + if (hasField4) { + output.WriteBool(4, field_names[5], Field4); + } + if (hasField5) { + output.WriteBool(5, field_names[6], Field5); + } + if (hasField6) { + output.WriteBool(6, field_names[7], Field6); + } + if (hasField7) { + output.WriteBool(7, field_names[8], Field7); + } + if (hasField8) { + output.WriteFloat(8, field_names[9], Field8); + } + if (hasField9) { + output.WriteBool(9, field_names[10], Field9); + } + if (hasField10) { + output.WriteFloat(10, field_names[1], Field10); + } + if (hasField11) { + output.WriteInt64(11, field_names[2], Field11); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + return CalcSerializedSize(); + } + } + + private int CalcSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (hasField1) { + size += pb::CodedOutputStream.ComputeFloatSize(1, Field1); + } + if (hasField2) { + size += pb::CodedOutputStream.ComputeFloatSize(2, Field2); + } + if (hasField3) { + size += pb::CodedOutputStream.ComputeFloatSize(3, Field3); + } + if (hasField4) { + size += pb::CodedOutputStream.ComputeBoolSize(4, Field4); + } + if (hasField5) { + size += pb::CodedOutputStream.ComputeBoolSize(5, Field5); + } + if (hasField6) { + size += pb::CodedOutputStream.ComputeBoolSize(6, Field6); + } + if (hasField7) { + size += pb::CodedOutputStream.ComputeBoolSize(7, Field7); + } + if (hasField8) { + size += pb::CodedOutputStream.ComputeFloatSize(8, Field8); + } + if (hasField9) { + size += pb::CodedOutputStream.ComputeBoolSize(9, Field9); + } + if (hasField10) { + size += pb::CodedOutputStream.ComputeFloatSize(10, Field10); + } + if (hasField11) { + size += pb::CodedOutputStream.ComputeInt64Size(11, Field11); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + public static SpeedMessage2GroupedMessage ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static SpeedMessage2GroupedMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static SpeedMessage2GroupedMessage ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static SpeedMessage2GroupedMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static SpeedMessage2GroupedMessage ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static SpeedMessage2GroupedMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static SpeedMessage2GroupedMessage ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static SpeedMessage2GroupedMessage ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static SpeedMessage2GroupedMessage ParseFrom(pb::ICodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static SpeedMessage2GroupedMessage ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + private SpeedMessage2GroupedMessage MakeReadOnly() { + return this; + } + + public static Builder CreateBuilder() { return new Builder(); } + public override Builder ToBuilder() { return CreateBuilder(this); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(SpeedMessage2GroupedMessage prototype) { + return new Builder(prototype); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() { + result = DefaultInstance; + resultIsReadOnly = true; + } + internal Builder(SpeedMessage2GroupedMessage cloneFrom) { + result = cloneFrom; + resultIsReadOnly = true; + } + + private bool resultIsReadOnly; + private SpeedMessage2GroupedMessage result; + + private SpeedMessage2GroupedMessage PrepareBuilder() { + if (resultIsReadOnly) { + SpeedMessage2GroupedMessage original = result; + result = new SpeedMessage2GroupedMessage(); + resultIsReadOnly = false; + MergeFrom(original); + } + return result; + } + + public override bool IsInitialized { + get { return result.IsInitialized; } + } + + protected override SpeedMessage2GroupedMessage MessageBeingBuilt { + get { return PrepareBuilder(); } + } + + public override Builder Clear() { + result = DefaultInstance; + resultIsReadOnly = true; + return this; + } + + public override Builder Clone() { + if (resultIsReadOnly) { + return new Builder(result); + } else { + return new Builder().MergeFrom(result); + } + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage.Descriptor; } + } + + public override SpeedMessage2GroupedMessage DefaultInstanceForType { + get { return global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage.DefaultInstance; } + } + + public override SpeedMessage2GroupedMessage BuildPartial() { + if (resultIsReadOnly) { + return result; + } + resultIsReadOnly = true; + return result.MakeReadOnly(); + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is SpeedMessage2GroupedMessage) { + return MergeFrom((SpeedMessage2GroupedMessage) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(SpeedMessage2GroupedMessage other) { + if (other == global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage.DefaultInstance) return this; + PrepareBuilder(); + if (other.HasField1) { + Field1 = other.Field1; + } + if (other.HasField2) { + Field2 = other.Field2; + } + if (other.HasField3) { + Field3 = other.Field3; + } + if (other.HasField4) { + Field4 = other.Field4; + } + if (other.HasField5) { + Field5 = other.Field5; + } + if (other.HasField6) { + Field6 = other.Field6; + } + if (other.HasField7) { + Field7 = other.Field7; + } + if (other.HasField8) { + Field8 = other.Field8; + } + if (other.HasField9) { + Field9 = other.Field9; + } + if (other.HasField10) { + Field10 = other.Field10; + } + if (other.HasField11) { + Field11 = other.Field11; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::ICodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + PrepareBuilder(); + pb::UnknownFieldSet.Builder unknownFields = null; + uint tag; + string field_name; + while (input.ReadTag(out tag, out field_name)) { + if(tag == 0 && field_name != null) { + int field_ordinal = global::System.Array.BinarySearch(_speedMessage2GroupedMessageFieldNames, field_name, global::System.StringComparer.Ordinal); + if(field_ordinal >= 0) + tag = _speedMessage2GroupedMessageFieldTags[field_ordinal]; + else { + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name); + continue; + } + } + switch (tag) { + case 0: { + throw pb::InvalidProtocolBufferException.InvalidTag(); + } + default: { + if (pb::WireFormat.IsEndGroupTag(tag)) { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name); + break; + } + case 13: { + result.hasField1 = input.ReadFloat(ref result.field1_); + break; + } + case 21: { + result.hasField2 = input.ReadFloat(ref result.field2_); + break; + } + case 29: { + result.hasField3 = input.ReadFloat(ref result.field3_); + break; + } + case 32: { + result.hasField4 = input.ReadBool(ref result.field4_); + break; + } + case 40: { + result.hasField5 = input.ReadBool(ref result.field5_); + break; + } + case 48: { + result.hasField6 = input.ReadBool(ref result.field6_); + break; + } + case 56: { + result.hasField7 = input.ReadBool(ref result.field7_); + break; + } + case 69: { + result.hasField8 = input.ReadFloat(ref result.field8_); + break; + } + case 72: { + result.hasField9 = input.ReadBool(ref result.field9_); + break; + } + case 85: { + result.hasField10 = input.ReadFloat(ref result.field10_); + break; + } + case 88: { + result.hasField11 = input.ReadInt64(ref result.field11_); + break; + } + } + } + + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + + + public bool HasField1 { + get { return result.hasField1; } + } + public float Field1 { + get { return result.Field1; } + set { SetField1(value); } + } + public Builder SetField1(float value) { + PrepareBuilder(); + result.hasField1 = true; + result.field1_ = value; + return this; + } + public Builder ClearField1() { + PrepareBuilder(); + result.hasField1 = false; + result.field1_ = 0F; + return this; + } + + public bool HasField2 { + get { return result.hasField2; } + } + public float Field2 { + get { return result.Field2; } + set { SetField2(value); } + } + public Builder SetField2(float value) { + PrepareBuilder(); + result.hasField2 = true; + result.field2_ = value; + return this; + } + public Builder ClearField2() { + PrepareBuilder(); + result.hasField2 = false; + result.field2_ = 0F; + return this; + } + + public bool HasField3 { + get { return result.hasField3; } + } + public float Field3 { + get { return result.Field3; } + set { SetField3(value); } + } + public Builder SetField3(float value) { + PrepareBuilder(); + result.hasField3 = true; + result.field3_ = value; + return this; + } + public Builder ClearField3() { + PrepareBuilder(); + result.hasField3 = false; + result.field3_ = 0F; + return this; + } + + public bool HasField4 { + get { return result.hasField4; } + } + public bool Field4 { + get { return result.Field4; } + set { SetField4(value); } + } + public Builder SetField4(bool value) { + PrepareBuilder(); + result.hasField4 = true; + result.field4_ = value; + return this; + } + public Builder ClearField4() { + PrepareBuilder(); + result.hasField4 = false; + result.field4_ = false; + return this; + } + + public bool HasField5 { + get { return result.hasField5; } + } + public bool Field5 { + get { return result.Field5; } + set { SetField5(value); } + } + public Builder SetField5(bool value) { + PrepareBuilder(); + result.hasField5 = true; + result.field5_ = value; + return this; + } + public Builder ClearField5() { + PrepareBuilder(); + result.hasField5 = false; + result.field5_ = false; + return this; + } + + public bool HasField6 { + get { return result.hasField6; } + } + public bool Field6 { + get { return result.Field6; } + set { SetField6(value); } + } + public Builder SetField6(bool value) { + PrepareBuilder(); + result.hasField6 = true; + result.field6_ = value; + return this; + } + public Builder ClearField6() { + PrepareBuilder(); + result.hasField6 = false; + result.field6_ = true; + return this; + } + + public bool HasField7 { + get { return result.hasField7; } + } + public bool Field7 { + get { return result.Field7; } + set { SetField7(value); } + } + public Builder SetField7(bool value) { + PrepareBuilder(); + result.hasField7 = true; + result.field7_ = value; + return this; + } + public Builder ClearField7() { + PrepareBuilder(); + result.hasField7 = false; + result.field7_ = false; + return this; + } + + public bool HasField8 { + get { return result.hasField8; } + } + public float Field8 { + get { return result.Field8; } + set { SetField8(value); } + } + public Builder SetField8(float value) { + PrepareBuilder(); + result.hasField8 = true; + result.field8_ = value; + return this; + } + public Builder ClearField8() { + PrepareBuilder(); + result.hasField8 = false; + result.field8_ = 0F; + return this; + } + + public bool HasField9 { + get { return result.hasField9; } + } + public bool Field9 { + get { return result.Field9; } + set { SetField9(value); } + } + public Builder SetField9(bool value) { + PrepareBuilder(); + result.hasField9 = true; + result.field9_ = value; + return this; + } + public Builder ClearField9() { + PrepareBuilder(); + result.hasField9 = false; + result.field9_ = false; + return this; + } + + public bool HasField10 { + get { return result.hasField10; } + } + public float Field10 { + get { return result.Field10; } + set { SetField10(value); } + } + public Builder SetField10(float value) { + PrepareBuilder(); + result.hasField10 = true; + result.field10_ = value; + return this; + } + public Builder ClearField10() { + PrepareBuilder(); + result.hasField10 = false; + result.field10_ = 0F; + return this; + } + + public bool HasField11 { + get { return result.hasField11; } + } + public long Field11 { + get { return result.Field11; } + set { SetField11(value); } + } + public Builder SetField11(long value) { + PrepareBuilder(); + result.hasField11 = true; + result.field11_ = value; + return this; + } + public Builder ClearField11() { + PrepareBuilder(); + result.hasField11 = false; + result.field11_ = 0L; + return this; + } + } + static SpeedMessage2GroupedMessage() { + object.ReferenceEquals(global::Google.ProtocolBuffers.TestProtos.GoogleSpeed.Descriptor, null); + } + } + + #endregion + +} + +#endregion Designer generated code diff --git a/csharp/src/ProtoBench/Properties/AssemblyInfo.cs b/csharp/src/ProtoBench/Properties/AssemblyInfo.cs index 8600c13e..cdffc5e7 100644 --- a/csharp/src/ProtoBench/Properties/AssemblyInfo.cs +++ b/csharp/src/ProtoBench/Properties/AssemblyInfo.cs @@ -15,7 +15,6 @@ using System.Runtime.InteropServices; [assembly: AssemblyCopyright("Copyright © 2009")] [assembly: AssemblyTrademark("")] [assembly: AssemblyCulture("")] -[assembly: CLSCompliant(true)] // Version information for an assembly consists of the following four values: // diff --git a/csharp/src/ProtoBench/ProtoBench.csproj b/csharp/src/ProtoBench/ProtoBench.csproj index 9df47745..280a54a9 100644 --- a/csharp/src/ProtoBench/ProtoBench.csproj +++ b/csharp/src/ProtoBench/ProtoBench.csproj @@ -1,8 +1,6 @@  - CLIENTPROFILE - NET35 Debug AnyCPU 9.0.30729 @@ -12,15 +10,16 @@ Properties Google.ProtocolBuffers.ProtoBench ProtoBench - v3.5 + v4.0 512 + Client true full false - bin\NET35\Debug - obj\NET35\Debug\ + bin\Debug + obj\Debug\ DEBUG;TRACE prompt 4 @@ -31,8 +30,8 @@ pdbonly true - bin\NET35\Release - obj\NET35\Release\ + bin\Release + obj\Release\ TRACE prompt 4 @@ -45,17 +44,16 @@ - - + + - - - - + + + @@ -70,6 +68,7 @@ + Always @@ -77,6 +76,9 @@ Always + + + - - Program - $(ProjectDir)..\..\lib\NUnit\tools\nunit-console.exe - /nologo /noshadow /labels /wait $(AssemblyName).dll - $(ProjectDir)$(OutputPath) - - \ No newline at end of file diff --git a/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.CF35.csproj b/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.CF35.csproj deleted file mode 100644 index 0c6344ed..00000000 --- a/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.CF35.csproj +++ /dev/null @@ -1,191 +0,0 @@ - - - COMPACT_FRAMEWORK - CF35 - TEST - Debug - AnyCPU - 9.0.30729 - 2.0 - {DD01ED24-3750-4567-9A23-1DB676A15610} - Library - Properties - Google.ProtocolBuffers - Google.ProtocolBuffers.Test - v3.5 - 512 - true - ..\..\keys\Google.ProtocolBuffers.snk - 3.5 - {4D628B5B-2FBC-4AA6-8C16-197242AEB884};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} - Smartphone - f27da329-3269-4191-98e0-c87d3d7f1db9 - - - true - full - false - bin\CF35\Debug - obj\CF35\Debug\ - DEBUG;TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOSERIALIZABLE;NOFILEVERSION - prompt - 4 - true - true - Off - true - - - pdbonly - true - bin\CF35\Release - obj\CF35\Release\ - TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOSERIALIZABLE;NOFILEVERSION - prompt - 4 - true - true - Off - true - - - - - - - - - - False - ..\..\lib\NUnit\lib\nunit.framework.dll - - - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.Silverlight.Testing.dll - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight.dll - - - - - Microsoft.VisualStudio.TestTools.cs - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - {231391AF-449C-4a39-986C-AD7F270F4750} - ProtocolBuffers.Serialization - - - {6908BDCE-D925-43F3-94AC-A531E6DF2591} - ProtocolBuffers - - - - - False - .NET Framework 3.5 SP1 Client Profile - false - - - False - .NET Framework 3.5 SP1 - true - - - False - Windows Installer 3.1 - true - - - - - - - - - - - - - - - - - Program - $(ProjectDir)..\..\lib\NUnit\tools\nunit-console.exe - /nologo /noshadow /labels /wait $(AssemblyName).dll - $(ProjectDir)$(OutputPath) - - \ No newline at end of file diff --git a/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.NET20.csproj b/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.NET20.csproj deleted file mode 100644 index f0453fa1..00000000 --- a/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.NET20.csproj +++ /dev/null @@ -1,178 +0,0 @@ - - - CLIENTPROFILE - NET20 - TEST - Debug - AnyCPU - 9.0.30729 - 2.0 - {DD01ED24-3750-4567-9A23-1DB676A15610} - Library - Properties - Google.ProtocolBuffers - Google.ProtocolBuffers.Test - v2.0 - 512 - true - ..\..\keys\Google.ProtocolBuffers.snk - 3.5 - - - true - full - false - bin\NET20\Debug - obj\NET20\Debug\ - DEBUG;TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOEXTENSIONS - prompt - 4 - true - true - Off - - - pdbonly - true - bin\NET20\Release - obj\NET20\Release\ - TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOEXTENSIONS - prompt - 4 - true - true - Off - - - - - - - - - False - ..\..\lib\NUnit\lib\nunit.framework.dll - - - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.Silverlight.Testing.dll - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight.dll - - - - - Microsoft.VisualStudio.TestTools.cs - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - {231391AF-449C-4a39-986C-AD7F270F4750} - ProtocolBuffers.Serialization - - - {6908BDCE-D925-43F3-94AC-A531E6DF2591} - ProtocolBuffers - - - - - False - .NET Framework 3.5 SP1 Client Profile - false - - - False - .NET Framework 3.5 SP1 - true - - - False - Windows Installer 3.1 - true - - - - - - - - - - Program - $(ProjectDir)..\..\lib\NUnit\tools\nunit-console.exe - /nologo /noshadow /labels /wait $(AssemblyName).dll - $(ProjectDir)$(OutputPath) - - \ No newline at end of file diff --git a/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.NET35.csproj b/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.NET35.csproj deleted file mode 100644 index 33630b44..00000000 --- a/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.NET35.csproj +++ /dev/null @@ -1,179 +0,0 @@ - - - CLIENTPROFILE - NET35 - TEST - Debug - AnyCPU - 9.0.30729 - 2.0 - {DD01ED24-3750-4567-9A23-1DB676A15610} - Library - Properties - Google.ProtocolBuffers - Google.ProtocolBuffers.Test - v3.5 - 512 - true - ..\..\keys\Google.ProtocolBuffers.snk - 3.5 - - - true - full - false - bin\NET35\Debug - obj\NET35\Debug\ - DEBUG;TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate) - prompt - 4 - true - true - Off - - - pdbonly - true - bin\NET35\Release - obj\NET35\Release\ - TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate) - prompt - 4 - true - true - Off - - - - - - - - - - False - ..\..\lib\NUnit\lib\nunit.framework.dll - - - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.Silverlight.Testing.dll - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight.dll - - - - - Microsoft.VisualStudio.TestTools.cs - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - {231391AF-449C-4a39-986C-AD7F270F4750} - ProtocolBuffers.Serialization - - - {6908BDCE-D925-43F3-94AC-A531E6DF2591} - ProtocolBuffers - - - - - False - .NET Framework 3.5 SP1 Client Profile - false - - - False - .NET Framework 3.5 SP1 - true - - - False - Windows Installer 3.1 - true - - - - - - - - - - Program - $(ProjectDir)..\..\lib\NUnit\tools\nunit-console.exe - /nologo /noshadow /labels /wait $(AssemblyName).dll - $(ProjectDir)$(OutputPath) - - \ No newline at end of file diff --git a/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.NET40.csproj b/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.NET40.csproj deleted file mode 100644 index 74ea7211..00000000 --- a/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.NET40.csproj +++ /dev/null @@ -1,179 +0,0 @@ - - - CLIENTPROFILE - NET40 - TEST - Debug - AnyCPU - 9.0.30729 - 2.0 - {DD01ED24-3750-4567-9A23-1DB676A15610} - Library - Properties - Google.ProtocolBuffers - Google.ProtocolBuffers.Test - v4.0 - 512 - true - ..\..\keys\Google.ProtocolBuffers.snk - 3.5 - - - true - full - false - bin\NET40\Debug - obj\NET40\Debug\ - DEBUG;TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate) - prompt - 4 - true - true - Off - - - pdbonly - true - bin\NET40\Release - obj\NET40\Release\ - TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate) - prompt - 4 - true - true - Off - - - - - - - - - - False - ..\..\lib\NUnit\lib\nunit.framework.dll - - - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.Silverlight.Testing.dll - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight.dll - - - - - Microsoft.VisualStudio.TestTools.cs - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - {231391AF-449C-4a39-986C-AD7F270F4750} - ProtocolBuffers.Serialization - - - {6908BDCE-D925-43F3-94AC-A531E6DF2591} - ProtocolBuffers - - - - - False - .NET Framework 3.5 SP1 Client Profile - false - - - False - .NET Framework 3.5 SP1 - true - - - False - Windows Installer 3.1 - true - - - - - - - - - - Program - $(ProjectDir)..\..\lib\NUnit\tools\nunit-console.exe - /nologo /noshadow /labels /wait $(AssemblyName).dll - $(ProjectDir)$(OutputPath) - - \ No newline at end of file diff --git a/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.PL40.csproj b/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.PL40.csproj deleted file mode 100644 index 018cf9d6..00000000 --- a/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.PL40.csproj +++ /dev/null @@ -1,213 +0,0 @@ - - - PORTABLE_LIBRARY - PL40 - TEST - Debug - AnyCPU - 9.0.30729 - 2.0 - {DD01ED24-3750-4567-9A23-1DB676A15610} - Library - Properties - Google.ProtocolBuffers - Google.ProtocolBuffers.Test - v4.0 - 512 - true - ..\..\keys\Google.ProtocolBuffers.snk - 3.5 - 10.0 - {A1591282-1198-4647-A2B1-27E5FF5F6F3B};{fae04ec0-301f-11d3-bf4b-00c04f79efbc} - - false - false - true - true - true - Google.ProtocolBuffers.Test.xap - Properties\AppManifest.xml - Google.ProtocolBuffers.App - TestPage.html - true - v4.0 - Properties\OutOfBrowserSettings.xml - true - - - true - full - false - bin\PL40\Debug - obj\PL40\Debug\ - DEBUG;TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOSERIALIZABLE;NOSORTEDLIST - prompt - 4 - true - true - Off - - - pdbonly - true - bin\PL40\Release - obj\PL40\Release\ - TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOSERIALIZABLE;NOSORTEDLIST - prompt - 4 - true - true - Off - - - - - - - - - - - - False - ..\..\lib\NUnit\lib\nunit.framework.dll - - - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.Silverlight.Testing.dll - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight.dll - - - - - Microsoft.VisualStudio.TestTools.cs - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - App.xaml - - - - - MSBuild:Compile - Designer - - - - - {231391AF-449C-4a39-986C-AD7F270F4750} - ProtocolBuffers.Serialization - - - {6908BDCE-D925-43F3-94AC-A531E6DF2591} - ProtocolBuffers - - - - - False - .NET Framework 3.5 SP1 Client Profile - false - - - False - .NET Framework 3.5 SP1 - true - - - False - Windows Installer 3.1 - true - - - - - - - - - - - - - - - - - Program - $(ProjectDir)..\..\lib\NUnit\tools\nunit-console.exe - /nologo /noshadow /labels /wait $(AssemblyName).dll - $(ProjectDir)$(OutputPath) - - \ No newline at end of file diff --git a/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.SL20.csproj b/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.SL20.csproj deleted file mode 100644 index e54fa25c..00000000 --- a/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.SL20.csproj +++ /dev/null @@ -1,214 +0,0 @@ - - - SILVERLIGHT - SL20 - TEST - Debug - AnyCPU - 9.0.30729 - 2.0 - {DD01ED24-3750-4567-9A23-1DB676A15610} - Library - Properties - Google.ProtocolBuffers - Google.ProtocolBuffers.Test - v2.0 - 512 - true - ..\..\keys\Google.ProtocolBuffers.snk - 3.5 - {A1591282-1198-4647-A2B1-27E5FF5F6F3B};{fae04ec0-301f-11d3-bf4b-00c04f79efbc} - true - false - false - true - true - Google.ProtocolBuffers.Test.xap - Properties\AppManifest.xml - Google.ProtocolBuffers.App - TestPage.html - true - v2.0 - Properties\OutOfBrowserSettings.xml - true - - - true - full - false - bin\SL20\Debug - obj\SL20\Debug\ - DEBUG;TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOSERIALIZABLE;NOSORTEDLIST;NOEXTENSIONS - prompt - 4 - true - true - Off - true - - - pdbonly - true - bin\SL20\Release - obj\SL20\Release\ - TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOSERIALIZABLE;NOSORTEDLIST;NOEXTENSIONS - prompt - 4 - true - true - Off - true - - - - - - - - - - - False - ..\..\lib\NUnit\lib\nunit.framework.dll - - - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.Silverlight.Testing.dll - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight.dll - - - - - Microsoft.VisualStudio.TestTools.cs - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - App.xaml - - - - - MSBuild:Compile - Designer - - - - - {231391AF-449C-4a39-986C-AD7F270F4750} - ProtocolBuffers.Serialization - - - {6908BDCE-D925-43F3-94AC-A531E6DF2591} - ProtocolBuffers - - - - - False - .NET Framework 3.5 SP1 Client Profile - false - - - False - .NET Framework 3.5 SP1 - true - - - False - Windows Installer 3.1 - true - - - - - - - - - - - - OfflineApplication - - - - - - - Program - $(ProjectDir)..\..\lib\NUnit\tools\nunit-console.exe - /nologo /noshadow /labels /wait $(AssemblyName).dll - $(ProjectDir)$(OutputPath) - - \ No newline at end of file diff --git a/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.SL30.csproj b/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.SL30.csproj deleted file mode 100644 index 76f6b1a2..00000000 --- a/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.SL30.csproj +++ /dev/null @@ -1,215 +0,0 @@ - - - SILVERLIGHT - SL30 - TEST - Debug - AnyCPU - 9.0.30729 - 2.0 - {DD01ED24-3750-4567-9A23-1DB676A15610} - Library - Properties - Google.ProtocolBuffers - Google.ProtocolBuffers.Test - v3.5 - 512 - true - ..\..\keys\Google.ProtocolBuffers.snk - 3.5 - {A1591282-1198-4647-A2B1-27E5FF5F6F3B};{fae04ec0-301f-11d3-bf4b-00c04f79efbc} - true - false - false - true - true - Google.ProtocolBuffers.Test.xap - Properties\AppManifest.xml - Google.ProtocolBuffers.App - TestPage.html - true - v3.5 - Properties\OutOfBrowserSettings.xml - true - - - true - full - false - bin\SL30\Debug - obj\SL30\Debug\ - DEBUG;TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOSERIALIZABLE;NOSORTEDLIST - prompt - 4 - true - true - Off - true - - - pdbonly - true - bin\SL30\Release - obj\SL30\Release\ - TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOSERIALIZABLE;NOSORTEDLIST - prompt - 4 - true - true - Off - true - - - - - - - - - - - - False - ..\..\lib\NUnit\lib\nunit.framework.dll - - - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.Silverlight.Testing.dll - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight.dll - - - - - Microsoft.VisualStudio.TestTools.cs - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - App.xaml - - - - - MSBuild:Compile - Designer - - - - - {231391AF-449C-4a39-986C-AD7F270F4750} - ProtocolBuffers.Serialization - - - {6908BDCE-D925-43F3-94AC-A531E6DF2591} - ProtocolBuffers - - - - - False - .NET Framework 3.5 SP1 Client Profile - false - - - False - .NET Framework 3.5 SP1 - true - - - False - Windows Installer 3.1 - true - - - - - - - - - - - - OfflineApplication - - - - - - - Program - $(ProjectDir)..\..\lib\NUnit\tools\nunit-console.exe - /nologo /noshadow /labels /wait $(AssemblyName).dll - $(ProjectDir)$(OutputPath) - - \ No newline at end of file diff --git a/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.SL40.csproj b/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.SL40.csproj deleted file mode 100644 index ade3dc35..00000000 --- a/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.SL40.csproj +++ /dev/null @@ -1,215 +0,0 @@ - - - SILVERLIGHT - SL40 - TEST - Debug - AnyCPU - 9.0.30729 - 2.0 - {DD01ED24-3750-4567-9A23-1DB676A15610} - Library - Properties - Google.ProtocolBuffers - Google.ProtocolBuffers.Test - v4.0 - 512 - true - ..\..\keys\Google.ProtocolBuffers.snk - 3.5 - {A1591282-1198-4647-A2B1-27E5FF5F6F3B};{fae04ec0-301f-11d3-bf4b-00c04f79efbc} - true - false - false - v4.0 - true - true - Google.ProtocolBuffers.Test.xap - Properties\AppManifest.xml - Google.ProtocolBuffers.App - TestPage.html - true - Properties\OutOfBrowserSettings.xml - true - - - true - full - false - bin\SL40\Debug - obj\SL40\Debug\ - DEBUG;TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOSERIALIZABLE;NOSORTEDLIST - prompt - 4 - true - true - Off - true - - - pdbonly - true - bin\SL40\Release - obj\SL40\Release\ - TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOSERIALIZABLE;NOSORTEDLIST - prompt - 4 - true - true - Off - true - - - - - - - - - - - - False - ..\..\lib\NUnit\lib\nunit.framework.dll - - - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.Silverlight.Testing.dll - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight.dll - - - - - Microsoft.VisualStudio.TestTools.cs - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - App.xaml - - - - - MSBuild:Compile - Designer - - - - - {231391AF-449C-4a39-986C-AD7F270F4750} - ProtocolBuffers.Serialization - - - {6908BDCE-D925-43F3-94AC-A531E6DF2591} - ProtocolBuffers - - - - - False - .NET Framework 3.5 SP1 Client Profile - false - - - False - .NET Framework 3.5 SP1 - true - - - False - Windows Installer 3.1 - true - - - - - - - - - - - - OfflineApplication - - - - - - - Program - $(ProjectDir)..\..\lib\NUnit\tools\nunit-console.exe - /nologo /noshadow /labels /wait $(AssemblyName).dll - $(ProjectDir)$(OutputPath) - - \ No newline at end of file diff --git a/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj b/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj index 5702c011..8d900266 100644 --- a/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj +++ b/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj @@ -13,18 +13,19 @@ Properties Google.ProtocolBuffers Google.ProtocolBuffers.Test - v3.5 + v4.0 512 true ..\..\keys\Google.ProtocolBuffers.snk 3.5 + Client true full false - bin\NET35\Debug - obj\NET35\Debug\ + bin\Debug + obj\Debug\ DEBUG;TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate) prompt 4 @@ -35,8 +36,8 @@ pdbonly true - bin\NET35\Release - obj\NET35\Release\ + bin\Release + obj\Release\ TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate) prompt 4 diff --git a/csharp/src/ProtocolBuffers.sln b/csharp/src/ProtocolBuffers.sln index 5eb488cf..6d609dc9 100644 --- a/csharp/src/ProtocolBuffers.sln +++ b/csharp/src/ProtocolBuffers.sln @@ -22,6 +22,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ProtoDump", "ProtoDump\Prot EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ProtoMunge", "ProtoMunge\ProtoMunge.csproj", "{8F09AF72-3327-4FA7-BC09-070B80221AB9}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ProtoBench", "ProtoBench\ProtoBench.csproj", "{C7A4A435-2813-41C8-AA87-BD914BA5223D}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -68,6 +70,10 @@ Global {8F09AF72-3327-4FA7-BC09-070B80221AB9}.Debug|Any CPU.Build.0 = Debug|Any CPU {8F09AF72-3327-4FA7-BC09-070B80221AB9}.Release|Any CPU.ActiveCfg = Release|Any CPU {8F09AF72-3327-4FA7-BC09-070B80221AB9}.Release|Any CPU.Build.0 = Release|Any CPU + {C7A4A435-2813-41C8-AA87-BD914BA5223D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {C7A4A435-2813-41C8-AA87-BD914BA5223D}.Debug|Any CPU.Build.0 = Debug|Any CPU + {C7A4A435-2813-41C8-AA87-BD914BA5223D}.Release|Any CPU.ActiveCfg = Release|Any CPU + {C7A4A435-2813-41C8-AA87-BD914BA5223D}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/csharp/src/ProtocolBuffers/FieldSet.cs b/csharp/src/ProtocolBuffers/FieldSet.cs index f3c08cf5..4177400f 100644 --- a/csharp/src/ProtocolBuffers/FieldSet.cs +++ b/csharp/src/ProtocolBuffers/FieldSet.cs @@ -88,7 +88,7 @@ namespace Google.ProtocolBuffers public static FieldSet CreateInstance() { // Use SortedList to keep fields in the canonical order - return new FieldSet(new SortedList()); + return new FieldSet(new SortedDictionary()); } /// @@ -111,7 +111,7 @@ namespace Google.ProtocolBuffers if (hasRepeats) { - var tmp = new SortedList(); + var tmp = new SortedDictionary(); foreach (KeyValuePair entry in fields) { IList list = entry.Value as IList; @@ -151,8 +151,8 @@ namespace Google.ProtocolBuffers { get { - SortedList copy = - new SortedList(); + SortedDictionary copy = + new SortedDictionary(); foreach (KeyValuePair fd in fields) { copy.Add((FieldDescriptor) fd.Key, fd.Value); diff --git a/csharp/src/ProtocolBuffers/GeneratedMessage.cs b/csharp/src/ProtocolBuffers/GeneratedMessage.cs index 6f4b6657..c17c15cf 100644 --- a/csharp/src/ProtocolBuffers/GeneratedMessage.cs +++ b/csharp/src/ProtocolBuffers/GeneratedMessage.cs @@ -75,8 +75,8 @@ namespace Google.ProtocolBuffers internal IDictionary GetMutableFieldMap() { - // Use a SortedList so we'll end up serializing fields in order - var ret = new SortedList(); + // Use a SortedDictionary so we'll end up serializing fields in order + var ret = new SortedDictionary(); MessageDescriptor descriptor = DescriptorForType; foreach (FieldDescriptor field in descriptor.Fields) { diff --git a/csharp/src/ProtocolBuffers/Properties/AssemblyInfo.cs b/csharp/src/ProtocolBuffers/Properties/AssemblyInfo.cs index 063f6666..806bd5d5 100644 --- a/csharp/src/ProtocolBuffers/Properties/AssemblyInfo.cs +++ b/csharp/src/ProtocolBuffers/Properties/AssemblyInfo.cs @@ -65,6 +65,3 @@ using System.Security; [assembly: AssemblyFileVersion("2.4.1.555")] #endif -#if CLIENTPROFILE // ROK - not defined in SL, CF, or PL -[assembly: AllowPartiallyTrustedCallers] -#endif diff --git a/csharp/src/ProtocolBuffers/ProtocolBuffers.csproj b/csharp/src/ProtocolBuffers/ProtocolBuffers.csproj index 5f6404a2..32a343ad 100644 --- a/csharp/src/ProtocolBuffers/ProtocolBuffers.csproj +++ b/csharp/src/ProtocolBuffers/ProtocolBuffers.csproj @@ -1,8 +1,6 @@  - CLIENTPROFILE - NET35 Debug AnyCPU 9.0.30729 @@ -12,18 +10,21 @@ Properties Google.ProtocolBuffers Google.ProtocolBuffers - v3.5 + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + Profile92 + v4.0 512 true ..\..\keys\Google.ProtocolBuffers.snk 3.5 + 10.0 true full false - bin\NET35\Debug - obj\NET35\Debug\ + bin\Debug + obj\Debug\ $(OutputPath)\$(AssemblyName).xml 1591, 1570, 1571, 1572, 1573, 1574 DEBUG;TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate) @@ -35,8 +36,8 @@ pdbonly true - bin\NET35\Release - obj\NET35\Release\ + bin\Release + obj\Release\ $(OutputPath)\$(AssemblyName).xml 1591, 1570, 1571, 1572, 1573, 1574 TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate) @@ -137,7 +138,7 @@ - + - - Program - $(ProjectDir)..\..\lib\NUnit\tools\nunit-console.exe - /nologo /noshadow /labels /wait $(AssemblyName).dll - $(ProjectDir)$(OutputPath) - - \ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.CF35.csproj b/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.CF35.csproj deleted file mode 100644 index 74edad11..00000000 --- a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.CF35.csproj +++ /dev/null @@ -1,134 +0,0 @@ - - - COMPACT_FRAMEWORK - CF35 - TEST - Debug - AnyCPU - 9.0.30729 - 2.0 - {EE01ED24-3750-4567-9A23-1DB676A15610} - Library - Properties - Google.ProtocolBuffers - Google.ProtocolBuffersLite.Test - v3.5 - 512 - true - ..\..\keys\Google.ProtocolBuffers.snk - 3.5 - {4D628B5B-2FBC-4AA6-8C16-197242AEB884};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} - Smartphone - f27da329-3269-4191-98e0-c87d3d7f1db9 - - - true - full - false - bin\CF35\Debug - obj\CF35\Debug\ - DEBUG;TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOSERIALIZABLE;NOFILEVERSION - prompt - 4 - true - true - Off - true - - - pdbonly - true - bin\CF35\Release - obj\CF35\Release\ - TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOSERIALIZABLE;NOFILEVERSION - prompt - 4 - true - true - Off - true - - - - - - - - - - False - ..\..\lib\NUnit\lib\nunit.framework.dll - - - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.Silverlight.Testing.dll - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight.dll - - - - - Microsoft.VisualStudio.TestTools.cs - - - Properties\AssemblyInfo.cs - - - SerializableAttribute.cs - - - TestRpcForMimeTypes.cs - - - TestRpcGenerator.cs - - - - - - - - - - - - - - - - - {E067A59D-9D0A-4A1F-92B1-38E4457241D1} - ProtocolBuffersLite.Serialization - - - {6969BDCE-D925-43F3-94AC-A531E6DF2591} - ProtocolBuffersLite - True - - - - - - - - - - - - - Program - $(ProjectDir)..\..\lib\NUnit\tools\nunit-console.exe - /nologo /noshadow /labels /wait $(AssemblyName).dll - $(ProjectDir)$(OutputPath) - - \ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.NET20.csproj b/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.NET20.csproj deleted file mode 100644 index 59f9375f..00000000 --- a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.NET20.csproj +++ /dev/null @@ -1,121 +0,0 @@ - - - CLIENTPROFILE - NET20 - TEST - Debug - AnyCPU - 9.0.30729 - 2.0 - {EE01ED24-3750-4567-9A23-1DB676A15610} - Library - Properties - Google.ProtocolBuffers - Google.ProtocolBuffersLite.Test - v2.0 - 512 - true - ..\..\keys\Google.ProtocolBuffers.snk - 3.5 - - - true - full - false - bin\NET20\Debug - obj\NET20\Debug\ - DEBUG;TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOEXTENSIONS - prompt - 4 - true - true - Off - - - pdbonly - true - bin\NET20\Release - obj\NET20\Release\ - TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOEXTENSIONS - prompt - 4 - true - true - Off - - - - - - - - - False - ..\..\lib\NUnit\lib\nunit.framework.dll - - - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.Silverlight.Testing.dll - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight.dll - - - - - Microsoft.VisualStudio.TestTools.cs - - - Properties\AssemblyInfo.cs - - - SerializableAttribute.cs - - - TestRpcForMimeTypes.cs - - - TestRpcGenerator.cs - - - - - - - - - - - - - - - - - {E067A59D-9D0A-4A1F-92B1-38E4457241D1} - ProtocolBuffersLite.Serialization - - - {6969BDCE-D925-43F3-94AC-A531E6DF2591} - ProtocolBuffersLite - True - - - - - - Program - $(ProjectDir)..\..\lib\NUnit\tools\nunit-console.exe - /nologo /noshadow /labels /wait $(AssemblyName).dll - $(ProjectDir)$(OutputPath) - - \ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.NET35.csproj b/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.NET35.csproj deleted file mode 100644 index e4ebfe1b..00000000 --- a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.NET35.csproj +++ /dev/null @@ -1,122 +0,0 @@ - - - CLIENTPROFILE - NET35 - TEST - Debug - AnyCPU - 9.0.30729 - 2.0 - {EE01ED24-3750-4567-9A23-1DB676A15610} - Library - Properties - Google.ProtocolBuffers - Google.ProtocolBuffersLite.Test - v3.5 - 512 - true - ..\..\keys\Google.ProtocolBuffers.snk - 3.5 - - - true - full - false - bin\NET35\Debug - obj\NET35\Debug\ - DEBUG;TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate) - prompt - 4 - true - true - Off - - - pdbonly - true - bin\NET35\Release - obj\NET35\Release\ - TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate) - prompt - 4 - true - true - Off - - - - - - - - - - False - ..\..\lib\NUnit\lib\nunit.framework.dll - - - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.Silverlight.Testing.dll - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight.dll - - - - - Microsoft.VisualStudio.TestTools.cs - - - Properties\AssemblyInfo.cs - - - SerializableAttribute.cs - - - TestRpcForMimeTypes.cs - - - TestRpcGenerator.cs - - - - - - - - - - - - - - - - - {E067A59D-9D0A-4A1F-92B1-38E4457241D1} - ProtocolBuffersLite.Serialization - - - {6969BDCE-D925-43F3-94AC-A531E6DF2591} - ProtocolBuffersLite - True - - - - - - Program - $(ProjectDir)..\..\lib\NUnit\tools\nunit-console.exe - /nologo /noshadow /labels /wait $(AssemblyName).dll - $(ProjectDir)$(OutputPath) - - \ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.NET40.csproj b/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.NET40.csproj deleted file mode 100644 index d02ac774..00000000 --- a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.NET40.csproj +++ /dev/null @@ -1,122 +0,0 @@ - - - CLIENTPROFILE - NET40 - TEST - Debug - AnyCPU - 9.0.30729 - 2.0 - {EE01ED24-3750-4567-9A23-1DB676A15610} - Library - Properties - Google.ProtocolBuffers - Google.ProtocolBuffersLite.Test - v4.0 - 512 - true - ..\..\keys\Google.ProtocolBuffers.snk - 3.5 - - - true - full - false - bin\NET40\Debug - obj\NET40\Debug\ - DEBUG;TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate) - prompt - 4 - true - true - Off - - - pdbonly - true - bin\NET40\Release - obj\NET40\Release\ - TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate) - prompt - 4 - true - true - Off - - - - - - - - - - False - ..\..\lib\NUnit\lib\nunit.framework.dll - - - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.Silverlight.Testing.dll - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight.dll - - - - - Microsoft.VisualStudio.TestTools.cs - - - Properties\AssemblyInfo.cs - - - SerializableAttribute.cs - - - TestRpcForMimeTypes.cs - - - TestRpcGenerator.cs - - - - - - - - - - - - - - - - - {E067A59D-9D0A-4A1F-92B1-38E4457241D1} - ProtocolBuffersLite.Serialization - - - {6969BDCE-D925-43F3-94AC-A531E6DF2591} - ProtocolBuffersLite - True - - - - - - Program - $(ProjectDir)..\..\lib\NUnit\tools\nunit-console.exe - /nologo /noshadow /labels /wait $(AssemblyName).dll - $(ProjectDir)$(OutputPath) - - \ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.PL40.csproj b/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.PL40.csproj deleted file mode 100644 index b645a01e..00000000 --- a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.PL40.csproj +++ /dev/null @@ -1,156 +0,0 @@ - - - PORTABLE_LIBRARY - PL40 - TEST - Debug - AnyCPU - 9.0.30729 - 2.0 - {EE01ED24-3750-4567-9A23-1DB676A15610} - Library - Properties - Google.ProtocolBuffers - Google.ProtocolBuffersLite.Test - v4.0 - 512 - true - ..\..\keys\Google.ProtocolBuffers.snk - 3.5 - 10.0 - {A1591282-1198-4647-A2B1-27E5FF5F6F3B};{fae04ec0-301f-11d3-bf4b-00c04f79efbc} - - false - false - true - true - true - Google.ProtocolBuffersLite.Test.xap - Properties\AppManifest.xml - Google.ProtocolBuffers.App - TestPage.html - true - v4.0 - Properties\OutOfBrowserSettings.xml - true - - - true - full - false - bin\PL40\Debug - obj\PL40\Debug\ - DEBUG;TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOSERIALIZABLE;NOSORTEDLIST - prompt - 4 - true - true - Off - - - pdbonly - true - bin\PL40\Release - obj\PL40\Release\ - TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOSERIALIZABLE;NOSORTEDLIST - prompt - 4 - true - true - Off - - - - - - - - - - - - False - ..\..\lib\NUnit\lib\nunit.framework.dll - - - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.Silverlight.Testing.dll - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight.dll - - - - - Microsoft.VisualStudio.TestTools.cs - - - Properties\AssemblyInfo.cs - - - SerializableAttribute.cs - - - TestRpcForMimeTypes.cs - - - TestRpcGenerator.cs - - - - - - - - - - - - - - - App.xaml - - - - - MSBuild:Compile - Designer - - - - - {E067A59D-9D0A-4A1F-92B1-38E4457241D1} - ProtocolBuffersLite.Serialization - - - {6969BDCE-D925-43F3-94AC-A531E6DF2591} - ProtocolBuffersLite - True - - - - - - - - - - - - - Program - $(ProjectDir)..\..\lib\NUnit\tools\nunit-console.exe - /nologo /noshadow /labels /wait $(AssemblyName).dll - $(ProjectDir)$(OutputPath) - - \ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.SL20.csproj b/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.SL20.csproj deleted file mode 100644 index b4ad946f..00000000 --- a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.SL20.csproj +++ /dev/null @@ -1,157 +0,0 @@ - - - SILVERLIGHT - SL20 - TEST - Debug - AnyCPU - 9.0.30729 - 2.0 - {EE01ED24-3750-4567-9A23-1DB676A15610} - Library - Properties - Google.ProtocolBuffers - Google.ProtocolBuffersLite.Test - v2.0 - 512 - true - ..\..\keys\Google.ProtocolBuffers.snk - 3.5 - {A1591282-1198-4647-A2B1-27E5FF5F6F3B};{fae04ec0-301f-11d3-bf4b-00c04f79efbc} - true - false - false - true - true - Google.ProtocolBuffersLite.Test.xap - Properties\AppManifest.xml - Google.ProtocolBuffers.App - TestPage.html - true - v2.0 - Properties\OutOfBrowserSettings.xml - true - - - true - full - false - bin\SL20\Debug - obj\SL20\Debug\ - DEBUG;TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOSERIALIZABLE;NOSORTEDLIST;NOEXTENSIONS - prompt - 4 - true - true - Off - true - - - pdbonly - true - bin\SL20\Release - obj\SL20\Release\ - TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOSERIALIZABLE;NOSORTEDLIST;NOEXTENSIONS - prompt - 4 - true - true - Off - true - - - - - - - - - - - False - ..\..\lib\NUnit\lib\nunit.framework.dll - - - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.Silverlight.Testing.dll - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight.dll - - - - - Microsoft.VisualStudio.TestTools.cs - - - Properties\AssemblyInfo.cs - - - SerializableAttribute.cs - - - TestRpcForMimeTypes.cs - - - TestRpcGenerator.cs - - - - - - - - - - - - - - - App.xaml - - - - - MSBuild:Compile - Designer - - - - - {E067A59D-9D0A-4A1F-92B1-38E4457241D1} - ProtocolBuffersLite.Serialization - - - {6969BDCE-D925-43F3-94AC-A531E6DF2591} - ProtocolBuffersLite - True - - - - - - - - OfflineApplication - - - - - - - Program - $(ProjectDir)..\..\lib\NUnit\tools\nunit-console.exe - /nologo /noshadow /labels /wait $(AssemblyName).dll - $(ProjectDir)$(OutputPath) - - \ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.SL30.csproj b/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.SL30.csproj deleted file mode 100644 index b5870ede..00000000 --- a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.SL30.csproj +++ /dev/null @@ -1,158 +0,0 @@ - - - SILVERLIGHT - SL30 - TEST - Debug - AnyCPU - 9.0.30729 - 2.0 - {EE01ED24-3750-4567-9A23-1DB676A15610} - Library - Properties - Google.ProtocolBuffers - Google.ProtocolBuffersLite.Test - v3.5 - 512 - true - ..\..\keys\Google.ProtocolBuffers.snk - 3.5 - {A1591282-1198-4647-A2B1-27E5FF5F6F3B};{fae04ec0-301f-11d3-bf4b-00c04f79efbc} - true - false - false - true - true - Google.ProtocolBuffersLite.Test.xap - Properties\AppManifest.xml - Google.ProtocolBuffers.App - TestPage.html - true - v3.5 - Properties\OutOfBrowserSettings.xml - true - - - true - full - false - bin\SL30\Debug - obj\SL30\Debug\ - DEBUG;TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOSERIALIZABLE;NOSORTEDLIST - prompt - 4 - true - true - Off - true - - - pdbonly - true - bin\SL30\Release - obj\SL30\Release\ - TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOSERIALIZABLE;NOSORTEDLIST - prompt - 4 - true - true - Off - true - - - - - - - - - - - - False - ..\..\lib\NUnit\lib\nunit.framework.dll - - - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.Silverlight.Testing.dll - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight.dll - - - - - Microsoft.VisualStudio.TestTools.cs - - - Properties\AssemblyInfo.cs - - - SerializableAttribute.cs - - - TestRpcForMimeTypes.cs - - - TestRpcGenerator.cs - - - - - - - - - - - - - - - App.xaml - - - - - MSBuild:Compile - Designer - - - - - {E067A59D-9D0A-4A1F-92B1-38E4457241D1} - ProtocolBuffersLite.Serialization - - - {6969BDCE-D925-43F3-94AC-A531E6DF2591} - ProtocolBuffersLite - True - - - - - - - - OfflineApplication - - - - - - - Program - $(ProjectDir)..\..\lib\NUnit\tools\nunit-console.exe - /nologo /noshadow /labels /wait $(AssemblyName).dll - $(ProjectDir)$(OutputPath) - - \ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.SL40.csproj b/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.SL40.csproj deleted file mode 100644 index ef1543ec..00000000 --- a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.SL40.csproj +++ /dev/null @@ -1,158 +0,0 @@ - - - SILVERLIGHT - SL40 - TEST - Debug - AnyCPU - 9.0.30729 - 2.0 - {EE01ED24-3750-4567-9A23-1DB676A15610} - Library - Properties - Google.ProtocolBuffers - Google.ProtocolBuffersLite.Test - v4.0 - 512 - true - ..\..\keys\Google.ProtocolBuffers.snk - 3.5 - {A1591282-1198-4647-A2B1-27E5FF5F6F3B};{fae04ec0-301f-11d3-bf4b-00c04f79efbc} - true - false - false - v4.0 - true - true - Google.ProtocolBuffersLite.Test.xap - Properties\AppManifest.xml - Google.ProtocolBuffers.App - TestPage.html - true - Properties\OutOfBrowserSettings.xml - true - - - true - full - false - bin\SL40\Debug - obj\SL40\Debug\ - DEBUG;TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOSERIALIZABLE;NOSORTEDLIST - prompt - 4 - true - true - Off - true - - - pdbonly - true - bin\SL40\Release - obj\SL40\Release\ - TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOSERIALIZABLE;NOSORTEDLIST - prompt - 4 - true - true - Off - true - - - - - - - - - - - - False - ..\..\lib\NUnit\lib\nunit.framework.dll - - - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.Silverlight.Testing.dll - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight.dll - - - - - Microsoft.VisualStudio.TestTools.cs - - - Properties\AssemblyInfo.cs - - - SerializableAttribute.cs - - - TestRpcForMimeTypes.cs - - - TestRpcGenerator.cs - - - - - - - - - - - - - - - App.xaml - - - - - MSBuild:Compile - Designer - - - - - {E067A59D-9D0A-4A1F-92B1-38E4457241D1} - ProtocolBuffersLite.Serialization - - - {6969BDCE-D925-43F3-94AC-A531E6DF2591} - ProtocolBuffersLite - True - - - - - - - - OfflineApplication - - - - - - - Program - $(ProjectDir)..\..\lib\NUnit\tools\nunit-console.exe - /nologo /noshadow /labels /wait $(AssemblyName).dll - $(ProjectDir)$(OutputPath) - - \ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.csproj b/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.csproj index 7701543c..12315442 100644 --- a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.csproj +++ b/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.csproj @@ -13,18 +13,19 @@ Properties Google.ProtocolBuffers Google.ProtocolBuffersLite.Test - v3.5 + v4.0 512 true ..\..\keys\Google.ProtocolBuffers.snk 3.5 + Client true full false - bin\NET35\Debug - obj\NET35\Debug\ + bin\Debug + obj\Debug\ DEBUG;TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate) prompt 4 @@ -35,8 +36,8 @@ pdbonly true - bin\NET35\Release - obj\NET35\Release\ + bin\Release + obj\Release\ TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate) prompt 4 diff --git a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.CF20.csproj b/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.CF20.csproj deleted file mode 100644 index 0ed3b36d..00000000 --- a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.CF20.csproj +++ /dev/null @@ -1,126 +0,0 @@ - - - COMPACT_FRAMEWORK - CF20 - TEST - Debug - AnyCPU - 9.0.30729 - 2.0 - {EEFFED24-3750-4567-9A23-1DB676A15610} - Library - Properties - Google.ProtocolBuffers - Google.ProtocolBuffersMixedLite.Test - v2.0 - 512 - true - ..\..\keys\Google.ProtocolBuffers.snk - 3.5 - {4D628B5B-2FBC-4AA6-8C16-197242AEB884};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} - Smartphone - f27da329-3269-4191-98e0-c87d3d7f1db9 - - - true - full - false - bin\CF20\Debug - obj\CF20\Debug\ - DEBUG;TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOSERIALIZABLE;NOFILEVERSION;NOEXTENSIONS - prompt - 4 - true - true - Off - true - - - pdbonly - true - bin\CF20\Release - obj\CF20\Release\ - TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOSERIALIZABLE;NOFILEVERSION;NOEXTENSIONS - prompt - 4 - true - true - Off - true - - - - - - - - - False - ..\..\lib\NUnit\lib\nunit.framework.dll - - - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.Silverlight.Testing.dll - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight.dll - - - - - Microsoft.VisualStudio.TestTools.cs - - - Properties\AssemblyInfo.cs - - - SerializableAttribute.cs - - - - - - - - - - - - - - - - - - - - - {6908BDCE-D925-43F3-94AC-A531E6DF2591} - ProtocolBuffers - - - - - - - - - - - - - Program - $(ProjectDir)..\..\lib\NUnit\tools\nunit-console.exe - /nologo /noshadow /labels /wait $(AssemblyName).dll - $(ProjectDir)$(OutputPath) - - \ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.CF35.csproj b/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.CF35.csproj deleted file mode 100644 index 50d4e643..00000000 --- a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.CF35.csproj +++ /dev/null @@ -1,127 +0,0 @@ - - - COMPACT_FRAMEWORK - CF35 - TEST - Debug - AnyCPU - 9.0.30729 - 2.0 - {EEFFED24-3750-4567-9A23-1DB676A15610} - Library - Properties - Google.ProtocolBuffers - Google.ProtocolBuffersMixedLite.Test - v3.5 - 512 - true - ..\..\keys\Google.ProtocolBuffers.snk - 3.5 - {4D628B5B-2FBC-4AA6-8C16-197242AEB884};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} - Smartphone - f27da329-3269-4191-98e0-c87d3d7f1db9 - - - true - full - false - bin\CF35\Debug - obj\CF35\Debug\ - DEBUG;TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOSERIALIZABLE;NOFILEVERSION - prompt - 4 - true - true - Off - true - - - pdbonly - true - bin\CF35\Release - obj\CF35\Release\ - TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOSERIALIZABLE;NOFILEVERSION - prompt - 4 - true - true - Off - true - - - - - - - - - - False - ..\..\lib\NUnit\lib\nunit.framework.dll - - - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.Silverlight.Testing.dll - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight.dll - - - - - Microsoft.VisualStudio.TestTools.cs - - - Properties\AssemblyInfo.cs - - - SerializableAttribute.cs - - - - - - - - - - - - - - - - - - - - - {6908BDCE-D925-43F3-94AC-A531E6DF2591} - ProtocolBuffers - - - - - - - - - - - - - Program - $(ProjectDir)..\..\lib\NUnit\tools\nunit-console.exe - /nologo /noshadow /labels /wait $(AssemblyName).dll - $(ProjectDir)$(OutputPath) - - \ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.NET20.csproj b/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.NET20.csproj deleted file mode 100644 index 80593a4d..00000000 --- a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.NET20.csproj +++ /dev/null @@ -1,114 +0,0 @@ - - - CLIENTPROFILE - NET20 - TEST - Debug - AnyCPU - 9.0.30729 - 2.0 - {EEFFED24-3750-4567-9A23-1DB676A15610} - Library - Properties - Google.ProtocolBuffers - Google.ProtocolBuffersMixedLite.Test - v2.0 - 512 - true - ..\..\keys\Google.ProtocolBuffers.snk - 3.5 - - - true - full - false - bin\NET20\Debug - obj\NET20\Debug\ - DEBUG;TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOEXTENSIONS - prompt - 4 - true - true - Off - - - pdbonly - true - bin\NET20\Release - obj\NET20\Release\ - TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOEXTENSIONS - prompt - 4 - true - true - Off - - - - - - - - - False - ..\..\lib\NUnit\lib\nunit.framework.dll - - - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.Silverlight.Testing.dll - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight.dll - - - - - Microsoft.VisualStudio.TestTools.cs - - - Properties\AssemblyInfo.cs - - - SerializableAttribute.cs - - - - - - - - - - - - - - - - - - - - - {6908BDCE-D925-43F3-94AC-A531E6DF2591} - ProtocolBuffers - - - - - - Program - $(ProjectDir)..\..\lib\NUnit\tools\nunit-console.exe - /nologo /noshadow /labels /wait $(AssemblyName).dll - $(ProjectDir)$(OutputPath) - - \ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.NET35.csproj b/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.NET35.csproj deleted file mode 100644 index e8b6d095..00000000 --- a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.NET35.csproj +++ /dev/null @@ -1,115 +0,0 @@ - - - CLIENTPROFILE - NET35 - TEST - Debug - AnyCPU - 9.0.30729 - 2.0 - {EEFFED24-3750-4567-9A23-1DB676A15610} - Library - Properties - Google.ProtocolBuffers - Google.ProtocolBuffersMixedLite.Test - v3.5 - 512 - true - ..\..\keys\Google.ProtocolBuffers.snk - 3.5 - - - true - full - false - bin\NET35\Debug - obj\NET35\Debug\ - DEBUG;TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate) - prompt - 4 - true - true - Off - - - pdbonly - true - bin\NET35\Release - obj\NET35\Release\ - TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate) - prompt - 4 - true - true - Off - - - - - - - - - - False - ..\..\lib\NUnit\lib\nunit.framework.dll - - - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.Silverlight.Testing.dll - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight.dll - - - - - Microsoft.VisualStudio.TestTools.cs - - - Properties\AssemblyInfo.cs - - - SerializableAttribute.cs - - - - - - - - - - - - - - - - - - - - - {6908BDCE-D925-43F3-94AC-A531E6DF2591} - ProtocolBuffers - - - - - - Program - $(ProjectDir)..\..\lib\NUnit\tools\nunit-console.exe - /nologo /noshadow /labels /wait $(AssemblyName).dll - $(ProjectDir)$(OutputPath) - - \ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.NET40.csproj b/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.NET40.csproj deleted file mode 100644 index 16ffefd6..00000000 --- a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.NET40.csproj +++ /dev/null @@ -1,115 +0,0 @@ - - - CLIENTPROFILE - NET40 - TEST - Debug - AnyCPU - 9.0.30729 - 2.0 - {EEFFED24-3750-4567-9A23-1DB676A15610} - Library - Properties - Google.ProtocolBuffers - Google.ProtocolBuffersMixedLite.Test - v4.0 - 512 - true - ..\..\keys\Google.ProtocolBuffers.snk - 3.5 - - - true - full - false - bin\NET40\Debug - obj\NET40\Debug\ - DEBUG;TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate) - prompt - 4 - true - true - Off - - - pdbonly - true - bin\NET40\Release - obj\NET40\Release\ - TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate) - prompt - 4 - true - true - Off - - - - - - - - - - False - ..\..\lib\NUnit\lib\nunit.framework.dll - - - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.Silverlight.Testing.dll - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight.dll - - - - - Microsoft.VisualStudio.TestTools.cs - - - Properties\AssemblyInfo.cs - - - SerializableAttribute.cs - - - - - - - - - - - - - - - - - - - - - {6908BDCE-D925-43F3-94AC-A531E6DF2591} - ProtocolBuffers - - - - - - Program - $(ProjectDir)..\..\lib\NUnit\tools\nunit-console.exe - /nologo /noshadow /labels /wait $(AssemblyName).dll - $(ProjectDir)$(OutputPath) - - \ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.PL40.csproj b/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.PL40.csproj deleted file mode 100644 index 3d1a77b5..00000000 --- a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.PL40.csproj +++ /dev/null @@ -1,149 +0,0 @@ - - - PORTABLE_LIBRARY - PL40 - TEST - Debug - AnyCPU - 9.0.30729 - 2.0 - {EEFFED24-3750-4567-9A23-1DB676A15610} - Library - Properties - Google.ProtocolBuffers - Google.ProtocolBuffersMixedLite.Test - v4.0 - 512 - true - ..\..\keys\Google.ProtocolBuffers.snk - 3.5 - 10.0 - {A1591282-1198-4647-A2B1-27E5FF5F6F3B};{fae04ec0-301f-11d3-bf4b-00c04f79efbc} - - false - false - true - true - true - Google.ProtocolBuffersMixedLite.Test.xap - Properties\AppManifest.xml - Google.ProtocolBuffers.App - TestPage.html - true - v4.0 - Properties\OutOfBrowserSettings.xml - true - - - true - full - false - bin\PL40\Debug - obj\PL40\Debug\ - DEBUG;TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOSERIALIZABLE;NOSORTEDLIST - prompt - 4 - true - true - Off - - - pdbonly - true - bin\PL40\Release - obj\PL40\Release\ - TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOSERIALIZABLE;NOSORTEDLIST - prompt - 4 - true - true - Off - - - - - - - - - - - - False - ..\..\lib\NUnit\lib\nunit.framework.dll - - - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.Silverlight.Testing.dll - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight.dll - - - - - Microsoft.VisualStudio.TestTools.cs - - - Properties\AssemblyInfo.cs - - - SerializableAttribute.cs - - - - - - - - - - - - - - - - - - - App.xaml - - - - - MSBuild:Compile - Designer - - - - - {6908BDCE-D925-43F3-94AC-A531E6DF2591} - ProtocolBuffers - - - - - - - - - - - - - Program - $(ProjectDir)..\..\lib\NUnit\tools\nunit-console.exe - /nologo /noshadow /labels /wait $(AssemblyName).dll - $(ProjectDir)$(OutputPath) - - \ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.SL20.csproj b/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.SL20.csproj deleted file mode 100644 index 22b2c272..00000000 --- a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.SL20.csproj +++ /dev/null @@ -1,150 +0,0 @@ - - - SILVERLIGHT - SL20 - TEST - Debug - AnyCPU - 9.0.30729 - 2.0 - {EEFFED24-3750-4567-9A23-1DB676A15610} - Library - Properties - Google.ProtocolBuffers - Google.ProtocolBuffersMixedLite.Test - v2.0 - 512 - true - ..\..\keys\Google.ProtocolBuffers.snk - 3.5 - {A1591282-1198-4647-A2B1-27E5FF5F6F3B};{fae04ec0-301f-11d3-bf4b-00c04f79efbc} - true - false - false - true - true - Google.ProtocolBuffersMixedLite.Test.xap - Properties\AppManifest.xml - Google.ProtocolBuffers.App - TestPage.html - true - v2.0 - Properties\OutOfBrowserSettings.xml - true - - - true - full - false - bin\SL20\Debug - obj\SL20\Debug\ - DEBUG;TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOSERIALIZABLE;NOSORTEDLIST;NOEXTENSIONS - prompt - 4 - true - true - Off - true - - - pdbonly - true - bin\SL20\Release - obj\SL20\Release\ - TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOSERIALIZABLE;NOSORTEDLIST;NOEXTENSIONS - prompt - 4 - true - true - Off - true - - - - - - - - - - - False - ..\..\lib\NUnit\lib\nunit.framework.dll - - - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.Silverlight.Testing.dll - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight.dll - - - - - Microsoft.VisualStudio.TestTools.cs - - - Properties\AssemblyInfo.cs - - - SerializableAttribute.cs - - - - - - - - - - - - - - - - - - - App.xaml - - - - - MSBuild:Compile - Designer - - - - - {6908BDCE-D925-43F3-94AC-A531E6DF2591} - ProtocolBuffers - - - - - - - - OfflineApplication - - - - - - - Program - $(ProjectDir)..\..\lib\NUnit\tools\nunit-console.exe - /nologo /noshadow /labels /wait $(AssemblyName).dll - $(ProjectDir)$(OutputPath) - - \ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.SL30.csproj b/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.SL30.csproj deleted file mode 100644 index 3627b765..00000000 --- a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.SL30.csproj +++ /dev/null @@ -1,151 +0,0 @@ - - - SILVERLIGHT - SL30 - TEST - Debug - AnyCPU - 9.0.30729 - 2.0 - {EEFFED24-3750-4567-9A23-1DB676A15610} - Library - Properties - Google.ProtocolBuffers - Google.ProtocolBuffersMixedLite.Test - v3.5 - 512 - true - ..\..\keys\Google.ProtocolBuffers.snk - 3.5 - {A1591282-1198-4647-A2B1-27E5FF5F6F3B};{fae04ec0-301f-11d3-bf4b-00c04f79efbc} - true - false - false - true - true - Google.ProtocolBuffersMixedLite.Test.xap - Properties\AppManifest.xml - Google.ProtocolBuffers.App - TestPage.html - true - v3.5 - Properties\OutOfBrowserSettings.xml - true - - - true - full - false - bin\SL30\Debug - obj\SL30\Debug\ - DEBUG;TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOSERIALIZABLE;NOSORTEDLIST - prompt - 4 - true - true - Off - true - - - pdbonly - true - bin\SL30\Release - obj\SL30\Release\ - TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOSERIALIZABLE;NOSORTEDLIST - prompt - 4 - true - true - Off - true - - - - - - - - - - - - False - ..\..\lib\NUnit\lib\nunit.framework.dll - - - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.Silverlight.Testing.dll - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight.dll - - - - - Microsoft.VisualStudio.TestTools.cs - - - Properties\AssemblyInfo.cs - - - SerializableAttribute.cs - - - - - - - - - - - - - - - - - - - App.xaml - - - - - MSBuild:Compile - Designer - - - - - {6908BDCE-D925-43F3-94AC-A531E6DF2591} - ProtocolBuffers - - - - - - - - OfflineApplication - - - - - - - Program - $(ProjectDir)..\..\lib\NUnit\tools\nunit-console.exe - /nologo /noshadow /labels /wait $(AssemblyName).dll - $(ProjectDir)$(OutputPath) - - \ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.SL40.csproj b/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.SL40.csproj deleted file mode 100644 index a98c4d38..00000000 --- a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.SL40.csproj +++ /dev/null @@ -1,151 +0,0 @@ - - - SILVERLIGHT - SL40 - TEST - Debug - AnyCPU - 9.0.30729 - 2.0 - {EEFFED24-3750-4567-9A23-1DB676A15610} - Library - Properties - Google.ProtocolBuffers - Google.ProtocolBuffersMixedLite.Test - v4.0 - 512 - true - ..\..\keys\Google.ProtocolBuffers.snk - 3.5 - {A1591282-1198-4647-A2B1-27E5FF5F6F3B};{fae04ec0-301f-11d3-bf4b-00c04f79efbc} - true - false - false - v4.0 - true - true - Google.ProtocolBuffersMixedLite.Test.xap - Properties\AppManifest.xml - Google.ProtocolBuffers.App - TestPage.html - true - Properties\OutOfBrowserSettings.xml - true - - - true - full - false - bin\SL40\Debug - obj\SL40\Debug\ - DEBUG;TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOSERIALIZABLE;NOSORTEDLIST - prompt - 4 - true - true - Off - true - - - pdbonly - true - bin\SL40\Release - obj\SL40\Release\ - TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate);NOSERIALIZABLE;NOSORTEDLIST - prompt - 4 - true - true - Off - true - - - - - - - - - - - - False - ..\..\lib\NUnit\lib\nunit.framework.dll - - - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.Silverlight.Testing.dll - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight.dll - - - - - Microsoft.VisualStudio.TestTools.cs - - - Properties\AssemblyInfo.cs - - - SerializableAttribute.cs - - - - - - - - - - - - - - - - - - - App.xaml - - - - - MSBuild:Compile - Designer - - - - - {6908BDCE-D925-43F3-94AC-A531E6DF2591} - ProtocolBuffers - - - - - - - - OfflineApplication - - - - - - - Program - $(ProjectDir)..\..\lib\NUnit\tools\nunit-console.exe - /nologo /noshadow /labels /wait $(AssemblyName).dll - $(ProjectDir)$(OutputPath) - - \ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.csproj b/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.csproj index 44b9a290..f7772f39 100644 --- a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.csproj +++ b/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.csproj @@ -13,18 +13,19 @@ Properties Google.ProtocolBuffers Google.ProtocolBuffersMixedLite.Test - v3.5 + v4.0 512 true ..\..\keys\Google.ProtocolBuffers.snk 3.5 + Client true full false - bin\NET35\Debug - obj\NET35\Debug\ + bin\Debug + obj\Debug\ DEBUG;TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate) prompt 4 @@ -35,8 +36,8 @@ pdbonly true - bin\NET35\Release - obj\NET35\Release\ + bin\Release + obj\Release\ TRACE;$(EnvironmentFlavor);$(EnvironmentTemplate) prompt 4 -- cgit v1.2.3 From c56475088d2d36d29a2640f35b9a8621796c051c Mon Sep 17 00:00:00 2001 From: Jon Skeet Date: Thu, 30 Apr 2015 11:05:36 +0100 Subject: Change to using xUnit for all unit tests, and fetch that via NuGet. This includes fetching the VS unit test runner package, so that tests can be run from Visual Studio's Test Explorer. --- .gitignore | 3 + .../Microsoft.VisualStudio.TestTools.cs | 54 - csharp/lib/NUnit-config/nunit-console.v2.0.config | 18 - csharp/lib/NUnit-config/nunit-console.v3.5.config | 18 - csharp/lib/NUnit-config/nunit-console.v4.0.config | 18 - .../ProtocolBuffers.Test/AbstractMessageTest.cs | 81 +- csharp/src/ProtocolBuffers.Test/ByteStringTest.cs | 77 +- .../ProtocolBuffers.Test/CodedInputStreamTest.cs | 272 +-- .../ProtocolBuffers.Test/CodedOutputStreamTest.cs | 223 ++- .../Collections/PopsicleListTest.cs | 84 +- .../Compatibility/BinaryCompatibilityTests.cs | 2 - .../Compatibility/CompatibilityTests.cs | 58 +- .../Compatibility/DictionaryCompatibilityTests.cs | 7 +- .../Compatibility/JsonCompatibilityTests.cs | 4 - .../Compatibility/TestResources.cs | 16 +- .../Compatibility/TextCompatibilityTests.cs | 8 +- .../Compatibility/XmlCompatibilityTests.cs | 4 - .../ProtocolBuffers.Test/DeprecatedMemberTest.cs | 21 +- csharp/src/ProtocolBuffers.Test/DescriptorsTest.cs | 264 ++- .../src/ProtocolBuffers.Test/DynamicMessageTest.cs | 62 +- .../ProtocolBuffers.Test/ExtendableMessageTest.cs | 136 +- .../ProtocolBuffers.Test/GeneratedBuilderTest.cs | 85 +- .../ProtocolBuffers.Test/GeneratedMessageTest.cs | 234 ++- csharp/src/ProtocolBuffers.Test/IssuesTest.cs | 13 +- .../MessageStreamIteratorTest.cs | 17 +- .../MessageStreamWriterTest.cs | 5 +- csharp/src/ProtocolBuffers.Test/MessageTest.cs | 219 +-- csharp/src/ProtocolBuffers.Test/MessageUtilTest.cs | 31 +- csharp/src/ProtocolBuffers.Test/NameHelpersTest.cs | 49 +- .../ProtocolBuffers.Test.csproj | 72 +- .../src/ProtocolBuffers.Test/ReflectionTester.cs | 958 +++++----- .../ProtocolBuffers.Test/ReusableBuilderTest.cs | 101 +- csharp/src/ProtocolBuffers.Test/TestCornerCases.cs | 16 +- .../ProtocolBuffers.Test/TestMimeMessageFormats.cs | 120 +- .../TestReaderForUrlEncoded.cs | 55 +- csharp/src/ProtocolBuffers.Test/TestUtil.cs | 1960 ++++++++++---------- .../ProtocolBuffers.Test/TestWriterFormatJson.cs | 146 +- .../ProtocolBuffers.Test/TestWriterFormatXml.cs | 129 +- csharp/src/ProtocolBuffers.Test/TextFormatTest.cs | 240 ++- .../ProtocolBuffers.Test/UnknownFieldSetTest.cs | 130 +- csharp/src/ProtocolBuffers.Test/WireFormatTest.cs | 75 +- csharp/src/ProtocolBuffers.Test/packages.config | 9 + .../AbstractBuilderLiteTest.cs | 128 +- .../AbstractMessageLiteTest.cs | 45 +- .../ExtendableBuilderLiteTest.cs | 127 +- .../ExtendableMessageLiteTest.cs | 217 ++- .../ProtocolBuffersLite.Test/InteropLiteTest.cs | 41 +- csharp/src/ProtocolBuffersLite.Test/LiteTest.cs | 31 +- .../MissingFieldAndExtensionTest.cs | 139 +- .../ProtocolBuffersLite.Test.csproj | 52 +- .../ProtocolBuffersLiteMixed.Test.csproj | 52 +- .../src/ProtocolBuffersLite.Test/TestLiteByApi.cs | 51 +- csharp/src/ProtocolBuffersLite.Test/TestUtil.cs | 31 - .../src/ProtocolBuffersLite.Test/packages.config | 9 + csharp/src/packages/repositories.config | 5 + 55 files changed, 3278 insertions(+), 3744 deletions(-) delete mode 100644 csharp/lib/NUnit-config/Microsoft.VisualStudio.TestTools.cs delete mode 100644 csharp/lib/NUnit-config/nunit-console.v2.0.config delete mode 100644 csharp/lib/NUnit-config/nunit-console.v3.5.config delete mode 100644 csharp/lib/NUnit-config/nunit-console.v4.0.config create mode 100644 csharp/src/ProtocolBuffers.Test/packages.config delete mode 100644 csharp/src/ProtocolBuffersLite.Test/TestUtil.cs create mode 100644 csharp/src/ProtocolBuffersLite.Test/packages.config create mode 100644 csharp/src/packages/repositories.config diff --git a/.gitignore b/.gitignore index 220e5c38..c21c20cf 100644 --- a/.gitignore +++ b/.gitignore @@ -79,3 +79,6 @@ javanano/target vsprojects/Debug vsprojects/Release +# NuGet packages: we want the repository configuration, but not the +# packages themselves. +/csharp/src/packages/*/ diff --git a/csharp/lib/NUnit-config/Microsoft.VisualStudio.TestTools.cs b/csharp/lib/NUnit-config/Microsoft.VisualStudio.TestTools.cs deleted file mode 100644 index fd151dae..00000000 --- a/csharp/lib/NUnit-config/Microsoft.VisualStudio.TestTools.cs +++ /dev/null @@ -1,54 +0,0 @@ - -using System; -#if CLIENTPROFILE -namespace Microsoft.VisualStudio.TestTools.UnitTesting -{ - [AttributeUsage(AttributeTargets.Class, Inherited = true, AllowMultiple = false)] - public sealed class TestClassAttribute : NUnit.Framework.TestFixtureAttribute - { - } - - [AttributeUsage(AttributeTargets.Method, Inherited = true, AllowMultiple = false)] - public sealed class TestMethodAttribute : NUnit.Framework.TestAttribute - { - } - - [AttributeUsage(AttributeTargets.Method, Inherited = true, AllowMultiple = false)] - public sealed class TestInitializeAttribute : NUnit.Framework.SetUpAttribute - { - } - - [AttributeUsage(AttributeTargets.Method, Inherited = true, AllowMultiple = false)] - public sealed class IgnoreAttribute : NUnit.Framework.IgnoreAttribute - { - } - - [AttributeUsage(AttributeTargets.Method, Inherited = true, AllowMultiple = false)] - public sealed class ExpectedExceptionAttribute : NUnit.Framework.ExpectedExceptionAttribute - { - public ExpectedExceptionAttribute(Type type) : base(type) - { } - } - - public class Assert : NUnit.Framework.Assert - { - [Obsolete("Do not use AreEqual on Byte[], use TestUtil.AssertBytesEqual(,)")] - public static void AreEqual(byte[] b1, byte[] b2) - { - NUnit.Framework.Assert.AreEqual(b1, b2); - } - - [Obsolete("No not use assert with miss-matched types.")] - public static new void AreEqual(object b1, object b2) - { - NUnit.Framework.Assert.AreEqual(b1, b2); - } - - //Allowed if the types match - public static void AreEqual(T b1, T b2) - { - NUnit.Framework.Assert.AreEqual(b1, b2); - } - } -} -#endif \ No newline at end of file diff --git a/csharp/lib/NUnit-config/nunit-console.v2.0.config b/csharp/lib/NUnit-config/nunit-console.v2.0.config deleted file mode 100644 index 30453c9b..00000000 --- a/csharp/lib/NUnit-config/nunit-console.v2.0.config +++ /dev/null @@ -1,18 +0,0 @@ - - - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/csharp/lib/NUnit-config/nunit-console.v3.5.config b/csharp/lib/NUnit-config/nunit-console.v3.5.config deleted file mode 100644 index 30453c9b..00000000 --- a/csharp/lib/NUnit-config/nunit-console.v3.5.config +++ /dev/null @@ -1,18 +0,0 @@ - - - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/csharp/lib/NUnit-config/nunit-console.v4.0.config b/csharp/lib/NUnit-config/nunit-console.v4.0.config deleted file mode 100644 index 08ee9547..00000000 --- a/csharp/lib/NUnit-config/nunit-console.v4.0.config +++ /dev/null @@ -1,18 +0,0 @@ - - - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/csharp/src/ProtocolBuffers.Test/AbstractMessageTest.cs b/csharp/src/ProtocolBuffers.Test/AbstractMessageTest.cs index 54f400c3..51606a37 100644 --- a/csharp/src/ProtocolBuffers.Test/AbstractMessageTest.cs +++ b/csharp/src/ProtocolBuffers.Test/AbstractMessageTest.cs @@ -38,15 +38,14 @@ using System; using System.Collections.Generic; using System.IO; using Google.ProtocolBuffers.Descriptors; -using Microsoft.VisualStudio.TestTools.UnitTesting; using Google.ProtocolBuffers.TestProtos; +using Xunit; namespace Google.ProtocolBuffers { - [TestClass] public class AbstractMessageTest { - [TestMethod] + [Fact] public void Clear() { AbstractMessageWrapper message = @@ -54,7 +53,7 @@ namespace Google.ProtocolBuffers TestUtil.AssertClear((TestAllTypes) message.WrappedMessage); } - [TestMethod] + [Fact] public void Copy() { AbstractMessageWrapper message = @@ -62,31 +61,31 @@ namespace Google.ProtocolBuffers TestUtil.AssertAllFieldsSet((TestAllTypes) message.WrappedMessage); } - [TestMethod] + [Fact] public void CreateAndBuild() { TestAllTypes.CreateBuilder() .Build(); } - [TestMethod] + [Fact] public void SerializedSize() { TestAllTypes message = TestUtil.GetAllSet(); IMessage abstractMessage = new AbstractMessageWrapper(TestUtil.GetAllSet()); - Assert.AreEqual(message.SerializedSize, abstractMessage.SerializedSize); + Assert.Equal(message.SerializedSize, abstractMessage.SerializedSize); } - [TestMethod] + [Fact] public void Serialization() { IMessage abstractMessage = new AbstractMessageWrapper(TestUtil.GetAllSet()); TestUtil.AssertAllFieldsSet(TestAllTypes.ParseFrom(abstractMessage.ToByteString())); - Assert.AreEqual(TestUtil.GetAllSet().ToByteString(), abstractMessage.ToByteString()); + Assert.Equal(TestUtil.GetAllSet().ToByteString(), abstractMessage.ToByteString()); } - [TestMethod] + [Fact] public void Parsing() { IBuilder builder = new AbstractMessageWrapper.Builder(TestAllTypes.CreateBuilder()); @@ -95,15 +94,15 @@ namespace Google.ProtocolBuffers TestUtil.AssertAllFieldsSet((TestAllTypes) message.WrappedMessage); } - [TestMethod] + [Fact] public void PackedSerialization() { IMessage abstractMessage = new AbstractMessageWrapper(TestUtil.GetPackedSet()); TestUtil.AssertPackedFieldsSet(TestPackedTypes.ParseFrom(abstractMessage.ToByteString())); - Assert.AreEqual(TestUtil.GetPackedSet().ToByteString(), abstractMessage.ToByteString()); + Assert.Equal(TestUtil.GetPackedSet().ToByteString(), abstractMessage.ToByteString()); } - [TestMethod] + [Fact] public void PackedParsing() { AbstractMessageWrapper.Builder builder = new AbstractMessageWrapper.Builder(TestPackedTypes.CreateBuilder()); @@ -111,7 +110,7 @@ namespace Google.ProtocolBuffers TestUtil.AssertPackedFieldsSet((TestPackedTypes)message.WrappedMessage); } - [TestMethod] + [Fact] public void UnpackedParsingOfPackedInput() { byte[] bytes = TestUtil.GetPackedSet().ToByteArray(); @@ -119,7 +118,7 @@ namespace Google.ProtocolBuffers TestUtil.AssertUnpackedFieldsSet(message); } - [TestMethod] + [Fact] public void PackedParsingOfUnpackedInput() { byte[] bytes = TestUnpackedTypes.ParseFrom(TestUtil.GetPackedSet().ToByteArray()).ToByteArray(); @@ -127,7 +126,7 @@ namespace Google.ProtocolBuffers TestUtil.AssertPackedFieldsSet(message); } - [TestMethod] + [Fact] public void UnpackedParsingOfPackedInputExtensions() { byte[] bytes = TestUtil.GetPackedSet().ToByteArray(); @@ -138,7 +137,7 @@ namespace Google.ProtocolBuffers TestUtil.AssertUnpackedExtensionsSet(message); } - [TestMethod] + [Fact] public void PackedParsingOfUnpackedInputExtensions() { byte[] bytes = TestUnpackedTypes.ParseFrom(TestUtil.GetPackedSet().ToByteArray()).ToByteArray(); @@ -148,13 +147,13 @@ namespace Google.ProtocolBuffers TestUtil.AssertPackedExtensionsSet(message); } - [TestMethod] + [Fact] public void OptimizedForSize() { // We're mostly only Checking that this class was compiled successfully. TestOptimizedForSize message = TestOptimizedForSize.CreateBuilder().SetI(1).Build(); message = TestOptimizedForSize.ParseFrom(message.ToByteString()); - Assert.AreEqual(2, message.SerializedSize); + Assert.Equal(2, message.SerializedSize); } // ----------------------------------------------------------------- @@ -165,40 +164,40 @@ namespace Google.ProtocolBuffers private static readonly TestRequired TestRequiredInitialized = TestRequired.CreateBuilder().SetA(1).SetB(2).SetC(3).Build(); - [TestMethod] + [Fact] public void IsInitialized() { TestRequired.Builder builder = TestRequired.CreateBuilder(); AbstractMessageWrapper.Builder abstractBuilder = new AbstractMessageWrapper.Builder(builder); - Assert.IsFalse(abstractBuilder.IsInitialized); + Assert.False(abstractBuilder.IsInitialized); builder.A = 1; - Assert.IsFalse(abstractBuilder.IsInitialized); + Assert.False(abstractBuilder.IsInitialized); builder.B = 1; - Assert.IsFalse(abstractBuilder.IsInitialized); + Assert.False(abstractBuilder.IsInitialized); builder.C = 1; - Assert.IsTrue(abstractBuilder.IsInitialized); + Assert.True(abstractBuilder.IsInitialized); } - [TestMethod] + [Fact] public void ForeignIsInitialized() { TestRequiredForeign.Builder builder = TestRequiredForeign.CreateBuilder(); AbstractMessageWrapper.Builder abstractBuilder = new AbstractMessageWrapper.Builder(builder); - Assert.IsTrue(abstractBuilder.IsInitialized); + Assert.True(abstractBuilder.IsInitialized); builder.SetOptionalMessage(TestRequiredUninitialized); - Assert.IsFalse(abstractBuilder.IsInitialized); + Assert.False(abstractBuilder.IsInitialized); builder.SetOptionalMessage(TestRequiredInitialized); - Assert.IsTrue(abstractBuilder.IsInitialized); + Assert.True(abstractBuilder.IsInitialized); builder.AddRepeatedMessage(TestRequiredUninitialized); - Assert.IsFalse(abstractBuilder.IsInitialized); + Assert.False(abstractBuilder.IsInitialized); builder.SetRepeatedMessage(0, TestRequiredInitialized); - Assert.IsTrue(abstractBuilder.IsInitialized); + Assert.True(abstractBuilder.IsInitialized); } // ----------------------------------------------------------------- @@ -227,7 +226,7 @@ namespace Google.ProtocolBuffers "repeated_string: \"qux\"\n" + "repeated_string: \"bar\"\n"; - [TestMethod] + [Fact] public void MergeFrom() { AbstractMessageWrapper result = (AbstractMessageWrapper) @@ -235,13 +234,13 @@ namespace Google.ProtocolBuffers .MergeFrom(MergeSource) .Build(); - Assert.AreEqual(MergeResultText, result.ToString()); + Assert.Equal(MergeResultText, result.ToString()); } // ----------------------------------------------------------------- // Tests for equals and hashCode - [TestMethod] + [Fact] public void EqualsAndHashCode() { TestAllTypes a = TestUtil.GetAllSet(); @@ -297,7 +296,7 @@ namespace Google.ProtocolBuffers private static void CheckEqualsIsConsistent(IMessage message) { // Object should be equal to itself. - Assert.AreEqual(message, message); + Assert.Equal(message, message); // Object should be equal to a dynamic copy of itself. DynamicMessage dynamic = DynamicMessage.CreateBuilder(message).Build(); @@ -309,9 +308,11 @@ namespace Google.ProtocolBuffers /// private static void CheckEqualsIsConsistent(IMessage message1, IMessage message2) { - Assert.AreEqual(message1, message2); - Assert.AreEqual(message2, message1); - Assert.AreEqual(message2.GetHashCode(), message1.GetHashCode()); + // Not using Assert.AreEqual as that checks for type equality, which isn't + // what we want bearing in mind the dynamic message checks. + Assert.True(message1.Equals(message2)); + Assert.True(message2.Equals(message1)); + Assert.Equal(message2.GetHashCode(), message1.GetHashCode()); } /// @@ -325,10 +326,10 @@ namespace Google.ProtocolBuffers private static void CheckNotEqual(IMessage m1, IMessage m2) { String equalsError = string.Format("{0} should not be equal to {1}", m1, m2); - Assert.IsFalse(m1.Equals(m2), equalsError); - Assert.IsFalse(m2.Equals(m1), equalsError); + Assert.False(m1.Equals(m2), equalsError); + Assert.False(m2.Equals(m1), equalsError); - Assert.IsFalse(m1.GetHashCode() == m2.GetHashCode(), + Assert.False(m1.GetHashCode() == m2.GetHashCode(), string.Format("{0} should have a different hash code from {1}", m1, m2)); } diff --git a/csharp/src/ProtocolBuffers.Test/ByteStringTest.cs b/csharp/src/ProtocolBuffers.Test/ByteStringTest.cs index 003307ae..92c4ef0b 100644 --- a/csharp/src/ProtocolBuffers.Test/ByteStringTest.cs +++ b/csharp/src/ProtocolBuffers.Test/ByteStringTest.cs @@ -36,113 +36,112 @@ using System; using System.Text; -using Microsoft.VisualStudio.TestTools.UnitTesting; +using Xunit; namespace Google.ProtocolBuffers { - [TestClass] public class ByteStringTest { - [TestMethod] + [Fact] public void EmptyByteStringHasZeroSize() { - Assert.AreEqual(0, ByteString.Empty.Length); + Assert.Equal(0, ByteString.Empty.Length); } - [TestMethod] + [Fact] public void CopyFromStringWithExplicitEncoding() { ByteString bs = ByteString.CopyFrom("AB", Encoding.Unicode); - Assert.AreEqual(4, bs.Length); - Assert.AreEqual(65, bs[0]); - Assert.AreEqual(0, bs[1]); - Assert.AreEqual(66, bs[2]); - Assert.AreEqual(0, bs[3]); + Assert.Equal(4, bs.Length); + Assert.Equal(65, bs[0]); + Assert.Equal(0, bs[1]); + Assert.Equal(66, bs[2]); + Assert.Equal(0, bs[3]); } - [TestMethod] + [Fact] public void IsEmptyWhenEmpty() { - Assert.IsTrue(ByteString.CopyFromUtf8("").IsEmpty); + Assert.True(ByteString.CopyFromUtf8("").IsEmpty); } - [TestMethod] + [Fact] public void IsEmptyWhenNotEmpty() { - Assert.IsFalse(ByteString.CopyFromUtf8("X").IsEmpty); + Assert.False(ByteString.CopyFromUtf8("X").IsEmpty); } - [TestMethod] + [Fact] public void CopyFromByteArrayCopiesContents() { byte[] data = new byte[1]; data[0] = 10; ByteString bs = ByteString.CopyFrom(data); - Assert.AreEqual(10, bs[0]); + Assert.Equal(10, bs[0]); data[0] = 5; - Assert.AreEqual(10, bs[0]); + Assert.Equal(10, bs[0]); } - [TestMethod] + [Fact] public void ToByteArrayCopiesContents() { ByteString bs = ByteString.CopyFromUtf8("Hello"); byte[] data = bs.ToByteArray(); - Assert.AreEqual((byte)'H', data[0]); - Assert.AreEqual((byte)'H', bs[0]); + Assert.Equal((byte)'H', data[0]); + Assert.Equal((byte)'H', bs[0]); data[0] = 0; - Assert.AreEqual(0, data[0]); - Assert.AreEqual((byte)'H', bs[0]); + Assert.Equal(0, data[0]); + Assert.Equal((byte)'H', bs[0]); } - [TestMethod] + [Fact] public void CopyFromUtf8UsesUtf8() { ByteString bs = ByteString.CopyFromUtf8("\u20ac"); - Assert.AreEqual(3, bs.Length); - Assert.AreEqual(0xe2, bs[0]); - Assert.AreEqual(0x82, bs[1]); - Assert.AreEqual(0xac, bs[2]); + Assert.Equal(3, bs.Length); + Assert.Equal(0xe2, bs[0]); + Assert.Equal(0x82, bs[1]); + Assert.Equal(0xac, bs[2]); } - [TestMethod] + [Fact] public void CopyFromPortion() { byte[] data = new byte[] {0, 1, 2, 3, 4, 5, 6}; ByteString bs = ByteString.CopyFrom(data, 2, 3); - Assert.AreEqual(3, bs.Length); - Assert.AreEqual(2, bs[0]); - Assert.AreEqual(3, bs[1]); + Assert.Equal(3, bs.Length); + Assert.Equal(2, bs[0]); + Assert.Equal(3, bs[1]); } - [TestMethod] + [Fact] public void ToStringUtf8() { ByteString bs = ByteString.CopyFromUtf8("\u20ac"); - Assert.AreEqual("\u20ac", bs.ToStringUtf8()); + Assert.Equal("\u20ac", bs.ToStringUtf8()); } - [TestMethod] + [Fact] public void ToStringWithExplicitEncoding() { ByteString bs = ByteString.CopyFrom("\u20ac", Encoding.Unicode); - Assert.AreEqual("\u20ac", bs.ToString(Encoding.Unicode)); + Assert.Equal("\u20ac", bs.ToString(Encoding.Unicode)); } - [TestMethod] + [Fact] public void FromBase64_WithText() { byte[] data = new byte[] {0, 1, 2, 3, 4, 5, 6}; string base64 = Convert.ToBase64String(data); ByteString bs = ByteString.FromBase64(base64); - TestUtil.AssertBytesEqual(data, bs.ToByteArray()); + Assert.Equal(data, bs.ToByteArray()); } - [TestMethod] + [Fact] public void FromBase64_Empty() { // Optimization which also fixes issue 61. - Assert.AreSame(ByteString.Empty, ByteString.FromBase64("")); + Assert.Same(ByteString.Empty, ByteString.FromBase64("")); } } } \ No newline at end of file diff --git a/csharp/src/ProtocolBuffers.Test/CodedInputStreamTest.cs b/csharp/src/ProtocolBuffers.Test/CodedInputStreamTest.cs index b09d3340..20bfef9e 100644 --- a/csharp/src/ProtocolBuffers.Test/CodedInputStreamTest.cs +++ b/csharp/src/ProtocolBuffers.Test/CodedInputStreamTest.cs @@ -39,12 +39,10 @@ using System.Collections.Generic; using System.IO; using Google.ProtocolBuffers.Descriptors; using Google.ProtocolBuffers.TestProtos; -using Microsoft.VisualStudio.TestTools.UnitTesting; -using System.Diagnostics; +using Xunit; namespace Google.ProtocolBuffers { - [TestClass] public class CodedInputStreamTest { /// @@ -68,21 +66,21 @@ namespace Google.ProtocolBuffers private static void AssertReadVarint(byte[] data, ulong value) { CodedInputStream input = CodedInputStream.CreateInstance(data); - Assert.AreEqual((uint) value, input.ReadRawVarint32()); + Assert.Equal((uint) value, input.ReadRawVarint32()); input = CodedInputStream.CreateInstance(data); - Assert.AreEqual(value, input.ReadRawVarint64()); - Assert.IsTrue(input.IsAtEnd); + Assert.Equal(value, input.ReadRawVarint64()); + Assert.True(input.IsAtEnd); // Try different block sizes. for (int bufferSize = 1; bufferSize <= 16; bufferSize *= 2) { input = CodedInputStream.CreateInstance(new SmallBlockInputStream(data, bufferSize)); - Assert.AreEqual((uint) value, input.ReadRawVarint32()); + Assert.Equal((uint) value, input.ReadRawVarint32()); input = CodedInputStream.CreateInstance(new SmallBlockInputStream(data, bufferSize)); - Assert.AreEqual(value, input.ReadRawVarint64()); - Assert.IsTrue(input.IsAtEnd); + Assert.Equal(value, input.ReadRawVarint64()); + Assert.True(input.IsAtEnd); } // Try reading directly from a MemoryStream. We want to verify that it @@ -92,8 +90,8 @@ namespace Google.ProtocolBuffers memoryStream.Write(data, 0, data.Length); memoryStream.WriteByte(0); memoryStream.Position = 0; - Assert.AreEqual((uint) value, CodedInputStream.ReadRawVarint32(memoryStream)); - Assert.AreEqual(data.Length, memoryStream.Position); + Assert.Equal((uint) value, CodedInputStream.ReadRawVarint32(memoryStream)); + Assert.Equal(data.Length, memoryStream.Position); } /// @@ -104,40 +102,19 @@ namespace Google.ProtocolBuffers private static void AssertReadVarintFailure(InvalidProtocolBufferException expected, byte[] data) { CodedInputStream input = CodedInputStream.CreateInstance(data); - try - { - input.ReadRawVarint32(); - Assert.Fail("Should have thrown an exception."); - } - catch (InvalidProtocolBufferException e) - { - Assert.AreEqual(expected.Message, e.Message); - } + var exception = Assert.Throws(() => input.ReadRawVarint32()); + Assert.Equal(expected.Message, exception.Message); input = CodedInputStream.CreateInstance(data); - try - { - input.ReadRawVarint64(); - Assert.Fail("Should have thrown an exception."); - } - catch (InvalidProtocolBufferException e) - { - Assert.AreEqual(expected.Message, e.Message); - } + exception = Assert.Throws(() => input.ReadRawVarint64()); + Assert.Equal(expected.Message, exception.Message); // Make sure we get the same error when reading directly from a Stream. - try - { - CodedInputStream.ReadRawVarint32(new MemoryStream(data)); - Assert.Fail("Should have thrown an exception."); - } - catch (InvalidProtocolBufferException e) - { - Assert.AreEqual(expected.Message, e.Message); - } + exception = Assert.Throws(() => CodedInputStream.ReadRawVarint32(new MemoryStream(data))); + Assert.Equal(expected.Message, exception.Message); } - [TestMethod] + [Fact] public void ReadVarint() { AssertReadVarint(Bytes(0x00), 0); @@ -182,16 +159,16 @@ namespace Google.ProtocolBuffers private static void AssertReadLittleEndian32(byte[] data, uint value) { CodedInputStream input = CodedInputStream.CreateInstance(data); - Assert.AreEqual(value, input.ReadRawLittleEndian32()); - Assert.IsTrue(input.IsAtEnd); + Assert.Equal(value, input.ReadRawLittleEndian32()); + Assert.True(input.IsAtEnd); // Try different block sizes. for (int blockSize = 1; blockSize <= 16; blockSize *= 2) { input = CodedInputStream.CreateInstance( new SmallBlockInputStream(data, blockSize)); - Assert.AreEqual(value, input.ReadRawLittleEndian32()); - Assert.IsTrue(input.IsAtEnd); + Assert.Equal(value, input.ReadRawLittleEndian32()); + Assert.True(input.IsAtEnd); } } @@ -202,20 +179,20 @@ namespace Google.ProtocolBuffers private static void AssertReadLittleEndian64(byte[] data, ulong value) { CodedInputStream input = CodedInputStream.CreateInstance(data); - Assert.AreEqual(value, input.ReadRawLittleEndian64()); - Assert.IsTrue(input.IsAtEnd); + Assert.Equal(value, input.ReadRawLittleEndian64()); + Assert.True(input.IsAtEnd); // Try different block sizes. for (int blockSize = 1; blockSize <= 16; blockSize *= 2) { input = CodedInputStream.CreateInstance( new SmallBlockInputStream(data, blockSize)); - Assert.AreEqual(value, input.ReadRawLittleEndian64()); - Assert.IsTrue(input.IsAtEnd); + Assert.Equal(value, input.ReadRawLittleEndian64()); + Assert.True(input.IsAtEnd); } } - [TestMethod] + [Fact] public void ReadLittleEndian() { AssertReadLittleEndian32(Bytes(0x78, 0x56, 0x34, 0x12), 0x12345678); @@ -227,41 +204,41 @@ namespace Google.ProtocolBuffers Bytes(0x78, 0x56, 0x34, 0x12, 0xf0, 0xde, 0xbc, 0x9a), 0x9abcdef012345678UL); } - [TestMethod] + [Fact] public void DecodeZigZag32() { - Assert.AreEqual(0, CodedInputStream.DecodeZigZag32(0)); - Assert.AreEqual(-1, CodedInputStream.DecodeZigZag32(1)); - Assert.AreEqual(1, CodedInputStream.DecodeZigZag32(2)); - Assert.AreEqual(-2, CodedInputStream.DecodeZigZag32(3)); - Assert.AreEqual(0x3FFFFFFF, CodedInputStream.DecodeZigZag32(0x7FFFFFFE)); - Assert.AreEqual(unchecked((int) 0xC0000000), CodedInputStream.DecodeZigZag32(0x7FFFFFFF)); - Assert.AreEqual(0x7FFFFFFF, CodedInputStream.DecodeZigZag32(0xFFFFFFFE)); - Assert.AreEqual(unchecked((int) 0x80000000), CodedInputStream.DecodeZigZag32(0xFFFFFFFF)); + Assert.Equal(0, CodedInputStream.DecodeZigZag32(0)); + Assert.Equal(-1, CodedInputStream.DecodeZigZag32(1)); + Assert.Equal(1, CodedInputStream.DecodeZigZag32(2)); + Assert.Equal(-2, CodedInputStream.DecodeZigZag32(3)); + Assert.Equal(0x3FFFFFFF, CodedInputStream.DecodeZigZag32(0x7FFFFFFE)); + Assert.Equal(unchecked((int) 0xC0000000), CodedInputStream.DecodeZigZag32(0x7FFFFFFF)); + Assert.Equal(0x7FFFFFFF, CodedInputStream.DecodeZigZag32(0xFFFFFFFE)); + Assert.Equal(unchecked((int) 0x80000000), CodedInputStream.DecodeZigZag32(0xFFFFFFFF)); } - [TestMethod] + [Fact] public void DecodeZigZag64() { - Assert.AreEqual(0, CodedInputStream.DecodeZigZag64(0)); - Assert.AreEqual(-1, CodedInputStream.DecodeZigZag64(1)); - Assert.AreEqual(1, CodedInputStream.DecodeZigZag64(2)); - Assert.AreEqual(-2, CodedInputStream.DecodeZigZag64(3)); - Assert.AreEqual(0x000000003FFFFFFFL, CodedInputStream.DecodeZigZag64(0x000000007FFFFFFEL)); - Assert.AreEqual(unchecked((long) 0xFFFFFFFFC0000000L), CodedInputStream.DecodeZigZag64(0x000000007FFFFFFFL)); - Assert.AreEqual(0x000000007FFFFFFFL, CodedInputStream.DecodeZigZag64(0x00000000FFFFFFFEL)); - Assert.AreEqual(unchecked((long) 0xFFFFFFFF80000000L), CodedInputStream.DecodeZigZag64(0x00000000FFFFFFFFL)); - Assert.AreEqual(0x7FFFFFFFFFFFFFFFL, CodedInputStream.DecodeZigZag64(0xFFFFFFFFFFFFFFFEL)); - Assert.AreEqual(unchecked((long) 0x8000000000000000L), CodedInputStream.DecodeZigZag64(0xFFFFFFFFFFFFFFFFL)); + Assert.Equal(0, CodedInputStream.DecodeZigZag64(0)); + Assert.Equal(-1, CodedInputStream.DecodeZigZag64(1)); + Assert.Equal(1, CodedInputStream.DecodeZigZag64(2)); + Assert.Equal(-2, CodedInputStream.DecodeZigZag64(3)); + Assert.Equal(0x000000003FFFFFFFL, CodedInputStream.DecodeZigZag64(0x000000007FFFFFFEL)); + Assert.Equal(unchecked((long) 0xFFFFFFFFC0000000L), CodedInputStream.DecodeZigZag64(0x000000007FFFFFFFL)); + Assert.Equal(0x000000007FFFFFFFL, CodedInputStream.DecodeZigZag64(0x00000000FFFFFFFEL)); + Assert.Equal(unchecked((long) 0xFFFFFFFF80000000L), CodedInputStream.DecodeZigZag64(0x00000000FFFFFFFFL)); + Assert.Equal(0x7FFFFFFFFFFFFFFFL, CodedInputStream.DecodeZigZag64(0xFFFFFFFFFFFFFFFEL)); + Assert.Equal(unchecked((long) 0x8000000000000000L), CodedInputStream.DecodeZigZag64(0xFFFFFFFFFFFFFFFFL)); } - [TestMethod] + [Fact] public void ReadWholeMessage() { TestAllTypes message = TestUtil.GetAllSet(); byte[] rawBytes = message.ToByteArray(); - Assert.AreEqual(rawBytes.Length, message.SerializedSize); + Assert.Equal(rawBytes.Length, message.SerializedSize); TestAllTypes message2 = TestAllTypes.ParseFrom(rawBytes); TestUtil.AssertAllFieldsSet(message2); @@ -273,7 +250,7 @@ namespace Google.ProtocolBuffers } } - [TestMethod] + [Fact] public void SkipWholeMessage() { TestAllTypes message = TestUtil.GetAllSet(); @@ -290,8 +267,8 @@ namespace Google.ProtocolBuffers while (input1.ReadTag(out tag, out name)) { uint tag2; - Assert.IsTrue(input2.ReadTag(out tag2, out name)); - Assert.AreEqual(tag, tag2); + Assert.True(input2.ReadTag(out tag2, out name)); + Assert.Equal(tag, tag2); unknownFields.MergeFieldFrom(tag, input1); input2.SkipField(); @@ -302,7 +279,7 @@ namespace Google.ProtocolBuffers /// Test that a bug in SkipRawBytes has been fixed: if the skip /// skips exactly up to a limit, this should bnot break things /// - [TestMethod] + [Fact] public void SkipRawBytesBug() { byte[] rawBytes = new byte[] {1, 2}; @@ -311,7 +288,7 @@ namespace Google.ProtocolBuffers int limit = input.PushLimit(1); input.SkipRawBytes(1); input.PopLimit(limit); - Assert.AreEqual(2, input.ReadRawByte()); + Assert.Equal(2, input.ReadRawByte()); } public void ReadHugeBlob() @@ -334,7 +311,7 @@ namespace Google.ProtocolBuffers // reading. TestAllTypes message2 = TestAllTypes.ParseFrom(message.ToByteString().CreateCodedInput()); - Assert.AreEqual(message.OptionalBytes, message2.OptionalBytes); + Assert.Equal(message.OptionalBytes, message2.OptionalBytes); // Make sure all the other fields were parsed correctly. TestAllTypes message3 = TestAllTypes.CreateBuilder(message2) @@ -343,7 +320,7 @@ namespace Google.ProtocolBuffers TestUtil.AssertAllFieldsSet(message3); } - [TestMethod] + [Fact] public void ReadMaliciouslyLargeBlob() { MemoryStream ms = new MemoryStream(); @@ -359,19 +336,12 @@ namespace Google.ProtocolBuffers CodedInputStream input = CodedInputStream.CreateInstance(ms); uint testtag; string ignore; - Assert.IsTrue(input.ReadTag(out testtag, out ignore)); - Assert.AreEqual(tag, testtag); + Assert.True(input.ReadTag(out testtag, out ignore)); + Assert.Equal(tag, testtag); - try - { - ByteString bytes = null; - input.ReadBytes(ref bytes); - Assert.Fail("Should have thrown an exception!"); - } - catch (InvalidProtocolBufferException) - { - // success. - } + ByteString bytes = null; + // TODO(jonskeet): Should this be ArgumentNullException instead? + Assert.Throws(() => input.ReadBytes(ref bytes)); } private static TestRecursiveMessage MakeRecursiveMessage(int depth) @@ -391,17 +361,17 @@ namespace Google.ProtocolBuffers { if (depth == 0) { - Assert.IsFalse(message.HasA); - Assert.AreEqual(5, message.I); + Assert.False(message.HasA); + Assert.Equal(5, message.I); } else { - Assert.IsTrue(message.HasA); + Assert.True(message.HasA); AssertMessageDepth(message.A, depth - 1); } } - [TestMethod] + [Fact] public void MaliciousRecursion() { ByteString data64 = MakeRecursiveMessage(64).ToByteString(); @@ -409,30 +379,14 @@ namespace Google.ProtocolBuffers AssertMessageDepth(TestRecursiveMessage.ParseFrom(data64), 64); - try - { - TestRecursiveMessage.ParseFrom(data65); - Assert.Fail("Should have thrown an exception!"); - } - catch (InvalidProtocolBufferException) - { - // success. - } + Assert.Throws(() => TestRecursiveMessage.ParseFrom(data65)); CodedInputStream input = data64.CreateCodedInput(); input.SetRecursionLimit(8); - try - { - TestRecursiveMessage.ParseFrom(input); - Assert.Fail("Should have thrown an exception!"); - } - catch (InvalidProtocolBufferException) - { - // success. - } + Assert.Throws(() => TestRecursiveMessage.ParseFrom(input)); } - [TestMethod] + [Fact] public void SizeLimit() { // Have to use a Stream rather than ByteString.CreateCodedInput as SizeLimit doesn't @@ -441,18 +395,10 @@ namespace Google.ProtocolBuffers CodedInputStream input = CodedInputStream.CreateInstance(ms); input.SetSizeLimit(16); - try - { - TestAllTypes.ParseFrom(input); - Assert.Fail("Should have thrown an exception!"); - } - catch (InvalidProtocolBufferException) - { - // success. - } + Assert.Throws(() => TestAllTypes.ParseFrom(input)); } - [TestMethod] + [Fact] public void ResetSizeCounter() { CodedInputStream input = CodedInputStream.CreateInstance( @@ -460,28 +406,12 @@ namespace Google.ProtocolBuffers input.SetSizeLimit(16); input.ReadRawBytes(16); - try - { - input.ReadRawByte(); - Assert.Fail("Should have thrown an exception!"); - } - catch (InvalidProtocolBufferException) - { - // Success. - } + Assert.Throws(() => input.ReadRawByte()); input.ResetSizeCounter(); input.ReadRawByte(); // No exception thrown. - try - { - input.ReadRawBytes(16); // Hits limit again. - Assert.Fail("Should have thrown an exception!"); - } - catch (InvalidProtocolBufferException) - { - // Success. - } + Assert.Throws(() => input.ReadRawBytes(16)); } /// @@ -489,7 +419,7 @@ namespace Google.ProtocolBuffers /// is thrown. Instead, the invalid bytes are replaced with the Unicode /// "replacement character" U+FFFD. /// - [TestMethod] + [Fact] public void ReadInvalidUtf8() { MemoryStream ms = new MemoryStream(); @@ -507,11 +437,11 @@ namespace Google.ProtocolBuffers uint testtag; string ignored; - Assert.IsTrue(input.ReadTag(out testtag, out ignored)); - Assert.AreEqual(tag, testtag); + Assert.True(input.ReadTag(out testtag, out ignored)); + Assert.Equal(tag, testtag); string text = null; input.ReadString(ref text); - Assert.AreEqual('\ufffd', text[0]); + Assert.Equal('\ufffd', text[0]); } /// @@ -537,7 +467,7 @@ namespace Google.ProtocolBuffers enum TestNegEnum { None = 0, Value = -2 } - [TestMethod] + [Fact] public void TestNegativeEnum() { byte[] bytes = new byte[10] { 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01 }; @@ -545,12 +475,12 @@ namespace Google.ProtocolBuffers object unk; TestNegEnum val = TestNegEnum.None; - Assert.IsTrue(input.ReadEnum(ref val, out unk)); - Assert.IsTrue(input.IsAtEnd); - Assert.AreEqual(TestNegEnum.Value, val); + Assert.True(input.ReadEnum(ref val, out unk)); + Assert.True(input.IsAtEnd); + Assert.Equal(TestNegEnum.Value, val); } - [TestMethod] + [Fact] public void TestNegativeEnumPackedArray() { int arraySize = 1 + (10 * 5); @@ -559,26 +489,26 @@ namespace Google.ProtocolBuffers CodedOutputStream output = CodedOutputStream.CreateInstance(bytes); output.WritePackedInt32Array(8, "", arraySize, new int[] { 0, -1, -2, -3, -4, -5 }); - Assert.AreEqual(0, output.SpaceLeft); + Assert.Equal(0, output.SpaceLeft); CodedInputStream input = CodedInputStream.CreateInstance(bytes); uint tag; string name; - Assert.IsTrue(input.ReadTag(out tag, out name)); + Assert.True(input.ReadTag(out tag, out name)); List values = new List(); ICollection unk; input.ReadEnumArray(tag, name, values, out unk); - Assert.AreEqual(2, values.Count); - Assert.AreEqual(TestNegEnum.None, values[0]); - Assert.AreEqual(TestNegEnum.Value, values[1]); + Assert.Equal(2, values.Count); + Assert.Equal(TestNegEnum.None, values[0]); + Assert.Equal(TestNegEnum.Value, values[1]); - Assert.IsNotNull(unk); - Assert.AreEqual(4, unk.Count); + Assert.NotNull(unk); + Assert.Equal(4, unk.Count); } - [TestMethod] + [Fact] public void TestNegativeEnumArray() { int arraySize = 1 + 1 + (11 * 5); @@ -587,27 +517,27 @@ namespace Google.ProtocolBuffers CodedOutputStream output = CodedOutputStream.CreateInstance(bytes); output.WriteInt32Array(8, "", new int[] { 0, -1, -2, -3, -4, -5 }); - Assert.AreEqual(0, output.SpaceLeft); + Assert.Equal(0, output.SpaceLeft); CodedInputStream input = CodedInputStream.CreateInstance(bytes); uint tag; string name; - Assert.IsTrue(input.ReadTag(out tag, out name)); + Assert.True(input.ReadTag(out tag, out name)); List values = new List(); ICollection unk; input.ReadEnumArray(tag, name, values, out unk); - Assert.AreEqual(2, values.Count); - Assert.AreEqual(TestNegEnum.None, values[0]); - Assert.AreEqual(TestNegEnum.Value, values[1]); + Assert.Equal(2, values.Count); + Assert.Equal(TestNegEnum.None, values[0]); + Assert.Equal(TestNegEnum.Value, values[1]); - Assert.IsNotNull(unk); - Assert.AreEqual(4, unk.Count); + Assert.NotNull(unk); + Assert.Equal(4, unk.Count); } //Issue 71: CodedInputStream.ReadBytes go to slow path unnecessarily - [TestMethod] + [Fact] public void TestSlowPathAvoidance() { using (var ms = new MemoryStream()) @@ -624,15 +554,15 @@ namespace Google.ProtocolBuffers string ignore; ByteString value; - Assert.IsTrue(input.ReadTag(out tag, out ignore)); - Assert.AreEqual(1, WireFormat.GetTagFieldNumber(tag)); + Assert.True(input.ReadTag(out tag, out ignore)); + Assert.Equal(1, WireFormat.GetTagFieldNumber(tag)); value = ByteString.Empty; - Assert.IsTrue(input.ReadBytes(ref value) && value.Length == 100); + Assert.True(input.ReadBytes(ref value) && value.Length == 100); - Assert.IsTrue(input.ReadTag(out tag, out ignore)); - Assert.AreEqual(2, WireFormat.GetTagFieldNumber(tag)); + Assert.True(input.ReadTag(out tag, out ignore)); + Assert.Equal(2, WireFormat.GetTagFieldNumber(tag)); value = ByteString.Empty; - Assert.IsTrue(input.ReadBytes(ref value) && value.Length == 100); + Assert.True(input.ReadBytes(ref value) && value.Length == 100); } } } diff --git a/csharp/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs b/csharp/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs index 8e4e9090..d9f53d74 100644 --- a/csharp/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs +++ b/csharp/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs @@ -38,11 +38,10 @@ using System; using System.Collections.Generic; using System.IO; using Google.ProtocolBuffers.TestProtos; -using Microsoft.VisualStudio.TestTools.UnitTesting; +using Xunit; namespace Google.ProtocolBuffers { - [TestClass] public class CodedOutputStreamTest { /// @@ -58,9 +57,9 @@ namespace Google.ProtocolBuffers CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput); output.WriteRawVarint32((uint) value); output.Flush(); - TestUtil.AssertBytesEqual(data, rawOutput.ToArray()); + Assert.Equal(data, rawOutput.ToArray()); // Also try computing size. - Assert.AreEqual(data.Length, CodedOutputStream.ComputeRawVarint32Size((uint) value)); + Assert.Equal(data.Length, CodedOutputStream.ComputeRawVarint32Size((uint) value)); } { @@ -68,10 +67,10 @@ namespace Google.ProtocolBuffers CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput); output.WriteRawVarint64(value); output.Flush(); - TestUtil.AssertBytesEqual(data, rawOutput.ToArray()); + Assert.Equal(data, rawOutput.ToArray()); // Also try computing size. - Assert.AreEqual(data.Length, CodedOutputStream.ComputeRawVarint64Size(value)); + Assert.Equal(data.Length, CodedOutputStream.ComputeRawVarint64Size(value)); } // Try different buffer sizes. @@ -85,7 +84,7 @@ namespace Google.ProtocolBuffers CodedOutputStream.CreateInstance(rawOutput, bufferSize); output.WriteRawVarint32((uint) value); output.Flush(); - TestUtil.AssertBytesEqual(data, rawOutput.ToArray()); + Assert.Equal(data, rawOutput.ToArray()); } { @@ -93,7 +92,7 @@ namespace Google.ProtocolBuffers CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput, bufferSize); output.WriteRawVarint64(value); output.Flush(); - TestUtil.AssertBytesEqual(data, rawOutput.ToArray()); + Assert.Equal(data, rawOutput.ToArray()); } } } @@ -101,7 +100,7 @@ namespace Google.ProtocolBuffers /// /// Tests WriteRawVarint32() and WriteRawVarint64() /// - [TestMethod] + [Fact] public void WriteVarint() { AssertWriteVarint(new byte[] {0x00}, 0); @@ -143,7 +142,7 @@ namespace Google.ProtocolBuffers CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput); output.WriteRawLittleEndian32(value); output.Flush(); - TestUtil.AssertBytesEqual(data, rawOutput.ToArray()); + Assert.Equal(data, rawOutput.ToArray()); // Try different buffer sizes. for (int bufferSize = 1; bufferSize <= 16; bufferSize *= 2) @@ -152,7 +151,7 @@ namespace Google.ProtocolBuffers output = CodedOutputStream.CreateInstance(rawOutput, bufferSize); output.WriteRawLittleEndian32(value); output.Flush(); - TestUtil.AssertBytesEqual(data, rawOutput.ToArray()); + Assert.Equal(data, rawOutput.ToArray()); } } @@ -166,7 +165,7 @@ namespace Google.ProtocolBuffers CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput); output.WriteRawLittleEndian64(value); output.Flush(); - TestUtil.AssertBytesEqual(data, rawOutput.ToArray()); + Assert.Equal(data, rawOutput.ToArray()); // Try different block sizes. for (int blockSize = 1; blockSize <= 16; blockSize *= 2) @@ -175,14 +174,14 @@ namespace Google.ProtocolBuffers output = CodedOutputStream.CreateInstance(rawOutput, blockSize); output.WriteRawLittleEndian64(value); output.Flush(); - TestUtil.AssertBytesEqual(data, rawOutput.ToArray()); + Assert.Equal(data, rawOutput.ToArray()); } } /// /// Tests writeRawLittleEndian32() and writeRawLittleEndian64(). /// - [TestMethod] + [Fact] public void WriteLittleEndian() { AssertWriteLittleEndian32(new byte[] {0x78, 0x56, 0x34, 0x12}, 0x12345678); @@ -196,7 +195,7 @@ namespace Google.ProtocolBuffers 0x9abcdef012345678UL); } - [TestMethod] + [Fact] public void WriteWholeMessage() { TestAllTypes message = TestUtil.GetAllSet(); @@ -220,7 +219,7 @@ namespace Google.ProtocolBuffers /// Tests writing a whole message with every packed field type. Ensures the /// wire format of packed fields is compatible with C++. /// - [TestMethod] + [Fact] public void WriteWholePackedFieldsMessage() { TestPackedTypes message = TestUtil.GetPackedSet(); @@ -230,97 +229,97 @@ namespace Google.ProtocolBuffers rawBytes); } - [TestMethod] + [Fact] public void EncodeZigZag32() { - Assert.AreEqual(0u, CodedOutputStream.EncodeZigZag32(0)); - Assert.AreEqual(1u, CodedOutputStream.EncodeZigZag32(-1)); - Assert.AreEqual(2u, CodedOutputStream.EncodeZigZag32(1)); - Assert.AreEqual(3u, CodedOutputStream.EncodeZigZag32(-2)); - Assert.AreEqual(0x7FFFFFFEu, CodedOutputStream.EncodeZigZag32(0x3FFFFFFF)); - Assert.AreEqual(0x7FFFFFFFu, CodedOutputStream.EncodeZigZag32(unchecked((int) 0xC0000000))); - Assert.AreEqual(0xFFFFFFFEu, CodedOutputStream.EncodeZigZag32(0x7FFFFFFF)); - Assert.AreEqual(0xFFFFFFFFu, CodedOutputStream.EncodeZigZag32(unchecked((int) 0x80000000))); + Assert.Equal(0u, CodedOutputStream.EncodeZigZag32(0)); + Assert.Equal(1u, CodedOutputStream.EncodeZigZag32(-1)); + Assert.Equal(2u, CodedOutputStream.EncodeZigZag32(1)); + Assert.Equal(3u, CodedOutputStream.EncodeZigZag32(-2)); + Assert.Equal(0x7FFFFFFEu, CodedOutputStream.EncodeZigZag32(0x3FFFFFFF)); + Assert.Equal(0x7FFFFFFFu, CodedOutputStream.EncodeZigZag32(unchecked((int) 0xC0000000))); + Assert.Equal(0xFFFFFFFEu, CodedOutputStream.EncodeZigZag32(0x7FFFFFFF)); + Assert.Equal(0xFFFFFFFFu, CodedOutputStream.EncodeZigZag32(unchecked((int) 0x80000000))); } - [TestMethod] + [Fact] public void EncodeZigZag64() { - Assert.AreEqual(0u, CodedOutputStream.EncodeZigZag64(0)); - Assert.AreEqual(1u, CodedOutputStream.EncodeZigZag64(-1)); - Assert.AreEqual(2u, CodedOutputStream.EncodeZigZag64(1)); - Assert.AreEqual(3u, CodedOutputStream.EncodeZigZag64(-2)); - Assert.AreEqual(0x000000007FFFFFFEuL, + Assert.Equal(0u, CodedOutputStream.EncodeZigZag64(0)); + Assert.Equal(1u, CodedOutputStream.EncodeZigZag64(-1)); + Assert.Equal(2u, CodedOutputStream.EncodeZigZag64(1)); + Assert.Equal(3u, CodedOutputStream.EncodeZigZag64(-2)); + Assert.Equal(0x000000007FFFFFFEuL, CodedOutputStream.EncodeZigZag64(unchecked((long) 0x000000003FFFFFFFUL))); - Assert.AreEqual(0x000000007FFFFFFFuL, + Assert.Equal(0x000000007FFFFFFFuL, CodedOutputStream.EncodeZigZag64(unchecked((long) 0xFFFFFFFFC0000000UL))); - Assert.AreEqual(0x00000000FFFFFFFEuL, + Assert.Equal(0x00000000FFFFFFFEuL, CodedOutputStream.EncodeZigZag64(unchecked((long) 0x000000007FFFFFFFUL))); - Assert.AreEqual(0x00000000FFFFFFFFuL, + Assert.Equal(0x00000000FFFFFFFFuL, CodedOutputStream.EncodeZigZag64(unchecked((long) 0xFFFFFFFF80000000UL))); - Assert.AreEqual(0xFFFFFFFFFFFFFFFEL, + Assert.Equal(0xFFFFFFFFFFFFFFFEL, CodedOutputStream.EncodeZigZag64(unchecked((long) 0x7FFFFFFFFFFFFFFFUL))); - Assert.AreEqual(0xFFFFFFFFFFFFFFFFL, + Assert.Equal(0xFFFFFFFFFFFFFFFFL, CodedOutputStream.EncodeZigZag64(unchecked((long) 0x8000000000000000UL))); } - [TestMethod] + [Fact] public void RoundTripZigZag32() { // Some easier-to-verify round-trip tests. The inputs (other than 0, 1, -1) // were chosen semi-randomly via keyboard bashing. - Assert.AreEqual(0, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(0))); - Assert.AreEqual(1, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(1))); - Assert.AreEqual(-1, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(-1))); - Assert.AreEqual(14927, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(14927))); - Assert.AreEqual(-3612, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(-3612))); + Assert.Equal(0, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(0))); + Assert.Equal(1, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(1))); + Assert.Equal(-1, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(-1))); + Assert.Equal(14927, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(14927))); + Assert.Equal(-3612, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(-3612))); } - [TestMethod] + [Fact] public void RoundTripZigZag64() { - Assert.AreEqual(0, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(0))); - Assert.AreEqual(1, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(1))); - Assert.AreEqual(-1, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-1))); - Assert.AreEqual(14927, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(14927))); - Assert.AreEqual(-3612, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-3612))); + Assert.Equal(0, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(0))); + Assert.Equal(1, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(1))); + Assert.Equal(-1, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-1))); + Assert.Equal(14927, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(14927))); + Assert.Equal(-3612, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-3612))); - Assert.AreEqual(856912304801416L, + Assert.Equal(856912304801416L, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(856912304801416L))); - Assert.AreEqual(-75123905439571256L, + Assert.Equal(-75123905439571256L, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-75123905439571256L))); } - [TestMethod] + [Fact] public void TestNegativeEnumNoTag() { - Assert.AreEqual(10, CodedOutputStream.ComputeInt32SizeNoTag(-2)); - Assert.AreEqual(10, CodedOutputStream.ComputeEnumSizeNoTag(-2)); + Assert.Equal(10, CodedOutputStream.ComputeInt32SizeNoTag(-2)); + Assert.Equal(10, CodedOutputStream.ComputeEnumSizeNoTag(-2)); byte[] bytes = new byte[10]; CodedOutputStream output = CodedOutputStream.CreateInstance(bytes); output.WriteEnumNoTag(-2); - Assert.AreEqual(0, output.SpaceLeft); - Assert.AreEqual("FE-FF-FF-FF-FF-FF-FF-FF-FF-01", BitConverter.ToString(bytes)); + Assert.Equal(0, output.SpaceLeft); + Assert.Equal("FE-FF-FF-FF-FF-FF-FF-FF-FF-01", BitConverter.ToString(bytes)); } - [TestMethod] + [Fact] public void TestNegativeEnumWithTag() { - Assert.AreEqual(11, CodedOutputStream.ComputeInt32Size(8, -2)); - Assert.AreEqual(11, CodedOutputStream.ComputeEnumSize(8, -2)); + Assert.Equal(11, CodedOutputStream.ComputeInt32Size(8, -2)); + Assert.Equal(11, CodedOutputStream.ComputeEnumSize(8, -2)); byte[] bytes = new byte[11]; CodedOutputStream output = CodedOutputStream.CreateInstance(bytes); output.WriteEnum(8, "", -2, -2); - Assert.AreEqual(0, output.SpaceLeft); + Assert.Equal(0, output.SpaceLeft); //fyi, 0x40 == 0x08 << 3 + 0, field num + wire format shift - Assert.AreEqual("40-FE-FF-FF-FF-FF-FF-FF-FF-FF-01", BitConverter.ToString(bytes)); + Assert.Equal("40-FE-FF-FF-FF-FF-FF-FF-FF-FF-01", BitConverter.ToString(bytes)); } - [TestMethod] + [Fact] public void TestNegativeEnumArrayPacked() { int arraySize = 1 + (10 * 5); @@ -329,22 +328,22 @@ namespace Google.ProtocolBuffers CodedOutputStream output = CodedOutputStream.CreateInstance(bytes); output.WritePackedEnumArray(8, "", arraySize, new int[] { 0, -1, -2, -3, -4, -5 }); - Assert.AreEqual(0, output.SpaceLeft); + Assert.Equal(0, output.SpaceLeft); CodedInputStream input = CodedInputStream.CreateInstance(bytes); uint tag; string name; - Assert.IsTrue(input.ReadTag(out tag, out name)); + Assert.True(input.ReadTag(out tag, out name)); List values = new List(); input.ReadInt32Array(tag, name, values); - Assert.AreEqual(6, values.Count); + Assert.Equal(6, values.Count); for (int i = 0; i > -6; i--) - Assert.AreEqual(i, values[Math.Abs(i)]); + Assert.Equal(i, values[Math.Abs(i)]); } - [TestMethod] + [Fact] public void TestNegativeEnumArray() { int arraySize = 1 + 1 + (11 * 5); @@ -353,22 +352,22 @@ namespace Google.ProtocolBuffers CodedOutputStream output = CodedOutputStream.CreateInstance(bytes); output.WriteEnumArray(8, "", new int[] { 0, -1, -2, -3, -4, -5 }); - Assert.AreEqual(0, output.SpaceLeft); + Assert.Equal(0, output.SpaceLeft); CodedInputStream input = CodedInputStream.CreateInstance(bytes); uint tag; string name; - Assert.IsTrue(input.ReadTag(out tag, out name)); + Assert.True(input.ReadTag(out tag, out name)); List values = new List(); input.ReadInt32Array(tag, name, values); - Assert.AreEqual(6, values.Count); + Assert.Equal(6, values.Count); for (int i = 0; i > -6; i--) - Assert.AreEqual(i, values[Math.Abs(i)]); + Assert.Equal(i, values[Math.Abs(i)]); } - [TestMethod] + [Fact] public void TestCodedInputOutputPosition() { byte[] content = new byte[110]; @@ -381,19 +380,19 @@ namespace Google.ProtocolBuffers CodedOutputStream cout = CodedOutputStream.CreateInstance(ms, 20); // Field 11: numeric value: 500 cout.WriteTag(11, WireFormat.WireType.Varint); - Assert.AreEqual(1, cout.Position); + Assert.Equal(1, cout.Position); cout.WriteInt32NoTag(500); - Assert.AreEqual(3, cout.Position); + Assert.Equal(3, cout.Position); //Field 12: length delimited 120 bytes cout.WriteTag(12, WireFormat.WireType.LengthDelimited); - Assert.AreEqual(4, cout.Position); + Assert.Equal(4, cout.Position); cout.WriteBytesNoTag(ByteString.CopyFrom(content)); - Assert.AreEqual(115, cout.Position); + Assert.Equal(115, cout.Position); // Field 13: fixed numeric value: 501 cout.WriteTag(13, WireFormat.WireType.Fixed32); - Assert.AreEqual(116, cout.Position); + Assert.Equal(116, cout.Position); cout.WriteSFixed32NoTag(501); - Assert.AreEqual(120, cout.Position); + Assert.Equal(120, cout.Position); cout.Flush(); } @@ -402,19 +401,19 @@ namespace Google.ProtocolBuffers CodedOutputStream cout = CodedOutputStream.CreateInstance(bytes); // Field 1: numeric value: 500 cout.WriteTag(1, WireFormat.WireType.Varint); - Assert.AreEqual(1, cout.Position); + Assert.Equal(1, cout.Position); cout.WriteInt32NoTag(500); - Assert.AreEqual(3, cout.Position); + Assert.Equal(3, cout.Position); //Field 2: length delimited 120 bytes cout.WriteTag(2, WireFormat.WireType.LengthDelimited); - Assert.AreEqual(4, cout.Position); + Assert.Equal(4, cout.Position); cout.WriteBytesNoTag(ByteString.CopyFrom(child)); - Assert.AreEqual(125, cout.Position); + Assert.Equal(125, cout.Position); // Field 3: fixed numeric value: 500 cout.WriteTag(3, WireFormat.WireType.Fixed32); - Assert.AreEqual(126, cout.Position); + Assert.Equal(126, cout.Position); cout.WriteSFixed32NoTag(501); - Assert.AreEqual(130, cout.Position); + Assert.Equal(130, cout.Position); cout.Flush(); } //Now test Input stream: @@ -423,49 +422,49 @@ namespace Google.ProtocolBuffers uint tag; int intValue = 0; string ignore; - Assert.AreEqual(0, cin.Position); + Assert.Equal(0, cin.Position); // Field 1: - Assert.IsTrue(cin.ReadTag(out tag, out ignore) && tag >> 3 == 1); - Assert.AreEqual(1, cin.Position); - Assert.IsTrue(cin.ReadInt32(ref intValue) && intValue == 500); - Assert.AreEqual(3, cin.Position); + Assert.True(cin.ReadTag(out tag, out ignore) && tag >> 3 == 1); + Assert.Equal(1, cin.Position); + Assert.True(cin.ReadInt32(ref intValue) && intValue == 500); + Assert.Equal(3, cin.Position); //Field 2: - Assert.IsTrue(cin.ReadTag(out tag, out ignore) && tag >> 3 == 2); - Assert.AreEqual(4, cin.Position); + Assert.True(cin.ReadTag(out tag, out ignore) && tag >> 3 == 2); + Assert.Equal(4, cin.Position); uint childlen = cin.ReadRawVarint32(); - Assert.AreEqual(120u, childlen); - Assert.AreEqual(5, cin.Position); + Assert.Equal(120u, childlen); + Assert.Equal(5, cin.Position); int oldlimit = cin.PushLimit((int)childlen); - Assert.AreEqual(5, cin.Position); + Assert.Equal(5, cin.Position); // Now we are reading child message { // Field 11: numeric value: 500 - Assert.IsTrue(cin.ReadTag(out tag, out ignore) && tag >> 3 == 11); - Assert.AreEqual(6, cin.Position); - Assert.IsTrue(cin.ReadInt32(ref intValue) && intValue == 500); - Assert.AreEqual(8, cin.Position); + Assert.True(cin.ReadTag(out tag, out ignore) && tag >> 3 == 11); + Assert.Equal(6, cin.Position); + Assert.True(cin.ReadInt32(ref intValue) && intValue == 500); + Assert.Equal(8, cin.Position); //Field 12: length delimited 120 bytes - Assert.IsTrue(cin.ReadTag(out tag, out ignore) && tag >> 3 == 12); - Assert.AreEqual(9, cin.Position); + Assert.True(cin.ReadTag(out tag, out ignore) && tag >> 3 == 12); + Assert.Equal(9, cin.Position); ByteString bstr = null; - Assert.IsTrue(cin.ReadBytes(ref bstr) && bstr.Length == 110 && bstr.ToByteArray()[109] == 109); - Assert.AreEqual(120, cin.Position); + Assert.True(cin.ReadBytes(ref bstr) && bstr.Length == 110 && bstr.ToByteArray()[109] == 109); + Assert.Equal(120, cin.Position); // Field 13: fixed numeric value: 501 - Assert.IsTrue(cin.ReadTag(out tag, out ignore) && tag >> 3 == 13); + Assert.True(cin.ReadTag(out tag, out ignore) && tag >> 3 == 13); // ROK - Previously broken here, this returned 126 failing to account for bufferSizeAfterLimit - Assert.AreEqual(121, cin.Position); - Assert.IsTrue(cin.ReadSFixed32(ref intValue) && intValue == 501); - Assert.AreEqual(125, cin.Position); - Assert.IsTrue(cin.IsAtEnd); + Assert.Equal(121, cin.Position); + Assert.True(cin.ReadSFixed32(ref intValue) && intValue == 501); + Assert.Equal(125, cin.Position); + Assert.True(cin.IsAtEnd); } cin.PopLimit(oldlimit); - Assert.AreEqual(125, cin.Position); + Assert.Equal(125, cin.Position); // Field 3: fixed numeric value: 501 - Assert.IsTrue(cin.ReadTag(out tag, out ignore) && tag >> 3 == 3); - Assert.AreEqual(126, cin.Position); - Assert.IsTrue(cin.ReadSFixed32(ref intValue) && intValue == 501); - Assert.AreEqual(130, cin.Position); - Assert.IsTrue(cin.IsAtEnd); + Assert.True(cin.ReadTag(out tag, out ignore) && tag >> 3 == 3); + Assert.Equal(126, cin.Position); + Assert.True(cin.ReadSFixed32(ref intValue) && intValue == 501); + Assert.Equal(130, cin.Position); + Assert.True(cin.IsAtEnd); } } } diff --git a/csharp/src/ProtocolBuffers.Test/Collections/PopsicleListTest.cs b/csharp/src/ProtocolBuffers.Test/Collections/PopsicleListTest.cs index 0bce60d9..29584705 100644 --- a/csharp/src/ProtocolBuffers.Test/Collections/PopsicleListTest.cs +++ b/csharp/src/ProtocolBuffers.Test/Collections/PopsicleListTest.cs @@ -36,40 +36,39 @@ using System; using System.Collections.Generic; -using Microsoft.VisualStudio.TestTools.UnitTesting; +using Xunit; namespace Google.ProtocolBuffers.Collections { - [TestClass] public class PopsicleListTest { - [TestMethod] + [Fact] public void MutatingOperationsOnFrozenList() { PopsicleList list = new PopsicleList(); list.MakeReadOnly(); - TestUtil.AssertNotSupported(() => list.Add("")); - TestUtil.AssertNotSupported(() => list.Clear()); - TestUtil.AssertNotSupported(() => list.Insert(0, "")); - TestUtil.AssertNotSupported(() => list.Remove("")); - TestUtil.AssertNotSupported(() => list.RemoveAt(0)); - TestUtil.AssertNotSupported(() => list.Add(new[] { "", "" })); + Assert.Throws(() => list.Add("")); + Assert.Throws(() => list.Clear()); + Assert.Throws(() => list.Insert(0, "")); + Assert.Throws(() => list.Remove("")); + Assert.Throws(() => list.RemoveAt(0)); + Assert.Throws(() => list.Add(new[] { "", "" })); } - [TestMethod] + [Fact] public void NonMutatingOperationsOnFrozenList() { PopsicleList list = new PopsicleList(); list.MakeReadOnly(); - Assert.IsFalse(list.Contains("")); - Assert.AreEqual(0, list.Count); + Assert.False(list.Contains("")); + Assert.Equal(0, list.Count); list.CopyTo(new string[5], 0); list.GetEnumerator(); - Assert.AreEqual(-1, list.IndexOf("")); - Assert.IsTrue(list.IsReadOnly); + Assert.Equal(-1, list.IndexOf("")); + Assert.True(list.IsReadOnly); } - [TestMethod] + [Fact] public void MutatingOperationsOnFluidList() { PopsicleList list = new PopsicleList(); @@ -81,73 +80,46 @@ namespace Google.ProtocolBuffers.Collections list.RemoveAt(0); } - [TestMethod] + [Fact] public void NonMutatingOperationsOnFluidList() { PopsicleList list = new PopsicleList(); - Assert.IsFalse(list.Contains("")); - Assert.AreEqual(0, list.Count); + Assert.False(list.Contains("")); + Assert.Equal(0, list.Count); list.CopyTo(new string[5], 0); list.GetEnumerator(); - Assert.AreEqual(-1, list.IndexOf("")); - Assert.IsFalse(list.IsReadOnly); + Assert.Equal(-1, list.IndexOf("")); + Assert.False(list.IsReadOnly); } - [TestMethod] + [Fact] public void DoesNotAddNullEnumerable() { PopsicleList list = new PopsicleList(); - try - { - list.Add((IEnumerable)null); - } - catch (ArgumentNullException) - { return; } - - Assert.Fail("List should not allow nulls."); + Assert.Throws(() => list.Add((IEnumerable) null)); } - [TestMethod] + [Fact] public void DoesNotAddRangeWithNull() { PopsicleList list = new PopsicleList(); - try - { - list.Add(new[] { "a", "b", null }); - } - catch (ArgumentNullException) - { return; } - - Assert.Fail("List should not allow nulls."); + // TODO(jonskeet): Change to ArgumentException? The argument isn't null... + Assert.Throws(() => list.Add(new[] {"a", "b", null})); } - [TestMethod] + [Fact] public void DoesNotAddNull() { PopsicleList list = new PopsicleList(); - try - { - list.Add((string)null); - } - catch (ArgumentNullException) - { return; } - - Assert.Fail("List should not allow nulls."); + Assert.Throws(() => list.Add((string) null)); } - [TestMethod] + [Fact] public void DoesNotSetNull() { PopsicleList list = new PopsicleList(); list.Add("a"); - try - { - list[0] = null; - } - catch (ArgumentNullException) - { return; } - - Assert.Fail("List should not allow nulls."); + Assert.Throws(() => list[0] = null); } } } \ No newline at end of file diff --git a/csharp/src/ProtocolBuffers.Test/Compatibility/BinaryCompatibilityTests.cs b/csharp/src/ProtocolBuffers.Test/Compatibility/BinaryCompatibilityTests.cs index 9707f8e8..30d257ad 100644 --- a/csharp/src/ProtocolBuffers.Test/Compatibility/BinaryCompatibilityTests.cs +++ b/csharp/src/ProtocolBuffers.Test/Compatibility/BinaryCompatibilityTests.cs @@ -1,9 +1,7 @@ using System; -using Microsoft.VisualStudio.TestTools.UnitTesting; namespace Google.ProtocolBuffers.Compatibility { - [TestClass] public class BinaryCompatibilityTests : CompatibilityTests { protected override object SerializeMessage(TMessage message) diff --git a/csharp/src/ProtocolBuffers.Test/Compatibility/CompatibilityTests.cs b/csharp/src/ProtocolBuffers.Test/Compatibility/CompatibilityTests.cs index 5befe96f..d918c926 100644 --- a/csharp/src/ProtocolBuffers.Test/Compatibility/CompatibilityTests.cs +++ b/csharp/src/ProtocolBuffers.Test/Compatibility/CompatibilityTests.cs @@ -1,6 +1,6 @@ using System; using Google.ProtocolBuffers.TestProtos; -using Microsoft.VisualStudio.TestTools.UnitTesting; +using Xunit; namespace Google.ProtocolBuffers.Compatibility @@ -22,10 +22,10 @@ namespace Google.ProtocolBuffers.Compatibility protected virtual void AssertOutputEquals(object lhs, object rhs) { - Assert.AreEqual(lhs, rhs); + Assert.Equal(lhs, rhs); } - [TestMethod] + [Fact] public virtual void RoundTripWithEmptyChildMessageSize() { SizeMessage1 msg = SizeMessage1.CreateBuilder() @@ -37,12 +37,12 @@ namespace Google.ProtocolBuffers.Compatibility SizeMessage1 copy = DeserializeMessage(content, SizeMessage1.CreateBuilder(), ExtensionRegistry.Empty).BuildPartial(); - Assert.AreEqual(msg, copy); + Assert.Equal(msg, copy); AssertOutputEquals(content, SerializeMessage(copy)); - Assert.AreEqual(Convert.ToBase64String(contents), Convert.ToBase64String(copy.ToByteArray())); + Assert.Equal(Convert.ToBase64String(contents), Convert.ToBase64String(copy.ToByteArray())); } - [TestMethod] + [Fact] public virtual void RoundTripWithEmptyChildMessageSpeed() { SpeedMessage1 msg = SpeedMessage1.CreateBuilder() @@ -54,12 +54,12 @@ namespace Google.ProtocolBuffers.Compatibility SpeedMessage1 copy = DeserializeMessage(content, SpeedMessage1.CreateBuilder(), ExtensionRegistry.Empty).BuildPartial(); - Assert.AreEqual(msg, copy); + Assert.Equal(msg, copy); AssertOutputEquals(content, SerializeMessage(copy)); - Assert.AreEqual(Convert.ToBase64String(contents), Convert.ToBase64String(copy.ToByteArray())); + Assert.Equal(Convert.ToBase64String(contents), Convert.ToBase64String(copy.ToByteArray())); } - [TestMethod] + [Fact] public virtual void RoundTripMessage1OptimizeSize() { SizeMessage1 msg = SizeMessage1.CreateBuilder().MergeFrom(TestResources.google_message1).Build(); @@ -67,12 +67,12 @@ namespace Google.ProtocolBuffers.Compatibility SizeMessage1 copy = DeserializeMessage(content, SizeMessage1.CreateBuilder(), ExtensionRegistry.Empty).Build(); - Assert.AreEqual(msg, copy); + Assert.Equal(msg, copy); AssertOutputEquals(content, SerializeMessage(copy)); - Assert.AreEqual(Convert.ToBase64String(TestResources.google_message1), Convert.ToBase64String(copy.ToByteArray())); + Assert.Equal(Convert.ToBase64String(TestResources.google_message1), Convert.ToBase64String(copy.ToByteArray())); } - [TestMethod] + [Fact] public virtual void RoundTripMessage2OptimizeSize() { SizeMessage2 msg = SizeMessage2.CreateBuilder().MergeFrom(TestResources.google_message2).Build(); @@ -80,12 +80,12 @@ namespace Google.ProtocolBuffers.Compatibility SizeMessage2 copy = DeserializeMessage(content, SizeMessage2.CreateBuilder(), ExtensionRegistry.Empty).Build(); - Assert.AreEqual(msg, copy); + Assert.Equal(msg, copy); AssertOutputEquals(content, SerializeMessage(copy)); - Assert.AreEqual(Convert.ToBase64String(TestResources.google_message2), Convert.ToBase64String(copy.ToByteArray())); + Assert.Equal(Convert.ToBase64String(TestResources.google_message2), Convert.ToBase64String(copy.ToByteArray())); } - [TestMethod] + [Fact] public virtual void RoundTripMessage1OptimizeSpeed() { SpeedMessage1 msg = SpeedMessage1.CreateBuilder().MergeFrom(TestResources.google_message1).Build(); @@ -93,12 +93,12 @@ namespace Google.ProtocolBuffers.Compatibility SpeedMessage1 copy = DeserializeMessage(content, SpeedMessage1.CreateBuilder(), ExtensionRegistry.Empty).Build(); - Assert.AreEqual(msg, copy); + Assert.Equal(msg, copy); AssertOutputEquals(content, SerializeMessage(copy)); - Assert.AreEqual(Convert.ToBase64String(TestResources.google_message1), Convert.ToBase64String(copy.ToByteArray())); + Assert.Equal(Convert.ToBase64String(TestResources.google_message1), Convert.ToBase64String(copy.ToByteArray())); } - [TestMethod] + [Fact] public virtual void RoundTripMessage2OptimizeSpeed() { SpeedMessage2 msg = SpeedMessage2.CreateBuilder().MergeFrom(TestResources.google_message2).Build(); @@ -106,9 +106,9 @@ namespace Google.ProtocolBuffers.Compatibility SpeedMessage2 copy = DeserializeMessage(content, SpeedMessage2.CreateBuilder(), ExtensionRegistry.Empty).Build(); - Assert.AreEqual(msg, copy); + Assert.Equal(msg, copy); AssertOutputEquals(content, SerializeMessage(copy)); - Assert.AreEqual(Convert.ToBase64String(TestResources.google_message2), Convert.ToBase64String(copy.ToByteArray())); + Assert.Equal(Convert.ToBase64String(TestResources.google_message2), Convert.ToBase64String(copy.ToByteArray())); } #region Test message builders @@ -185,7 +185,7 @@ namespace Google.ProtocolBuffers.Compatibility #endregion - [TestMethod] + [Fact] public void TestRoundTripAllTypes() { TestAllTypes msg = AddAllTypes(new TestAllTypes.Builder()).Build(); @@ -193,12 +193,12 @@ namespace Google.ProtocolBuffers.Compatibility TestAllTypes copy = DeserializeMessage(content, TestAllTypes.CreateBuilder(), ExtensionRegistry.Empty).Build(); - Assert.AreEqual(msg, copy); + Assert.Equal(msg, copy); AssertOutputEquals(content, SerializeMessage(copy)); - Assert.AreEqual(Convert.ToBase64String(msg.ToByteArray()), Convert.ToBase64String(copy.ToByteArray())); + Assert.Equal(Convert.ToBase64String(msg.ToByteArray()), Convert.ToBase64String(copy.ToByteArray())); } - [TestMethod] + [Fact] public void TestRoundTripRepeatedTypes() { TestAllTypes msg = AddRepeatedTypes(new TestAllTypes.Builder(), 5).Build(); @@ -206,12 +206,12 @@ namespace Google.ProtocolBuffers.Compatibility TestAllTypes copy = DeserializeMessage(content, TestAllTypes.CreateBuilder(), ExtensionRegistry.Empty).Build(); - Assert.AreEqual(msg, copy); + Assert.Equal(msg, copy); AssertOutputEquals(content, SerializeMessage(copy)); - Assert.AreEqual(Convert.ToBase64String(msg.ToByteArray()), Convert.ToBase64String(copy.ToByteArray())); + Assert.Equal(Convert.ToBase64String(msg.ToByteArray()), Convert.ToBase64String(copy.ToByteArray())); } - [TestMethod] + [Fact] public void TestRoundTripPackedTypes() { TestPackedTypes msg = AddPackedTypes(new TestPackedTypes.Builder(), 5).Build(); @@ -219,9 +219,9 @@ namespace Google.ProtocolBuffers.Compatibility TestPackedTypes copy = DeserializeMessage(content, TestPackedTypes.CreateBuilder(), ExtensionRegistry.Empty).Build(); - Assert.AreEqual(msg, copy); + Assert.Equal(msg, copy); AssertOutputEquals(content, SerializeMessage(copy)); - Assert.AreEqual(Convert.ToBase64String(msg.ToByteArray()), Convert.ToBase64String(copy.ToByteArray())); + Assert.Equal(Convert.ToBase64String(msg.ToByteArray()), Convert.ToBase64String(copy.ToByteArray())); } } } diff --git a/csharp/src/ProtocolBuffers.Test/Compatibility/DictionaryCompatibilityTests.cs b/csharp/src/ProtocolBuffers.Test/Compatibility/DictionaryCompatibilityTests.cs index 73037cce..f555b101 100644 --- a/csharp/src/ProtocolBuffers.Test/Compatibility/DictionaryCompatibilityTests.cs +++ b/csharp/src/ProtocolBuffers.Test/Compatibility/DictionaryCompatibilityTests.cs @@ -1,13 +1,10 @@ using System; using System.Collections.Generic; -using System.IO; -using System.Text; using Google.ProtocolBuffers.Serialization; -using Microsoft.VisualStudio.TestTools.UnitTesting; +using Xunit; namespace Google.ProtocolBuffers.Compatibility { - [TestClass] public class DictionaryCompatibilityTests : CompatibilityTests { protected override object SerializeMessage(TMessage message) @@ -28,7 +25,7 @@ namespace Google.ProtocolBuffers.Compatibility IDictionary left = (IDictionary)lhs; IDictionary right = (IDictionary)rhs; - Assert.AreEqual( + Assert.Equal( String.Join(",", new List(left.Keys).ToArray()), String.Join(",", new List(right.Keys).ToArray()) ); diff --git a/csharp/src/ProtocolBuffers.Test/Compatibility/JsonCompatibilityTests.cs b/csharp/src/ProtocolBuffers.Test/Compatibility/JsonCompatibilityTests.cs index 74603108..3c943d33 100644 --- a/csharp/src/ProtocolBuffers.Test/Compatibility/JsonCompatibilityTests.cs +++ b/csharp/src/ProtocolBuffers.Test/Compatibility/JsonCompatibilityTests.cs @@ -1,11 +1,8 @@ using System.IO; -using System.Text; using Google.ProtocolBuffers.Serialization; -using Microsoft.VisualStudio.TestTools.UnitTesting; namespace Google.ProtocolBuffers.Compatibility { - [TestClass] public class JsonCompatibilityTests : CompatibilityTests { protected override object SerializeMessage(TMessage message) @@ -23,7 +20,6 @@ namespace Google.ProtocolBuffers.Compatibility } } - [TestClass] public class JsonCompatibilityFormattedTests : CompatibilityTests { protected override object SerializeMessage(TMessage message) diff --git a/csharp/src/ProtocolBuffers.Test/Compatibility/TestResources.cs b/csharp/src/ProtocolBuffers.Test/Compatibility/TestResources.cs index c3ce5883..4d1187a4 100644 --- a/csharp/src/ProtocolBuffers.Test/Compatibility/TestResources.cs +++ b/csharp/src/ProtocolBuffers.Test/Compatibility/TestResources.cs @@ -1,8 +1,5 @@ -using System; -using System.Collections.Generic; -using System.IO; -using System.Text; -using Microsoft.VisualStudio.TestTools.UnitTesting; +using System.IO; +using Xunit; namespace Google.ProtocolBuffers.Compatibility { @@ -15,11 +12,11 @@ namespace Google.ProtocolBuffers.Compatibility Stream resource = typeof(TestResources).Assembly.GetManifestResourceStream( typeof(TestResources).Namespace + ".google_message1.dat"); - Assert.IsNotNull(resource, "Unable to the locate resource: google_message1"); + Assert.NotNull(resource); byte[] bytes = new byte[resource.Length]; int amtRead = resource.Read(bytes, 0, bytes.Length); - Assert.AreEqual(bytes.Length, amtRead); + Assert.Equal(bytes.Length, amtRead); return bytes; } } @@ -30,11 +27,10 @@ namespace Google.ProtocolBuffers.Compatibility Stream resource = typeof(TestResources).Assembly.GetManifestResourceStream( typeof(TestResources).Namespace + ".google_message2.dat"); - Assert.IsNotNull(resource, "Unable to the locate resource: google_message2"); - + Assert.NotNull(resource); byte[] bytes = new byte[resource.Length]; int amtRead = resource.Read(bytes, 0, bytes.Length); - Assert.AreEqual(bytes.Length, amtRead); + Assert.Equal(bytes.Length, amtRead); return bytes; } } diff --git a/csharp/src/ProtocolBuffers.Test/Compatibility/TextCompatibilityTests.cs b/csharp/src/ProtocolBuffers.Test/Compatibility/TextCompatibilityTests.cs index c2eaadf6..2d74cf9f 100644 --- a/csharp/src/ProtocolBuffers.Test/Compatibility/TextCompatibilityTests.cs +++ b/csharp/src/ProtocolBuffers.Test/Compatibility/TextCompatibilityTests.cs @@ -1,10 +1,8 @@ -using System.ComponentModel; using System.IO; -using Microsoft.VisualStudio.TestTools.UnitTesting; +using Xunit; namespace Google.ProtocolBuffers.Compatibility { - [TestClass] public class TextCompatibilityTests : CompatibilityTests { protected override object SerializeMessage(TMessage message) @@ -20,14 +18,14 @@ namespace Google.ProtocolBuffers.Compatibility return builder; } //This test can take a very long time to run. - [TestMethod] + [Fact] public override void RoundTripMessage2OptimizeSize() { //base.RoundTripMessage2OptimizeSize(); } //This test can take a very long time to run. - [TestMethod] + [Fact] public override void RoundTripMessage2OptimizeSpeed() { //base.RoundTripMessage2OptimizeSpeed(); diff --git a/csharp/src/ProtocolBuffers.Test/Compatibility/XmlCompatibilityTests.cs b/csharp/src/ProtocolBuffers.Test/Compatibility/XmlCompatibilityTests.cs index 70614744..313523eb 100644 --- a/csharp/src/ProtocolBuffers.Test/Compatibility/XmlCompatibilityTests.cs +++ b/csharp/src/ProtocolBuffers.Test/Compatibility/XmlCompatibilityTests.cs @@ -1,12 +1,9 @@ using System.IO; using System.Xml; using Google.ProtocolBuffers.Serialization; -using Google.ProtocolBuffers.TestProtos; -using Microsoft.VisualStudio.TestTools.UnitTesting; namespace Google.ProtocolBuffers.Compatibility { - [TestClass] public class XmlCompatibilityTests : CompatibilityTests { protected override object SerializeMessage(TMessage message) @@ -24,7 +21,6 @@ namespace Google.ProtocolBuffers.Compatibility } } - [TestClass] public class XmlCompatibilityFormattedTests : CompatibilityTests { protected override object SerializeMessage(TMessage message) diff --git a/csharp/src/ProtocolBuffers.Test/DeprecatedMemberTest.cs b/csharp/src/ProtocolBuffers.Test/DeprecatedMemberTest.cs index 0901f043..21d21928 100644 --- a/csharp/src/ProtocolBuffers.Test/DeprecatedMemberTest.cs +++ b/csharp/src/ProtocolBuffers.Test/DeprecatedMemberTest.cs @@ -1,22 +1,19 @@ using System; -using System.Collections.Generic; using System.Reflection; -using System.Text; -using Microsoft.VisualStudio.TestTools.UnitTesting; using UnitTest.Issues.TestProtos; +using Xunit; namespace Google.ProtocolBuffers { - [TestClass] public class DeprecatedMemberTest { private static void AssertIsDeprecated(MemberInfo member) { - Assert.IsNotNull(member); - Assert.IsTrue(member.IsDefined(typeof(ObsoleteAttribute), false), "Member not obsolete: " + member); + Assert.NotNull(member); + Assert.True(member.IsDefined(typeof(ObsoleteAttribute), false), "Member not obsolete: " + member); } - [TestMethod] + [Fact] public void TestDepreatedPrimitiveValue() { AssertIsDeprecated(typeof(DeprecatedFieldsMessage).GetProperty("HasPrimitiveValue")); @@ -27,7 +24,7 @@ namespace Google.ProtocolBuffers AssertIsDeprecated(typeof(DeprecatedFieldsMessage.Builder).GetMethod("ClearPrimitiveValue")); AssertIsDeprecated(typeof(DeprecatedFieldsMessage.Builder).GetMethod("SetPrimitiveValue")); } - [TestMethod] + [Fact] public void TestDepreatedPrimitiveArray() { AssertIsDeprecated(typeof(DeprecatedFieldsMessage).GetProperty("PrimitiveArrayList")); @@ -42,7 +39,7 @@ namespace Google.ProtocolBuffers AssertIsDeprecated(typeof(DeprecatedFieldsMessage.Builder).GetMethod("AddRangePrimitiveArray")); AssertIsDeprecated(typeof(DeprecatedFieldsMessage.Builder).GetMethod("ClearPrimitiveArray")); } - [TestMethod] + [Fact] public void TestDepreatedMessageValue() { AssertIsDeprecated(typeof(DeprecatedFieldsMessage).GetProperty("HasMessageValue")); @@ -55,7 +52,7 @@ namespace Google.ProtocolBuffers AssertIsDeprecated(typeof(DeprecatedFieldsMessage.Builder).GetMethod("SetMessageValue", new[] { typeof(DeprecatedChild) })); AssertIsDeprecated(typeof(DeprecatedFieldsMessage.Builder).GetMethod("SetMessageValue", new[] { typeof(DeprecatedChild.Builder) })); } - [TestMethod] + [Fact] public void TestDepreatedMessageArray() { AssertIsDeprecated(typeof(DeprecatedFieldsMessage).GetProperty("MessageArrayList")); @@ -72,7 +69,7 @@ namespace Google.ProtocolBuffers AssertIsDeprecated(typeof(DeprecatedFieldsMessage.Builder).GetMethod("AddRangeMessageArray")); AssertIsDeprecated(typeof(DeprecatedFieldsMessage.Builder).GetMethod("ClearMessageArray")); } - [TestMethod] + [Fact] public void TestDepreatedEnumValue() { AssertIsDeprecated(typeof(DeprecatedFieldsMessage).GetProperty("HasEnumValue")); @@ -83,7 +80,7 @@ namespace Google.ProtocolBuffers AssertIsDeprecated(typeof(DeprecatedFieldsMessage.Builder).GetMethod("ClearEnumValue")); AssertIsDeprecated(typeof(DeprecatedFieldsMessage.Builder).GetMethod("SetEnumValue")); } - [TestMethod] + [Fact] public void TestDepreatedEnumArray() { AssertIsDeprecated(typeof(DeprecatedFieldsMessage).GetProperty("EnumArrayList")); diff --git a/csharp/src/ProtocolBuffers.Test/DescriptorsTest.cs b/csharp/src/ProtocolBuffers.Test/DescriptorsTest.cs index e74236fb..680887d3 100644 --- a/csharp/src/ProtocolBuffers.Test/DescriptorsTest.cs +++ b/csharp/src/ProtocolBuffers.Test/DescriptorsTest.cs @@ -34,10 +34,9 @@ #endregion -using System.Text; using Google.ProtocolBuffers.Descriptors; using Google.ProtocolBuffers.TestProtos; -using Microsoft.VisualStudio.TestTools.UnitTesting; +using Xunit; namespace Google.ProtocolBuffers { @@ -45,106 +44,105 @@ namespace Google.ProtocolBuffers /// Tests for descriptors. (Not in its own namespace or broken up into individual classes as the /// size doesn't warrant it. On the other hand, this makes me feel a bit dirty...) /// - [TestClass] public class DescriptorsTest { - [TestMethod] + [Fact] public void FileDescriptor() { FileDescriptor file = Unittest.Descriptor; - Assert.AreEqual("google/protobuf/unittest.proto", file.Name); - Assert.AreEqual("protobuf_unittest", file.Package); + Assert.Equal("google/protobuf/unittest.proto", file.Name); + Assert.Equal("protobuf_unittest", file.Package); - Assert.AreEqual("UnittestProto", file.Options.JavaOuterClassname); - Assert.AreEqual("google/protobuf/unittest.proto", file.Proto.Name); + Assert.Equal("UnittestProto", file.Options.JavaOuterClassname); + Assert.Equal("google/protobuf/unittest.proto", file.Proto.Name); // unittest.proto doesn't have any public imports, but unittest_import.proto does. - Assert.AreEqual(0, file.PublicDependencies.Count); - Assert.AreEqual(1, UnittestImport.Descriptor.PublicDependencies.Count); - Assert.AreEqual(UnittestImportPublic.Descriptor, UnittestImport.Descriptor.PublicDependencies[0]); + Assert.Equal(0, file.PublicDependencies.Count); + Assert.Equal(1, UnittestImport.Descriptor.PublicDependencies.Count); + Assert.Equal(UnittestImportPublic.Descriptor, UnittestImport.Descriptor.PublicDependencies[0]); - Assert.AreEqual(1, file.Dependencies.Count); - Assert.AreEqual(UnittestImport.Descriptor, file.Dependencies[0]); + Assert.Equal(1, file.Dependencies.Count); + Assert.Equal(UnittestImport.Descriptor, file.Dependencies[0]); MessageDescriptor messageType = TestAllTypes.Descriptor; - Assert.AreEqual(messageType, file.MessageTypes[0]); - Assert.AreEqual(messageType, file.FindTypeByName("TestAllTypes")); - Assert.IsNull(file.FindTypeByName("NoSuchType")); - Assert.IsNull(file.FindTypeByName("protobuf_unittest.TestAllTypes")); + Assert.Equal(messageType, file.MessageTypes[0]); + Assert.Equal(messageType, file.FindTypeByName("TestAllTypes")); + Assert.Null(file.FindTypeByName("NoSuchType")); + Assert.Null(file.FindTypeByName("protobuf_unittest.TestAllTypes")); for (int i = 0; i < file.MessageTypes.Count; i++) { - Assert.AreEqual(i, file.MessageTypes[i].Index); + Assert.Equal(i, file.MessageTypes[i].Index); } - Assert.AreEqual(file.EnumTypes[0], file.FindTypeByName("ForeignEnum")); - Assert.IsNull(file.FindTypeByName("NoSuchType")); - Assert.IsNull(file.FindTypeByName("protobuf_unittest.ForeignEnum")); - Assert.AreEqual(1, UnittestImport.Descriptor.EnumTypes.Count); - Assert.AreEqual("ImportEnum", UnittestImport.Descriptor.EnumTypes[0].Name); + Assert.Equal(file.EnumTypes[0], file.FindTypeByName("ForeignEnum")); + Assert.Null(file.FindTypeByName("NoSuchType")); + Assert.Null(file.FindTypeByName("protobuf_unittest.ForeignEnum")); + Assert.Equal(1, UnittestImport.Descriptor.EnumTypes.Count); + Assert.Equal("ImportEnum", UnittestImport.Descriptor.EnumTypes[0].Name); for (int i = 0; i < file.EnumTypes.Count; i++) { - Assert.AreEqual(i, file.EnumTypes[i].Index); + Assert.Equal(i, file.EnumTypes[i].Index); } FieldDescriptor extension = Unittest.OptionalInt32Extension.Descriptor; - Assert.AreEqual(extension, file.Extensions[0]); - Assert.AreEqual(extension, file.FindTypeByName("optional_int32_extension")); - Assert.IsNull(file.FindTypeByName("no_such_ext")); - Assert.IsNull(file.FindTypeByName("protobuf_unittest.optional_int32_extension")); - Assert.AreEqual(0, UnittestImport.Descriptor.Extensions.Count); + Assert.Equal(extension, file.Extensions[0]); + Assert.Equal(extension, file.FindTypeByName("optional_int32_extension")); + Assert.Null(file.FindTypeByName("no_such_ext")); + Assert.Null(file.FindTypeByName("protobuf_unittest.optional_int32_extension")); + Assert.Equal(0, UnittestImport.Descriptor.Extensions.Count); for (int i = 0; i < file.Extensions.Count; i++) { - Assert.AreEqual(i, file.Extensions[i].Index); + Assert.Equal(i, file.Extensions[i].Index); } } - [TestMethod] + [Fact] public void MessageDescriptor() { MessageDescriptor messageType = TestAllTypes.Descriptor; MessageDescriptor nestedType = TestAllTypes.Types.NestedMessage.Descriptor; - Assert.AreEqual("TestAllTypes", messageType.Name); - Assert.AreEqual("protobuf_unittest.TestAllTypes", messageType.FullName); - Assert.AreEqual(Unittest.Descriptor, messageType.File); - Assert.IsNull(messageType.ContainingType); - Assert.AreEqual(DescriptorProtos.MessageOptions.DefaultInstance, messageType.Options); - Assert.AreEqual("TestAllTypes", messageType.Proto.Name); + Assert.Equal("TestAllTypes", messageType.Name); + Assert.Equal("protobuf_unittest.TestAllTypes", messageType.FullName); + Assert.Equal(Unittest.Descriptor, messageType.File); + Assert.Null(messageType.ContainingType); + Assert.Equal(DescriptorProtos.MessageOptions.DefaultInstance, messageType.Options); + Assert.Equal("TestAllTypes", messageType.Proto.Name); - Assert.AreEqual("NestedMessage", nestedType.Name); - Assert.AreEqual("protobuf_unittest.TestAllTypes.NestedMessage", nestedType.FullName); - Assert.AreEqual(Unittest.Descriptor, nestedType.File); - Assert.AreEqual(messageType, nestedType.ContainingType); + Assert.Equal("NestedMessage", nestedType.Name); + Assert.Equal("protobuf_unittest.TestAllTypes.NestedMessage", nestedType.FullName); + Assert.Equal(Unittest.Descriptor, nestedType.File); + Assert.Equal(messageType, nestedType.ContainingType); FieldDescriptor field = messageType.Fields[0]; - Assert.AreEqual("optional_int32", field.Name); - Assert.AreEqual(field, messageType.FindDescriptor("optional_int32")); - Assert.IsNull(messageType.FindDescriptor("no_such_field")); - Assert.AreEqual(field, messageType.FindFieldByNumber(1)); - Assert.IsNull(messageType.FindFieldByNumber(571283)); + Assert.Equal("optional_int32", field.Name); + Assert.Equal(field, messageType.FindDescriptor("optional_int32")); + Assert.Null(messageType.FindDescriptor("no_such_field")); + Assert.Equal(field, messageType.FindFieldByNumber(1)); + Assert.Null(messageType.FindFieldByNumber(571283)); for (int i = 0; i < messageType.Fields.Count; i++) { - Assert.AreEqual(i, messageType.Fields[i].Index); + Assert.Equal(i, messageType.Fields[i].Index); } - Assert.AreEqual(nestedType, messageType.NestedTypes[0]); - Assert.AreEqual(nestedType, messageType.FindDescriptor("NestedMessage")); - Assert.IsNull(messageType.FindDescriptor("NoSuchType")); + Assert.Equal(nestedType, messageType.NestedTypes[0]); + Assert.Equal(nestedType, messageType.FindDescriptor("NestedMessage")); + Assert.Null(messageType.FindDescriptor("NoSuchType")); for (int i = 0; i < messageType.NestedTypes.Count; i++) { - Assert.AreEqual(i, messageType.NestedTypes[i].Index); + Assert.Equal(i, messageType.NestedTypes[i].Index); } - Assert.AreEqual(messageType.EnumTypes[0], messageType.FindDescriptor("NestedEnum")); - Assert.IsNull(messageType.FindDescriptor("NoSuchType")); + Assert.Equal(messageType.EnumTypes[0], messageType.FindDescriptor("NestedEnum")); + Assert.Null(messageType.FindDescriptor("NoSuchType")); for (int i = 0; i < messageType.EnumTypes.Count; i++) { - Assert.AreEqual(i, messageType.EnumTypes[i].Index); + Assert.Equal(i, messageType.EnumTypes[i].Index); } } - [TestMethod] + [Fact] public void FieldDescriptor() { MessageDescriptor messageType = TestAllTypes.Descriptor; @@ -155,54 +153,54 @@ namespace Google.ProtocolBuffers FieldDescriptor extension = Unittest.OptionalInt32Extension.Descriptor; FieldDescriptor nestedExtension = TestRequired.Single.Descriptor; - Assert.AreEqual("optional_int32", primitiveField.Name); - Assert.AreEqual("protobuf_unittest.TestAllTypes.optional_int32", + Assert.Equal("optional_int32", primitiveField.Name); + Assert.Equal("protobuf_unittest.TestAllTypes.optional_int32", primitiveField.FullName); - Assert.AreEqual(1, primitiveField.FieldNumber); - Assert.AreEqual(messageType, primitiveField.ContainingType); - Assert.AreEqual(Unittest.Descriptor, primitiveField.File); - Assert.AreEqual(FieldType.Int32, primitiveField.FieldType); - Assert.AreEqual(MappedType.Int32, primitiveField.MappedType); - Assert.AreEqual(DescriptorProtos.FieldOptions.DefaultInstance, primitiveField.Options); - Assert.IsFalse(primitiveField.IsExtension); - Assert.AreEqual("optional_int32", primitiveField.Proto.Name); - - Assert.AreEqual("optional_nested_enum", enumField.Name); - Assert.AreEqual(FieldType.Enum, enumField.FieldType); - Assert.AreEqual(MappedType.Enum, enumField.MappedType); - // Assert.AreEqual(TestAllTypes.Types.NestedEnum.DescriptorProtoFile, enumField.EnumType); - - Assert.AreEqual("optional_foreign_message", messageField.Name); - Assert.AreEqual(FieldType.Message, messageField.FieldType); - Assert.AreEqual(MappedType.Message, messageField.MappedType); - Assert.AreEqual(ForeignMessage.Descriptor, messageField.MessageType); - - Assert.AreEqual("optional_cord", cordField.Name); - Assert.AreEqual(FieldType.String, cordField.FieldType); - Assert.AreEqual(MappedType.String, cordField.MappedType); - Assert.AreEqual(DescriptorProtos.FieldOptions.Types.CType.CORD, cordField.Options.Ctype); - - Assert.AreEqual("optional_int32_extension", extension.Name); - Assert.AreEqual("protobuf_unittest.optional_int32_extension", extension.FullName); - Assert.AreEqual(1, extension.FieldNumber); - Assert.AreEqual(TestAllExtensions.Descriptor, extension.ContainingType); - Assert.AreEqual(Unittest.Descriptor, extension.File); - Assert.AreEqual(FieldType.Int32, extension.FieldType); - Assert.AreEqual(MappedType.Int32, extension.MappedType); - Assert.AreEqual(DescriptorProtos.FieldOptions.DefaultInstance, + Assert.Equal(1, primitiveField.FieldNumber); + Assert.Equal(messageType, primitiveField.ContainingType); + Assert.Equal(Unittest.Descriptor, primitiveField.File); + Assert.Equal(FieldType.Int32, primitiveField.FieldType); + Assert.Equal(MappedType.Int32, primitiveField.MappedType); + Assert.Equal(DescriptorProtos.FieldOptions.DefaultInstance, primitiveField.Options); + Assert.False(primitiveField.IsExtension); + Assert.Equal("optional_int32", primitiveField.Proto.Name); + + Assert.Equal("optional_nested_enum", enumField.Name); + Assert.Equal(FieldType.Enum, enumField.FieldType); + Assert.Equal(MappedType.Enum, enumField.MappedType); + // Assert.Equal(TestAllTypes.Types.NestedEnum.DescriptorProtoFile, enumField.EnumType); + + Assert.Equal("optional_foreign_message", messageField.Name); + Assert.Equal(FieldType.Message, messageField.FieldType); + Assert.Equal(MappedType.Message, messageField.MappedType); + Assert.Equal(ForeignMessage.Descriptor, messageField.MessageType); + + Assert.Equal("optional_cord", cordField.Name); + Assert.Equal(FieldType.String, cordField.FieldType); + Assert.Equal(MappedType.String, cordField.MappedType); + Assert.Equal(DescriptorProtos.FieldOptions.Types.CType.CORD, cordField.Options.Ctype); + + Assert.Equal("optional_int32_extension", extension.Name); + Assert.Equal("protobuf_unittest.optional_int32_extension", extension.FullName); + Assert.Equal(1, extension.FieldNumber); + Assert.Equal(TestAllExtensions.Descriptor, extension.ContainingType); + Assert.Equal(Unittest.Descriptor, extension.File); + Assert.Equal(FieldType.Int32, extension.FieldType); + Assert.Equal(MappedType.Int32, extension.MappedType); + Assert.Equal(DescriptorProtos.FieldOptions.DefaultInstance, extension.Options); - Assert.IsTrue(extension.IsExtension); - Assert.AreEqual(null, extension.ExtensionScope); - Assert.AreEqual("optional_int32_extension", extension.Proto.Name); + Assert.True(extension.IsExtension); + Assert.Equal(null, extension.ExtensionScope); + Assert.Equal("optional_int32_extension", extension.Proto.Name); - Assert.AreEqual("single", nestedExtension.Name); - Assert.AreEqual("protobuf_unittest.TestRequired.single", + Assert.Equal("single", nestedExtension.Name); + Assert.Equal("protobuf_unittest.TestRequired.single", nestedExtension.FullName); - Assert.AreEqual(TestRequired.Descriptor, + Assert.Equal(TestRequired.Descriptor, nestedExtension.ExtensionScope); } - [TestMethod] + [Fact] public void FieldDescriptorLabel() { FieldDescriptor requiredField = @@ -212,76 +210,76 @@ namespace Google.ProtocolBuffers FieldDescriptor repeatedField = TestAllTypes.Descriptor.FindDescriptor("repeated_int32"); - Assert.IsTrue(requiredField.IsRequired); - Assert.IsFalse(requiredField.IsRepeated); - Assert.IsFalse(optionalField.IsRequired); - Assert.IsFalse(optionalField.IsRepeated); - Assert.IsFalse(repeatedField.IsRequired); - Assert.IsTrue(repeatedField.IsRepeated); + Assert.True(requiredField.IsRequired); + Assert.False(requiredField.IsRepeated); + Assert.False(optionalField.IsRequired); + Assert.False(optionalField.IsRepeated); + Assert.False(repeatedField.IsRequired); + Assert.True(repeatedField.IsRepeated); } - [TestMethod] + [Fact] public void FieldDescriptorDefault() { MessageDescriptor d = TestAllTypes.Descriptor; - Assert.IsFalse(d.FindDescriptor("optional_int32").HasDefaultValue); - Assert.AreEqual(0, d.FindDescriptor("optional_int32").DefaultValue); - Assert.IsTrue(d.FindDescriptor("default_int32").HasDefaultValue); - Assert.AreEqual(41, d.FindDescriptor("default_int32").DefaultValue); + Assert.False(d.FindDescriptor("optional_int32").HasDefaultValue); + Assert.Equal(0, d.FindDescriptor("optional_int32").DefaultValue); + Assert.True(d.FindDescriptor("default_int32").HasDefaultValue); + Assert.Equal(41, d.FindDescriptor("default_int32").DefaultValue); d = TestExtremeDefaultValues.Descriptor; - Assert.AreEqual(TestExtremeDefaultValues.DefaultInstance.EscapedBytes, + Assert.Equal(TestExtremeDefaultValues.DefaultInstance.EscapedBytes, d.FindDescriptor("escaped_bytes").DefaultValue); - Assert.AreEqual(uint.MaxValue, d.FindDescriptor("large_uint32").DefaultValue); - Assert.AreEqual(ulong.MaxValue, d.FindDescriptor("large_uint64").DefaultValue); + Assert.Equal(uint.MaxValue, d.FindDescriptor("large_uint32").DefaultValue); + Assert.Equal(ulong.MaxValue, d.FindDescriptor("large_uint64").DefaultValue); } - [TestMethod] + [Fact] public void EnumDescriptor() { // Note: this test is a bit different to the Java version because there's no static way of getting to the descriptor EnumDescriptor enumType = Unittest.Descriptor.FindTypeByName("ForeignEnum"); EnumDescriptor nestedType = TestAllTypes.Descriptor.FindDescriptor("NestedEnum"); - Assert.AreEqual("ForeignEnum", enumType.Name); - Assert.AreEqual("protobuf_unittest.ForeignEnum", enumType.FullName); - Assert.AreEqual(Unittest.Descriptor, enumType.File); - Assert.IsNull(enumType.ContainingType); - Assert.AreEqual(DescriptorProtos.EnumOptions.DefaultInstance, + Assert.Equal("ForeignEnum", enumType.Name); + Assert.Equal("protobuf_unittest.ForeignEnum", enumType.FullName); + Assert.Equal(Unittest.Descriptor, enumType.File); + Assert.Null(enumType.ContainingType); + Assert.Equal(DescriptorProtos.EnumOptions.DefaultInstance, enumType.Options); - Assert.AreEqual("NestedEnum", nestedType.Name); - Assert.AreEqual("protobuf_unittest.TestAllTypes.NestedEnum", + Assert.Equal("NestedEnum", nestedType.Name); + Assert.Equal("protobuf_unittest.TestAllTypes.NestedEnum", nestedType.FullName); - Assert.AreEqual(Unittest.Descriptor, nestedType.File); - Assert.AreEqual(TestAllTypes.Descriptor, nestedType.ContainingType); + Assert.Equal(Unittest.Descriptor, nestedType.File); + Assert.Equal(TestAllTypes.Descriptor, nestedType.ContainingType); EnumValueDescriptor value = enumType.FindValueByName("FOREIGN_FOO"); - Assert.AreEqual(value, enumType.Values[0]); - Assert.AreEqual("FOREIGN_FOO", value.Name); - Assert.AreEqual(4, value.Number); - Assert.AreEqual((int) ForeignEnum.FOREIGN_FOO, value.Number); - Assert.AreEqual(value, enumType.FindValueByNumber(4)); - Assert.IsNull(enumType.FindValueByName("NO_SUCH_VALUE")); + Assert.Equal(value, enumType.Values[0]); + Assert.Equal("FOREIGN_FOO", value.Name); + Assert.Equal(4, value.Number); + Assert.Equal((int) ForeignEnum.FOREIGN_FOO, value.Number); + Assert.Equal(value, enumType.FindValueByNumber(4)); + Assert.Null(enumType.FindValueByName("NO_SUCH_VALUE")); for (int i = 0; i < enumType.Values.Count; i++) { - Assert.AreEqual(i, enumType.Values[i].Index); + Assert.Equal(i, enumType.Values[i].Index); } } - [TestMethod] + [Fact] public void CustomOptions() { MessageDescriptor descriptor = TestMessageWithCustomOptions.Descriptor; - Assert.IsTrue(descriptor.Options.HasExtension(UnittestCustomOptions.MessageOpt1)); - Assert.AreEqual(-56, descriptor.Options.GetExtension(UnittestCustomOptions.MessageOpt1)); + Assert.True(descriptor.Options.HasExtension(UnittestCustomOptions.MessageOpt1)); + Assert.Equal(-56, descriptor.Options.GetExtension(UnittestCustomOptions.MessageOpt1)); FieldDescriptor field = descriptor.FindFieldByName("field1"); - Assert.IsNotNull(field); + Assert.NotNull(field); - Assert.IsTrue(field.Options.HasExtension(UnittestCustomOptions.FieldOpt1)); - Assert.AreEqual(8765432109uL, field.Options.GetExtension(UnittestCustomOptions.FieldOpt1)); + Assert.True(field.Options.HasExtension(UnittestCustomOptions.FieldOpt1)); + Assert.Equal(8765432109uL, field.Options.GetExtension(UnittestCustomOptions.FieldOpt1)); } } diff --git a/csharp/src/ProtocolBuffers.Test/DynamicMessageTest.cs b/csharp/src/ProtocolBuffers.Test/DynamicMessageTest.cs index 92515999..39f122aa 100644 --- a/csharp/src/ProtocolBuffers.Test/DynamicMessageTest.cs +++ b/csharp/src/ProtocolBuffers.Test/DynamicMessageTest.cs @@ -37,26 +37,24 @@ using System; using System.Collections.Generic; using Google.ProtocolBuffers.TestProtos; -using Microsoft.VisualStudio.TestTools.UnitTesting; +using Xunit; namespace Google.ProtocolBuffers { - [TestClass] public class DynamicMessageTest { private ReflectionTester reflectionTester; private ReflectionTester extensionsReflectionTester; private ReflectionTester packedReflectionTester; - [TestInitialize] - public void SetUp() + public DynamicMessageTest() { reflectionTester = ReflectionTester.CreateTestAllTypesInstance(); extensionsReflectionTester = ReflectionTester.CreateTestAllExtensionsInstance(); packedReflectionTester = ReflectionTester.CreateTestPackedTypesInstance(); } - [TestMethod] + [Fact] public void DynamicMessageAccessors() { IBuilder builder = DynamicMessage.CreateBuilder(TestAllTypes.Descriptor); @@ -65,30 +63,22 @@ namespace Google.ProtocolBuffers reflectionTester.AssertAllFieldsSetViaReflection(message); } - [TestMethod] + [Fact] public void DoubleBuildError() { DynamicMessage.Builder builder = DynamicMessage.CreateBuilder(TestAllTypes.Descriptor); builder.Build(); - try - { - builder.Build(); - Assert.Fail("Should have thrown exception."); - } - catch (InvalidOperationException) - { - // Success. - } - } - - [TestMethod] + Assert.Throws(() => builder.Build()); + } + + [Fact] public void DynamicMessageSettersRejectNull() { IBuilder builder = DynamicMessage.CreateBuilder(TestAllTypes.Descriptor); reflectionTester.AssertReflectionSettersRejectNull(builder); } - [TestMethod] + [Fact] public void DynamicMessageExtensionAccessors() { // We don't need to extensively test DynamicMessage's handling of @@ -100,14 +90,14 @@ namespace Google.ProtocolBuffers extensionsReflectionTester.AssertAllFieldsSetViaReflection(message); } - [TestMethod] + [Fact] public void DynamicMessageExtensionSettersRejectNull() { IBuilder builder = DynamicMessage.CreateBuilder(TestAllExtensions.Descriptor); extensionsReflectionTester.AssertReflectionSettersRejectNull(builder); } - [TestMethod] + [Fact] public void DynamicMessageRepeatedSetters() { IBuilder builder = DynamicMessage.CreateBuilder(TestAllTypes.Descriptor); @@ -117,21 +107,21 @@ namespace Google.ProtocolBuffers reflectionTester.AssertRepeatedFieldsModifiedViaReflection(message); } - [TestMethod] + [Fact] public void DynamicMessageRepeatedSettersRejectNull() { IBuilder builder = DynamicMessage.CreateBuilder(TestAllTypes.Descriptor); reflectionTester.AssertReflectionRepeatedSettersRejectNull(builder); } - [TestMethod] + [Fact] public void DynamicMessageDefaults() { reflectionTester.AssertClearViaReflection(DynamicMessage.GetDefaultInstance(TestAllTypes.Descriptor)); reflectionTester.AssertClearViaReflection(DynamicMessage.CreateBuilder(TestAllTypes.Descriptor).Build()); } - [TestMethod] + [Fact] public void DynamicMessageSerializedSize() { TestAllTypes message = TestUtil.GetAllSet(); @@ -140,10 +130,10 @@ namespace Google.ProtocolBuffers reflectionTester.SetAllFieldsViaReflection(dynamicBuilder); IMessage dynamicMessage = dynamicBuilder.WeakBuild(); - Assert.AreEqual(message.SerializedSize, dynamicMessage.SerializedSize); + Assert.Equal(message.SerializedSize, dynamicMessage.SerializedSize); } - [TestMethod] + [Fact] public void DynamicMessageSerialization() { IBuilder builder = DynamicMessage.CreateBuilder(TestAllTypes.Descriptor); @@ -156,10 +146,10 @@ namespace Google.ProtocolBuffers TestUtil.AssertAllFieldsSet(message2); // In fact, the serialized forms should be exactly the same, byte-for-byte. - Assert.AreEqual(TestUtil.GetAllSet().ToByteString(), rawBytes); + Assert.Equal(TestUtil.GetAllSet().ToByteString(), rawBytes); } - [TestMethod] + [Fact] public void DynamicMessageParsing() { TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); @@ -172,7 +162,7 @@ namespace Google.ProtocolBuffers reflectionTester.AssertAllFieldsSetViaReflection(message2); } - [TestMethod] + [Fact] public void DynamicMessagePackedSerialization() { IBuilder builder = DynamicMessage.CreateBuilder(TestPackedTypes.Descriptor); @@ -185,11 +175,11 @@ namespace Google.ProtocolBuffers TestUtil.AssertPackedFieldsSet(message2); // In fact, the serialized forms should be exactly the same, byte-for-byte. - Assert.AreEqual(TestUtil.GetPackedSet().ToByteString(), rawBytes); + Assert.Equal(TestUtil.GetPackedSet().ToByteString(), rawBytes); } - [TestMethod] - public void testDynamicMessagePackedParsing() + [Fact] + public void DynamicMessagePackedParsing() { TestPackedTypes.Builder builder = TestPackedTypes.CreateBuilder(); TestUtil.SetPackedFields(builder); @@ -201,7 +191,7 @@ namespace Google.ProtocolBuffers packedReflectionTester.AssertPackedFieldsSetViaReflection(message2); } - [TestMethod] + [Fact] public void DynamicMessageCopy() { TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); @@ -212,7 +202,7 @@ namespace Google.ProtocolBuffers reflectionTester.AssertAllFieldsSetViaReflection(copy); } - [TestMethod] + [Fact] public void ToBuilder() { DynamicMessage.Builder builder = @@ -230,8 +220,8 @@ namespace Google.ProtocolBuffers reflectionTester.AssertAllFieldsSetViaReflection(derived); IList values = derived.UnknownFields.FieldDictionary[unknownFieldNum].VarintList; - Assert.AreEqual(1, values.Count); - Assert.AreEqual(unknownFieldVal, values[0]); + Assert.Equal(1, values.Count); + Assert.Equal(unknownFieldVal, values[0]); } } } \ No newline at end of file diff --git a/csharp/src/ProtocolBuffers.Test/ExtendableMessageTest.cs b/csharp/src/ProtocolBuffers.Test/ExtendableMessageTest.cs index 4e0bf8e6..f329270b 100644 --- a/csharp/src/ProtocolBuffers.Test/ExtendableMessageTest.cs +++ b/csharp/src/ProtocolBuffers.Test/ExtendableMessageTest.cs @@ -35,24 +35,22 @@ #endregion using System; -using System.Collections.Generic; -using Google.ProtocolBuffers; using Google.ProtocolBuffers.TestProtos; -using Microsoft.VisualStudio.TestTools.UnitTesting; +using Xunit; namespace Google.ProtocolBuffers { - [TestClass] public class ExtendableMessageTest { - [TestMethod, ExpectedException(typeof(ArgumentException))] + [Fact] public void ExtensionWriterInvalidExtension() { - TestPackedExtensions.CreateBuilder()[Unittest.OptionalForeignMessageExtension.Descriptor] = - ForeignMessage.DefaultInstance; + Assert.Throws(() => + TestPackedExtensions.CreateBuilder()[Unittest.OptionalForeignMessageExtension.Descriptor] = + ForeignMessage.DefaultInstance); } - [TestMethod] + [Fact] public void ExtensionWriterTest() { TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder() @@ -128,75 +126,75 @@ namespace Google.ProtocolBuffers registry); TestAllExtensions copy = copyBuilder.Build(); - TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray()); + Assert.Equal(msg.ToByteArray(), copy.ToByteArray()); - Assert.AreEqual(true, copy.GetExtension(Unittest.DefaultBoolExtension)); - Assert.AreEqual(ByteString.CopyFromUtf8("123"), copy.GetExtension(Unittest.DefaultBytesExtension)); - Assert.AreEqual("123", copy.GetExtension(Unittest.DefaultCordExtension)); - Assert.AreEqual(123, copy.GetExtension(Unittest.DefaultDoubleExtension)); - Assert.AreEqual(123u, copy.GetExtension(Unittest.DefaultFixed32Extension)); - Assert.AreEqual(123u, copy.GetExtension(Unittest.DefaultFixed64Extension)); - Assert.AreEqual(123, copy.GetExtension(Unittest.DefaultFloatExtension)); - Assert.AreEqual(ForeignEnum.FOREIGN_BAZ, copy.GetExtension(Unittest.DefaultForeignEnumExtension)); - Assert.AreEqual(ImportEnum.IMPORT_BAZ, copy.GetExtension(Unittest.DefaultImportEnumExtension)); - Assert.AreEqual(123, copy.GetExtension(Unittest.DefaultInt32Extension)); - Assert.AreEqual(123, copy.GetExtension(Unittest.DefaultInt64Extension)); - Assert.AreEqual(TestAllTypes.Types.NestedEnum.FOO, + Assert.Equal(true, copy.GetExtension(Unittest.DefaultBoolExtension)); + Assert.Equal(ByteString.CopyFromUtf8("123"), copy.GetExtension(Unittest.DefaultBytesExtension)); + Assert.Equal("123", copy.GetExtension(Unittest.DefaultCordExtension)); + Assert.Equal(123, copy.GetExtension(Unittest.DefaultDoubleExtension)); + Assert.Equal(123u, copy.GetExtension(Unittest.DefaultFixed32Extension)); + Assert.Equal(123u, copy.GetExtension(Unittest.DefaultFixed64Extension)); + Assert.Equal(123, copy.GetExtension(Unittest.DefaultFloatExtension)); + Assert.Equal(ForeignEnum.FOREIGN_BAZ, copy.GetExtension(Unittest.DefaultForeignEnumExtension)); + Assert.Equal(ImportEnum.IMPORT_BAZ, copy.GetExtension(Unittest.DefaultImportEnumExtension)); + Assert.Equal(123, copy.GetExtension(Unittest.DefaultInt32Extension)); + Assert.Equal(123, copy.GetExtension(Unittest.DefaultInt64Extension)); + Assert.Equal(TestAllTypes.Types.NestedEnum.FOO, copy.GetExtension(Unittest.DefaultNestedEnumExtension)); - Assert.AreEqual(123, copy.GetExtension(Unittest.DefaultSfixed32Extension)); - Assert.AreEqual(123, copy.GetExtension(Unittest.DefaultSfixed64Extension)); - Assert.AreEqual(123, copy.GetExtension(Unittest.DefaultSint32Extension)); - Assert.AreEqual(123, copy.GetExtension(Unittest.DefaultSint64Extension)); - Assert.AreEqual("123", copy.GetExtension(Unittest.DefaultStringExtension)); - Assert.AreEqual("123", copy.GetExtension(Unittest.DefaultStringPieceExtension)); - Assert.AreEqual(123u, copy.GetExtension(Unittest.DefaultUint32Extension)); - Assert.AreEqual(123u, copy.GetExtension(Unittest.DefaultUint64Extension)); + Assert.Equal(123, copy.GetExtension(Unittest.DefaultSfixed32Extension)); + Assert.Equal(123, copy.GetExtension(Unittest.DefaultSfixed64Extension)); + Assert.Equal(123, copy.GetExtension(Unittest.DefaultSint32Extension)); + Assert.Equal(123, copy.GetExtension(Unittest.DefaultSint64Extension)); + Assert.Equal("123", copy.GetExtension(Unittest.DefaultStringExtension)); + Assert.Equal("123", copy.GetExtension(Unittest.DefaultStringPieceExtension)); + Assert.Equal(123u, copy.GetExtension(Unittest.DefaultUint32Extension)); + Assert.Equal(123u, copy.GetExtension(Unittest.DefaultUint64Extension)); - Assert.AreEqual(true, copy.GetExtension(Unittest.OptionalBoolExtension)); - Assert.AreEqual(ByteString.CopyFromUtf8("123"), copy.GetExtension(Unittest.OptionalBytesExtension)); - Assert.AreEqual("123", copy.GetExtension(Unittest.OptionalCordExtension)); - Assert.AreEqual(123, copy.GetExtension(Unittest.OptionalDoubleExtension)); - Assert.AreEqual(123u, copy.GetExtension(Unittest.OptionalFixed32Extension)); - Assert.AreEqual(123u, copy.GetExtension(Unittest.OptionalFixed64Extension)); - Assert.AreEqual(123, copy.GetExtension(Unittest.OptionalFloatExtension)); - Assert.AreEqual(ForeignEnum.FOREIGN_BAZ, copy.GetExtension(Unittest.OptionalForeignEnumExtension)); - Assert.AreEqual(ImportEnum.IMPORT_BAZ, copy.GetExtension(Unittest.OptionalImportEnumExtension)); - Assert.AreEqual(123, copy.GetExtension(Unittest.OptionalInt32Extension)); - Assert.AreEqual(123, copy.GetExtension(Unittest.OptionalInt64Extension)); - Assert.AreEqual(TestAllTypes.Types.NestedEnum.FOO, + Assert.Equal(true, copy.GetExtension(Unittest.OptionalBoolExtension)); + Assert.Equal(ByteString.CopyFromUtf8("123"), copy.GetExtension(Unittest.OptionalBytesExtension)); + Assert.Equal("123", copy.GetExtension(Unittest.OptionalCordExtension)); + Assert.Equal(123, copy.GetExtension(Unittest.OptionalDoubleExtension)); + Assert.Equal(123u, copy.GetExtension(Unittest.OptionalFixed32Extension)); + Assert.Equal(123u, copy.GetExtension(Unittest.OptionalFixed64Extension)); + Assert.Equal(123, copy.GetExtension(Unittest.OptionalFloatExtension)); + Assert.Equal(ForeignEnum.FOREIGN_BAZ, copy.GetExtension(Unittest.OptionalForeignEnumExtension)); + Assert.Equal(ImportEnum.IMPORT_BAZ, copy.GetExtension(Unittest.OptionalImportEnumExtension)); + Assert.Equal(123, copy.GetExtension(Unittest.OptionalInt32Extension)); + Assert.Equal(123, copy.GetExtension(Unittest.OptionalInt64Extension)); + Assert.Equal(TestAllTypes.Types.NestedEnum.FOO, copy.GetExtension(Unittest.OptionalNestedEnumExtension)); - Assert.AreEqual(123, copy.GetExtension(Unittest.OptionalSfixed32Extension)); - Assert.AreEqual(123, copy.GetExtension(Unittest.OptionalSfixed64Extension)); - Assert.AreEqual(123, copy.GetExtension(Unittest.OptionalSint32Extension)); - Assert.AreEqual(123, copy.GetExtension(Unittest.OptionalSint64Extension)); - Assert.AreEqual("123", copy.GetExtension(Unittest.OptionalStringExtension)); - Assert.AreEqual("123", copy.GetExtension(Unittest.OptionalStringPieceExtension)); - Assert.AreEqual(123u, copy.GetExtension(Unittest.OptionalUint32Extension)); - Assert.AreEqual(123u, copy.GetExtension(Unittest.OptionalUint64Extension)); + Assert.Equal(123, copy.GetExtension(Unittest.OptionalSfixed32Extension)); + Assert.Equal(123, copy.GetExtension(Unittest.OptionalSfixed64Extension)); + Assert.Equal(123, copy.GetExtension(Unittest.OptionalSint32Extension)); + Assert.Equal(123, copy.GetExtension(Unittest.OptionalSint64Extension)); + Assert.Equal("123", copy.GetExtension(Unittest.OptionalStringExtension)); + Assert.Equal("123", copy.GetExtension(Unittest.OptionalStringPieceExtension)); + Assert.Equal(123u, copy.GetExtension(Unittest.OptionalUint32Extension)); + Assert.Equal(123u, copy.GetExtension(Unittest.OptionalUint64Extension)); - Assert.AreEqual(true, copy.GetExtension(Unittest.RepeatedBoolExtension, 0)); - Assert.AreEqual(ByteString.CopyFromUtf8("123"), + Assert.Equal(true, copy.GetExtension(Unittest.RepeatedBoolExtension, 0)); + Assert.Equal(ByteString.CopyFromUtf8("123"), copy.GetExtension(Unittest.RepeatedBytesExtension, 0)); - Assert.AreEqual("123", copy.GetExtension(Unittest.RepeatedCordExtension, 0)); - Assert.AreEqual(123, copy.GetExtension(Unittest.RepeatedDoubleExtension, 0)); - Assert.AreEqual(123u, copy.GetExtension(Unittest.RepeatedFixed32Extension, 0)); - Assert.AreEqual(123u, copy.GetExtension(Unittest.RepeatedFixed64Extension, 0)); - Assert.AreEqual(123, copy.GetExtension(Unittest.RepeatedFloatExtension, 0)); - Assert.AreEqual(ForeignEnum.FOREIGN_BAZ, + Assert.Equal("123", copy.GetExtension(Unittest.RepeatedCordExtension, 0)); + Assert.Equal(123, copy.GetExtension(Unittest.RepeatedDoubleExtension, 0)); + Assert.Equal(123u, copy.GetExtension(Unittest.RepeatedFixed32Extension, 0)); + Assert.Equal(123u, copy.GetExtension(Unittest.RepeatedFixed64Extension, 0)); + Assert.Equal(123, copy.GetExtension(Unittest.RepeatedFloatExtension, 0)); + Assert.Equal(ForeignEnum.FOREIGN_BAZ, copy.GetExtension(Unittest.RepeatedForeignEnumExtension, 0)); - Assert.AreEqual(ImportEnum.IMPORT_BAZ, copy.GetExtension(Unittest.RepeatedImportEnumExtension, 0)); - Assert.AreEqual(123, copy.GetExtension(Unittest.RepeatedInt32Extension, 0)); - Assert.AreEqual(123, copy.GetExtension(Unittest.RepeatedInt64Extension, 0)); - Assert.AreEqual(TestAllTypes.Types.NestedEnum.FOO, + Assert.Equal(ImportEnum.IMPORT_BAZ, copy.GetExtension(Unittest.RepeatedImportEnumExtension, 0)); + Assert.Equal(123, copy.GetExtension(Unittest.RepeatedInt32Extension, 0)); + Assert.Equal(123, copy.GetExtension(Unittest.RepeatedInt64Extension, 0)); + Assert.Equal(TestAllTypes.Types.NestedEnum.FOO, copy.GetExtension(Unittest.RepeatedNestedEnumExtension, 0)); - Assert.AreEqual(123, copy.GetExtension(Unittest.RepeatedSfixed32Extension, 0)); - Assert.AreEqual(123, copy.GetExtension(Unittest.RepeatedSfixed64Extension, 0)); - Assert.AreEqual(123, copy.GetExtension(Unittest.RepeatedSint32Extension, 0)); - Assert.AreEqual(123, copy.GetExtension(Unittest.RepeatedSint64Extension, 0)); - Assert.AreEqual("123", copy.GetExtension(Unittest.RepeatedStringExtension, 0)); - Assert.AreEqual("123", copy.GetExtension(Unittest.RepeatedStringPieceExtension, 0)); - Assert.AreEqual(123u, copy.GetExtension(Unittest.RepeatedUint32Extension, 0)); - Assert.AreEqual(123u, copy.GetExtension(Unittest.RepeatedUint64Extension, 0)); + Assert.Equal(123, copy.GetExtension(Unittest.RepeatedSfixed32Extension, 0)); + Assert.Equal(123, copy.GetExtension(Unittest.RepeatedSfixed64Extension, 0)); + Assert.Equal(123, copy.GetExtension(Unittest.RepeatedSint32Extension, 0)); + Assert.Equal(123, copy.GetExtension(Unittest.RepeatedSint64Extension, 0)); + Assert.Equal("123", copy.GetExtension(Unittest.RepeatedStringExtension, 0)); + Assert.Equal("123", copy.GetExtension(Unittest.RepeatedStringPieceExtension, 0)); + Assert.Equal(123u, copy.GetExtension(Unittest.RepeatedUint32Extension, 0)); + Assert.Equal(123u, copy.GetExtension(Unittest.RepeatedUint64Extension, 0)); } } } \ No newline at end of file diff --git a/csharp/src/ProtocolBuffers.Test/GeneratedBuilderTest.cs b/csharp/src/ProtocolBuffers.Test/GeneratedBuilderTest.cs index 1dcb1c21..692bfd11 100644 --- a/csharp/src/ProtocolBuffers.Test/GeneratedBuilderTest.cs +++ b/csharp/src/ProtocolBuffers.Test/GeneratedBuilderTest.cs @@ -1,12 +1,10 @@ using System; using System.Collections.Generic; -using System.Text; using Google.ProtocolBuffers.TestProtos; -using Microsoft.VisualStudio.TestTools.UnitTesting; +using Xunit; namespace Google.ProtocolBuffers { - [TestClass] public class GeneratedBuilderTest { class OneTimeEnumerator : IEnumerable @@ -19,107 +17,86 @@ namespace Google.ProtocolBuffers } public IEnumerator GetEnumerator() { - Assert.IsFalse(_enumerated, "The collection {0} has already been enumerated", GetType()); + Assert.False(_enumerated); _enumerated = true; yield return _item; } System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() - { return GetEnumerator(); } + { + return GetEnumerator(); + } } - [TestMethod] + [Fact] public void DoesNotEnumerateTwiceForMessageList() { TestAllTypes.Builder b = new TestAllTypes.Builder(); - b.AddRangeRepeatedForeignMessage( - new OneTimeEnumerator( - ForeignMessage.DefaultInstance)); + b.AddRangeRepeatedForeignMessage(new OneTimeEnumerator(ForeignMessage.DefaultInstance)); } - [TestMethod] + + [Fact] public void DoesNotEnumerateTwiceForPrimitiveList() { TestAllTypes.Builder b = new TestAllTypes.Builder(); b.AddRangeRepeatedInt32(new OneTimeEnumerator(1)); } - [TestMethod] + + [Fact] public void DoesNotEnumerateTwiceForStringList() { TestAllTypes.Builder b = new TestAllTypes.Builder(); b.AddRangeRepeatedString(new OneTimeEnumerator("test")); } - [TestMethod] + + [Fact] public void DoesNotEnumerateTwiceForEnumList() { TestAllTypes.Builder b = new TestAllTypes.Builder(); b.AddRangeRepeatedForeignEnum(new OneTimeEnumerator(ForeignEnum.FOREIGN_BAR)); } - - private delegate void TestMethod(); - - private static void AssertThrows(TestMethod method) where T : Exception - { - try - { - method(); - } - catch (Exception error) - { - if (error is T) - return; - throw; - } - Assert.Fail("Expected exception of type " + typeof(T)); - } - - [TestMethod] + + [Fact] public void DoesNotAddNullToMessageListByAddRange() { TestAllTypes.Builder b = new TestAllTypes.Builder(); - AssertThrows( - () => b.AddRangeRepeatedForeignMessage(new ForeignMessage[] { null }) - ); + Assert.Throws(() => b.AddRangeRepeatedForeignMessage(new ForeignMessage[] { null })); } - [TestMethod] + + [Fact] public void DoesNotAddNullToMessageListByAdd() { TestAllTypes.Builder b = new TestAllTypes.Builder(); - AssertThrows( - () => b.AddRepeatedForeignMessage((ForeignMessage)null) - ); + Assert.Throws(() => b.AddRepeatedForeignMessage((ForeignMessage)null)); } - [TestMethod] + + [Fact] public void DoesNotAddNullToMessageListBySet() { TestAllTypes.Builder b = new TestAllTypes.Builder(); b.AddRepeatedForeignMessage(ForeignMessage.DefaultInstance); - AssertThrows( - () => b.SetRepeatedForeignMessage(0, (ForeignMessage)null) - ); + Assert.Throws(() => b.SetRepeatedForeignMessage(0, (ForeignMessage)null)); } - [TestMethod] + + [Fact] public void DoesNotAddNullToStringListByAddRange() { TestAllTypes.Builder b = new TestAllTypes.Builder(); - AssertThrows( - () => b.AddRangeRepeatedString(new String[] { null }) - ); + Assert.Throws(() => b.AddRangeRepeatedString(new String[] { null })); } - [TestMethod] + + [Fact] public void DoesNotAddNullToStringListByAdd() { TestAllTypes.Builder b = new TestAllTypes.Builder(); - AssertThrows( - () => b.AddRepeatedString(null) - ); + Assert.Throws(() => b.AddRepeatedString(null)); } - [TestMethod] + + [Fact] public void DoesNotAddNullToStringListBySet() { TestAllTypes.Builder b = new TestAllTypes.Builder(); b.AddRepeatedString("one"); - AssertThrows( - () => b.SetRepeatedString(0, null) - ); + Assert.Throws(() => b.SetRepeatedString(0, null)); } } } diff --git a/csharp/src/ProtocolBuffers.Test/GeneratedMessageTest.cs b/csharp/src/ProtocolBuffers.Test/GeneratedMessageTest.cs index 0e8b9807..a9052954 100644 --- a/csharp/src/ProtocolBuffers.Test/GeneratedMessageTest.cs +++ b/csharp/src/ProtocolBuffers.Test/GeneratedMessageTest.cs @@ -38,31 +38,29 @@ using System; using System.Collections.Generic; using Google.ProtocolBuffers.Collections; using Google.ProtocolBuffers.TestProtos; -using Microsoft.VisualStudio.TestTools.UnitTesting; +using Xunit; namespace Google.ProtocolBuffers { - [TestClass] public class GeneratedMessageTest { - private ReflectionTester reflectionTester; - private ReflectionTester extensionsReflectionTester; + private readonly ReflectionTester reflectionTester; + private readonly ReflectionTester extensionsReflectionTester; - [TestInitialize] - public void SetUp() + public GeneratedMessageTest() { reflectionTester = ReflectionTester.CreateTestAllTypesInstance(); extensionsReflectionTester = ReflectionTester.CreateTestAllExtensionsInstance(); } - [TestMethod] + [Fact] public void RepeatedAddPrimitiveBeforeBuild() { TestAllTypes message = new TestAllTypes.Builder {RepeatedInt32List = {1, 2, 3}}.Build(); TestUtil.AssertEqual(new int[] {1, 2, 3}, message.RepeatedInt32List); } - [TestMethod] + [Fact] public void AddPrimitiveFailsAfterBuild() { TestAllTypes.Builder builder = new TestAllTypes.Builder(); @@ -70,18 +68,10 @@ namespace Google.ProtocolBuffers list.Add(1); // Fine builder.Build(); - try - { - list.Add(2); - Assert.Fail("List should be frozen"); - } - catch (NotSupportedException) - { - // Expected - } + Assert.Throws(() => list.Add(2)); } - [TestMethod] + [Fact] public void RepeatedAddMessageBeforeBuild() { TestAllTypes message = new TestAllTypes.Builder @@ -89,36 +79,28 @@ namespace Google.ProtocolBuffers RepeatedNestedMessageList = {new TestAllTypes.Types.NestedMessage.Builder {Bb = 10}.Build()} }.Build(); - Assert.AreEqual(1, message.RepeatedNestedMessageCount); - Assert.AreEqual(10, message.RepeatedNestedMessageList[0].Bb); + Assert.Equal(1, message.RepeatedNestedMessageCount); + Assert.Equal(10, message.RepeatedNestedMessageList[0].Bb); } - [TestMethod] + [Fact] public void AddMessageFailsAfterBuild() { TestAllTypes.Builder builder = new TestAllTypes.Builder(); IList list = builder.RepeatedNestedMessageList; builder.Build(); - try - { - list.Add(new TestAllTypes.Types.NestedMessage.Builder {Bb = 10}.Build()); - Assert.Fail("List should be frozen"); - } - catch (NotSupportedException) - { - // Expected - } + Assert.Throws(() => list.Add(new TestAllTypes.Types.NestedMessage.Builder { Bb = 10 }.Build())); } - [TestMethod] + [Fact] public void DefaultInstance() { - Assert.AreSame(TestAllTypes.DefaultInstance, TestAllTypes.DefaultInstance.DefaultInstanceForType); - Assert.AreSame(TestAllTypes.DefaultInstance, TestAllTypes.CreateBuilder().DefaultInstanceForType); + Assert.Same(TestAllTypes.DefaultInstance, TestAllTypes.DefaultInstance.DefaultInstanceForType); + Assert.Same(TestAllTypes.DefaultInstance, TestAllTypes.CreateBuilder().DefaultInstanceForType); } - [TestMethod] + [Fact] public void Accessors() { TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); @@ -127,25 +109,25 @@ namespace Google.ProtocolBuffers TestUtil.AssertAllFieldsSet(message); } - [TestMethod] + [Fact] public void SettersRejectNull() { TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); - TestUtil.AssertArgumentNullException(() => builder.SetOptionalString(null)); - TestUtil.AssertArgumentNullException(() => builder.SetOptionalBytes(null)); - TestUtil.AssertArgumentNullException( + Assert.Throws(() => builder.SetOptionalString(null)); + Assert.Throws(() => builder.SetOptionalBytes(null)); + Assert.Throws( () => builder.SetOptionalNestedMessage((TestAllTypes.Types.NestedMessage) null)); - TestUtil.AssertArgumentNullException( + Assert.Throws( () => builder.SetOptionalNestedMessage((TestAllTypes.Types.NestedMessage.Builder) null)); - TestUtil.AssertArgumentNullException(() => builder.AddRepeatedString(null)); - TestUtil.AssertArgumentNullException(() => builder.AddRepeatedBytes(null)); - TestUtil.AssertArgumentNullException( + Assert.Throws(() => builder.AddRepeatedString(null)); + Assert.Throws(() => builder.AddRepeatedBytes(null)); + Assert.Throws( () => builder.AddRepeatedNestedMessage((TestAllTypes.Types.NestedMessage) null)); - TestUtil.AssertArgumentNullException( + Assert.Throws( () => builder.AddRepeatedNestedMessage((TestAllTypes.Types.NestedMessage.Builder) null)); } - [TestMethod] + [Fact] public void RepeatedSetters() { TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); @@ -155,7 +137,7 @@ namespace Google.ProtocolBuffers TestUtil.AssertRepeatedFieldsModified(message); } - [TestMethod] + [Fact] public void RepeatedAppend() { TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); @@ -169,26 +151,26 @@ namespace Google.ProtocolBuffers TestAllTypes message = builder.Build(); TestUtil.AssertEqual(message.RepeatedInt32List, new int[] {1, 2, 3, 4}); TestUtil.AssertEqual(message.RepeatedForeignEnumList, new ForeignEnum[] {ForeignEnum.FOREIGN_BAZ}); - Assert.AreEqual(1, message.RepeatedForeignMessageCount); - Assert.AreEqual(12, message.GetRepeatedForeignMessage(0).C); + Assert.Equal(1, message.RepeatedForeignMessageCount); + Assert.Equal(12, message.GetRepeatedForeignMessage(0).C); } - [TestMethod] + [Fact] public void RepeatedAppendRejectsNull() { TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); ForeignMessage foreignMessage = ForeignMessage.CreateBuilder().SetC(12).Build(); - TestUtil.AssertArgumentNullException( + Assert.Throws( () => builder.AddRangeRepeatedForeignMessage(new[] {foreignMessage, null})); - TestUtil.AssertArgumentNullException(() => builder.AddRangeRepeatedForeignMessage(null)); - TestUtil.AssertArgumentNullException(() => builder.AddRangeRepeatedForeignEnum(null)); - TestUtil.AssertArgumentNullException(() => builder.AddRangeRepeatedString(new[] {"one", null})); - TestUtil.AssertArgumentNullException( + Assert.Throws(() => builder.AddRangeRepeatedForeignMessage(null)); + Assert.Throws(() => builder.AddRangeRepeatedForeignEnum(null)); + Assert.Throws(() => builder.AddRangeRepeatedString(new[] {"one", null})); + Assert.Throws( () => builder.AddRangeRepeatedBytes(new[] {TestUtil.ToBytes("one"), null})); } - [TestMethod] + [Fact] public void SettingForeignMessageUsingBuilder() { TestAllTypes message = TestAllTypes.CreateBuilder() @@ -199,10 +181,10 @@ namespace Google.ProtocolBuffers // Create expected version passing foreign message instance explicitly. .SetOptionalForeignMessage(ForeignMessage.CreateBuilder().SetC(123).Build()) .Build(); - Assert.AreEqual(expectedMessage, message); + Assert.Equal(expectedMessage, message); } - [TestMethod] + [Fact] public void SettingRepeatedForeignMessageUsingBuilder() { TestAllTypes message = TestAllTypes.CreateBuilder() @@ -213,10 +195,10 @@ namespace Google.ProtocolBuffers // Create expected version passing foreign message instance explicitly. .AddRepeatedForeignMessage(ForeignMessage.CreateBuilder().SetC(456).Build()) .Build(); - Assert.AreEqual(expectedMessage, message); + Assert.Equal(expectedMessage, message); } - [TestMethod] + [Fact] public void SettingRepeatedValuesUsingRangeInCollectionInitializer() { int[] values = {1, 2, 3}; @@ -224,29 +206,29 @@ namespace Google.ProtocolBuffers { RepeatedSint32List = {values} }.Build(); - Assert.IsTrue(Lists.Equals(values, message.RepeatedSint32List)); + Assert.True(Lists.Equals(values, message.RepeatedSint32List)); } - [TestMethod] + [Fact] public void SettingRepeatedValuesUsingIndividualValuesInCollectionInitializer() { TestAllTypes message = new TestAllTypes.Builder { RepeatedSint32List = {6, 7} }.Build(); - Assert.IsTrue(Lists.Equals(new int[] {6, 7}, message.RepeatedSint32List)); + Assert.True(Lists.Equals(new int[] {6, 7}, message.RepeatedSint32List)); } - [TestMethod] + [Fact] public void Defaults() { TestUtil.AssertClear(TestAllTypes.DefaultInstance); TestUtil.AssertClear(TestAllTypes.CreateBuilder().Build()); - Assert.AreEqual("\u1234", TestExtremeDefaultValues.DefaultInstance.Utf8String); + Assert.Equal("\u1234", TestExtremeDefaultValues.DefaultInstance.Utf8String); } - [TestMethod] + [Fact] public void ReflectionGetters() { TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); @@ -255,7 +237,7 @@ namespace Google.ProtocolBuffers reflectionTester.AssertAllFieldsSetViaReflection(message); } - [TestMethod] + [Fact] public void ReflectionSetters() { TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); @@ -264,7 +246,7 @@ namespace Google.ProtocolBuffers TestUtil.AssertAllFieldsSet(message); } - [TestMethod] + [Fact] public void ReflectionClear() { TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); @@ -274,14 +256,14 @@ namespace Google.ProtocolBuffers TestUtil.AssertClear(message); } - [TestMethod] + [Fact] public void ReflectionSettersRejectNull() { TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); reflectionTester.AssertReflectionSettersRejectNull(builder); } - [TestMethod] + [Fact] public void ReflectionRepeatedSetters() { TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); @@ -291,14 +273,14 @@ namespace Google.ProtocolBuffers TestUtil.AssertRepeatedFieldsModified(message); } - [TestMethod] + [Fact] public void TestReflectionRepeatedSettersRejectNull() { TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); reflectionTester.AssertReflectionRepeatedSettersRejectNull(builder); } - [TestMethod] + [Fact] public void ReflectionDefaults() { TestUtil.TestInMultipleCultures(() => @@ -313,7 +295,7 @@ namespace Google.ProtocolBuffers // ================================================================= // Extensions. - [TestMethod] + [Fact] public void ExtensionAccessors() { TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder(); @@ -322,7 +304,7 @@ namespace Google.ProtocolBuffers TestUtil.AssertAllExtensionsSet(message); } - [TestMethod] + [Fact] public void ExtensionRepeatedSetters() { TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder(); @@ -332,14 +314,14 @@ namespace Google.ProtocolBuffers TestUtil.AssertRepeatedExtensionsModified(message); } - [TestMethod] + [Fact] public void ExtensionDefaults() { TestUtil.AssertExtensionsClear(TestAllExtensions.DefaultInstance); TestUtil.AssertExtensionsClear(TestAllExtensions.CreateBuilder().Build()); } - [TestMethod] + [Fact] public void ExtensionReflectionGetters() { TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder(); @@ -348,7 +330,7 @@ namespace Google.ProtocolBuffers extensionsReflectionTester.AssertAllFieldsSetViaReflection(message); } - [TestMethod] + [Fact] public void ExtensionReflectionSetters() { TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder(); @@ -357,14 +339,14 @@ namespace Google.ProtocolBuffers TestUtil.AssertAllExtensionsSet(message); } - [TestMethod] + [Fact] public void ExtensionReflectionSettersRejectNull() { TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder(); extensionsReflectionTester.AssertReflectionSettersRejectNull(builder); } - [TestMethod] + [Fact] public void ExtensionReflectionRepeatedSetters() { TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder(); @@ -374,14 +356,14 @@ namespace Google.ProtocolBuffers TestUtil.AssertRepeatedExtensionsModified(message); } - [TestMethod] + [Fact] public void ExtensionReflectionRepeatedSettersRejectNull() { TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder(); extensionsReflectionTester.AssertReflectionRepeatedSettersRejectNull(builder); } - [TestMethod] + [Fact] public void ExtensionReflectionDefaults() { TestUtil.TestInMultipleCultures(() => @@ -393,33 +375,33 @@ namespace Google.ProtocolBuffers }); } - [TestMethod] + [Fact] public void ClearExtension() { // ClearExtension() is not actually used in TestUtil, so try it manually. - Assert.IsFalse(TestAllExtensions.CreateBuilder() + Assert.False(TestAllExtensions.CreateBuilder() .SetExtension(Unittest.OptionalInt32Extension, 1) .ClearExtension(Unittest.OptionalInt32Extension) .HasExtension(Unittest.OptionalInt32Extension)); - Assert.AreEqual(0, TestAllExtensions.CreateBuilder() + Assert.Equal(0, TestAllExtensions.CreateBuilder() .AddExtension(Unittest.RepeatedInt32Extension, 1) .ClearExtension(Unittest.RepeatedInt32Extension) .GetExtensionCount(Unittest.RepeatedInt32Extension)); } - [TestMethod] + [Fact] public void ExtensionMergeFrom() { TestAllExtensions original = TestAllExtensions.CreateBuilder() .SetExtension(Unittest.OptionalInt32Extension, 1).Build(); TestAllExtensions merged = TestAllExtensions.CreateBuilder().MergeFrom(original).Build(); - Assert.IsTrue((merged.HasExtension(Unittest.OptionalInt32Extension))); - Assert.AreEqual(1, (int) merged.GetExtension(Unittest.OptionalInt32Extension)); + Assert.True((merged.HasExtension(Unittest.OptionalInt32Extension))); + Assert.Equal(1, (int) merged.GetExtension(Unittest.OptionalInt32Extension)); } /* Removed multiple files option for the moment - [TestMethod] + [Fact] public void MultipleFilesOption() { // We mostly just want to check that things compile. MessageWithNoOuter message = MessageWithNoOuter.CreateBuilder() @@ -428,63 +410,63 @@ namespace Google.ProtocolBuffers .SetNestedEnum(MessageWithNoOuter.Types.NestedEnum.BAZ) .SetForeignEnum(EnumWithNoOuter.BAR) .Build(); - Assert.AreEqual(message, MessageWithNoOuter.ParseFrom(message.ToByteString())); + Assert.Equal(message, MessageWithNoOuter.ParseFrom(message.ToByteString())); - Assert.AreEqual(MultiFileProto.DescriptorProtoFile, MessageWithNoOuter.DescriptorProtoFile.File); + Assert.Equal(MultiFileProto.DescriptorProtoFile, MessageWithNoOuter.DescriptorProtoFile.File); FieldDescriptor field = MessageWithNoOuter.DescriptorProtoFile.FindDescriptor("foreign_enum"); - Assert.AreEqual(MultiFileProto.DescriptorProtoFile.FindTypeByName("EnumWithNoOuter") + Assert.Equal(MultiFileProto.DescriptorProtoFile.FindTypeByName("EnumWithNoOuter") .FindValueByNumber((int)EnumWithNoOuter.BAR), message[field]); - Assert.AreEqual(MultiFileProto.DescriptorProtoFile, ServiceWithNoOuter.DescriptorProtoFile.File); + Assert.Equal(MultiFileProto.DescriptorProtoFile, ServiceWithNoOuter.DescriptorProtoFile.File); - Assert.IsFalse(TestAllExtensions.DefaultInstance.HasExtension(MultiFileProto.ExtensionWithOuter)); + Assert.False(TestAllExtensions.DefaultInstance.HasExtension(MultiFileProto.ExtensionWithOuter)); }*/ - [TestMethod] + [Fact] public void OptionalFieldWithRequiredSubfieldsOptimizedForSize() { TestOptionalOptimizedForSize message = TestOptionalOptimizedForSize.DefaultInstance; - Assert.IsTrue(message.IsInitialized); + Assert.True(message.IsInitialized); message = TestOptionalOptimizedForSize.CreateBuilder().SetO( TestRequiredOptimizedForSize.CreateBuilder().BuildPartial() ).BuildPartial(); - Assert.IsFalse(message.IsInitialized); + Assert.False(message.IsInitialized); message = TestOptionalOptimizedForSize.CreateBuilder().SetO( TestRequiredOptimizedForSize.CreateBuilder().SetX(5).BuildPartial() ).BuildPartial(); - Assert.IsTrue(message.IsInitialized); + Assert.True(message.IsInitialized); } - [TestMethod] + [Fact] public void OptimizedForSizeMergeUsesAllFieldsFromTarget() { TestOptimizedForSize withFieldSet = new TestOptimizedForSize.Builder {I = 10}.Build(); TestOptimizedForSize.Builder builder = new TestOptimizedForSize.Builder(); builder.MergeFrom(withFieldSet); TestOptimizedForSize built = builder.Build(); - Assert.AreEqual(10, built.I); + Assert.Equal(10, built.I); } - [TestMethod] + [Fact] public void UninitializedExtensionInOptimizedForSizeMakesMessageUninitialized() { TestOptimizedForSize.Builder builder = new TestOptimizedForSize.Builder(); builder.SetExtension(TestOptimizedForSize.TestExtension2, new TestRequiredOptimizedForSize.Builder().BuildPartial()); - Assert.IsFalse(builder.IsInitialized); - Assert.IsFalse(builder.BuildPartial().IsInitialized); + Assert.False(builder.IsInitialized); + Assert.False(builder.BuildPartial().IsInitialized); builder = new TestOptimizedForSize.Builder(); builder.SetExtension(TestOptimizedForSize.TestExtension2, new TestRequiredOptimizedForSize.Builder {X = 10}.BuildPartial()); - Assert.IsTrue(builder.IsInitialized); - Assert.IsTrue(builder.BuildPartial().IsInitialized); + Assert.True(builder.IsInitialized); + Assert.True(builder.BuildPartial().IsInitialized); } - [TestMethod] + [Fact] public void ToBuilder() { TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); @@ -493,40 +475,40 @@ namespace Google.ProtocolBuffers TestUtil.AssertAllFieldsSet(message.ToBuilder().Build()); } - [TestMethod] + [Fact] public void FieldConstantValues() { - Assert.AreEqual(TestAllTypes.Types.NestedMessage.BbFieldNumber, 1); - Assert.AreEqual(TestAllTypes.OptionalInt32FieldNumber, 1); - Assert.AreEqual(TestAllTypes.OptionalGroupFieldNumber, 16); - Assert.AreEqual(TestAllTypes.OptionalNestedMessageFieldNumber, 18); - Assert.AreEqual(TestAllTypes.OptionalNestedEnumFieldNumber, 21); - Assert.AreEqual(TestAllTypes.RepeatedInt32FieldNumber, 31); - Assert.AreEqual(TestAllTypes.RepeatedGroupFieldNumber, 46); - Assert.AreEqual(TestAllTypes.RepeatedNestedMessageFieldNumber, 48); - Assert.AreEqual(TestAllTypes.RepeatedNestedEnumFieldNumber, 51); + Assert.Equal(TestAllTypes.Types.NestedMessage.BbFieldNumber, 1); + Assert.Equal(TestAllTypes.OptionalInt32FieldNumber, 1); + Assert.Equal(TestAllTypes.OptionalGroupFieldNumber, 16); + Assert.Equal(TestAllTypes.OptionalNestedMessageFieldNumber, 18); + Assert.Equal(TestAllTypes.OptionalNestedEnumFieldNumber, 21); + Assert.Equal(TestAllTypes.RepeatedInt32FieldNumber, 31); + Assert.Equal(TestAllTypes.RepeatedGroupFieldNumber, 46); + Assert.Equal(TestAllTypes.RepeatedNestedMessageFieldNumber, 48); + Assert.Equal(TestAllTypes.RepeatedNestedEnumFieldNumber, 51); } - [TestMethod] + [Fact] public void ExtensionConstantValues() { - Assert.AreEqual(TestRequired.SingleFieldNumber, 1000); - Assert.AreEqual(TestRequired.MultiFieldNumber, 1001); - Assert.AreEqual(Unittest.OptionalInt32ExtensionFieldNumber, 1); - Assert.AreEqual(Unittest.OptionalGroupExtensionFieldNumber, 16); - Assert.AreEqual(Unittest.OptionalNestedMessageExtensionFieldNumber, 18); - Assert.AreEqual(Unittest.OptionalNestedEnumExtensionFieldNumber, 21); - Assert.AreEqual(Unittest.RepeatedInt32ExtensionFieldNumber, 31); - Assert.AreEqual(Unittest.RepeatedGroupExtensionFieldNumber, 46); - Assert.AreEqual(Unittest.RepeatedNestedMessageExtensionFieldNumber, 48); - Assert.AreEqual(Unittest.RepeatedNestedEnumExtensionFieldNumber, 51); + Assert.Equal(TestRequired.SingleFieldNumber, 1000); + Assert.Equal(TestRequired.MultiFieldNumber, 1001); + Assert.Equal(Unittest.OptionalInt32ExtensionFieldNumber, 1); + Assert.Equal(Unittest.OptionalGroupExtensionFieldNumber, 16); + Assert.Equal(Unittest.OptionalNestedMessageExtensionFieldNumber, 18); + Assert.Equal(Unittest.OptionalNestedEnumExtensionFieldNumber, 21); + Assert.Equal(Unittest.RepeatedInt32ExtensionFieldNumber, 31); + Assert.Equal(Unittest.RepeatedGroupExtensionFieldNumber, 46); + Assert.Equal(Unittest.RepeatedNestedMessageExtensionFieldNumber, 48); + Assert.Equal(Unittest.RepeatedNestedEnumExtensionFieldNumber, 51); } - [TestMethod] + [Fact] public void EmptyPackedValue() { TestPackedTypes empty = new TestPackedTypes.Builder().Build(); - Assert.AreEqual(0, empty.SerializedSize); + Assert.Equal(0, empty.SerializedSize); } } } \ No newline at end of file diff --git a/csharp/src/ProtocolBuffers.Test/IssuesTest.cs b/csharp/src/ProtocolBuffers.Test/IssuesTest.cs index a80021c5..afd93f86 100644 --- a/csharp/src/ProtocolBuffers.Test/IssuesTest.cs +++ b/csharp/src/ProtocolBuffers.Test/IssuesTest.cs @@ -35,13 +35,9 @@ #endregion -using System; -using System.Collections.Generic; -using Google.ProtocolBuffers.Collections; using Google.ProtocolBuffers.Descriptors; -using Google.ProtocolBuffers.TestProtos; -using Microsoft.VisualStudio.TestTools.UnitTesting; using UnitTest.Issues.TestProtos; +using Xunit; namespace Google.ProtocolBuffers @@ -49,17 +45,16 @@ namespace Google.ProtocolBuffers /// /// Tests for issues which aren't easily compartmentalized into other unit tests. /// - [TestClass] public class IssuesTest { // Issue 45 - [TestMethod] + [Fact] public void FieldCalledItem() { ItemField message = new ItemField.Builder { Item = 3 }.Build(); FieldDescriptor field = ItemField.Descriptor.FindFieldByName("item"); - Assert.IsNotNull(field); - Assert.AreEqual(3, (int)message[field]); + Assert.NotNull(field); + Assert.Equal(3, (int)message[field]); } } } diff --git a/csharp/src/ProtocolBuffers.Test/MessageStreamIteratorTest.cs b/csharp/src/ProtocolBuffers.Test/MessageStreamIteratorTest.cs index 78f059f7..7304861a 100644 --- a/csharp/src/ProtocolBuffers.Test/MessageStreamIteratorTest.cs +++ b/csharp/src/ProtocolBuffers.Test/MessageStreamIteratorTest.cs @@ -37,28 +37,27 @@ using System.Collections.Generic; using System.IO; using Google.ProtocolBuffers.TestProtos; -using Microsoft.VisualStudio.TestTools.UnitTesting; +using Xunit; using NestedMessage = Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage; namespace Google.ProtocolBuffers { - [TestClass] public class MessageStreamIteratorTest { - [TestMethod] + [Fact] public void ThreeMessagesInMemory() { MemoryStream stream = new MemoryStream(MessageStreamWriterTest.ThreeMessageData); IEnumerable iterator = MessageStreamIterator.FromStreamProvider(() => stream); List messages = new List(iterator); - Assert.AreEqual(3, messages.Count); - Assert.AreEqual(5, messages[0].Bb); - Assert.AreEqual(1500, messages[1].Bb); - Assert.IsFalse(messages[2].HasBb); + Assert.Equal(3, messages.Count); + Assert.Equal(5, messages[0].Bb); + Assert.Equal(1500, messages[1].Bb); + Assert.False(messages[2].HasBb); } - [TestMethod] + [Fact] public void ManyMessagesShouldNotTriggerSizeAlert() { int messageSize = TestUtil.GetAllSet().SerializedSize; @@ -84,7 +83,7 @@ namespace Google.ProtocolBuffers count++; TestUtil.AssertAllFieldsSet(message); } - Assert.AreEqual(correctCount, count); + Assert.Equal(correctCount, count); } } } diff --git a/csharp/src/ProtocolBuffers.Test/MessageStreamWriterTest.cs b/csharp/src/ProtocolBuffers.Test/MessageStreamWriterTest.cs index 53772523..3bcc5ff6 100644 --- a/csharp/src/ProtocolBuffers.Test/MessageStreamWriterTest.cs +++ b/csharp/src/ProtocolBuffers.Test/MessageStreamWriterTest.cs @@ -35,12 +35,11 @@ #endregion using System.IO; -using Microsoft.VisualStudio.TestTools.UnitTesting; +using Xunit; using NestedMessage = Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage; namespace Google.ProtocolBuffers { - [TestClass] public class MessageStreamWriterTest { internal static readonly byte[] ThreeMessageData = new byte[] @@ -55,7 +54,7 @@ namespace Google.ProtocolBuffers (1 << 3) | 2, 0, // Field 1, no data (third message) }; - [TestMethod] + [Fact] public void ThreeMessages() { NestedMessage message1 = new NestedMessage.Builder {Bb = 5}.Build(); diff --git a/csharp/src/ProtocolBuffers.Test/MessageTest.cs b/csharp/src/ProtocolBuffers.Test/MessageTest.cs index 8bb0fac7..8c8e6445 100644 --- a/csharp/src/ProtocolBuffers.Test/MessageTest.cs +++ b/csharp/src/ProtocolBuffers.Test/MessageTest.cs @@ -37,7 +37,7 @@ using System.IO; using Google.ProtocolBuffers.Descriptors; using Google.ProtocolBuffers.TestProtos; -using Microsoft.VisualStudio.TestTools.UnitTesting; +using Xunit; namespace Google.ProtocolBuffers { @@ -45,7 +45,6 @@ namespace Google.ProtocolBuffers /// Miscellaneous tests for message operations that apply to both /// generated and dynamic messages. /// - [TestClass] public class MessageTest { // ================================================================= @@ -77,12 +76,12 @@ namespace Google.ProtocolBuffers "repeated_string: \"qux\"\n" + "repeated_string: \"bar\"\n"; - [TestMethod] + [Fact] public void MergeFrom() { TestAllTypes result = TestAllTypes.CreateBuilder(MergeDest).MergeFrom(MergeSource).Build(); - Assert.AreEqual(MergeResultText, result.ToString()); + Assert.Equal(MergeResultText, result.ToString()); } /// @@ -90,20 +89,20 @@ namespace Google.ProtocolBuffers /// As long as they have the same descriptor, this should work, but it is an /// entirely different code path. /// - [TestMethod] + [Fact] public void MergeFromDynamic() { TestAllTypes result = (TestAllTypes) TestAllTypes.CreateBuilder(MergeDest) .MergeFrom(DynamicMessage.CreateBuilder(MergeSource).Build()) .Build(); - Assert.AreEqual(MergeResultText, result.ToString()); + Assert.Equal(MergeResultText, result.ToString()); } /// /// Test merging two DynamicMessages. /// - [TestMethod] + [Fact] public void DynamicMergeFrom() { DynamicMessage result = (DynamicMessage) DynamicMessage.CreateBuilder(MergeDest) @@ -112,7 +111,7 @@ namespace Google.ProtocolBuffers DynamicMessage.CreateBuilder(MergeSource).Build()) .Build(); - Assert.AreEqual(MergeResultText, result.ToString()); + Assert.Equal(MergeResultText, result.ToString()); } // ================================================================= @@ -127,157 +126,143 @@ namespace Google.ProtocolBuffers C = 3 }.Build(); - [TestMethod] + [Fact] public void Initialization() { TestRequired.Builder builder = TestRequired.CreateBuilder(); - Assert.IsFalse(builder.IsInitialized); + Assert.False(builder.IsInitialized); builder.A = 1; - Assert.IsFalse(builder.IsInitialized); + Assert.False(builder.IsInitialized); builder.B = 1; - Assert.IsFalse(builder.IsInitialized); + Assert.False(builder.IsInitialized); builder.C = 1; - Assert.IsTrue(builder.IsInitialized); + Assert.True(builder.IsInitialized); } - [TestMethod] + [Fact] public void UninitializedBuilderToString() { TestRequired.Builder builder = TestRequired.CreateBuilder().SetA(1); - Assert.AreEqual("a: 1\n", builder.ToString()); + Assert.Equal("a: 1\n", builder.ToString()); } - [TestMethod] + [Fact] public void RequiredForeign() { TestRequiredForeign.Builder builder = TestRequiredForeign.CreateBuilder(); - Assert.IsTrue(builder.IsInitialized); + Assert.True(builder.IsInitialized); builder.SetOptionalMessage(TestRequiredUninitialized); - Assert.IsFalse(builder.IsInitialized); + Assert.False(builder.IsInitialized); builder.SetOptionalMessage(TestRequiredInitialized); - Assert.IsTrue(builder.IsInitialized); + Assert.True(builder.IsInitialized); builder.AddRepeatedMessage(TestRequiredUninitialized); - Assert.IsFalse(builder.IsInitialized); + Assert.False(builder.IsInitialized); builder.SetRepeatedMessage(0, TestRequiredInitialized); - Assert.IsTrue(builder.IsInitialized); + Assert.True(builder.IsInitialized); } - [TestMethod] + [Fact] public void RequiredExtension() { TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder(); - Assert.IsTrue(builder.IsInitialized); + Assert.True(builder.IsInitialized); builder.SetExtension(TestRequired.Single, TestRequiredUninitialized); - Assert.IsFalse(builder.IsInitialized); + Assert.False(builder.IsInitialized); builder.SetExtension(TestRequired.Single, TestRequiredInitialized); - Assert.IsTrue(builder.IsInitialized); + Assert.True(builder.IsInitialized); builder.AddExtension(TestRequired.Multi, TestRequiredUninitialized); - Assert.IsFalse(builder.IsInitialized); + Assert.False(builder.IsInitialized); builder.SetExtension(TestRequired.Multi, 0, TestRequiredInitialized); - Assert.IsTrue(builder.IsInitialized); + Assert.True(builder.IsInitialized); } - [TestMethod] + [Fact] public void RequiredDynamic() { MessageDescriptor descriptor = TestRequired.Descriptor; DynamicMessage.Builder builder = DynamicMessage.CreateBuilder(descriptor); - Assert.IsFalse(builder.IsInitialized); + Assert.False(builder.IsInitialized); builder[descriptor.FindDescriptor("a")] = 1; - Assert.IsFalse(builder.IsInitialized); + Assert.False(builder.IsInitialized); builder[descriptor.FindDescriptor("b")] = 1; - Assert.IsFalse(builder.IsInitialized); + Assert.False(builder.IsInitialized); builder[descriptor.FindDescriptor("c")] = 1; - Assert.IsTrue(builder.IsInitialized); + Assert.True(builder.IsInitialized); } - [TestMethod] + [Fact] public void RequiredDynamicForeign() { MessageDescriptor descriptor = TestRequiredForeign.Descriptor; DynamicMessage.Builder builder = DynamicMessage.CreateBuilder(descriptor); - Assert.IsTrue(builder.IsInitialized); + Assert.True(builder.IsInitialized); builder[descriptor.FindDescriptor("optional_message")] = TestRequiredUninitialized; - Assert.IsFalse(builder.IsInitialized); + Assert.False(builder.IsInitialized); builder[descriptor.FindDescriptor("optional_message")] = TestRequiredInitialized; - Assert.IsTrue(builder.IsInitialized); + Assert.True(builder.IsInitialized); builder.AddRepeatedField(descriptor.FindDescriptor("repeated_message"), TestRequiredUninitialized); - Assert.IsFalse(builder.IsInitialized); + Assert.False(builder.IsInitialized); builder.SetRepeatedField(descriptor.FindDescriptor("repeated_message"), 0, TestRequiredInitialized); - Assert.IsTrue(builder.IsInitialized); + Assert.True(builder.IsInitialized); } - [TestMethod] + [Fact] public void UninitializedException() { - try - { - TestRequired.CreateBuilder().Build(); - Assert.Fail("Should have thrown an exception."); - } - catch (UninitializedMessageException e) - { - Assert.AreEqual("Message missing required fields: a, b, c", e.Message); - } + var e = Assert.Throws(() => TestRequired.CreateBuilder().Build()); + Assert.Equal("Message missing required fields: a, b, c", e.Message); } - [TestMethod] + [Fact] public void BuildPartial() { // We're mostly testing that no exception is thrown. TestRequired message = TestRequired.CreateBuilder().BuildPartial(); - Assert.IsFalse(message.IsInitialized); + Assert.False(message.IsInitialized); } - [TestMethod] + [Fact] public void NestedUninitializedException() { - try - { - TestRequiredForeign.CreateBuilder() + var e = Assert.Throws(() => TestRequiredForeign.CreateBuilder() .SetOptionalMessage(TestRequiredUninitialized) .AddRepeatedMessage(TestRequiredUninitialized) .AddRepeatedMessage(TestRequiredUninitialized) - .Build(); - Assert.Fail("Should have thrown an exception."); - } - catch (UninitializedMessageException e) - { - Assert.AreEqual( - "Message missing required fields: " + - "optional_message.a, " + - "optional_message.b, " + - "optional_message.c, " + - "repeated_message[0].a, " + - "repeated_message[0].b, " + - "repeated_message[0].c, " + - "repeated_message[1].a, " + - "repeated_message[1].b, " + - "repeated_message[1].c", - e.Message); - } + .Build()); + Assert.Equal( + "Message missing required fields: " + + "optional_message.a, " + + "optional_message.b, " + + "optional_message.c, " + + "repeated_message[0].a, " + + "repeated_message[0].b, " + + "repeated_message[0].c, " + + "repeated_message[1].a, " + + "repeated_message[1].b, " + + "repeated_message[1].c", + e.Message); } - [TestMethod] + [Fact] public void BuildNestedPartial() { // We're mostly testing that no exception is thrown. @@ -287,24 +272,17 @@ namespace Google.ProtocolBuffers .AddRepeatedMessage(TestRequiredUninitialized) .AddRepeatedMessage(TestRequiredUninitialized) .BuildPartial(); - Assert.IsFalse(message.IsInitialized); + Assert.False(message.IsInitialized); } - [TestMethod] - public void ParseUnititialized() + [Fact] + public void ParseUninitialized() { - try - { - TestRequired.ParseFrom(ByteString.Empty); - Assert.Fail("Should have thrown an exception."); - } - catch (InvalidProtocolBufferException e) - { - Assert.AreEqual("Message missing required fields: a, b, c", e.Message); - } + var e = Assert.Throws(() => TestRequired.ParseFrom(ByteString.Empty)); + Assert.Equal("Message missing required fields: a, b, c", e.Message); } - [TestMethod] + [Fact] public void ParseNestedUnititialized() { ByteString data = @@ -314,66 +292,45 @@ namespace Google.ProtocolBuffers .AddRepeatedMessage(TestRequiredUninitialized) .BuildPartial().ToByteString(); - try - { - TestRequiredForeign.ParseFrom(data); - Assert.Fail("Should have thrown an exception."); - } - catch (InvalidProtocolBufferException e) - { - Assert.AreEqual( - "Message missing required fields: " + - "optional_message.a, " + - "optional_message.b, " + - "optional_message.c, " + - "repeated_message[0].a, " + - "repeated_message[0].b, " + - "repeated_message[0].c, " + - "repeated_message[1].a, " + - "repeated_message[1].b, " + - "repeated_message[1].c", - e.Message); - } + var e = Assert.Throws(() => TestRequiredForeign.ParseFrom(data)); + Assert.Equal( + "Message missing required fields: " + + "optional_message.a, " + + "optional_message.b, " + + "optional_message.c, " + + "repeated_message[0].a, " + + "repeated_message[0].b, " + + "repeated_message[0].c, " + + "repeated_message[1].a, " + + "repeated_message[1].b, " + + "repeated_message[1].c", + e.Message); } - [TestMethod] + [Fact] public void DynamicUninitializedException() { - try - { - DynamicMessage.CreateBuilder(TestRequired.Descriptor).Build(); - Assert.Fail("Should have thrown an exception."); - } - catch (UninitializedMessageException e) - { - Assert.AreEqual("Message missing required fields: a, b, c", e.Message); - } + var e = Assert.Throws(() => DynamicMessage.CreateBuilder(TestRequired.Descriptor).Build()); + Assert.Equal("Message missing required fields: a, b, c", e.Message); } - [TestMethod] + [Fact] public void DynamicBuildPartial() { // We're mostly testing that no exception is thrown. DynamicMessage message = DynamicMessage.CreateBuilder(TestRequired.Descriptor).BuildPartial(); - Assert.IsFalse(message.Initialized); + Assert.False(message.Initialized); } - [TestMethod] + [Fact] public void DynamicParseUnititialized() { - try - { - MessageDescriptor descriptor = TestRequired.Descriptor; - DynamicMessage.ParseFrom(descriptor, ByteString.Empty); - Assert.Fail("Should have thrown an exception."); - } - catch (InvalidProtocolBufferException e) - { - Assert.AreEqual("Message missing required fields: a, b, c", e.Message); - } + MessageDescriptor descriptor = TestRequired.Descriptor; + var e = Assert.Throws(() => DynamicMessage.ParseFrom(descriptor, ByteString.Empty)); + Assert.Equal("Message missing required fields: a, b, c", e.Message); } - [TestMethod] + [Fact] public void PackedTypesWrittenDirectlyToStream() { TestPackedTypes message = new TestPackedTypes.Builder {PackedInt32List = {0, 1, 2}}.Build(); @@ -381,7 +338,7 @@ namespace Google.ProtocolBuffers message.WriteTo(stream); stream.Position = 0; TestPackedTypes readMessage = TestPackedTypes.ParseFrom(stream); - Assert.AreEqual(message, readMessage); + Assert.Equal(message, readMessage); } } } \ No newline at end of file diff --git a/csharp/src/ProtocolBuffers.Test/MessageUtilTest.cs b/csharp/src/ProtocolBuffers.Test/MessageUtilTest.cs index 4c33dbbd..186d9399 100644 --- a/csharp/src/ProtocolBuffers.Test/MessageUtilTest.cs +++ b/csharp/src/ProtocolBuffers.Test/MessageUtilTest.cs @@ -36,52 +36,47 @@ using System; using Google.ProtocolBuffers.TestProtos; -using Microsoft.VisualStudio.TestTools.UnitTesting; +using Xunit; namespace Google.ProtocolBuffers { - [TestClass] public class MessageUtilTest { - [TestMethod] - [ExpectedException(typeof(ArgumentNullException))] + [Fact] public void NullTypeName() { - MessageUtil.GetDefaultMessage((string) null); + Assert.Throws(() => MessageUtil.GetDefaultMessage((string) null)); } - [TestMethod] - [ExpectedException(typeof(ArgumentException))] + [Fact] public void InvalidTypeName() { - MessageUtil.GetDefaultMessage("invalidtypename"); + Assert.Throws(() => MessageUtil.GetDefaultMessage("invalidtypename")); } - [TestMethod] + [Fact] public void ValidTypeName() { - Assert.AreSame(TestAllTypes.DefaultInstance, + Assert.Same(TestAllTypes.DefaultInstance, MessageUtil.GetDefaultMessage(typeof(TestAllTypes).AssemblyQualifiedName)); } - [TestMethod] - [ExpectedException(typeof(ArgumentNullException))] + [Fact] public void NullType() { - MessageUtil.GetDefaultMessage((Type) null); + Assert.Throws(() => MessageUtil.GetDefaultMessage((Type)null)); } - [TestMethod] - [ExpectedException(typeof(ArgumentException))] + [Fact] public void NonMessageType() { - MessageUtil.GetDefaultMessage(typeof(string)); + Assert.Throws(() => MessageUtil.GetDefaultMessage(typeof(string))); } - [TestMethod] + [Fact] public void ValidType() { - Assert.AreSame(TestAllTypes.DefaultInstance, MessageUtil.GetDefaultMessage(typeof(TestAllTypes))); + Assert.Same(TestAllTypes.DefaultInstance, MessageUtil.GetDefaultMessage(typeof(TestAllTypes))); } } } \ No newline at end of file diff --git a/csharp/src/ProtocolBuffers.Test/NameHelpersTest.cs b/csharp/src/ProtocolBuffers.Test/NameHelpersTest.cs index 50ab373d..034bbf1c 100644 --- a/csharp/src/ProtocolBuffers.Test/NameHelpersTest.cs +++ b/csharp/src/ProtocolBuffers.Test/NameHelpersTest.cs @@ -34,49 +34,48 @@ #endregion -using Microsoft.VisualStudio.TestTools.UnitTesting; +using Xunit; namespace Google.ProtocolBuffers { - [TestClass] public class NameHelpersTest { - [TestMethod] + [Fact] public void UnderscoresToPascalCase() { - Assert.AreEqual("FooBar", NameHelpers.UnderscoresToPascalCase("Foo_bar")); - Assert.AreEqual("FooBar", NameHelpers.UnderscoresToPascalCase("foo_bar")); - Assert.AreEqual("Foo0Bar", NameHelpers.UnderscoresToPascalCase("Foo0bar")); - Assert.AreEqual("FooBar", NameHelpers.UnderscoresToPascalCase("Foo_+_Bar")); + Assert.Equal("FooBar", NameHelpers.UnderscoresToPascalCase("Foo_bar")); + Assert.Equal("FooBar", NameHelpers.UnderscoresToPascalCase("foo_bar")); + Assert.Equal("Foo0Bar", NameHelpers.UnderscoresToPascalCase("Foo0bar")); + Assert.Equal("FooBar", NameHelpers.UnderscoresToPascalCase("Foo_+_Bar")); - Assert.AreEqual("Bar", NameHelpers.UnderscoresToPascalCase("__+bar")); - Assert.AreEqual("Bar", NameHelpers.UnderscoresToPascalCase("bar_")); - Assert.AreEqual("_0Bar", NameHelpers.UnderscoresToPascalCase("_0bar")); - Assert.AreEqual("_1Bar", NameHelpers.UnderscoresToPascalCase("_1_bar")); + Assert.Equal("Bar", NameHelpers.UnderscoresToPascalCase("__+bar")); + Assert.Equal("Bar", NameHelpers.UnderscoresToPascalCase("bar_")); + Assert.Equal("_0Bar", NameHelpers.UnderscoresToPascalCase("_0bar")); + Assert.Equal("_1Bar", NameHelpers.UnderscoresToPascalCase("_1_bar")); } - [TestMethod] + [Fact] public void UnderscoresToCamelCase() { - Assert.AreEqual("fooBar", NameHelpers.UnderscoresToCamelCase("Foo_bar")); - Assert.AreEqual("fooBar", NameHelpers.UnderscoresToCamelCase("foo_bar")); - Assert.AreEqual("foo0Bar", NameHelpers.UnderscoresToCamelCase("Foo0bar")); - Assert.AreEqual("fooBar", NameHelpers.UnderscoresToCamelCase("Foo_+_Bar")); + Assert.Equal("fooBar", NameHelpers.UnderscoresToCamelCase("Foo_bar")); + Assert.Equal("fooBar", NameHelpers.UnderscoresToCamelCase("foo_bar")); + Assert.Equal("foo0Bar", NameHelpers.UnderscoresToCamelCase("Foo0bar")); + Assert.Equal("fooBar", NameHelpers.UnderscoresToCamelCase("Foo_+_Bar")); - Assert.AreEqual("bar", NameHelpers.UnderscoresToCamelCase("__+bar")); - Assert.AreEqual("bar", NameHelpers.UnderscoresToCamelCase("bar_")); - Assert.AreEqual("_0Bar", NameHelpers.UnderscoresToCamelCase("_0bar")); - Assert.AreEqual("_1Bar", NameHelpers.UnderscoresToCamelCase("_1_bar")); + Assert.Equal("bar", NameHelpers.UnderscoresToCamelCase("__+bar")); + Assert.Equal("bar", NameHelpers.UnderscoresToCamelCase("bar_")); + Assert.Equal("_0Bar", NameHelpers.UnderscoresToCamelCase("_0bar")); + Assert.Equal("_1Bar", NameHelpers.UnderscoresToCamelCase("_1_bar")); } - [TestMethod] + [Fact] public void StripSuffix() { string text = "FooBar"; - Assert.IsFalse(NameHelpers.StripSuffix(ref text, "Foo")); - Assert.AreEqual("FooBar", text); - Assert.IsTrue(NameHelpers.StripSuffix(ref text, "Bar")); - Assert.AreEqual("Foo", text); + Assert.False(NameHelpers.StripSuffix(ref text, "Foo")); + Assert.Equal("FooBar", text); + Assert.True(NameHelpers.StripSuffix(ref text, "Bar")); + Assert.Equal("Foo", text); } } } \ No newline at end of file diff --git a/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj b/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj index 8d900266..50c0b63e 100644 --- a/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj +++ b/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj @@ -1,9 +1,8 @@  + + - CLIENTPROFILE - NET35 - TEST Debug AnyCPU 9.0.30729 @@ -13,12 +12,14 @@ Properties Google.ProtocolBuffers Google.ProtocolBuffers.Test - v4.0 + v4.5 512 true ..\..\keys\Google.ProtocolBuffers.snk 3.5 - Client + + + d37384c8 true @@ -32,6 +33,7 @@ true true Off + false pdbonly @@ -44,32 +46,23 @@ true true Off + false - - - - False - ..\..\lib\NUnit\lib\nunit.framework.dll + + ..\packages\xunit.abstractions.2.0.0\lib\net35\xunit.abstractions.dll - - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.Silverlight.Testing.dll + + ..\packages\xunit.assert.2.0.0\lib\portable-net45+win+wpa81+wp80+monotouch+monoandroid+Xamarin.iOS\xunit.assert.dll - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight.dll + + ..\packages\xunit.extensibility.core.2.0.0\lib\portable-net45+win+wpa81+wp80+monotouch+monoandroid+Xamarin.iOS\xunit.core.dll - - Microsoft.VisualStudio.TestTools.cs - @@ -131,28 +124,16 @@ ProtocolBuffers - - - False - .NET Framework 3.5 SP1 Client Profile - false - - - False - .NET Framework 3.5 SP1 - true - - - False - Windows Installer 3.1 - true - - - + + + + + + - - Program - $(ProjectDir)..\..\lib\NUnit\tools\nunit-console.exe - /nologo /noshadow /labels /wait $(AssemblyName).dll - $(ProjectDir)$(OutputPath) - + + + This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them. For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}. + + + + \ No newline at end of file diff --git a/csharp/src/ProtocolBuffers.Test/ReflectionTester.cs b/csharp/src/ProtocolBuffers.Test/ReflectionTester.cs index 5385d316..5fa22fef 100644 --- a/csharp/src/ProtocolBuffers.Test/ReflectionTester.cs +++ b/csharp/src/ProtocolBuffers.Test/ReflectionTester.cs @@ -37,7 +37,7 @@ using System; using Google.ProtocolBuffers.Descriptors; using Google.ProtocolBuffers.TestProtos; -using Microsoft.VisualStudio.TestTools.UnitTesting; +using Xunit; #pragma warning disable 618 // Disable warning about obsolete use miss-matched assert arguments @@ -97,7 +97,7 @@ namespace Google.ProtocolBuffers this.extensionRegistry = extensionRegistry; this.file = baseDescriptor.File; - Assert.AreEqual(1, file.Dependencies.Count); + Assert.Equal(1, file.Dependencies.Count); this.importFile = file.Dependencies[0]; MessageDescriptor testAllTypes; @@ -108,7 +108,7 @@ namespace Google.ProtocolBuffers else { testAllTypes = file.FindTypeByName("TestAllTypes"); - Assert.IsNotNull(testAllTypes); + Assert.NotNull(testAllTypes); } if (extensionRegistry == null) @@ -136,14 +136,14 @@ namespace Google.ProtocolBuffers this.foreignEnum = file.FindTypeByName("ForeignEnum"); this.importEnum = importFile.FindTypeByName("ImportEnum"); - Assert.IsNotNull(optionalGroup); - Assert.IsNotNull(repeatedGroup); - Assert.IsNotNull(nestedMessage); - Assert.IsNotNull(foreignMessage); - Assert.IsNotNull(importMessage); - Assert.IsNotNull(nestedEnum); - Assert.IsNotNull(foreignEnum); - Assert.IsNotNull(importEnum); + Assert.NotNull(optionalGroup); + Assert.NotNull(repeatedGroup); + Assert.NotNull(nestedMessage); + Assert.NotNull(foreignMessage); + Assert.NotNull(importMessage); + Assert.NotNull(nestedEnum); + Assert.NotNull(foreignEnum); + Assert.NotNull(importEnum); this.nestedB = nestedMessage.FindDescriptor("bb"); this.foreignC = foreignMessage.FindDescriptor("c"); @@ -161,20 +161,20 @@ namespace Google.ProtocolBuffers this.groupA = optionalGroup.FindDescriptor("a"); this.repeatedGroupA = repeatedGroup.FindDescriptor("a"); - Assert.IsNotNull(groupA); - Assert.IsNotNull(repeatedGroupA); - Assert.IsNotNull(nestedB); - Assert.IsNotNull(foreignC); - Assert.IsNotNull(importD); - Assert.IsNotNull(nestedFoo); - Assert.IsNotNull(nestedBar); - Assert.IsNotNull(nestedBaz); - Assert.IsNotNull(foreignFoo); - Assert.IsNotNull(foreignBar); - Assert.IsNotNull(foreignBaz); - Assert.IsNotNull(importFoo); - Assert.IsNotNull(importBar); - Assert.IsNotNull(importBaz); + Assert.NotNull(groupA); + Assert.NotNull(repeatedGroupA); + Assert.NotNull(nestedB); + Assert.NotNull(foreignC); + Assert.NotNull(importD); + Assert.NotNull(nestedFoo); + Assert.NotNull(nestedBar); + Assert.NotNull(nestedBaz); + Assert.NotNull(foreignFoo); + Assert.NotNull(foreignBar); + Assert.NotNull(foreignBaz); + Assert.NotNull(importFoo); + Assert.NotNull(importBar); + Assert.NotNull(importBaz); } /// @@ -216,7 +216,7 @@ namespace Google.ProtocolBuffers { result = file.FindTypeByName(name + "_extension"); } - Assert.IsNotNull(result); + Assert.NotNull(result); return result; } @@ -233,8 +233,8 @@ namespace Google.ProtocolBuffers else { ExtensionInfo extension = extensionRegistry[field.ContainingType, field.FieldNumber]; - Assert.IsNotNull(extension); - Assert.IsNotNull(extension.DefaultInstance); + Assert.NotNull(extension); + Assert.NotNull(extension.DefaultInstance); return (IBuilder) extension.DefaultInstance.WeakCreateBuilderForType(); } } @@ -449,199 +449,199 @@ namespace Google.ProtocolBuffers /// public void AssertAllFieldsSetViaReflection(IMessage message) { - Assert.IsTrue(message.HasField(f("optional_int32"))); - Assert.IsTrue(message.HasField(f("optional_int64"))); - Assert.IsTrue(message.HasField(f("optional_uint32"))); - Assert.IsTrue(message.HasField(f("optional_uint64"))); - Assert.IsTrue(message.HasField(f("optional_sint32"))); - Assert.IsTrue(message.HasField(f("optional_sint64"))); - Assert.IsTrue(message.HasField(f("optional_fixed32"))); - Assert.IsTrue(message.HasField(f("optional_fixed64"))); - Assert.IsTrue(message.HasField(f("optional_sfixed32"))); - Assert.IsTrue(message.HasField(f("optional_sfixed64"))); - Assert.IsTrue(message.HasField(f("optional_float"))); - Assert.IsTrue(message.HasField(f("optional_double"))); - Assert.IsTrue(message.HasField(f("optional_bool"))); - Assert.IsTrue(message.HasField(f("optional_string"))); - Assert.IsTrue(message.HasField(f("optional_bytes"))); - - Assert.IsTrue(message.HasField(f("optionalgroup"))); - Assert.IsTrue(message.HasField(f("optional_nested_message"))); - Assert.IsTrue(message.HasField(f("optional_foreign_message"))); - Assert.IsTrue(message.HasField(f("optional_import_message"))); - - Assert.IsTrue(((IMessage) message[f("optionalgroup")]).HasField(groupA)); - Assert.IsTrue(((IMessage) message[f("optional_nested_message")]).HasField(nestedB)); - Assert.IsTrue(((IMessage) message[f("optional_foreign_message")]).HasField(foreignC)); - Assert.IsTrue(((IMessage) message[f("optional_import_message")]).HasField(importD)); - - Assert.IsTrue(message.HasField(f("optional_nested_enum"))); - Assert.IsTrue(message.HasField(f("optional_foreign_enum"))); - Assert.IsTrue(message.HasField(f("optional_import_enum"))); - - Assert.IsTrue(message.HasField(f("optional_string_piece"))); - Assert.IsTrue(message.HasField(f("optional_cord"))); - - Assert.AreEqual(101, message[f("optional_int32")]); - Assert.AreEqual(102L, message[f("optional_int64")]); - Assert.AreEqual(103u, message[f("optional_uint32")]); - Assert.AreEqual(104UL, message[f("optional_uint64")]); - Assert.AreEqual(105, message[f("optional_sint32")]); - Assert.AreEqual(106L, message[f("optional_sint64")]); - Assert.AreEqual(107U, message[f("optional_fixed32")]); - Assert.AreEqual(108UL, message[f("optional_fixed64")]); - Assert.AreEqual(109, message[f("optional_sfixed32")]); - Assert.AreEqual(110L, message[f("optional_sfixed64")]); - Assert.AreEqual(111F, message[f("optional_float")]); - Assert.AreEqual(112D, message[f("optional_double")]); - Assert.AreEqual(true, message[f("optional_bool")]); - Assert.AreEqual("115", message[f("optional_string")]); - Assert.AreEqual(TestUtil.ToBytes("116"), message[f("optional_bytes")]); - - Assert.AreEqual(117, ((IMessage) message[f("optionalgroup")])[groupA]); - Assert.AreEqual(118, ((IMessage) message[f("optional_nested_message")])[nestedB]); - Assert.AreEqual(119, ((IMessage) message[f("optional_foreign_message")])[foreignC]); - Assert.AreEqual(120, ((IMessage) message[f("optional_import_message")])[importD]); - - Assert.AreEqual(nestedBaz, message[f("optional_nested_enum")]); - Assert.AreEqual(foreignBaz, message[f("optional_foreign_enum")]); - Assert.AreEqual(importBaz, message[f("optional_import_enum")]); - - Assert.AreEqual("124", message[f("optional_string_piece")]); - Assert.AreEqual("125", message[f("optional_cord")]); + Assert.True(message.HasField(f("optional_int32"))); + Assert.True(message.HasField(f("optional_int64"))); + Assert.True(message.HasField(f("optional_uint32"))); + Assert.True(message.HasField(f("optional_uint64"))); + Assert.True(message.HasField(f("optional_sint32"))); + Assert.True(message.HasField(f("optional_sint64"))); + Assert.True(message.HasField(f("optional_fixed32"))); + Assert.True(message.HasField(f("optional_fixed64"))); + Assert.True(message.HasField(f("optional_sfixed32"))); + Assert.True(message.HasField(f("optional_sfixed64"))); + Assert.True(message.HasField(f("optional_float"))); + Assert.True(message.HasField(f("optional_double"))); + Assert.True(message.HasField(f("optional_bool"))); + Assert.True(message.HasField(f("optional_string"))); + Assert.True(message.HasField(f("optional_bytes"))); + + Assert.True(message.HasField(f("optionalgroup"))); + Assert.True(message.HasField(f("optional_nested_message"))); + Assert.True(message.HasField(f("optional_foreign_message"))); + Assert.True(message.HasField(f("optional_import_message"))); + + Assert.True(((IMessage) message[f("optionalgroup")]).HasField(groupA)); + Assert.True(((IMessage) message[f("optional_nested_message")]).HasField(nestedB)); + Assert.True(((IMessage) message[f("optional_foreign_message")]).HasField(foreignC)); + Assert.True(((IMessage) message[f("optional_import_message")]).HasField(importD)); + + Assert.True(message.HasField(f("optional_nested_enum"))); + Assert.True(message.HasField(f("optional_foreign_enum"))); + Assert.True(message.HasField(f("optional_import_enum"))); + + Assert.True(message.HasField(f("optional_string_piece"))); + Assert.True(message.HasField(f("optional_cord"))); + + Assert.Equal(101, message[f("optional_int32")]); + Assert.Equal(102L, message[f("optional_int64")]); + Assert.Equal(103u, message[f("optional_uint32")]); + Assert.Equal(104UL, message[f("optional_uint64")]); + Assert.Equal(105, message[f("optional_sint32")]); + Assert.Equal(106L, message[f("optional_sint64")]); + Assert.Equal(107U, message[f("optional_fixed32")]); + Assert.Equal(108UL, message[f("optional_fixed64")]); + Assert.Equal(109, message[f("optional_sfixed32")]); + Assert.Equal(110L, message[f("optional_sfixed64")]); + Assert.Equal(111F, message[f("optional_float")]); + Assert.Equal(112D, message[f("optional_double")]); + Assert.Equal(true, message[f("optional_bool")]); + Assert.Equal("115", message[f("optional_string")]); + Assert.Equal(TestUtil.ToBytes("116"), message[f("optional_bytes")]); + + Assert.Equal(117, ((IMessage) message[f("optionalgroup")])[groupA]); + Assert.Equal(118, ((IMessage) message[f("optional_nested_message")])[nestedB]); + Assert.Equal(119, ((IMessage) message[f("optional_foreign_message")])[foreignC]); + Assert.Equal(120, ((IMessage) message[f("optional_import_message")])[importD]); + + Assert.Equal(nestedBaz, message[f("optional_nested_enum")]); + Assert.Equal(foreignBaz, message[f("optional_foreign_enum")]); + Assert.Equal(importBaz, message[f("optional_import_enum")]); + + Assert.Equal("124", message[f("optional_string_piece")]); + Assert.Equal("125", message[f("optional_cord")]); // ----------------------------------------------------------------- - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_int32"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_int64"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_uint32"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_uint64"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sint32"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sint64"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_fixed32"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_fixed64"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sfixed32"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sfixed64"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_float"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_double"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_bool"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_string"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_bytes"))); - - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeatedgroup"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_nested_message"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_foreign_message"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_import_message"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_nested_enum"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_foreign_enum"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_import_enum"))); - - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_string_piece"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_cord"))); - - Assert.AreEqual(201, message[f("repeated_int32"), 0]); - Assert.AreEqual(202L, message[f("repeated_int64"), 0]); - Assert.AreEqual(203U, message[f("repeated_uint32"), 0]); - Assert.AreEqual(204UL, message[f("repeated_uint64"), 0]); - Assert.AreEqual(205, message[f("repeated_sint32"), 0]); - Assert.AreEqual(206L, message[f("repeated_sint64"), 0]); - Assert.AreEqual(207U, message[f("repeated_fixed32"), 0]); - Assert.AreEqual(208UL, message[f("repeated_fixed64"), 0]); - Assert.AreEqual(209, message[f("repeated_sfixed32"), 0]); - Assert.AreEqual(210L, message[f("repeated_sfixed64"), 0]); - Assert.AreEqual(211F, message[f("repeated_float"), 0]); - Assert.AreEqual(212D, message[f("repeated_double"), 0]); - Assert.AreEqual(true, message[f("repeated_bool"), 0]); - Assert.AreEqual("215", message[f("repeated_string"), 0]); - Assert.AreEqual(TestUtil.ToBytes("216"), message[f("repeated_bytes"), 0]); - - Assert.AreEqual(217, ((IMessage) message[f("repeatedgroup"), 0])[repeatedGroupA]); - Assert.AreEqual(218, ((IMessage) message[f("repeated_nested_message"), 0])[nestedB]); - Assert.AreEqual(219, ((IMessage) message[f("repeated_foreign_message"), 0])[foreignC]); - Assert.AreEqual(220, ((IMessage) message[f("repeated_import_message"), 0])[importD]); - - Assert.AreEqual(nestedBar, message[f("repeated_nested_enum"), 0]); - Assert.AreEqual(foreignBar, message[f("repeated_foreign_enum"), 0]); - Assert.AreEqual(importBar, message[f("repeated_import_enum"), 0]); - - Assert.AreEqual("224", message[f("repeated_string_piece"), 0]); - Assert.AreEqual("225", message[f("repeated_cord"), 0]); - - Assert.AreEqual(301, message[f("repeated_int32"), 1]); - Assert.AreEqual(302L, message[f("repeated_int64"), 1]); - Assert.AreEqual(303U, message[f("repeated_uint32"), 1]); - Assert.AreEqual(304UL, message[f("repeated_uint64"), 1]); - Assert.AreEqual(305, message[f("repeated_sint32"), 1]); - Assert.AreEqual(306L, message[f("repeated_sint64"), 1]); - Assert.AreEqual(307U, message[f("repeated_fixed32"), 1]); - Assert.AreEqual(308UL, message[f("repeated_fixed64"), 1]); - Assert.AreEqual(309, message[f("repeated_sfixed32"), 1]); - Assert.AreEqual(310L, message[f("repeated_sfixed64"), 1]); - Assert.AreEqual(311F, message[f("repeated_float"), 1]); - Assert.AreEqual(312D, message[f("repeated_double"), 1]); - Assert.AreEqual(false, message[f("repeated_bool"), 1]); - Assert.AreEqual("315", message[f("repeated_string"), 1]); - Assert.AreEqual(TestUtil.ToBytes("316"), message[f("repeated_bytes"), 1]); - - Assert.AreEqual(317, ((IMessage) message[f("repeatedgroup"), 1])[repeatedGroupA]); - Assert.AreEqual(318, ((IMessage) message[f("repeated_nested_message"), 1])[nestedB]); - Assert.AreEqual(319, ((IMessage) message[f("repeated_foreign_message"), 1])[foreignC]); - Assert.AreEqual(320, ((IMessage) message[f("repeated_import_message"), 1])[importD]); - - Assert.AreEqual(nestedBaz, message[f("repeated_nested_enum"), 1]); - Assert.AreEqual(foreignBaz, message[f("repeated_foreign_enum"), 1]); - Assert.AreEqual(importBaz, message[f("repeated_import_enum"), 1]); - - Assert.AreEqual("324", message[f("repeated_string_piece"), 1]); - Assert.AreEqual("325", message[f("repeated_cord"), 1]); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_int32"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_int64"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_uint32"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_uint64"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_sint32"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_sint64"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_fixed32"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_fixed64"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_sfixed32"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_sfixed64"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_float"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_double"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_bool"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_string"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_bytes"))); + + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeatedgroup"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_nested_message"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_foreign_message"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_import_message"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_nested_enum"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_foreign_enum"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_import_enum"))); + + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_string_piece"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_cord"))); + + Assert.Equal(201, message[f("repeated_int32"), 0]); + Assert.Equal(202L, message[f("repeated_int64"), 0]); + Assert.Equal(203U, message[f("repeated_uint32"), 0]); + Assert.Equal(204UL, message[f("repeated_uint64"), 0]); + Assert.Equal(205, message[f("repeated_sint32"), 0]); + Assert.Equal(206L, message[f("repeated_sint64"), 0]); + Assert.Equal(207U, message[f("repeated_fixed32"), 0]); + Assert.Equal(208UL, message[f("repeated_fixed64"), 0]); + Assert.Equal(209, message[f("repeated_sfixed32"), 0]); + Assert.Equal(210L, message[f("repeated_sfixed64"), 0]); + Assert.Equal(211F, message[f("repeated_float"), 0]); + Assert.Equal(212D, message[f("repeated_double"), 0]); + Assert.Equal(true, message[f("repeated_bool"), 0]); + Assert.Equal("215", message[f("repeated_string"), 0]); + Assert.Equal(TestUtil.ToBytes("216"), message[f("repeated_bytes"), 0]); + + Assert.Equal(217, ((IMessage) message[f("repeatedgroup"), 0])[repeatedGroupA]); + Assert.Equal(218, ((IMessage) message[f("repeated_nested_message"), 0])[nestedB]); + Assert.Equal(219, ((IMessage) message[f("repeated_foreign_message"), 0])[foreignC]); + Assert.Equal(220, ((IMessage) message[f("repeated_import_message"), 0])[importD]); + + Assert.Equal(nestedBar, message[f("repeated_nested_enum"), 0]); + Assert.Equal(foreignBar, message[f("repeated_foreign_enum"), 0]); + Assert.Equal(importBar, message[f("repeated_import_enum"), 0]); + + Assert.Equal("224", message[f("repeated_string_piece"), 0]); + Assert.Equal("225", message[f("repeated_cord"), 0]); + + Assert.Equal(301, message[f("repeated_int32"), 1]); + Assert.Equal(302L, message[f("repeated_int64"), 1]); + Assert.Equal(303U, message[f("repeated_uint32"), 1]); + Assert.Equal(304UL, message[f("repeated_uint64"), 1]); + Assert.Equal(305, message[f("repeated_sint32"), 1]); + Assert.Equal(306L, message[f("repeated_sint64"), 1]); + Assert.Equal(307U, message[f("repeated_fixed32"), 1]); + Assert.Equal(308UL, message[f("repeated_fixed64"), 1]); + Assert.Equal(309, message[f("repeated_sfixed32"), 1]); + Assert.Equal(310L, message[f("repeated_sfixed64"), 1]); + Assert.Equal(311F, message[f("repeated_float"), 1]); + Assert.Equal(312D, message[f("repeated_double"), 1]); + Assert.Equal(false, message[f("repeated_bool"), 1]); + Assert.Equal("315", message[f("repeated_string"), 1]); + Assert.Equal(TestUtil.ToBytes("316"), message[f("repeated_bytes"), 1]); + + Assert.Equal(317, ((IMessage) message[f("repeatedgroup"), 1])[repeatedGroupA]); + Assert.Equal(318, ((IMessage) message[f("repeated_nested_message"), 1])[nestedB]); + Assert.Equal(319, ((IMessage) message[f("repeated_foreign_message"), 1])[foreignC]); + Assert.Equal(320, ((IMessage) message[f("repeated_import_message"), 1])[importD]); + + Assert.Equal(nestedBaz, message[f("repeated_nested_enum"), 1]); + Assert.Equal(foreignBaz, message[f("repeated_foreign_enum"), 1]); + Assert.Equal(importBaz, message[f("repeated_import_enum"), 1]); + + Assert.Equal("324", message[f("repeated_string_piece"), 1]); + Assert.Equal("325", message[f("repeated_cord"), 1]); // ----------------------------------------------------------------- - Assert.IsTrue(message.HasField(f("default_int32"))); - Assert.IsTrue(message.HasField(f("default_int64"))); - Assert.IsTrue(message.HasField(f("default_uint32"))); - Assert.IsTrue(message.HasField(f("default_uint64"))); - Assert.IsTrue(message.HasField(f("default_sint32"))); - Assert.IsTrue(message.HasField(f("default_sint64"))); - Assert.IsTrue(message.HasField(f("default_fixed32"))); - Assert.IsTrue(message.HasField(f("default_fixed64"))); - Assert.IsTrue(message.HasField(f("default_sfixed32"))); - Assert.IsTrue(message.HasField(f("default_sfixed64"))); - Assert.IsTrue(message.HasField(f("default_float"))); - Assert.IsTrue(message.HasField(f("default_double"))); - Assert.IsTrue(message.HasField(f("default_bool"))); - Assert.IsTrue(message.HasField(f("default_string"))); - Assert.IsTrue(message.HasField(f("default_bytes"))); - - Assert.IsTrue(message.HasField(f("default_nested_enum"))); - Assert.IsTrue(message.HasField(f("default_foreign_enum"))); - Assert.IsTrue(message.HasField(f("default_import_enum"))); - - Assert.IsTrue(message.HasField(f("default_string_piece"))); - Assert.IsTrue(message.HasField(f("default_cord"))); - - Assert.AreEqual(401, message[f("default_int32")]); - Assert.AreEqual(402L, message[f("default_int64")]); - Assert.AreEqual(403U, message[f("default_uint32")]); - Assert.AreEqual(404UL, message[f("default_uint64")]); - Assert.AreEqual(405, message[f("default_sint32")]); - Assert.AreEqual(406L, message[f("default_sint64")]); - Assert.AreEqual(407U, message[f("default_fixed32")]); - Assert.AreEqual(408UL, message[f("default_fixed64")]); - Assert.AreEqual(409, message[f("default_sfixed32")]); - Assert.AreEqual(410L, message[f("default_sfixed64")]); - Assert.AreEqual(411F, message[f("default_float")]); - Assert.AreEqual(412D, message[f("default_double")]); - Assert.AreEqual(false, message[f("default_bool")]); - Assert.AreEqual("415", message[f("default_string")]); - Assert.AreEqual(TestUtil.ToBytes("416"), message[f("default_bytes")]); - - Assert.AreEqual(nestedFoo, message[f("default_nested_enum")]); - Assert.AreEqual(foreignFoo, message[f("default_foreign_enum")]); - Assert.AreEqual(importFoo, message[f("default_import_enum")]); - - Assert.AreEqual("424", message[f("default_string_piece")]); - Assert.AreEqual("425", message[f("default_cord")]); + Assert.True(message.HasField(f("default_int32"))); + Assert.True(message.HasField(f("default_int64"))); + Assert.True(message.HasField(f("default_uint32"))); + Assert.True(message.HasField(f("default_uint64"))); + Assert.True(message.HasField(f("default_sint32"))); + Assert.True(message.HasField(f("default_sint64"))); + Assert.True(message.HasField(f("default_fixed32"))); + Assert.True(message.HasField(f("default_fixed64"))); + Assert.True(message.HasField(f("default_sfixed32"))); + Assert.True(message.HasField(f("default_sfixed64"))); + Assert.True(message.HasField(f("default_float"))); + Assert.True(message.HasField(f("default_double"))); + Assert.True(message.HasField(f("default_bool"))); + Assert.True(message.HasField(f("default_string"))); + Assert.True(message.HasField(f("default_bytes"))); + + Assert.True(message.HasField(f("default_nested_enum"))); + Assert.True(message.HasField(f("default_foreign_enum"))); + Assert.True(message.HasField(f("default_import_enum"))); + + Assert.True(message.HasField(f("default_string_piece"))); + Assert.True(message.HasField(f("default_cord"))); + + Assert.Equal(401, message[f("default_int32")]); + Assert.Equal(402L, message[f("default_int64")]); + Assert.Equal(403U, message[f("default_uint32")]); + Assert.Equal(404UL, message[f("default_uint64")]); + Assert.Equal(405, message[f("default_sint32")]); + Assert.Equal(406L, message[f("default_sint64")]); + Assert.Equal(407U, message[f("default_fixed32")]); + Assert.Equal(408UL, message[f("default_fixed64")]); + Assert.Equal(409, message[f("default_sfixed32")]); + Assert.Equal(410L, message[f("default_sfixed64")]); + Assert.Equal(411F, message[f("default_float")]); + Assert.Equal(412D, message[f("default_double")]); + Assert.Equal(false, message[f("default_bool")]); + Assert.Equal("415", message[f("default_string")]); + Assert.Equal(TestUtil.ToBytes("416"), message[f("default_bytes")]); + + Assert.Equal(nestedFoo, message[f("default_nested_enum")]); + Assert.Equal(foreignFoo, message[f("default_foreign_enum")]); + Assert.Equal(importFoo, message[f("default_import_enum")]); + + Assert.Equal("424", message[f("default_string_piece")]); + Assert.Equal("425", message[f("default_cord")]); } /// @@ -651,148 +651,148 @@ namespace Google.ProtocolBuffers public void AssertClearViaReflection(IMessage message) { // has_blah() should initially be false for all optional fields. - Assert.IsFalse(message.HasField(f("optional_int32"))); - Assert.IsFalse(message.HasField(f("optional_int64"))); - Assert.IsFalse(message.HasField(f("optional_uint32"))); - Assert.IsFalse(message.HasField(f("optional_uint64"))); - Assert.IsFalse(message.HasField(f("optional_sint32"))); - Assert.IsFalse(message.HasField(f("optional_sint64"))); - Assert.IsFalse(message.HasField(f("optional_fixed32"))); - Assert.IsFalse(message.HasField(f("optional_fixed64"))); - Assert.IsFalse(message.HasField(f("optional_sfixed32"))); - Assert.IsFalse(message.HasField(f("optional_sfixed64"))); - Assert.IsFalse(message.HasField(f("optional_float"))); - Assert.IsFalse(message.HasField(f("optional_double"))); - Assert.IsFalse(message.HasField(f("optional_bool"))); - Assert.IsFalse(message.HasField(f("optional_string"))); - Assert.IsFalse(message.HasField(f("optional_bytes"))); - - Assert.IsFalse(message.HasField(f("optionalgroup"))); - Assert.IsFalse(message.HasField(f("optional_nested_message"))); - Assert.IsFalse(message.HasField(f("optional_foreign_message"))); - Assert.IsFalse(message.HasField(f("optional_import_message"))); - - Assert.IsFalse(message.HasField(f("optional_nested_enum"))); - Assert.IsFalse(message.HasField(f("optional_foreign_enum"))); - Assert.IsFalse(message.HasField(f("optional_import_enum"))); - - Assert.IsFalse(message.HasField(f("optional_string_piece"))); - Assert.IsFalse(message.HasField(f("optional_cord"))); + Assert.False(message.HasField(f("optional_int32"))); + Assert.False(message.HasField(f("optional_int64"))); + Assert.False(message.HasField(f("optional_uint32"))); + Assert.False(message.HasField(f("optional_uint64"))); + Assert.False(message.HasField(f("optional_sint32"))); + Assert.False(message.HasField(f("optional_sint64"))); + Assert.False(message.HasField(f("optional_fixed32"))); + Assert.False(message.HasField(f("optional_fixed64"))); + Assert.False(message.HasField(f("optional_sfixed32"))); + Assert.False(message.HasField(f("optional_sfixed64"))); + Assert.False(message.HasField(f("optional_float"))); + Assert.False(message.HasField(f("optional_double"))); + Assert.False(message.HasField(f("optional_bool"))); + Assert.False(message.HasField(f("optional_string"))); + Assert.False(message.HasField(f("optional_bytes"))); + + Assert.False(message.HasField(f("optionalgroup"))); + Assert.False(message.HasField(f("optional_nested_message"))); + Assert.False(message.HasField(f("optional_foreign_message"))); + Assert.False(message.HasField(f("optional_import_message"))); + + Assert.False(message.HasField(f("optional_nested_enum"))); + Assert.False(message.HasField(f("optional_foreign_enum"))); + Assert.False(message.HasField(f("optional_import_enum"))); + + Assert.False(message.HasField(f("optional_string_piece"))); + Assert.False(message.HasField(f("optional_cord"))); // Optional fields without defaults are set to zero or something like it. - Assert.AreEqual(0, message[f("optional_int32")]); - Assert.AreEqual(0L, message[f("optional_int64")]); - Assert.AreEqual(0U, message[f("optional_uint32")]); - Assert.AreEqual(0UL, message[f("optional_uint64")]); - Assert.AreEqual(0, message[f("optional_sint32")]); - Assert.AreEqual(0L, message[f("optional_sint64")]); - Assert.AreEqual(0U, message[f("optional_fixed32")]); - Assert.AreEqual(0UL, message[f("optional_fixed64")]); - Assert.AreEqual(0, message[f("optional_sfixed32")]); - Assert.AreEqual(0L, message[f("optional_sfixed64")]); - Assert.AreEqual(0F, message[f("optional_float")]); - Assert.AreEqual(0D, message[f("optional_double")]); - Assert.AreEqual(false, message[f("optional_bool")]); - Assert.AreEqual("", message[f("optional_string")]); - Assert.AreEqual(ByteString.Empty, message[f("optional_bytes")]); + Assert.Equal(0, message[f("optional_int32")]); + Assert.Equal(0L, message[f("optional_int64")]); + Assert.Equal(0U, message[f("optional_uint32")]); + Assert.Equal(0UL, message[f("optional_uint64")]); + Assert.Equal(0, message[f("optional_sint32")]); + Assert.Equal(0L, message[f("optional_sint64")]); + Assert.Equal(0U, message[f("optional_fixed32")]); + Assert.Equal(0UL, message[f("optional_fixed64")]); + Assert.Equal(0, message[f("optional_sfixed32")]); + Assert.Equal(0L, message[f("optional_sfixed64")]); + Assert.Equal(0F, message[f("optional_float")]); + Assert.Equal(0D, message[f("optional_double")]); + Assert.Equal(false, message[f("optional_bool")]); + Assert.Equal("", message[f("optional_string")]); + Assert.Equal(ByteString.Empty, message[f("optional_bytes")]); // Embedded messages should also be clear. - Assert.IsFalse(((IMessage) message[f("optionalgroup")]).HasField(groupA)); - Assert.IsFalse(((IMessage) message[f("optional_nested_message")]) + Assert.False(((IMessage) message[f("optionalgroup")]).HasField(groupA)); + Assert.False(((IMessage) message[f("optional_nested_message")]) .HasField(nestedB)); - Assert.IsFalse(((IMessage) message[f("optional_foreign_message")]) + Assert.False(((IMessage) message[f("optional_foreign_message")]) .HasField(foreignC)); - Assert.IsFalse(((IMessage) message[f("optional_import_message")]) + Assert.False(((IMessage) message[f("optional_import_message")]) .HasField(importD)); - Assert.AreEqual(0, ((IMessage) message[f("optionalgroup")])[groupA]); - Assert.AreEqual(0, ((IMessage) message[f("optional_nested_message")])[nestedB]); - Assert.AreEqual(0, ((IMessage) message[f("optional_foreign_message")])[foreignC]); - Assert.AreEqual(0, ((IMessage) message[f("optional_import_message")])[importD]); + Assert.Equal(0, ((IMessage) message[f("optionalgroup")])[groupA]); + Assert.Equal(0, ((IMessage) message[f("optional_nested_message")])[nestedB]); + Assert.Equal(0, ((IMessage) message[f("optional_foreign_message")])[foreignC]); + Assert.Equal(0, ((IMessage) message[f("optional_import_message")])[importD]); // Enums without defaults are set to the first value in the enum. - Assert.AreEqual(nestedFoo, message[f("optional_nested_enum")]); - Assert.AreEqual(foreignFoo, message[f("optional_foreign_enum")]); - Assert.AreEqual(importFoo, message[f("optional_import_enum")]); + Assert.Equal(nestedFoo, message[f("optional_nested_enum")]); + Assert.Equal(foreignFoo, message[f("optional_foreign_enum")]); + Assert.Equal(importFoo, message[f("optional_import_enum")]); - Assert.AreEqual("", message[f("optional_string_piece")]); - Assert.AreEqual("", message[f("optional_cord")]); + Assert.Equal("", message[f("optional_string_piece")]); + Assert.Equal("", message[f("optional_cord")]); // Repeated fields are empty. - Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_int32"))); - Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_int64"))); - Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_uint32"))); - Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_uint64"))); - Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_sint32"))); - Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_sint64"))); - Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_fixed32"))); - Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_fixed64"))); - Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_sfixed32"))); - Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_sfixed64"))); - Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_float"))); - Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_double"))); - Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_bool"))); - Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_string"))); - Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_bytes"))); - - Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeatedgroup"))); - Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_nested_message"))); - Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_foreign_message"))); - Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_import_message"))); - Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_nested_enum"))); - Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_foreign_enum"))); - Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_import_enum"))); - - Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_string_piece"))); - Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_cord"))); + Assert.Equal(0, message.GetRepeatedFieldCount(f("repeated_int32"))); + Assert.Equal(0, message.GetRepeatedFieldCount(f("repeated_int64"))); + Assert.Equal(0, message.GetRepeatedFieldCount(f("repeated_uint32"))); + Assert.Equal(0, message.GetRepeatedFieldCount(f("repeated_uint64"))); + Assert.Equal(0, message.GetRepeatedFieldCount(f("repeated_sint32"))); + Assert.Equal(0, message.GetRepeatedFieldCount(f("repeated_sint64"))); + Assert.Equal(0, message.GetRepeatedFieldCount(f("repeated_fixed32"))); + Assert.Equal(0, message.GetRepeatedFieldCount(f("repeated_fixed64"))); + Assert.Equal(0, message.GetRepeatedFieldCount(f("repeated_sfixed32"))); + Assert.Equal(0, message.GetRepeatedFieldCount(f("repeated_sfixed64"))); + Assert.Equal(0, message.GetRepeatedFieldCount(f("repeated_float"))); + Assert.Equal(0, message.GetRepeatedFieldCount(f("repeated_double"))); + Assert.Equal(0, message.GetRepeatedFieldCount(f("repeated_bool"))); + Assert.Equal(0, message.GetRepeatedFieldCount(f("repeated_string"))); + Assert.Equal(0, message.GetRepeatedFieldCount(f("repeated_bytes"))); + + Assert.Equal(0, message.GetRepeatedFieldCount(f("repeatedgroup"))); + Assert.Equal(0, message.GetRepeatedFieldCount(f("repeated_nested_message"))); + Assert.Equal(0, message.GetRepeatedFieldCount(f("repeated_foreign_message"))); + Assert.Equal(0, message.GetRepeatedFieldCount(f("repeated_import_message"))); + Assert.Equal(0, message.GetRepeatedFieldCount(f("repeated_nested_enum"))); + Assert.Equal(0, message.GetRepeatedFieldCount(f("repeated_foreign_enum"))); + Assert.Equal(0, message.GetRepeatedFieldCount(f("repeated_import_enum"))); + + Assert.Equal(0, message.GetRepeatedFieldCount(f("repeated_string_piece"))); + Assert.Equal(0, message.GetRepeatedFieldCount(f("repeated_cord"))); // has_blah() should also be false for all default fields. - Assert.IsFalse(message.HasField(f("default_int32"))); - Assert.IsFalse(message.HasField(f("default_int64"))); - Assert.IsFalse(message.HasField(f("default_uint32"))); - Assert.IsFalse(message.HasField(f("default_uint64"))); - Assert.IsFalse(message.HasField(f("default_sint32"))); - Assert.IsFalse(message.HasField(f("default_sint64"))); - Assert.IsFalse(message.HasField(f("default_fixed32"))); - Assert.IsFalse(message.HasField(f("default_fixed64"))); - Assert.IsFalse(message.HasField(f("default_sfixed32"))); - Assert.IsFalse(message.HasField(f("default_sfixed64"))); - Assert.IsFalse(message.HasField(f("default_float"))); - Assert.IsFalse(message.HasField(f("default_double"))); - Assert.IsFalse(message.HasField(f("default_bool"))); - Assert.IsFalse(message.HasField(f("default_string"))); - Assert.IsFalse(message.HasField(f("default_bytes"))); - - Assert.IsFalse(message.HasField(f("default_nested_enum"))); - Assert.IsFalse(message.HasField(f("default_foreign_enum"))); - Assert.IsFalse(message.HasField(f("default_import_enum"))); - - Assert.IsFalse(message.HasField(f("default_string_piece"))); - Assert.IsFalse(message.HasField(f("default_cord"))); + Assert.False(message.HasField(f("default_int32"))); + Assert.False(message.HasField(f("default_int64"))); + Assert.False(message.HasField(f("default_uint32"))); + Assert.False(message.HasField(f("default_uint64"))); + Assert.False(message.HasField(f("default_sint32"))); + Assert.False(message.HasField(f("default_sint64"))); + Assert.False(message.HasField(f("default_fixed32"))); + Assert.False(message.HasField(f("default_fixed64"))); + Assert.False(message.HasField(f("default_sfixed32"))); + Assert.False(message.HasField(f("default_sfixed64"))); + Assert.False(message.HasField(f("default_float"))); + Assert.False(message.HasField(f("default_double"))); + Assert.False(message.HasField(f("default_bool"))); + Assert.False(message.HasField(f("default_string"))); + Assert.False(message.HasField(f("default_bytes"))); + + Assert.False(message.HasField(f("default_nested_enum"))); + Assert.False(message.HasField(f("default_foreign_enum"))); + Assert.False(message.HasField(f("default_import_enum"))); + + Assert.False(message.HasField(f("default_string_piece"))); + Assert.False(message.HasField(f("default_cord"))); // Fields with defaults have their default values (duh). - Assert.AreEqual(41, message[f("default_int32")]); - Assert.AreEqual(42L, message[f("default_int64")]); - Assert.AreEqual(43U, message[f("default_uint32")]); - Assert.AreEqual(44UL, message[f("default_uint64")]); - Assert.AreEqual(-45, message[f("default_sint32")]); - Assert.AreEqual(46L, message[f("default_sint64")]); - Assert.AreEqual(47U, message[f("default_fixed32")]); - Assert.AreEqual(48UL, message[f("default_fixed64")]); - Assert.AreEqual(49, message[f("default_sfixed32")]); - Assert.AreEqual(-50L, message[f("default_sfixed64")]); - Assert.AreEqual(51.5F, message[f("default_float")]); - Assert.AreEqual(52e3D, message[f("default_double")]); - Assert.AreEqual(true, message[f("default_bool")]); - Assert.AreEqual("hello", message[f("default_string")]); - Assert.AreEqual(TestUtil.ToBytes("world"), message[f("default_bytes")]); - - Assert.AreEqual(nestedBar, message[f("default_nested_enum")]); - Assert.AreEqual(foreignBar, message[f("default_foreign_enum")]); - Assert.AreEqual(importBar, message[f("default_import_enum")]); - - Assert.AreEqual("abc", message[f("default_string_piece")]); - Assert.AreEqual("123", message[f("default_cord")]); + Assert.Equal(41, message[f("default_int32")]); + Assert.Equal(42L, message[f("default_int64")]); + Assert.Equal(43U, message[f("default_uint32")]); + Assert.Equal(44UL, message[f("default_uint64")]); + Assert.Equal(-45, message[f("default_sint32")]); + Assert.Equal(46L, message[f("default_sint64")]); + Assert.Equal(47U, message[f("default_fixed32")]); + Assert.Equal(48UL, message[f("default_fixed64")]); + Assert.Equal(49, message[f("default_sfixed32")]); + Assert.Equal(-50L, message[f("default_sfixed64")]); + Assert.Equal(51.5F, message[f("default_float")]); + Assert.Equal(52e3D, message[f("default_double")]); + Assert.Equal(true, message[f("default_bool")]); + Assert.Equal("hello", message[f("default_string")]); + Assert.Equal(TestUtil.ToBytes("world"), message[f("default_bytes")]); + + Assert.Equal(nestedBar, message[f("default_nested_enum")]); + Assert.Equal(foreignBar, message[f("default_foreign_enum")]); + Assert.Equal(importBar, message[f("default_import_enum")]); + + Assert.Equal("abc", message[f("default_string_piece")]); + Assert.Equal("123", message[f("default_cord")]); } // --------------------------------------------------------------- @@ -802,88 +802,88 @@ namespace Google.ProtocolBuffers // ModifyRepeatedFields only sets the second repeated element of each // field. In addition to verifying this, we also verify that the first // element and size were *not* modified. - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_int32"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_int64"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_uint32"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_uint64"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sint32"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sint64"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_fixed32"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_fixed64"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sfixed32"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sfixed64"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_float"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_double"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_bool"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_string"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_bytes"))); - - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeatedgroup"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_nested_message"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_foreign_message"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_import_message"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_nested_enum"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_foreign_enum"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_import_enum"))); - - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_string_piece"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_cord"))); - - Assert.AreEqual(201, message[f("repeated_int32"), 0]); - Assert.AreEqual(202L, message[f("repeated_int64"), 0]); - Assert.AreEqual(203U, message[f("repeated_uint32"), 0]); - Assert.AreEqual(204UL, message[f("repeated_uint64"), 0]); - Assert.AreEqual(205, message[f("repeated_sint32"), 0]); - Assert.AreEqual(206L, message[f("repeated_sint64"), 0]); - Assert.AreEqual(207U, message[f("repeated_fixed32"), 0]); - Assert.AreEqual(208UL, message[f("repeated_fixed64"), 0]); - Assert.AreEqual(209, message[f("repeated_sfixed32"), 0]); - Assert.AreEqual(210L, message[f("repeated_sfixed64"), 0]); - Assert.AreEqual(211F, message[f("repeated_float"), 0]); - Assert.AreEqual(212D, message[f("repeated_double"), 0]); - Assert.AreEqual(true, message[f("repeated_bool"), 0]); - Assert.AreEqual("215", message[f("repeated_string"), 0]); - Assert.AreEqual(TestUtil.ToBytes("216"), message[f("repeated_bytes"), 0]); - - Assert.AreEqual(217, ((IMessage) message[f("repeatedgroup"), 0])[repeatedGroupA]); - Assert.AreEqual(218, ((IMessage) message[f("repeated_nested_message"), 0])[nestedB]); - Assert.AreEqual(219, ((IMessage) message[f("repeated_foreign_message"), 0])[foreignC]); - Assert.AreEqual(220, ((IMessage) message[f("repeated_import_message"), 0])[importD]); - - Assert.AreEqual(nestedBar, message[f("repeated_nested_enum"), 0]); - Assert.AreEqual(foreignBar, message[f("repeated_foreign_enum"), 0]); - Assert.AreEqual(importBar, message[f("repeated_import_enum"), 0]); - - Assert.AreEqual("224", message[f("repeated_string_piece"), 0]); - Assert.AreEqual("225", message[f("repeated_cord"), 0]); - - Assert.AreEqual(501, message[f("repeated_int32"), 1]); - Assert.AreEqual(502L, message[f("repeated_int64"), 1]); - Assert.AreEqual(503U, message[f("repeated_uint32"), 1]); - Assert.AreEqual(504UL, message[f("repeated_uint64"), 1]); - Assert.AreEqual(505, message[f("repeated_sint32"), 1]); - Assert.AreEqual(506L, message[f("repeated_sint64"), 1]); - Assert.AreEqual(507U, message[f("repeated_fixed32"), 1]); - Assert.AreEqual(508UL, message[f("repeated_fixed64"), 1]); - Assert.AreEqual(509, message[f("repeated_sfixed32"), 1]); - Assert.AreEqual(510L, message[f("repeated_sfixed64"), 1]); - Assert.AreEqual(511F, message[f("repeated_float"), 1]); - Assert.AreEqual(512D, message[f("repeated_double"), 1]); - Assert.AreEqual(true, message[f("repeated_bool"), 1]); - Assert.AreEqual("515", message[f("repeated_string"), 1]); - Assert.AreEqual(TestUtil.ToBytes("516"), message[f("repeated_bytes"), 1]); - - Assert.AreEqual(517, ((IMessage) message[f("repeatedgroup"), 1])[repeatedGroupA]); - Assert.AreEqual(518, ((IMessage) message[f("repeated_nested_message"), 1])[nestedB]); - Assert.AreEqual(519, ((IMessage) message[f("repeated_foreign_message"), 1])[foreignC]); - Assert.AreEqual(520, ((IMessage) message[f("repeated_import_message"), 1])[importD]); - - Assert.AreEqual(nestedFoo, message[f("repeated_nested_enum"), 1]); - Assert.AreEqual(foreignFoo, message[f("repeated_foreign_enum"), 1]); - Assert.AreEqual(importFoo, message[f("repeated_import_enum"), 1]); - - Assert.AreEqual("524", message[f("repeated_string_piece"), 1]); - Assert.AreEqual("525", message[f("repeated_cord"), 1]); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_int32"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_int64"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_uint32"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_uint64"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_sint32"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_sint64"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_fixed32"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_fixed64"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_sfixed32"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_sfixed64"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_float"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_double"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_bool"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_string"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_bytes"))); + + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeatedgroup"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_nested_message"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_foreign_message"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_import_message"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_nested_enum"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_foreign_enum"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_import_enum"))); + + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_string_piece"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("repeated_cord"))); + + Assert.Equal(201, message[f("repeated_int32"), 0]); + Assert.Equal(202L, message[f("repeated_int64"), 0]); + Assert.Equal(203U, message[f("repeated_uint32"), 0]); + Assert.Equal(204UL, message[f("repeated_uint64"), 0]); + Assert.Equal(205, message[f("repeated_sint32"), 0]); + Assert.Equal(206L, message[f("repeated_sint64"), 0]); + Assert.Equal(207U, message[f("repeated_fixed32"), 0]); + Assert.Equal(208UL, message[f("repeated_fixed64"), 0]); + Assert.Equal(209, message[f("repeated_sfixed32"), 0]); + Assert.Equal(210L, message[f("repeated_sfixed64"), 0]); + Assert.Equal(211F, message[f("repeated_float"), 0]); + Assert.Equal(212D, message[f("repeated_double"), 0]); + Assert.Equal(true, message[f("repeated_bool"), 0]); + Assert.Equal("215", message[f("repeated_string"), 0]); + Assert.Equal(TestUtil.ToBytes("216"), message[f("repeated_bytes"), 0]); + + Assert.Equal(217, ((IMessage) message[f("repeatedgroup"), 0])[repeatedGroupA]); + Assert.Equal(218, ((IMessage) message[f("repeated_nested_message"), 0])[nestedB]); + Assert.Equal(219, ((IMessage) message[f("repeated_foreign_message"), 0])[foreignC]); + Assert.Equal(220, ((IMessage) message[f("repeated_import_message"), 0])[importD]); + + Assert.Equal(nestedBar, message[f("repeated_nested_enum"), 0]); + Assert.Equal(foreignBar, message[f("repeated_foreign_enum"), 0]); + Assert.Equal(importBar, message[f("repeated_import_enum"), 0]); + + Assert.Equal("224", message[f("repeated_string_piece"), 0]); + Assert.Equal("225", message[f("repeated_cord"), 0]); + + Assert.Equal(501, message[f("repeated_int32"), 1]); + Assert.Equal(502L, message[f("repeated_int64"), 1]); + Assert.Equal(503U, message[f("repeated_uint32"), 1]); + Assert.Equal(504UL, message[f("repeated_uint64"), 1]); + Assert.Equal(505, message[f("repeated_sint32"), 1]); + Assert.Equal(506L, message[f("repeated_sint64"), 1]); + Assert.Equal(507U, message[f("repeated_fixed32"), 1]); + Assert.Equal(508UL, message[f("repeated_fixed64"), 1]); + Assert.Equal(509, message[f("repeated_sfixed32"), 1]); + Assert.Equal(510L, message[f("repeated_sfixed64"), 1]); + Assert.Equal(511F, message[f("repeated_float"), 1]); + Assert.Equal(512D, message[f("repeated_double"), 1]); + Assert.Equal(true, message[f("repeated_bool"), 1]); + Assert.Equal("515", message[f("repeated_string"), 1]); + Assert.Equal(TestUtil.ToBytes("516"), message[f("repeated_bytes"), 1]); + + Assert.Equal(517, ((IMessage) message[f("repeatedgroup"), 1])[repeatedGroupA]); + Assert.Equal(518, ((IMessage) message[f("repeated_nested_message"), 1])[nestedB]); + Assert.Equal(519, ((IMessage) message[f("repeated_foreign_message"), 1])[foreignC]); + Assert.Equal(520, ((IMessage) message[f("repeated_import_message"), 1])[importD]); + + Assert.Equal(nestedFoo, message[f("repeated_nested_enum"), 1]); + Assert.Equal(foreignFoo, message[f("repeated_foreign_enum"), 1]); + Assert.Equal(importFoo, message[f("repeated_import_enum"), 1]); + + Assert.Equal("524", message[f("repeated_string_piece"), 1]); + Assert.Equal("525", message[f("repeated_cord"), 1]); } /// @@ -892,15 +892,15 @@ namespace Google.ProtocolBuffers /// public void AssertReflectionSettersRejectNull(IBuilder builder) { - TestUtil.AssertArgumentNullException(() => builder[f("optional_string")] = null); - TestUtil.AssertArgumentNullException(() => builder[f("optional_bytes")] = null); - TestUtil.AssertArgumentNullException(() => builder[f("optional_nested_enum")] = null); - TestUtil.AssertArgumentNullException(() => builder[f("optional_nested_message")] = null); - TestUtil.AssertArgumentNullException(() => builder[f("optional_nested_message")] = null); - TestUtil.AssertArgumentNullException(() => builder.WeakAddRepeatedField(f("repeated_string"), null)); - TestUtil.AssertArgumentNullException(() => builder.WeakAddRepeatedField(f("repeated_bytes"), null)); - TestUtil.AssertArgumentNullException(() => builder.WeakAddRepeatedField(f("repeated_nested_enum"), null)); - TestUtil.AssertArgumentNullException(() => builder.WeakAddRepeatedField(f("repeated_nested_message"), null)); + Assert.Throws(() => builder[f("optional_string")] = null); + Assert.Throws(() => builder[f("optional_bytes")] = null); + Assert.Throws(() => builder[f("optional_nested_enum")] = null); + Assert.Throws(() => builder[f("optional_nested_message")] = null); + Assert.Throws(() => builder[f("optional_nested_message")] = null); + Assert.Throws(() => builder.WeakAddRepeatedField(f("repeated_string"), null)); + Assert.Throws(() => builder.WeakAddRepeatedField(f("repeated_bytes"), null)); + Assert.Throws(() => builder.WeakAddRepeatedField(f("repeated_nested_enum"), null)); + Assert.Throws(() => builder.WeakAddRepeatedField(f("repeated_nested_message"), null)); } /// @@ -910,14 +910,14 @@ namespace Google.ProtocolBuffers public void AssertReflectionRepeatedSettersRejectNull(IBuilder builder) { builder.WeakAddRepeatedField(f("repeated_string"), "one"); - TestUtil.AssertArgumentNullException(() => builder.SetRepeatedField(f("repeated_string"), 0, null)); + Assert.Throws(() => builder.SetRepeatedField(f("repeated_string"), 0, null)); builder.WeakAddRepeatedField(f("repeated_bytes"), TestUtil.ToBytes("one")); - TestUtil.AssertArgumentNullException(() => builder.SetRepeatedField(f("repeated_bytes"), 0, null)); + Assert.Throws(() => builder.SetRepeatedField(f("repeated_bytes"), 0, null)); builder.WeakAddRepeatedField(f("repeated_nested_enum"), nestedBaz); - TestUtil.AssertArgumentNullException(() => builder.SetRepeatedField(f("repeated_nested_enum"), 0, null)); + Assert.Throws(() => builder.SetRepeatedField(f("repeated_nested_enum"), 0, null)); builder.WeakAddRepeatedField(f("repeated_nested_message"), new TestAllTypes.Types.NestedMessage.Builder {Bb = 218}.Build()); - TestUtil.AssertArgumentNullException(() => builder.SetRepeatedField(f("repeated_nested_message"), 0, null)); + Assert.Throws(() => builder.SetRepeatedField(f("repeated_nested_message"), 0, null)); } public void SetPackedFieldsViaReflection(IBuilder message) @@ -955,50 +955,50 @@ namespace Google.ProtocolBuffers public void AssertPackedFieldsSetViaReflection(IMessage message) { - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_int32"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_int64"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_uint32"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_uint64"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_sint32"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_sint64"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_fixed32"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_fixed64"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_sfixed32"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_sfixed64"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_float"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_double"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_bool"))); - Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_enum"))); - - Assert.AreEqual(601, message[f("packed_int32"), 0]); - Assert.AreEqual(602L, message[f("packed_int64"), 0]); - Assert.AreEqual(603u, message[f("packed_uint32"), 0]); - Assert.AreEqual(604uL, message[f("packed_uint64"), 0]); - Assert.AreEqual(605, message[f("packed_sint32"), 0]); - Assert.AreEqual(606L, message[f("packed_sint64"), 0]); - Assert.AreEqual(607u, message[f("packed_fixed32"), 0]); - Assert.AreEqual(608uL, message[f("packed_fixed64"), 0]); - Assert.AreEqual(609, message[f("packed_sfixed32"), 0]); - Assert.AreEqual(610L, message[f("packed_sfixed64"), 0]); - Assert.AreEqual(611F, message[f("packed_float"), 0]); - Assert.AreEqual(612D, message[f("packed_double"), 0]); - Assert.AreEqual(true, message[f("packed_bool"), 0]); - Assert.AreEqual(foreignBar, message[f("packed_enum"), 0]); - - Assert.AreEqual(701, message[f("packed_int32"), 1]); - Assert.AreEqual(702L, message[f("packed_int64"), 1]); - Assert.AreEqual(703u, message[f("packed_uint32"), 1]); - Assert.AreEqual(704uL, message[f("packed_uint64"), 1]); - Assert.AreEqual(705, message[f("packed_sint32"), 1]); - Assert.AreEqual(706L, message[f("packed_sint64"), 1]); - Assert.AreEqual(707u, message[f("packed_fixed32"), 1]); - Assert.AreEqual(708uL, message[f("packed_fixed64"), 1]); - Assert.AreEqual(709, message[f("packed_sfixed32"), 1]); - Assert.AreEqual(710L, message[f("packed_sfixed64"), 1]); - Assert.AreEqual(711F, message[f("packed_float"), 1]); - Assert.AreEqual(712D, message[f("packed_double"), 1]); - Assert.AreEqual(false, message[f("packed_bool"), 1]); - Assert.AreEqual(foreignBaz, message[f("packed_enum"), 1]); + Assert.Equal(2, message.GetRepeatedFieldCount(f("packed_int32"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("packed_int64"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("packed_uint32"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("packed_uint64"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("packed_sint32"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("packed_sint64"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("packed_fixed32"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("packed_fixed64"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("packed_sfixed32"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("packed_sfixed64"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("packed_float"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("packed_double"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("packed_bool"))); + Assert.Equal(2, message.GetRepeatedFieldCount(f("packed_enum"))); + + Assert.Equal(601, message[f("packed_int32"), 0]); + Assert.Equal(602L, message[f("packed_int64"), 0]); + Assert.Equal(603u, message[f("packed_uint32"), 0]); + Assert.Equal(604uL, message[f("packed_uint64"), 0]); + Assert.Equal(605, message[f("packed_sint32"), 0]); + Assert.Equal(606L, message[f("packed_sint64"), 0]); + Assert.Equal(607u, message[f("packed_fixed32"), 0]); + Assert.Equal(608uL, message[f("packed_fixed64"), 0]); + Assert.Equal(609, message[f("packed_sfixed32"), 0]); + Assert.Equal(610L, message[f("packed_sfixed64"), 0]); + Assert.Equal(611F, message[f("packed_float"), 0]); + Assert.Equal(612D, message[f("packed_double"), 0]); + Assert.Equal(true, message[f("packed_bool"), 0]); + Assert.Equal(foreignBar, message[f("packed_enum"), 0]); + + Assert.Equal(701, message[f("packed_int32"), 1]); + Assert.Equal(702L, message[f("packed_int64"), 1]); + Assert.Equal(703u, message[f("packed_uint32"), 1]); + Assert.Equal(704uL, message[f("packed_uint64"), 1]); + Assert.Equal(705, message[f("packed_sint32"), 1]); + Assert.Equal(706L, message[f("packed_sint64"), 1]); + Assert.Equal(707u, message[f("packed_fixed32"), 1]); + Assert.Equal(708uL, message[f("packed_fixed64"), 1]); + Assert.Equal(709, message[f("packed_sfixed32"), 1]); + Assert.Equal(710L, message[f("packed_sfixed64"), 1]); + Assert.Equal(711F, message[f("packed_float"), 1]); + Assert.Equal(712D, message[f("packed_double"), 1]); + Assert.Equal(false, message[f("packed_bool"), 1]); + Assert.Equal(foreignBaz, message[f("packed_enum"), 1]); } } } \ No newline at end of file diff --git a/csharp/src/ProtocolBuffers.Test/ReusableBuilderTest.cs b/csharp/src/ProtocolBuffers.Test/ReusableBuilderTest.cs index a63f6575..e6b6a1b3 100644 --- a/csharp/src/ProtocolBuffers.Test/ReusableBuilderTest.cs +++ b/csharp/src/ProtocolBuffers.Test/ReusableBuilderTest.cs @@ -1,48 +1,43 @@ using System; -using System.Collections.Generic; -using System.ComponentModel; -using System.Text; using Google.ProtocolBuffers.Collections; -using Microsoft.VisualStudio.TestTools.UnitTesting; using Google.ProtocolBuffers.TestProtos; -using Google.ProtocolBuffers.Serialization; using UnitTest.Issues.TestProtos; +using Xunit; namespace Google.ProtocolBuffers { - [TestClass] public class ReusableBuilderTest { //Issue 28: Circular message dependencies result in null defaults for DefaultInstance - [TestMethod] + [Fact] public void EnsureStaticCicularReference() { MyMessageAReferenceB ab = MyMessageAReferenceB.DefaultInstance; - Assert.IsNotNull(ab); - Assert.IsNotNull(ab.Value); + Assert.NotNull(ab); + Assert.NotNull(ab.Value); MyMessageBReferenceA ba = MyMessageBReferenceA.DefaultInstance; - Assert.IsNotNull(ba); - Assert.IsNotNull(ba.Value); + Assert.NotNull(ba); + Assert.NotNull(ba.Value); } - [TestMethod] + [Fact] public void TestModifyDefaultInstance() { //verify that the default instance has correctly been marked as read-only - Assert.AreEqual(typeof(PopsicleList), TestAllTypes.DefaultInstance.RepeatedBoolList.GetType()); + Assert.Equal(typeof(PopsicleList), TestAllTypes.DefaultInstance.RepeatedBoolList.GetType()); PopsicleList list = (PopsicleList)TestAllTypes.DefaultInstance.RepeatedBoolList; - Assert.IsTrue(list.IsReadOnly); + Assert.True(list.IsReadOnly); } - [TestMethod] + [Fact] public void TestUnmodifiedDefaultInstance() { //Simply calling ToBuilder().Build() no longer creates a copy of the message TestAllTypes.Builder builder = TestAllTypes.DefaultInstance.ToBuilder(); - Assert.IsTrue(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); + Assert.True(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); } - [TestMethod] + [Fact] public void BuildMultipleWithoutChange() { //Calling Build() or BuildPartial() does not require a copy of the message @@ -51,31 +46,31 @@ namespace Google.ProtocolBuffers TestAllTypes first = builder.BuildPartial(); //Still the same instance? - Assert.IsTrue(ReferenceEquals(first, builder.Build())); + Assert.True(ReferenceEquals(first, builder.Build())); //Still the same instance? - Assert.IsTrue(ReferenceEquals(first, builder.BuildPartial().ToBuilder().Build())); + Assert.True(ReferenceEquals(first, builder.BuildPartial().ToBuilder().Build())); } - [TestMethod] + [Fact] public void MergeFromDefaultInstance() { TestAllTypes.Builder builder = TestAllTypes.DefaultInstance.ToBuilder(); - Assert.IsTrue(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); + Assert.True(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); builder.MergeFrom(TestAllTypes.DefaultInstance); - Assert.IsTrue(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); + Assert.True(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); } - [TestMethod] + [Fact] public void BuildNewBuilderIsDefaultInstance() { - Assert.IsTrue(ReferenceEquals(TestAllTypes.DefaultInstance, new TestAllTypes.Builder().Build())); - Assert.IsTrue(ReferenceEquals(TestAllTypes.DefaultInstance, TestAllTypes.CreateBuilder().Build())); + Assert.True(ReferenceEquals(TestAllTypes.DefaultInstance, new TestAllTypes.Builder().Build())); + Assert.True(ReferenceEquals(TestAllTypes.DefaultInstance, TestAllTypes.CreateBuilder().Build())); //last test, if you clear a builder it reverts to default instance - Assert.IsTrue(ReferenceEquals(TestAllTypes.DefaultInstance, + Assert.True(ReferenceEquals(TestAllTypes.DefaultInstance, TestAllTypes.CreateBuilder().SetOptionalBool(true).Build().ToBuilder().Clear().Build())); } - [TestMethod] + [Fact] public void BuildModifyAndRebuild() { TestAllTypes.Builder b1 = new TestAllTypes.Builder(); @@ -91,80 +86,80 @@ namespace Google.ProtocolBuffers TestAllTypes m2 = b1.Build(); - Assert.AreEqual("{\"optional_foreign_message\":{},\"repeated_int32\":[2],\"default_int32\":1}", Extensions.ToJson(m1)); - Assert.AreEqual("{\"optional_foreign_message\":{\"c\":7},\"repeated_int32\":[2,6],\"default_int32\":5}", Extensions.ToJson(m2)); + Assert.Equal("{\"optional_foreign_message\":{},\"repeated_int32\":[2],\"default_int32\":1}", Extensions.ToJson(m1)); + Assert.Equal("{\"optional_foreign_message\":{\"c\":7},\"repeated_int32\":[2,6],\"default_int32\":5}", Extensions.ToJson(m2)); } - [TestMethod] + [Fact] public void CloneOnChangePrimitive() { TestAllTypes.Builder builder = TestAllTypes.DefaultInstance.ToBuilder(); - Assert.IsTrue(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); + Assert.True(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); builder.SetDefaultBool(true); - Assert.IsFalse(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); + Assert.False(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); } - [TestMethod] + [Fact] public void CloneOnAddRepeatedBool() { TestAllTypes.Builder builder = TestAllTypes.DefaultInstance.ToBuilder(); - Assert.IsTrue(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); + Assert.True(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); builder.AddRepeatedBool(true); - Assert.IsFalse(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); + Assert.False(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); } - [TestMethod] + [Fact] public void CloneOnGetRepeatedBoolList() { TestAllTypes.Builder builder = TestAllTypes.DefaultInstance.ToBuilder(); - Assert.IsTrue(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); + Assert.True(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); GC.KeepAlive(builder.RepeatedBoolList); - Assert.IsFalse(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); + Assert.False(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); } - [TestMethod] + [Fact] public void CloneOnChangeMessage() { TestAllTypes.Builder builder = TestAllTypes.DefaultInstance.ToBuilder(); - Assert.IsTrue(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); + Assert.True(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); builder.SetOptionalForeignMessage(new ForeignMessage.Builder()); - Assert.IsFalse(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); + Assert.False(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); } - [TestMethod] + [Fact] public void CloneOnClearMessage() { TestAllTypes.Builder builder = TestAllTypes.DefaultInstance.ToBuilder(); - Assert.IsTrue(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); + Assert.True(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); builder.ClearOptionalForeignMessage(); - Assert.IsFalse(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); + Assert.False(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); } - [TestMethod] + [Fact] public void CloneOnGetRepeatedForeignMessageList() { TestAllTypes.Builder builder = TestAllTypes.DefaultInstance.ToBuilder(); - Assert.IsTrue(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); + Assert.True(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); GC.KeepAlive(builder.RepeatedForeignMessageList); - Assert.IsFalse(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); + Assert.False(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); } - [TestMethod] + [Fact] public void CloneOnChangeEnumValue() { TestAllTypes.Builder builder = TestAllTypes.DefaultInstance.ToBuilder(); - Assert.IsTrue(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); + Assert.True(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); builder.SetOptionalForeignEnum(ForeignEnum.FOREIGN_BAR); - Assert.IsFalse(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); + Assert.False(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); } - [TestMethod] + [Fact] public void CloneOnGetRepeatedForeignEnumList() { TestAllTypes.Builder builder = TestAllTypes.DefaultInstance.ToBuilder(); - Assert.IsTrue(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); + Assert.True(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); GC.KeepAlive(builder.RepeatedForeignEnumList); - Assert.IsFalse(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); + Assert.False(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build())); } } diff --git a/csharp/src/ProtocolBuffers.Test/TestCornerCases.cs b/csharp/src/ProtocolBuffers.Test/TestCornerCases.cs index 0be4e1d4..5bec24f1 100644 --- a/csharp/src/ProtocolBuffers.Test/TestCornerCases.cs +++ b/csharp/src/ProtocolBuffers.Test/TestCornerCases.cs @@ -1,15 +1,11 @@ -using System; -using System.Collections.Generic; -using System.Text; -using Microsoft.VisualStudio.TestTools.UnitTesting; -using UnitTest.Issues.TestProtos; +using UnitTest.Issues.TestProtos; +using Xunit; namespace Google.ProtocolBuffers { - [TestClass] public class TestCornerCases { - [TestMethod] + [Fact] public void TestRoundTripNegativeEnums() { NegativeEnumMessage msg = NegativeEnumMessage.CreateBuilder() @@ -23,16 +19,16 @@ namespace Google.ProtocolBuffers .AddPackedValues(NegativeEnum.FiveBelow) //10 .Build(); - Assert.AreEqual(58, msg.SerializedSize); + Assert.Equal(58, msg.SerializedSize); byte[] bytes = new byte[58]; CodedOutputStream output = CodedOutputStream.CreateInstance(bytes); msg.WriteTo(output); - Assert.AreEqual(0, output.SpaceLeft); + Assert.Equal(0, output.SpaceLeft); NegativeEnumMessage copy = NegativeEnumMessage.ParseFrom(bytes); - Assert.AreEqual(msg, copy); + Assert.Equal(msg, copy); } } } diff --git a/csharp/src/ProtocolBuffers.Test/TestMimeMessageFormats.cs b/csharp/src/ProtocolBuffers.Test/TestMimeMessageFormats.cs index c16f567f..5caa2e23 100644 --- a/csharp/src/ProtocolBuffers.Test/TestMimeMessageFormats.cs +++ b/csharp/src/ProtocolBuffers.Test/TestMimeMessageFormats.cs @@ -5,11 +5,10 @@ using System.Text; using Google.ProtocolBuffers.Serialization; using Google.ProtocolBuffers.Serialization.Http; using Google.ProtocolBuffers.TestProtos; -using Microsoft.VisualStudio.TestTools.UnitTesting; +using Xunit; namespace Google.ProtocolBuffers { - [TestClass] public class TestMimeMessageFormats { // There is a whole host of various json mime types in use around the net, this is the set we accept... @@ -17,85 +16,91 @@ namespace Google.ProtocolBuffers readonly IEnumerable XmlTypes = new string[] { "text/xml", "application/xml" }; readonly IEnumerable ProtobufTypes = new string[] { "application/binary", "application/x-protobuf", "application/vnd.google.protobuf" }; - [TestMethod] + [Fact] public void TestReadJsonMimeTypes() { foreach (string type in JsonTypes) { - Assert.IsTrue( + Assert.True( MessageFormatFactory.CreateInputStream(new MessageFormatOptions(), type, Stream.Null) is JsonFormatReader); } - Assert.IsTrue( + Assert.True( MessageFormatFactory.CreateInputStream(new MessageFormatOptions() { DefaultContentType = "application/json" }, null, Stream.Null) is JsonFormatReader); } - [TestMethod] + + [Fact] public void TestWriteJsonMimeTypes() { foreach (string type in JsonTypes) { - Assert.IsTrue( + Assert.True( MessageFormatFactory.CreateOutputStream(new MessageFormatOptions(), type, Stream.Null) is JsonFormatWriter); } - Assert.IsTrue( + Assert.True( MessageFormatFactory.CreateOutputStream(new MessageFormatOptions() { DefaultContentType = "application/json" }, null, Stream.Null) is JsonFormatWriter); } - [TestMethod] + + [Fact] public void TestReadXmlMimeTypes() { foreach (string type in XmlTypes) { - Assert.IsTrue( + Assert.True( MessageFormatFactory.CreateInputStream(new MessageFormatOptions(), type, Stream.Null) is XmlFormatReader); } - Assert.IsTrue( + Assert.True( MessageFormatFactory.CreateInputStream(new MessageFormatOptions() { DefaultContentType = "application/xml" }, null, Stream.Null) is XmlFormatReader); } - [TestMethod] + + [Fact] public void TestWriteXmlMimeTypes() { foreach (string type in XmlTypes) { - Assert.IsTrue( + Assert.True( MessageFormatFactory.CreateOutputStream(new MessageFormatOptions(), type, Stream.Null) is XmlFormatWriter); } - Assert.IsTrue( + Assert.True( MessageFormatFactory.CreateOutputStream(new MessageFormatOptions() { DefaultContentType = "application/xml" }, null, Stream.Null) is XmlFormatWriter); } - [TestMethod] + + [Fact] public void TestReadProtoMimeTypes() { foreach (string type in ProtobufTypes) { - Assert.IsTrue( + Assert.True( MessageFormatFactory.CreateInputStream(new MessageFormatOptions(), type, Stream.Null) is CodedInputStream); } - Assert.IsTrue( + Assert.True( MessageFormatFactory.CreateInputStream(new MessageFormatOptions() { DefaultContentType = "application/vnd.google.protobuf" }, null, Stream.Null) is CodedInputStream); } - [TestMethod] + + [Fact] public void TestWriteProtoMimeTypes() { foreach (string type in ProtobufTypes) { - Assert.IsTrue( + Assert.True( MessageFormatFactory.CreateOutputStream(new MessageFormatOptions(), type, Stream.Null) is CodedOutputStream); } - Assert.IsTrue( + Assert.True( MessageFormatFactory.CreateOutputStream(new MessageFormatOptions() { DefaultContentType = "application/vnd.google.protobuf" }, null, Stream.Null) is CodedOutputStream); } - [TestMethod] + + [Fact] public void TestMergeFromJsonType() { TestXmlMessage msg = Extensions.MergeFrom(new TestXmlMessage.Builder(), @@ -103,10 +108,11 @@ namespace Google.ProtocolBuffers Extensions.ToJson(TestXmlMessage.CreateBuilder().SetText("a").SetNumber(1).Build()) ))) .Build(); - Assert.AreEqual("a", msg.Text); - Assert.AreEqual(1, msg.Number); + Assert.Equal("a", msg.Text); + Assert.Equal(1, msg.Number); } - [TestMethod] + + [Fact] public void TestMergeFromXmlType() { TestXmlMessage msg = Extensions.MergeFrom(new TestXmlMessage.Builder(), @@ -114,10 +120,10 @@ namespace Google.ProtocolBuffers Extensions.ToXml(TestXmlMessage.CreateBuilder().SetText("a").SetNumber(1).Build()) ))) .Build(); - Assert.AreEqual("a", msg.Text); - Assert.AreEqual(1, msg.Number); + Assert.Equal("a", msg.Text); + Assert.Equal(1, msg.Number); } - [TestMethod] + [Fact] public void TestMergeFromProtoType() { TestXmlMessage msg = Extensions.MergeFrom(new TestXmlMessage.Builder(), @@ -125,28 +131,30 @@ namespace Google.ProtocolBuffers TestXmlMessage.CreateBuilder().SetText("a").SetNumber(1).Build().ToByteArray() )) .Build(); - Assert.AreEqual("a", msg.Text); - Assert.AreEqual(1, msg.Number); + Assert.Equal("a", msg.Text); + Assert.Equal(1, msg.Number); } - [TestMethod] + + [Fact] public void TestWriteToJsonType() { MemoryStream ms = new MemoryStream(); Extensions.WriteTo(TestXmlMessage.CreateBuilder().SetText("a").SetNumber(1).Build(), new MessageFormatOptions(), "application/json", ms); - Assert.AreEqual(@"{""text"":""a"",""number"":1}", Encoding.UTF8.GetString(ms.ToArray(), 0, (int)ms.Length)); + Assert.Equal(@"{""text"":""a"",""number"":1}", Encoding.UTF8.GetString(ms.ToArray(), 0, (int)ms.Length)); } - [TestMethod] + + [Fact] public void TestWriteToXmlType() { MemoryStream ms = new MemoryStream(); Extensions.WriteTo(TestXmlMessage.CreateBuilder().SetText("a").SetNumber(1).Build(), new MessageFormatOptions(), "application/xml", ms); - Assert.AreEqual("a1", Encoding.UTF8.GetString(ms.ToArray(), 0, (int)ms.Length)); + Assert.Equal("a1", Encoding.UTF8.GetString(ms.ToArray(), 0, (int)ms.Length)); } - [TestMethod] + [Fact] public void TestWriteToProtoType() { MemoryStream ms = new MemoryStream(); @@ -154,9 +162,10 @@ namespace Google.ProtocolBuffers new MessageFormatOptions(), "application/vnd.google.protobuf", ms); byte[] bytes = TestXmlMessage.CreateBuilder().SetText("a").SetNumber(1).Build().ToByteArray(); - TestUtil.AssertBytesEqual(bytes, ms.ToArray()); + Assert.Equal(bytes, ms.ToArray()); } - [TestMethod] + + [Fact] public void TestXmlReaderOptions() { MemoryStream ms = new MemoryStream(); @@ -175,12 +184,13 @@ namespace Google.ProtocolBuffers options, "application/xml", ms) .Build(); - Assert.AreEqual("a", msg.Text); - Assert.AreEqual(1, msg.NumbersList[0]); - Assert.AreEqual(2, msg.NumbersList[1]); + Assert.Equal("a", msg.Text); + Assert.Equal(1, msg.NumbersList[0]); + Assert.Equal(2, msg.NumbersList[1]); } - [TestMethod] + + [Fact] public void TestXmlWriterOptions() { TestXmlMessage message = TestXmlMessage.CreateBuilder().SetText("a").AddNumbers(1).AddNumbers(2).Build(); @@ -199,30 +209,32 @@ namespace Google.ProtocolBuffers .SetOptions(XmlReaderOptions.ReadNestedArrays) .Merge("root-node", builder); - Assert.AreEqual("a", builder.Text); - Assert.AreEqual(1, builder.NumbersList[0]); - Assert.AreEqual(2, builder.NumbersList[1]); + Assert.Equal("a", builder.Text); + Assert.Equal(1, builder.NumbersList[0]); + Assert.Equal(2, builder.NumbersList[1]); } - [TestMethod] + + [Fact] public void TestJsonFormatted() { MemoryStream ms = new MemoryStream(); Extensions.WriteTo(TestXmlMessage.CreateBuilder().SetText("a").SetNumber(1).Build(), new MessageFormatOptions() { FormattedOutput = true }, "application/json", ms); - Assert.AreEqual("{\r\n \"text\": \"a\",\r\n \"number\": 1\r\n}", Encoding.UTF8.GetString(ms.ToArray(), 0, (int)ms.Length)); + Assert.Equal("{\r\n \"text\": \"a\",\r\n \"number\": 1\r\n}", Encoding.UTF8.GetString(ms.ToArray(), 0, (int)ms.Length)); } - [TestMethod] + + [Fact] public void TestXmlFormatted() { MemoryStream ms = new MemoryStream(); Extensions.WriteTo(TestXmlMessage.CreateBuilder().SetText("a").SetNumber(1).Build(), new MessageFormatOptions() { FormattedOutput = true }, "application/xml", ms); - Assert.AreEqual("\r\n a\r\n 1\r\n", Encoding.UTF8.GetString(ms.ToArray(), 0, (int)ms.Length)); + Assert.Equal("\r\n a\r\n 1\r\n", Encoding.UTF8.GetString(ms.ToArray(), 0, (int)ms.Length)); } - [TestMethod] + [Fact] public void TestReadCustomMimeTypes() { var options = new MessageFormatOptions(); @@ -230,7 +242,7 @@ namespace Google.ProtocolBuffers options.MimeInputTypes.Clear(); //Add our own options.MimeInputTypes.Add("-custom-XML-mime-type-", XmlFormatReader.CreateInstance); - Assert.AreEqual(1, options.MimeInputTypes.Count); + Assert.Equal(1, options.MimeInputTypes.Count); Stream xmlStream = new MemoryStream(Encoding.UTF8.GetBytes( Extensions.ToXml(TestXmlMessage.CreateBuilder().SetText("a").SetNumber(1).Build()) @@ -239,11 +251,11 @@ namespace Google.ProtocolBuffers TestXmlMessage msg = Extensions.MergeFrom(new TestXmlMessage.Builder(), options, "-custom-XML-mime-type-", xmlStream) .Build(); - Assert.AreEqual("a", msg.Text); - Assert.AreEqual(1, msg.Number); + Assert.Equal("a", msg.Text); + Assert.Equal(1, msg.Number); } - [TestMethod] + [Fact] public void TestWriteToCustomType() { var options = new MessageFormatOptions(); @@ -252,13 +264,13 @@ namespace Google.ProtocolBuffers //Add our own options.MimeOutputTypes.Add("-custom-XML-mime-type-", XmlFormatWriter.CreateInstance); - Assert.AreEqual(1, options.MimeOutputTypes.Count); + Assert.Equal(1, options.MimeOutputTypes.Count); MemoryStream ms = new MemoryStream(); Extensions.WriteTo(TestXmlMessage.CreateBuilder().SetText("a").SetNumber(1).Build(), options, "-custom-XML-mime-type-", ms); - Assert.AreEqual("a1", Encoding.UTF8.GetString(ms.ToArray(), 0, (int)ms.Length)); + Assert.Equal("a1", Encoding.UTF8.GetString(ms.ToArray(), 0, (int)ms.Length)); } } } \ No newline at end of file diff --git a/csharp/src/ProtocolBuffers.Test/TestReaderForUrlEncoded.cs b/csharp/src/ProtocolBuffers.Test/TestReaderForUrlEncoded.cs index 1c43e24d..b262667a 100644 --- a/csharp/src/ProtocolBuffers.Test/TestReaderForUrlEncoded.cs +++ b/csharp/src/ProtocolBuffers.Test/TestReaderForUrlEncoded.cs @@ -1,16 +1,15 @@ using System; using System.IO; using System.Text; -using Microsoft.VisualStudio.TestTools.UnitTesting; using Google.ProtocolBuffers.TestProtos; using Google.ProtocolBuffers.Serialization.Http; +using Xunit; namespace Google.ProtocolBuffers { - [TestClass] public class TestReaderForUrlEncoded { - [TestMethod] + [Fact] public void Example_FromQueryString() { Uri sampleUri = new Uri("http://sample.com/Path/File.ext?text=two+three%20four&valid=true&numbers=1&numbers=2", UriKind.Absolute); @@ -21,14 +20,14 @@ namespace Google.ProtocolBuffers builder.MergeFrom(input); TestXmlMessage message = builder.Build(); - Assert.AreEqual(true, message.Valid); - Assert.AreEqual("two three four", message.Text); - Assert.AreEqual(2, message.NumbersCount); - Assert.AreEqual(1, message.NumbersList[0]); - Assert.AreEqual(2, message.NumbersList[1]); + Assert.Equal(true, message.Valid); + Assert.Equal("two three four", message.Text); + Assert.Equal(2, message.NumbersCount); + Assert.Equal(1, message.NumbersList[0]); + Assert.Equal(2, message.NumbersList[1]); } - [TestMethod] + [Fact] public void Example_FromFormData() { Stream rawPost = new MemoryStream(Encoding.UTF8.GetBytes("text=two+three%20four&valid=true&numbers=1&numbers=2"), false); @@ -39,46 +38,46 @@ namespace Google.ProtocolBuffers builder.MergeFrom(input); TestXmlMessage message = builder.Build(); - Assert.AreEqual(true, message.Valid); - Assert.AreEqual("two three four", message.Text); - Assert.AreEqual(2, message.NumbersCount); - Assert.AreEqual(1, message.NumbersList[0]); - Assert.AreEqual(2, message.NumbersList[1]); + Assert.Equal(true, message.Valid); + Assert.Equal("two three four", message.Text); + Assert.Equal(2, message.NumbersCount); + Assert.Equal(1, message.NumbersList[0]); + Assert.Equal(2, message.NumbersList[1]); } - [TestMethod] + [Fact] public void TestEmptyValues() { ICodedInputStream input = FormUrlEncodedReader.CreateInstance("valid=true&text=&numbers=1"); TestXmlMessage.Builder builder = TestXmlMessage.CreateBuilder(); builder.MergeFrom(input); - Assert.IsTrue(builder.Valid); - Assert.IsTrue(builder.HasText); - Assert.AreEqual("", builder.Text); - Assert.AreEqual(1, builder.NumbersCount); - Assert.AreEqual(1, builder.NumbersList[0]); + Assert.True(builder.Valid); + Assert.True(builder.HasText); + Assert.Equal("", builder.Text); + Assert.Equal(1, builder.NumbersCount); + Assert.Equal(1, builder.NumbersList[0]); } - [TestMethod] + [Fact] public void TestNoValue() { ICodedInputStream input = FormUrlEncodedReader.CreateInstance("valid=true&text&numbers=1"); TestXmlMessage.Builder builder = TestXmlMessage.CreateBuilder(); builder.MergeFrom(input); - Assert.IsTrue(builder.Valid); - Assert.IsTrue(builder.HasText); - Assert.AreEqual("", builder.Text); - Assert.AreEqual(1, builder.NumbersCount); - Assert.AreEqual(1, builder.NumbersList[0]); + Assert.True(builder.Valid); + Assert.True(builder.HasText); + Assert.Equal("", builder.Text); + Assert.Equal(1, builder.NumbersCount); + Assert.Equal(1, builder.NumbersList[0]); } - [TestMethod, ExpectedException(typeof(NotSupportedException))] + [Fact] public void FormUrlEncodedReaderDoesNotSupportChildren() { ICodedInputStream input = FormUrlEncodedReader.CreateInstance("child=uh0"); - TestXmlMessage.CreateBuilder().MergeFrom(input); + Assert.Throws(() => TestXmlMessage.CreateBuilder().MergeFrom(input)); } } } diff --git a/csharp/src/ProtocolBuffers.Test/TestUtil.cs b/csharp/src/ProtocolBuffers.Test/TestUtil.cs index ec30cbcd..83509c18 100644 --- a/csharp/src/ProtocolBuffers.Test/TestUtil.cs +++ b/csharp/src/ProtocolBuffers.Test/TestUtil.cs @@ -41,7 +41,7 @@ using System.IO; using System.Text; using System.Threading; using Google.ProtocolBuffers.TestProtos; -using Microsoft.VisualStudio.TestTools.UnitTesting; +using Xunit; namespace Google.ProtocolBuffers { @@ -324,343 +324,343 @@ namespace Google.ProtocolBuffers /// internal static void AssertAllFieldsSet(TestAllTypes message) { - Assert.IsTrue(message.HasOptionalInt32); - Assert.IsTrue(message.HasOptionalInt64); - Assert.IsTrue(message.HasOptionalUint32); - Assert.IsTrue(message.HasOptionalUint64); - Assert.IsTrue(message.HasOptionalSint32); - Assert.IsTrue(message.HasOptionalSint64); - Assert.IsTrue(message.HasOptionalFixed32); - Assert.IsTrue(message.HasOptionalFixed64); - Assert.IsTrue(message.HasOptionalSfixed32); - Assert.IsTrue(message.HasOptionalSfixed64); - Assert.IsTrue(message.HasOptionalFloat); - Assert.IsTrue(message.HasOptionalDouble); - Assert.IsTrue(message.HasOptionalBool); - Assert.IsTrue(message.HasOptionalString); - Assert.IsTrue(message.HasOptionalBytes); - - Assert.IsTrue(message.HasOptionalGroup); - Assert.IsTrue(message.HasOptionalNestedMessage); - Assert.IsTrue(message.HasOptionalForeignMessage); - Assert.IsTrue(message.HasOptionalImportMessage); - - Assert.IsTrue(message.OptionalGroup.HasA); - Assert.IsTrue(message.OptionalNestedMessage.HasBb); - Assert.IsTrue(message.OptionalForeignMessage.HasC); - Assert.IsTrue(message.OptionalImportMessage.HasD); - - Assert.IsTrue(message.HasOptionalNestedEnum); - Assert.IsTrue(message.HasOptionalForeignEnum); - Assert.IsTrue(message.HasOptionalImportEnum); - - Assert.IsTrue(message.HasOptionalStringPiece); - Assert.IsTrue(message.HasOptionalCord); - - Assert.AreEqual(101, message.OptionalInt32); - Assert.AreEqual(102, message.OptionalInt64); - Assert.AreEqual(103u, message.OptionalUint32); - Assert.AreEqual(104u, message.OptionalUint64); - Assert.AreEqual(105, message.OptionalSint32); - Assert.AreEqual(106, message.OptionalSint64); - Assert.AreEqual(107u, message.OptionalFixed32); - Assert.AreEqual(108u, message.OptionalFixed64); - Assert.AreEqual(109, message.OptionalSfixed32); - Assert.AreEqual(110, message.OptionalSfixed64); - Assert.AreEqual(111, message.OptionalFloat); - Assert.AreEqual(112, message.OptionalDouble); - Assert.AreEqual(true, message.OptionalBool); - Assert.AreEqual("115", message.OptionalString); - Assert.AreEqual(ToBytes("116"), message.OptionalBytes); - - Assert.AreEqual(117, message.OptionalGroup.A); - Assert.AreEqual(118, message.OptionalNestedMessage.Bb); - Assert.AreEqual(119, message.OptionalForeignMessage.C); - Assert.AreEqual(120, message.OptionalImportMessage.D); - - Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAZ, message.OptionalNestedEnum); - Assert.AreEqual(ForeignEnum.FOREIGN_BAZ, message.OptionalForeignEnum); - Assert.AreEqual(ImportEnum.IMPORT_BAZ, message.OptionalImportEnum); - - Assert.AreEqual("124", message.OptionalStringPiece); - Assert.AreEqual("125", message.OptionalCord); + Assert.True(message.HasOptionalInt32); + Assert.True(message.HasOptionalInt64); + Assert.True(message.HasOptionalUint32); + Assert.True(message.HasOptionalUint64); + Assert.True(message.HasOptionalSint32); + Assert.True(message.HasOptionalSint64); + Assert.True(message.HasOptionalFixed32); + Assert.True(message.HasOptionalFixed64); + Assert.True(message.HasOptionalSfixed32); + Assert.True(message.HasOptionalSfixed64); + Assert.True(message.HasOptionalFloat); + Assert.True(message.HasOptionalDouble); + Assert.True(message.HasOptionalBool); + Assert.True(message.HasOptionalString); + Assert.True(message.HasOptionalBytes); + + Assert.True(message.HasOptionalGroup); + Assert.True(message.HasOptionalNestedMessage); + Assert.True(message.HasOptionalForeignMessage); + Assert.True(message.HasOptionalImportMessage); + + Assert.True(message.OptionalGroup.HasA); + Assert.True(message.OptionalNestedMessage.HasBb); + Assert.True(message.OptionalForeignMessage.HasC); + Assert.True(message.OptionalImportMessage.HasD); + + Assert.True(message.HasOptionalNestedEnum); + Assert.True(message.HasOptionalForeignEnum); + Assert.True(message.HasOptionalImportEnum); + + Assert.True(message.HasOptionalStringPiece); + Assert.True(message.HasOptionalCord); + + Assert.Equal(101, message.OptionalInt32); + Assert.Equal(102, message.OptionalInt64); + Assert.Equal(103u, message.OptionalUint32); + Assert.Equal(104u, message.OptionalUint64); + Assert.Equal(105, message.OptionalSint32); + Assert.Equal(106, message.OptionalSint64); + Assert.Equal(107u, message.OptionalFixed32); + Assert.Equal(108u, message.OptionalFixed64); + Assert.Equal(109, message.OptionalSfixed32); + Assert.Equal(110, message.OptionalSfixed64); + Assert.Equal(111, message.OptionalFloat); + Assert.Equal(112, message.OptionalDouble); + Assert.Equal(true, message.OptionalBool); + Assert.Equal("115", message.OptionalString); + Assert.Equal(ToBytes("116"), message.OptionalBytes); + + Assert.Equal(117, message.OptionalGroup.A); + Assert.Equal(118, message.OptionalNestedMessage.Bb); + Assert.Equal(119, message.OptionalForeignMessage.C); + Assert.Equal(120, message.OptionalImportMessage.D); + + Assert.Equal(TestAllTypes.Types.NestedEnum.BAZ, message.OptionalNestedEnum); + Assert.Equal(ForeignEnum.FOREIGN_BAZ, message.OptionalForeignEnum); + Assert.Equal(ImportEnum.IMPORT_BAZ, message.OptionalImportEnum); + + Assert.Equal("124", message.OptionalStringPiece); + Assert.Equal("125", message.OptionalCord); // ----------------------------------------------------------------- - Assert.AreEqual(2, message.RepeatedInt32Count); - Assert.AreEqual(2, message.RepeatedInt64Count); - Assert.AreEqual(2, message.RepeatedUint32Count); - Assert.AreEqual(2, message.RepeatedUint64Count); - Assert.AreEqual(2, message.RepeatedSint32Count); - Assert.AreEqual(2, message.RepeatedSint64Count); - Assert.AreEqual(2, message.RepeatedFixed32Count); - Assert.AreEqual(2, message.RepeatedFixed64Count); - Assert.AreEqual(2, message.RepeatedSfixed32Count); - Assert.AreEqual(2, message.RepeatedSfixed64Count); - Assert.AreEqual(2, message.RepeatedFloatCount); - Assert.AreEqual(2, message.RepeatedDoubleCount); - Assert.AreEqual(2, message.RepeatedBoolCount); - Assert.AreEqual(2, message.RepeatedStringCount); - Assert.AreEqual(2, message.RepeatedBytesCount); - - Assert.AreEqual(2, message.RepeatedGroupCount); - Assert.AreEqual(2, message.RepeatedNestedMessageCount); - Assert.AreEqual(2, message.RepeatedForeignMessageCount); - Assert.AreEqual(2, message.RepeatedImportMessageCount); - Assert.AreEqual(2, message.RepeatedNestedEnumCount); - Assert.AreEqual(2, message.RepeatedForeignEnumCount); - Assert.AreEqual(2, message.RepeatedImportEnumCount); - - Assert.AreEqual(2, message.RepeatedStringPieceCount); - Assert.AreEqual(2, message.RepeatedCordCount); - - Assert.AreEqual(201, message.GetRepeatedInt32(0)); - Assert.AreEqual(202, message.GetRepeatedInt64(0)); - Assert.AreEqual(203u, message.GetRepeatedUint32(0)); - Assert.AreEqual(204u, message.GetRepeatedUint64(0)); - Assert.AreEqual(205, message.GetRepeatedSint32(0)); - Assert.AreEqual(206, message.GetRepeatedSint64(0)); - Assert.AreEqual(207u, message.GetRepeatedFixed32(0)); - Assert.AreEqual(208u, message.GetRepeatedFixed64(0)); - Assert.AreEqual(209, message.GetRepeatedSfixed32(0)); - Assert.AreEqual(210, message.GetRepeatedSfixed64(0)); - Assert.AreEqual(211, message.GetRepeatedFloat(0)); - Assert.AreEqual(212, message.GetRepeatedDouble(0)); - Assert.AreEqual(true, message.GetRepeatedBool(0)); - Assert.AreEqual("215", message.GetRepeatedString(0)); - Assert.AreEqual(ToBytes("216"), message.GetRepeatedBytes(0)); - - Assert.AreEqual(217, message.GetRepeatedGroup(0).A); - Assert.AreEqual(218, message.GetRepeatedNestedMessage(0).Bb); - Assert.AreEqual(219, message.GetRepeatedForeignMessage(0).C); - Assert.AreEqual(220, message.GetRepeatedImportMessage(0).D); - - Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, message.GetRepeatedNestedEnum(0)); - Assert.AreEqual(ForeignEnum.FOREIGN_BAR, message.GetRepeatedForeignEnum(0)); - Assert.AreEqual(ImportEnum.IMPORT_BAR, message.GetRepeatedImportEnum(0)); - - Assert.AreEqual("224", message.GetRepeatedStringPiece(0)); - Assert.AreEqual("225", message.GetRepeatedCord(0)); - - Assert.AreEqual(301, message.GetRepeatedInt32(1)); - Assert.AreEqual(302, message.GetRepeatedInt64(1)); - Assert.AreEqual(303u, message.GetRepeatedUint32(1)); - Assert.AreEqual(304u, message.GetRepeatedUint64(1)); - Assert.AreEqual(305, message.GetRepeatedSint32(1)); - Assert.AreEqual(306, message.GetRepeatedSint64(1)); - Assert.AreEqual(307u, message.GetRepeatedFixed32(1)); - Assert.AreEqual(308u, message.GetRepeatedFixed64(1)); - Assert.AreEqual(309, message.GetRepeatedSfixed32(1)); - Assert.AreEqual(310, message.GetRepeatedSfixed64(1)); - Assert.AreEqual(311, message.GetRepeatedFloat(1), 0.0); - Assert.AreEqual(312, message.GetRepeatedDouble(1), 0.0); - Assert.AreEqual(false, message.GetRepeatedBool(1)); - Assert.AreEqual("315", message.GetRepeatedString(1)); - Assert.AreEqual(ToBytes("316"), message.GetRepeatedBytes(1)); - - Assert.AreEqual(317, message.GetRepeatedGroup(1).A); - Assert.AreEqual(318, message.GetRepeatedNestedMessage(1).Bb); - Assert.AreEqual(319, message.GetRepeatedForeignMessage(1).C); - Assert.AreEqual(320, message.GetRepeatedImportMessage(1).D); - - Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAZ, message.GetRepeatedNestedEnum(1)); - Assert.AreEqual(ForeignEnum.FOREIGN_BAZ, message.GetRepeatedForeignEnum(1)); - Assert.AreEqual(ImportEnum.IMPORT_BAZ, message.GetRepeatedImportEnum(1)); - - Assert.AreEqual("324", message.GetRepeatedStringPiece(1)); - Assert.AreEqual("325", message.GetRepeatedCord(1)); + Assert.Equal(2, message.RepeatedInt32Count); + Assert.Equal(2, message.RepeatedInt64Count); + Assert.Equal(2, message.RepeatedUint32Count); + Assert.Equal(2, message.RepeatedUint64Count); + Assert.Equal(2, message.RepeatedSint32Count); + Assert.Equal(2, message.RepeatedSint64Count); + Assert.Equal(2, message.RepeatedFixed32Count); + Assert.Equal(2, message.RepeatedFixed64Count); + Assert.Equal(2, message.RepeatedSfixed32Count); + Assert.Equal(2, message.RepeatedSfixed64Count); + Assert.Equal(2, message.RepeatedFloatCount); + Assert.Equal(2, message.RepeatedDoubleCount); + Assert.Equal(2, message.RepeatedBoolCount); + Assert.Equal(2, message.RepeatedStringCount); + Assert.Equal(2, message.RepeatedBytesCount); + + Assert.Equal(2, message.RepeatedGroupCount); + Assert.Equal(2, message.RepeatedNestedMessageCount); + Assert.Equal(2, message.RepeatedForeignMessageCount); + Assert.Equal(2, message.RepeatedImportMessageCount); + Assert.Equal(2, message.RepeatedNestedEnumCount); + Assert.Equal(2, message.RepeatedForeignEnumCount); + Assert.Equal(2, message.RepeatedImportEnumCount); + + Assert.Equal(2, message.RepeatedStringPieceCount); + Assert.Equal(2, message.RepeatedCordCount); + + Assert.Equal(201, message.GetRepeatedInt32(0)); + Assert.Equal(202, message.GetRepeatedInt64(0)); + Assert.Equal(203u, message.GetRepeatedUint32(0)); + Assert.Equal(204u, message.GetRepeatedUint64(0)); + Assert.Equal(205, message.GetRepeatedSint32(0)); + Assert.Equal(206, message.GetRepeatedSint64(0)); + Assert.Equal(207u, message.GetRepeatedFixed32(0)); + Assert.Equal(208u, message.GetRepeatedFixed64(0)); + Assert.Equal(209, message.GetRepeatedSfixed32(0)); + Assert.Equal(210, message.GetRepeatedSfixed64(0)); + Assert.Equal(211, message.GetRepeatedFloat(0)); + Assert.Equal(212, message.GetRepeatedDouble(0)); + Assert.Equal(true, message.GetRepeatedBool(0)); + Assert.Equal("215", message.GetRepeatedString(0)); + Assert.Equal(ToBytes("216"), message.GetRepeatedBytes(0)); + + Assert.Equal(217, message.GetRepeatedGroup(0).A); + Assert.Equal(218, message.GetRepeatedNestedMessage(0).Bb); + Assert.Equal(219, message.GetRepeatedForeignMessage(0).C); + Assert.Equal(220, message.GetRepeatedImportMessage(0).D); + + Assert.Equal(TestAllTypes.Types.NestedEnum.BAR, message.GetRepeatedNestedEnum(0)); + Assert.Equal(ForeignEnum.FOREIGN_BAR, message.GetRepeatedForeignEnum(0)); + Assert.Equal(ImportEnum.IMPORT_BAR, message.GetRepeatedImportEnum(0)); + + Assert.Equal("224", message.GetRepeatedStringPiece(0)); + Assert.Equal("225", message.GetRepeatedCord(0)); + + Assert.Equal(301, message.GetRepeatedInt32(1)); + Assert.Equal(302, message.GetRepeatedInt64(1)); + Assert.Equal(303u, message.GetRepeatedUint32(1)); + Assert.Equal(304u, message.GetRepeatedUint64(1)); + Assert.Equal(305, message.GetRepeatedSint32(1)); + Assert.Equal(306, message.GetRepeatedSint64(1)); + Assert.Equal(307u, message.GetRepeatedFixed32(1)); + Assert.Equal(308u, message.GetRepeatedFixed64(1)); + Assert.Equal(309, message.GetRepeatedSfixed32(1)); + Assert.Equal(310, message.GetRepeatedSfixed64(1)); + Assert.Equal(311f, message.GetRepeatedFloat(1)); + Assert.Equal(312d, message.GetRepeatedDouble(1)); + Assert.Equal(false, message.GetRepeatedBool(1)); + Assert.Equal("315", message.GetRepeatedString(1)); + Assert.Equal(ToBytes("316"), message.GetRepeatedBytes(1)); + + Assert.Equal(317, message.GetRepeatedGroup(1).A); + Assert.Equal(318, message.GetRepeatedNestedMessage(1).Bb); + Assert.Equal(319, message.GetRepeatedForeignMessage(1).C); + Assert.Equal(320, message.GetRepeatedImportMessage(1).D); + + Assert.Equal(TestAllTypes.Types.NestedEnum.BAZ, message.GetRepeatedNestedEnum(1)); + Assert.Equal(ForeignEnum.FOREIGN_BAZ, message.GetRepeatedForeignEnum(1)); + Assert.Equal(ImportEnum.IMPORT_BAZ, message.GetRepeatedImportEnum(1)); + + Assert.Equal("324", message.GetRepeatedStringPiece(1)); + Assert.Equal("325", message.GetRepeatedCord(1)); // ----------------------------------------------------------------- - Assert.IsTrue(message.HasDefaultInt32); - Assert.IsTrue(message.HasDefaultInt64); - Assert.IsTrue(message.HasDefaultUint32); - Assert.IsTrue(message.HasDefaultUint64); - Assert.IsTrue(message.HasDefaultSint32); - Assert.IsTrue(message.HasDefaultSint64); - Assert.IsTrue(message.HasDefaultFixed32); - Assert.IsTrue(message.HasDefaultFixed64); - Assert.IsTrue(message.HasDefaultSfixed32); - Assert.IsTrue(message.HasDefaultSfixed64); - Assert.IsTrue(message.HasDefaultFloat); - Assert.IsTrue(message.HasDefaultDouble); - Assert.IsTrue(message.HasDefaultBool); - Assert.IsTrue(message.HasDefaultString); - Assert.IsTrue(message.HasDefaultBytes); - - Assert.IsTrue(message.HasDefaultNestedEnum); - Assert.IsTrue(message.HasDefaultForeignEnum); - Assert.IsTrue(message.HasDefaultImportEnum); - - Assert.IsTrue(message.HasDefaultStringPiece); - Assert.IsTrue(message.HasDefaultCord); - - Assert.AreEqual(401, message.DefaultInt32); - Assert.AreEqual(402, message.DefaultInt64); - Assert.AreEqual(403u, message.DefaultUint32); - Assert.AreEqual(404u, message.DefaultUint64); - Assert.AreEqual(405, message.DefaultSint32); - Assert.AreEqual(406, message.DefaultSint64); - Assert.AreEqual(407u, message.DefaultFixed32); - Assert.AreEqual(408u, message.DefaultFixed64); - Assert.AreEqual(409, message.DefaultSfixed32); - Assert.AreEqual(410, message.DefaultSfixed64); - Assert.AreEqual(411, message.DefaultFloat); - Assert.AreEqual(412, message.DefaultDouble); - Assert.AreEqual(false, message.DefaultBool); - Assert.AreEqual("415", message.DefaultString); - Assert.AreEqual(ToBytes("416"), message.DefaultBytes); - - Assert.AreEqual(TestAllTypes.Types.NestedEnum.FOO, message.DefaultNestedEnum); - Assert.AreEqual(ForeignEnum.FOREIGN_FOO, message.DefaultForeignEnum); - Assert.AreEqual(ImportEnum.IMPORT_FOO, message.DefaultImportEnum); - - Assert.AreEqual("424", message.DefaultStringPiece); - Assert.AreEqual("425", message.DefaultCord); + Assert.True(message.HasDefaultInt32); + Assert.True(message.HasDefaultInt64); + Assert.True(message.HasDefaultUint32); + Assert.True(message.HasDefaultUint64); + Assert.True(message.HasDefaultSint32); + Assert.True(message.HasDefaultSint64); + Assert.True(message.HasDefaultFixed32); + Assert.True(message.HasDefaultFixed64); + Assert.True(message.HasDefaultSfixed32); + Assert.True(message.HasDefaultSfixed64); + Assert.True(message.HasDefaultFloat); + Assert.True(message.HasDefaultDouble); + Assert.True(message.HasDefaultBool); + Assert.True(message.HasDefaultString); + Assert.True(message.HasDefaultBytes); + + Assert.True(message.HasDefaultNestedEnum); + Assert.True(message.HasDefaultForeignEnum); + Assert.True(message.HasDefaultImportEnum); + + Assert.True(message.HasDefaultStringPiece); + Assert.True(message.HasDefaultCord); + + Assert.Equal(401, message.DefaultInt32); + Assert.Equal(402, message.DefaultInt64); + Assert.Equal(403u, message.DefaultUint32); + Assert.Equal(404u, message.DefaultUint64); + Assert.Equal(405, message.DefaultSint32); + Assert.Equal(406, message.DefaultSint64); + Assert.Equal(407u, message.DefaultFixed32); + Assert.Equal(408u, message.DefaultFixed64); + Assert.Equal(409, message.DefaultSfixed32); + Assert.Equal(410, message.DefaultSfixed64); + Assert.Equal(411, message.DefaultFloat); + Assert.Equal(412, message.DefaultDouble); + Assert.Equal(false, message.DefaultBool); + Assert.Equal("415", message.DefaultString); + Assert.Equal(ToBytes("416"), message.DefaultBytes); + + Assert.Equal(TestAllTypes.Types.NestedEnum.FOO, message.DefaultNestedEnum); + Assert.Equal(ForeignEnum.FOREIGN_FOO, message.DefaultForeignEnum); + Assert.Equal(ImportEnum.IMPORT_FOO, message.DefaultImportEnum); + + Assert.Equal("424", message.DefaultStringPiece); + Assert.Equal("425", message.DefaultCord); } internal static void AssertClear(TestAllTypes message) { // HasBlah() should initially be false for all optional fields. - Assert.IsFalse(message.HasOptionalInt32); - Assert.IsFalse(message.HasOptionalInt64); - Assert.IsFalse(message.HasOptionalUint32); - Assert.IsFalse(message.HasOptionalUint64); - Assert.IsFalse(message.HasOptionalSint32); - Assert.IsFalse(message.HasOptionalSint64); - Assert.IsFalse(message.HasOptionalFixed32); - Assert.IsFalse(message.HasOptionalFixed64); - Assert.IsFalse(message.HasOptionalSfixed32); - Assert.IsFalse(message.HasOptionalSfixed64); - Assert.IsFalse(message.HasOptionalFloat); - Assert.IsFalse(message.HasOptionalDouble); - Assert.IsFalse(message.HasOptionalBool); - Assert.IsFalse(message.HasOptionalString); - Assert.IsFalse(message.HasOptionalBytes); - - Assert.IsFalse(message.HasOptionalGroup); - Assert.IsFalse(message.HasOptionalNestedMessage); - Assert.IsFalse(message.HasOptionalForeignMessage); - Assert.IsFalse(message.HasOptionalImportMessage); - - Assert.IsFalse(message.HasOptionalNestedEnum); - Assert.IsFalse(message.HasOptionalForeignEnum); - Assert.IsFalse(message.HasOptionalImportEnum); - - Assert.IsFalse(message.HasOptionalStringPiece); - Assert.IsFalse(message.HasOptionalCord); + Assert.False(message.HasOptionalInt32); + Assert.False(message.HasOptionalInt64); + Assert.False(message.HasOptionalUint32); + Assert.False(message.HasOptionalUint64); + Assert.False(message.HasOptionalSint32); + Assert.False(message.HasOptionalSint64); + Assert.False(message.HasOptionalFixed32); + Assert.False(message.HasOptionalFixed64); + Assert.False(message.HasOptionalSfixed32); + Assert.False(message.HasOptionalSfixed64); + Assert.False(message.HasOptionalFloat); + Assert.False(message.HasOptionalDouble); + Assert.False(message.HasOptionalBool); + Assert.False(message.HasOptionalString); + Assert.False(message.HasOptionalBytes); + + Assert.False(message.HasOptionalGroup); + Assert.False(message.HasOptionalNestedMessage); + Assert.False(message.HasOptionalForeignMessage); + Assert.False(message.HasOptionalImportMessage); + + Assert.False(message.HasOptionalNestedEnum); + Assert.False(message.HasOptionalForeignEnum); + Assert.False(message.HasOptionalImportEnum); + + Assert.False(message.HasOptionalStringPiece); + Assert.False(message.HasOptionalCord); // Optional fields without defaults are set to zero or something like it. - Assert.AreEqual(0, message.OptionalInt32); - Assert.AreEqual(0, message.OptionalInt64); - Assert.AreEqual(0u, message.OptionalUint32); - Assert.AreEqual(0u, message.OptionalUint64); - Assert.AreEqual(0, message.OptionalSint32); - Assert.AreEqual(0, message.OptionalSint64); - Assert.AreEqual(0u, message.OptionalFixed32); - Assert.AreEqual(0u, message.OptionalFixed64); - Assert.AreEqual(0, message.OptionalSfixed32); - Assert.AreEqual(0, message.OptionalSfixed64); - Assert.AreEqual(0, message.OptionalFloat); - Assert.AreEqual(0, message.OptionalDouble); - Assert.AreEqual(false, message.OptionalBool); - Assert.AreEqual("", message.OptionalString); - Assert.AreEqual(ByteString.Empty, message.OptionalBytes); + Assert.Equal(0, message.OptionalInt32); + Assert.Equal(0, message.OptionalInt64); + Assert.Equal(0u, message.OptionalUint32); + Assert.Equal(0u, message.OptionalUint64); + Assert.Equal(0, message.OptionalSint32); + Assert.Equal(0, message.OptionalSint64); + Assert.Equal(0u, message.OptionalFixed32); + Assert.Equal(0u, message.OptionalFixed64); + Assert.Equal(0, message.OptionalSfixed32); + Assert.Equal(0, message.OptionalSfixed64); + Assert.Equal(0, message.OptionalFloat); + Assert.Equal(0, message.OptionalDouble); + Assert.Equal(false, message.OptionalBool); + Assert.Equal("", message.OptionalString); + Assert.Equal(ByteString.Empty, message.OptionalBytes); // Embedded messages should also be clear. - Assert.IsFalse(message.OptionalGroup.HasA); - Assert.IsFalse(message.OptionalNestedMessage.HasBb); - Assert.IsFalse(message.OptionalForeignMessage.HasC); - Assert.IsFalse(message.OptionalImportMessage.HasD); + Assert.False(message.OptionalGroup.HasA); + Assert.False(message.OptionalNestedMessage.HasBb); + Assert.False(message.OptionalForeignMessage.HasC); + Assert.False(message.OptionalImportMessage.HasD); - Assert.AreEqual(0, message.OptionalGroup.A); - Assert.AreEqual(0, message.OptionalNestedMessage.Bb); - Assert.AreEqual(0, message.OptionalForeignMessage.C); - Assert.AreEqual(0, message.OptionalImportMessage.D); + Assert.Equal(0, message.OptionalGroup.A); + Assert.Equal(0, message.OptionalNestedMessage.Bb); + Assert.Equal(0, message.OptionalForeignMessage.C); + Assert.Equal(0, message.OptionalImportMessage.D); // Enums without defaults are set to the first value in the enum. - Assert.AreEqual(TestAllTypes.Types.NestedEnum.FOO, message.OptionalNestedEnum); - Assert.AreEqual(ForeignEnum.FOREIGN_FOO, message.OptionalForeignEnum); - Assert.AreEqual(ImportEnum.IMPORT_FOO, message.OptionalImportEnum); + Assert.Equal(TestAllTypes.Types.NestedEnum.FOO, message.OptionalNestedEnum); + Assert.Equal(ForeignEnum.FOREIGN_FOO, message.OptionalForeignEnum); + Assert.Equal(ImportEnum.IMPORT_FOO, message.OptionalImportEnum); - Assert.AreEqual("", message.OptionalStringPiece); - Assert.AreEqual("", message.OptionalCord); + Assert.Equal("", message.OptionalStringPiece); + Assert.Equal("", message.OptionalCord); // Repeated fields are empty. - Assert.AreEqual(0, message.RepeatedInt32Count); - Assert.AreEqual(0, message.RepeatedInt64Count); - Assert.AreEqual(0, message.RepeatedUint32Count); - Assert.AreEqual(0, message.RepeatedUint64Count); - Assert.AreEqual(0, message.RepeatedSint32Count); - Assert.AreEqual(0, message.RepeatedSint64Count); - Assert.AreEqual(0, message.RepeatedFixed32Count); - Assert.AreEqual(0, message.RepeatedFixed64Count); - Assert.AreEqual(0, message.RepeatedSfixed32Count); - Assert.AreEqual(0, message.RepeatedSfixed64Count); - Assert.AreEqual(0, message.RepeatedFloatCount); - Assert.AreEqual(0, message.RepeatedDoubleCount); - Assert.AreEqual(0, message.RepeatedBoolCount); - Assert.AreEqual(0, message.RepeatedStringCount); - Assert.AreEqual(0, message.RepeatedBytesCount); - - Assert.AreEqual(0, message.RepeatedGroupCount); - Assert.AreEqual(0, message.RepeatedNestedMessageCount); - Assert.AreEqual(0, message.RepeatedForeignMessageCount); - Assert.AreEqual(0, message.RepeatedImportMessageCount); - Assert.AreEqual(0, message.RepeatedNestedEnumCount); - Assert.AreEqual(0, message.RepeatedForeignEnumCount); - Assert.AreEqual(0, message.RepeatedImportEnumCount); - - Assert.AreEqual(0, message.RepeatedStringPieceCount); - Assert.AreEqual(0, message.RepeatedCordCount); + Assert.Equal(0, message.RepeatedInt32Count); + Assert.Equal(0, message.RepeatedInt64Count); + Assert.Equal(0, message.RepeatedUint32Count); + Assert.Equal(0, message.RepeatedUint64Count); + Assert.Equal(0, message.RepeatedSint32Count); + Assert.Equal(0, message.RepeatedSint64Count); + Assert.Equal(0, message.RepeatedFixed32Count); + Assert.Equal(0, message.RepeatedFixed64Count); + Assert.Equal(0, message.RepeatedSfixed32Count); + Assert.Equal(0, message.RepeatedSfixed64Count); + Assert.Equal(0, message.RepeatedFloatCount); + Assert.Equal(0, message.RepeatedDoubleCount); + Assert.Equal(0, message.RepeatedBoolCount); + Assert.Equal(0, message.RepeatedStringCount); + Assert.Equal(0, message.RepeatedBytesCount); + + Assert.Equal(0, message.RepeatedGroupCount); + Assert.Equal(0, message.RepeatedNestedMessageCount); + Assert.Equal(0, message.RepeatedForeignMessageCount); + Assert.Equal(0, message.RepeatedImportMessageCount); + Assert.Equal(0, message.RepeatedNestedEnumCount); + Assert.Equal(0, message.RepeatedForeignEnumCount); + Assert.Equal(0, message.RepeatedImportEnumCount); + + Assert.Equal(0, message.RepeatedStringPieceCount); + Assert.Equal(0, message.RepeatedCordCount); // HasBlah() should also be false for all default fields. - Assert.IsFalse(message.HasDefaultInt32); - Assert.IsFalse(message.HasDefaultInt64); - Assert.IsFalse(message.HasDefaultUint32); - Assert.IsFalse(message.HasDefaultUint64); - Assert.IsFalse(message.HasDefaultSint32); - Assert.IsFalse(message.HasDefaultSint64); - Assert.IsFalse(message.HasDefaultFixed32); - Assert.IsFalse(message.HasDefaultFixed64); - Assert.IsFalse(message.HasDefaultSfixed32); - Assert.IsFalse(message.HasDefaultSfixed64); - Assert.IsFalse(message.HasDefaultFloat); - Assert.IsFalse(message.HasDefaultDouble); - Assert.IsFalse(message.HasDefaultBool); - Assert.IsFalse(message.HasDefaultString); - Assert.IsFalse(message.HasDefaultBytes); - - Assert.IsFalse(message.HasDefaultNestedEnum); - Assert.IsFalse(message.HasDefaultForeignEnum); - Assert.IsFalse(message.HasDefaultImportEnum); - - Assert.IsFalse(message.HasDefaultStringPiece); - Assert.IsFalse(message.HasDefaultCord); + Assert.False(message.HasDefaultInt32); + Assert.False(message.HasDefaultInt64); + Assert.False(message.HasDefaultUint32); + Assert.False(message.HasDefaultUint64); + Assert.False(message.HasDefaultSint32); + Assert.False(message.HasDefaultSint64); + Assert.False(message.HasDefaultFixed32); + Assert.False(message.HasDefaultFixed64); + Assert.False(message.HasDefaultSfixed32); + Assert.False(message.HasDefaultSfixed64); + Assert.False(message.HasDefaultFloat); + Assert.False(message.HasDefaultDouble); + Assert.False(message.HasDefaultBool); + Assert.False(message.HasDefaultString); + Assert.False(message.HasDefaultBytes); + + Assert.False(message.HasDefaultNestedEnum); + Assert.False(message.HasDefaultForeignEnum); + Assert.False(message.HasDefaultImportEnum); + + Assert.False(message.HasDefaultStringPiece); + Assert.False(message.HasDefaultCord); // Fields with defaults have their default values (duh). - Assert.AreEqual(41, message.DefaultInt32); - Assert.AreEqual(42, message.DefaultInt64); - Assert.AreEqual(43u, message.DefaultUint32); - Assert.AreEqual(44u, message.DefaultUint64); - Assert.AreEqual(-45, message.DefaultSint32); - Assert.AreEqual(46, message.DefaultSint64); - Assert.AreEqual(47u, message.DefaultFixed32); - Assert.AreEqual(48u, message.DefaultFixed64); - Assert.AreEqual(49, message.DefaultSfixed32); - Assert.AreEqual(-50, message.DefaultSfixed64); - Assert.AreEqual(51.5, message.DefaultFloat, 0.0); - Assert.AreEqual(52e3, message.DefaultDouble, 0.0); - Assert.AreEqual(true, message.DefaultBool); - Assert.AreEqual("hello", message.DefaultString); - Assert.AreEqual(ToBytes("world"), message.DefaultBytes); - - Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, message.DefaultNestedEnum); - Assert.AreEqual(ForeignEnum.FOREIGN_BAR, message.DefaultForeignEnum); - Assert.AreEqual(ImportEnum.IMPORT_BAR, message.DefaultImportEnum); - - Assert.AreEqual("abc", message.DefaultStringPiece); - Assert.AreEqual("123", message.DefaultCord); + Assert.Equal(41, message.DefaultInt32); + Assert.Equal(42, message.DefaultInt64); + Assert.Equal(43u, message.DefaultUint32); + Assert.Equal(44u, message.DefaultUint64); + Assert.Equal(-45, message.DefaultSint32); + Assert.Equal(46, message.DefaultSint64); + Assert.Equal(47u, message.DefaultFixed32); + Assert.Equal(48u, message.DefaultFixed64); + Assert.Equal(49, message.DefaultSfixed32); + Assert.Equal(-50, message.DefaultSfixed64); + Assert.Equal(51.5f, message.DefaultFloat); + Assert.Equal(52e3d, message.DefaultDouble); + Assert.Equal(true, message.DefaultBool); + Assert.Equal("hello", message.DefaultString); + Assert.Equal(ToBytes("world"), message.DefaultBytes); + + Assert.Equal(TestAllTypes.Types.NestedEnum.BAR, message.DefaultNestedEnum); + Assert.Equal(ForeignEnum.FOREIGN_BAR, message.DefaultForeignEnum); + Assert.Equal(ImportEnum.IMPORT_BAR, message.DefaultImportEnum); + + Assert.Equal("abc", message.DefaultStringPiece); + Assert.Equal("123", message.DefaultCord); } /// @@ -855,89 +855,89 @@ namespace Google.ProtocolBuffers // ModifyRepeatedFields only sets the second repeated element of each // field. In addition to verifying this, we also verify that the first // element and size were *not* modified. - Assert.AreEqual(2, message.RepeatedInt32Count); - Assert.AreEqual(2, message.RepeatedInt64Count); - Assert.AreEqual(2, message.RepeatedUint32Count); - Assert.AreEqual(2, message.RepeatedUint64Count); - Assert.AreEqual(2, message.RepeatedSint32Count); - Assert.AreEqual(2, message.RepeatedSint64Count); - Assert.AreEqual(2, message.RepeatedFixed32Count); - Assert.AreEqual(2, message.RepeatedFixed64Count); - Assert.AreEqual(2, message.RepeatedSfixed32Count); - Assert.AreEqual(2, message.RepeatedSfixed64Count); - Assert.AreEqual(2, message.RepeatedFloatCount); - Assert.AreEqual(2, message.RepeatedDoubleCount); - Assert.AreEqual(2, message.RepeatedBoolCount); - Assert.AreEqual(2, message.RepeatedStringCount); - Assert.AreEqual(2, message.RepeatedBytesCount); - - Assert.AreEqual(2, message.RepeatedGroupCount); - Assert.AreEqual(2, message.RepeatedNestedMessageCount); - Assert.AreEqual(2, message.RepeatedForeignMessageCount); - Assert.AreEqual(2, message.RepeatedImportMessageCount); - Assert.AreEqual(2, message.RepeatedNestedEnumCount); - Assert.AreEqual(2, message.RepeatedForeignEnumCount); - Assert.AreEqual(2, message.RepeatedImportEnumCount); - - Assert.AreEqual(2, message.RepeatedStringPieceCount); - Assert.AreEqual(2, message.RepeatedCordCount); - - Assert.AreEqual(201, message.GetRepeatedInt32(0)); - Assert.AreEqual(202L, message.GetRepeatedInt64(0)); - Assert.AreEqual(203U, message.GetRepeatedUint32(0)); - Assert.AreEqual(204UL, message.GetRepeatedUint64(0)); - Assert.AreEqual(205, message.GetRepeatedSint32(0)); - Assert.AreEqual(206L, message.GetRepeatedSint64(0)); - Assert.AreEqual(207U, message.GetRepeatedFixed32(0)); - Assert.AreEqual(208UL, message.GetRepeatedFixed64(0)); - Assert.AreEqual(209, message.GetRepeatedSfixed32(0)); - Assert.AreEqual(210L, message.GetRepeatedSfixed64(0)); - Assert.AreEqual(211F, message.GetRepeatedFloat(0)); - Assert.AreEqual(212D, message.GetRepeatedDouble(0)); - Assert.AreEqual(true, message.GetRepeatedBool(0)); - Assert.AreEqual("215", message.GetRepeatedString(0)); - Assert.AreEqual(ToBytes("216"), message.GetRepeatedBytes(0)); - - Assert.AreEqual(217, message.GetRepeatedGroup(0).A); - Assert.AreEqual(218, message.GetRepeatedNestedMessage(0).Bb); - Assert.AreEqual(219, message.GetRepeatedForeignMessage(0).C); - Assert.AreEqual(220, message.GetRepeatedImportMessage(0).D); - - Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, message.GetRepeatedNestedEnum(0)); - Assert.AreEqual(ForeignEnum.FOREIGN_BAR, message.GetRepeatedForeignEnum(0)); - Assert.AreEqual(ImportEnum.IMPORT_BAR, message.GetRepeatedImportEnum(0)); - - Assert.AreEqual("224", message.GetRepeatedStringPiece(0)); - Assert.AreEqual("225", message.GetRepeatedCord(0)); + Assert.Equal(2, message.RepeatedInt32Count); + Assert.Equal(2, message.RepeatedInt64Count); + Assert.Equal(2, message.RepeatedUint32Count); + Assert.Equal(2, message.RepeatedUint64Count); + Assert.Equal(2, message.RepeatedSint32Count); + Assert.Equal(2, message.RepeatedSint64Count); + Assert.Equal(2, message.RepeatedFixed32Count); + Assert.Equal(2, message.RepeatedFixed64Count); + Assert.Equal(2, message.RepeatedSfixed32Count); + Assert.Equal(2, message.RepeatedSfixed64Count); + Assert.Equal(2, message.RepeatedFloatCount); + Assert.Equal(2, message.RepeatedDoubleCount); + Assert.Equal(2, message.RepeatedBoolCount); + Assert.Equal(2, message.RepeatedStringCount); + Assert.Equal(2, message.RepeatedBytesCount); + + Assert.Equal(2, message.RepeatedGroupCount); + Assert.Equal(2, message.RepeatedNestedMessageCount); + Assert.Equal(2, message.RepeatedForeignMessageCount); + Assert.Equal(2, message.RepeatedImportMessageCount); + Assert.Equal(2, message.RepeatedNestedEnumCount); + Assert.Equal(2, message.RepeatedForeignEnumCount); + Assert.Equal(2, message.RepeatedImportEnumCount); + + Assert.Equal(2, message.RepeatedStringPieceCount); + Assert.Equal(2, message.RepeatedCordCount); + + Assert.Equal(201, message.GetRepeatedInt32(0)); + Assert.Equal(202L, message.GetRepeatedInt64(0)); + Assert.Equal(203U, message.GetRepeatedUint32(0)); + Assert.Equal(204UL, message.GetRepeatedUint64(0)); + Assert.Equal(205, message.GetRepeatedSint32(0)); + Assert.Equal(206L, message.GetRepeatedSint64(0)); + Assert.Equal(207U, message.GetRepeatedFixed32(0)); + Assert.Equal(208UL, message.GetRepeatedFixed64(0)); + Assert.Equal(209, message.GetRepeatedSfixed32(0)); + Assert.Equal(210L, message.GetRepeatedSfixed64(0)); + Assert.Equal(211F, message.GetRepeatedFloat(0)); + Assert.Equal(212D, message.GetRepeatedDouble(0)); + Assert.Equal(true, message.GetRepeatedBool(0)); + Assert.Equal("215", message.GetRepeatedString(0)); + Assert.Equal(ToBytes("216"), message.GetRepeatedBytes(0)); + + Assert.Equal(217, message.GetRepeatedGroup(0).A); + Assert.Equal(218, message.GetRepeatedNestedMessage(0).Bb); + Assert.Equal(219, message.GetRepeatedForeignMessage(0).C); + Assert.Equal(220, message.GetRepeatedImportMessage(0).D); + + Assert.Equal(TestAllTypes.Types.NestedEnum.BAR, message.GetRepeatedNestedEnum(0)); + Assert.Equal(ForeignEnum.FOREIGN_BAR, message.GetRepeatedForeignEnum(0)); + Assert.Equal(ImportEnum.IMPORT_BAR, message.GetRepeatedImportEnum(0)); + + Assert.Equal("224", message.GetRepeatedStringPiece(0)); + Assert.Equal("225", message.GetRepeatedCord(0)); // Actually verify the second (modified) elements now. - Assert.AreEqual(501, message.GetRepeatedInt32(1)); - Assert.AreEqual(502L, message.GetRepeatedInt64(1)); - Assert.AreEqual(503U, message.GetRepeatedUint32(1)); - Assert.AreEqual(504UL, message.GetRepeatedUint64(1)); - Assert.AreEqual(505, message.GetRepeatedSint32(1)); - Assert.AreEqual(506L, message.GetRepeatedSint64(1)); - Assert.AreEqual(507U, message.GetRepeatedFixed32(1)); - Assert.AreEqual(508UL, message.GetRepeatedFixed64(1)); - Assert.AreEqual(509, message.GetRepeatedSfixed32(1)); - Assert.AreEqual(510L, message.GetRepeatedSfixed64(1)); - Assert.AreEqual(511F, message.GetRepeatedFloat(1)); - Assert.AreEqual(512D, message.GetRepeatedDouble(1)); - Assert.AreEqual(true, message.GetRepeatedBool(1)); - Assert.AreEqual("515", message.GetRepeatedString(1)); - Assert.AreEqual(ToBytes("516"), message.GetRepeatedBytes(1)); - - Assert.AreEqual(517, message.GetRepeatedGroup(1).A); - Assert.AreEqual(518, message.GetRepeatedNestedMessage(1).Bb); - Assert.AreEqual(519, message.GetRepeatedForeignMessage(1).C); - Assert.AreEqual(520, message.GetRepeatedImportMessage(1).D); - - Assert.AreEqual(TestAllTypes.Types.NestedEnum.FOO, message.GetRepeatedNestedEnum(1)); - Assert.AreEqual(ForeignEnum.FOREIGN_FOO, message.GetRepeatedForeignEnum(1)); - Assert.AreEqual(ImportEnum.IMPORT_FOO, message.GetRepeatedImportEnum(1)); - - Assert.AreEqual("524", message.GetRepeatedStringPiece(1)); - Assert.AreEqual("525", message.GetRepeatedCord(1)); + Assert.Equal(501, message.GetRepeatedInt32(1)); + Assert.Equal(502L, message.GetRepeatedInt64(1)); + Assert.Equal(503U, message.GetRepeatedUint32(1)); + Assert.Equal(504UL, message.GetRepeatedUint64(1)); + Assert.Equal(505, message.GetRepeatedSint32(1)); + Assert.Equal(506L, message.GetRepeatedSint64(1)); + Assert.Equal(507U, message.GetRepeatedFixed32(1)); + Assert.Equal(508UL, message.GetRepeatedFixed64(1)); + Assert.Equal(509, message.GetRepeatedSfixed32(1)); + Assert.Equal(510L, message.GetRepeatedSfixed64(1)); + Assert.Equal(511F, message.GetRepeatedFloat(1)); + Assert.Equal(512D, message.GetRepeatedDouble(1)); + Assert.Equal(true, message.GetRepeatedBool(1)); + Assert.Equal("515", message.GetRepeatedString(1)); + Assert.Equal(ToBytes("516"), message.GetRepeatedBytes(1)); + + Assert.Equal(517, message.GetRepeatedGroup(1).A); + Assert.Equal(518, message.GetRepeatedNestedMessage(1).Bb); + Assert.Equal(519, message.GetRepeatedForeignMessage(1).C); + Assert.Equal(520, message.GetRepeatedImportMessage(1).D); + + Assert.Equal(TestAllTypes.Types.NestedEnum.FOO, message.GetRepeatedNestedEnum(1)); + Assert.Equal(ForeignEnum.FOREIGN_FOO, message.GetRepeatedForeignEnum(1)); + Assert.Equal(ImportEnum.IMPORT_FOO, message.GetRepeatedImportEnum(1)); + + Assert.Equal("524", message.GetRepeatedStringPiece(1)); + Assert.Equal("525", message.GetRepeatedCord(1)); } /// @@ -949,222 +949,222 @@ namespace Google.ProtocolBuffers { foreach (T secondElement in second) { - Assert.IsTrue(firstEnumerator.MoveNext(), "First enumerator ran out of elements too early."); - Assert.AreEqual(firstEnumerator.Current, secondElement); + Assert.True(firstEnumerator.MoveNext(), "First enumerator ran out of elements too early."); + Assert.Equal(firstEnumerator.Current, secondElement); } - Assert.IsFalse(firstEnumerator.MoveNext(), "Second enumerator ran out of elements too early."); + Assert.False(firstEnumerator.MoveNext(), "Second enumerator ran out of elements too early."); } } internal static void AssertEqualBytes(byte[] expected, byte[] actual) { - Assert.AreEqual(ByteString.CopyFrom(expected), ByteString.CopyFrom(actual)); + Assert.Equal(ByteString.CopyFrom(expected), ByteString.CopyFrom(actual)); } internal static void AssertAllExtensionsSet(TestAllExtensions message) { - Assert.IsTrue(message.HasExtension(Unittest.OptionalInt32Extension)); - Assert.IsTrue(message.HasExtension(Unittest.OptionalInt64Extension)); - Assert.IsTrue(message.HasExtension(Unittest.OptionalUint32Extension)); - Assert.IsTrue(message.HasExtension(Unittest.OptionalUint64Extension)); - Assert.IsTrue(message.HasExtension(Unittest.OptionalSint32Extension)); - Assert.IsTrue(message.HasExtension(Unittest.OptionalSint64Extension)); - Assert.IsTrue(message.HasExtension(Unittest.OptionalFixed32Extension)); - Assert.IsTrue(message.HasExtension(Unittest.OptionalFixed64Extension)); - Assert.IsTrue(message.HasExtension(Unittest.OptionalSfixed32Extension)); - Assert.IsTrue(message.HasExtension(Unittest.OptionalSfixed64Extension)); - Assert.IsTrue(message.HasExtension(Unittest.OptionalFloatExtension)); - Assert.IsTrue(message.HasExtension(Unittest.OptionalDoubleExtension)); - Assert.IsTrue(message.HasExtension(Unittest.OptionalBoolExtension)); - Assert.IsTrue(message.HasExtension(Unittest.OptionalStringExtension)); - Assert.IsTrue(message.HasExtension(Unittest.OptionalBytesExtension)); - - Assert.IsTrue(message.HasExtension(Unittest.OptionalGroupExtension)); - Assert.IsTrue(message.HasExtension(Unittest.OptionalNestedMessageExtension)); - Assert.IsTrue(message.HasExtension(Unittest.OptionalForeignMessageExtension)); - Assert.IsTrue(message.HasExtension(Unittest.OptionalImportMessageExtension)); - - Assert.IsTrue(message.GetExtension(Unittest.OptionalGroupExtension).HasA); - Assert.IsTrue(message.GetExtension(Unittest.OptionalNestedMessageExtension).HasBb); - Assert.IsTrue(message.GetExtension(Unittest.OptionalForeignMessageExtension).HasC); - Assert.IsTrue(message.GetExtension(Unittest.OptionalImportMessageExtension).HasD); - - Assert.IsTrue(message.HasExtension(Unittest.OptionalNestedEnumExtension)); - Assert.IsTrue(message.HasExtension(Unittest.OptionalForeignEnumExtension)); - Assert.IsTrue(message.HasExtension(Unittest.OptionalImportEnumExtension)); - - Assert.IsTrue(message.HasExtension(Unittest.OptionalStringPieceExtension)); - Assert.IsTrue(message.HasExtension(Unittest.OptionalCordExtension)); - - Assert.AreEqual(101, message.GetExtension(Unittest.OptionalInt32Extension)); - Assert.AreEqual(102L, message.GetExtension(Unittest.OptionalInt64Extension)); - Assert.AreEqual(103U, message.GetExtension(Unittest.OptionalUint32Extension)); - Assert.AreEqual(104UL, message.GetExtension(Unittest.OptionalUint64Extension)); - Assert.AreEqual(105, message.GetExtension(Unittest.OptionalSint32Extension)); - Assert.AreEqual(106L, message.GetExtension(Unittest.OptionalSint64Extension)); - Assert.AreEqual(107U, message.GetExtension(Unittest.OptionalFixed32Extension)); - Assert.AreEqual(108UL, message.GetExtension(Unittest.OptionalFixed64Extension)); - Assert.AreEqual(109, message.GetExtension(Unittest.OptionalSfixed32Extension)); - Assert.AreEqual(110L, message.GetExtension(Unittest.OptionalSfixed64Extension)); - Assert.AreEqual(111F, message.GetExtension(Unittest.OptionalFloatExtension)); - Assert.AreEqual(112D, message.GetExtension(Unittest.OptionalDoubleExtension)); - Assert.AreEqual(true, message.GetExtension(Unittest.OptionalBoolExtension)); - Assert.AreEqual("115", message.GetExtension(Unittest.OptionalStringExtension)); - Assert.AreEqual(ToBytes("116"), message.GetExtension(Unittest.OptionalBytesExtension)); - - Assert.AreEqual(117, message.GetExtension(Unittest.OptionalGroupExtension).A); - Assert.AreEqual(118, message.GetExtension(Unittest.OptionalNestedMessageExtension).Bb); - Assert.AreEqual(119, message.GetExtension(Unittest.OptionalForeignMessageExtension).C); - Assert.AreEqual(120, message.GetExtension(Unittest.OptionalImportMessageExtension).D); - - Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAZ, + Assert.True(message.HasExtension(Unittest.OptionalInt32Extension)); + Assert.True(message.HasExtension(Unittest.OptionalInt64Extension)); + Assert.True(message.HasExtension(Unittest.OptionalUint32Extension)); + Assert.True(message.HasExtension(Unittest.OptionalUint64Extension)); + Assert.True(message.HasExtension(Unittest.OptionalSint32Extension)); + Assert.True(message.HasExtension(Unittest.OptionalSint64Extension)); + Assert.True(message.HasExtension(Unittest.OptionalFixed32Extension)); + Assert.True(message.HasExtension(Unittest.OptionalFixed64Extension)); + Assert.True(message.HasExtension(Unittest.OptionalSfixed32Extension)); + Assert.True(message.HasExtension(Unittest.OptionalSfixed64Extension)); + Assert.True(message.HasExtension(Unittest.OptionalFloatExtension)); + Assert.True(message.HasExtension(Unittest.OptionalDoubleExtension)); + Assert.True(message.HasExtension(Unittest.OptionalBoolExtension)); + Assert.True(message.HasExtension(Unittest.OptionalStringExtension)); + Assert.True(message.HasExtension(Unittest.OptionalBytesExtension)); + + Assert.True(message.HasExtension(Unittest.OptionalGroupExtension)); + Assert.True(message.HasExtension(Unittest.OptionalNestedMessageExtension)); + Assert.True(message.HasExtension(Unittest.OptionalForeignMessageExtension)); + Assert.True(message.HasExtension(Unittest.OptionalImportMessageExtension)); + + Assert.True(message.GetExtension(Unittest.OptionalGroupExtension).HasA); + Assert.True(message.GetExtension(Unittest.OptionalNestedMessageExtension).HasBb); + Assert.True(message.GetExtension(Unittest.OptionalForeignMessageExtension).HasC); + Assert.True(message.GetExtension(Unittest.OptionalImportMessageExtension).HasD); + + Assert.True(message.HasExtension(Unittest.OptionalNestedEnumExtension)); + Assert.True(message.HasExtension(Unittest.OptionalForeignEnumExtension)); + Assert.True(message.HasExtension(Unittest.OptionalImportEnumExtension)); + + Assert.True(message.HasExtension(Unittest.OptionalStringPieceExtension)); + Assert.True(message.HasExtension(Unittest.OptionalCordExtension)); + + Assert.Equal(101, message.GetExtension(Unittest.OptionalInt32Extension)); + Assert.Equal(102L, message.GetExtension(Unittest.OptionalInt64Extension)); + Assert.Equal(103U, message.GetExtension(Unittest.OptionalUint32Extension)); + Assert.Equal(104UL, message.GetExtension(Unittest.OptionalUint64Extension)); + Assert.Equal(105, message.GetExtension(Unittest.OptionalSint32Extension)); + Assert.Equal(106L, message.GetExtension(Unittest.OptionalSint64Extension)); + Assert.Equal(107U, message.GetExtension(Unittest.OptionalFixed32Extension)); + Assert.Equal(108UL, message.GetExtension(Unittest.OptionalFixed64Extension)); + Assert.Equal(109, message.GetExtension(Unittest.OptionalSfixed32Extension)); + Assert.Equal(110L, message.GetExtension(Unittest.OptionalSfixed64Extension)); + Assert.Equal(111F, message.GetExtension(Unittest.OptionalFloatExtension)); + Assert.Equal(112D, message.GetExtension(Unittest.OptionalDoubleExtension)); + Assert.Equal(true, message.GetExtension(Unittest.OptionalBoolExtension)); + Assert.Equal("115", message.GetExtension(Unittest.OptionalStringExtension)); + Assert.Equal(ToBytes("116"), message.GetExtension(Unittest.OptionalBytesExtension)); + + Assert.Equal(117, message.GetExtension(Unittest.OptionalGroupExtension).A); + Assert.Equal(118, message.GetExtension(Unittest.OptionalNestedMessageExtension).Bb); + Assert.Equal(119, message.GetExtension(Unittest.OptionalForeignMessageExtension).C); + Assert.Equal(120, message.GetExtension(Unittest.OptionalImportMessageExtension).D); + + Assert.Equal(TestAllTypes.Types.NestedEnum.BAZ, message.GetExtension(Unittest.OptionalNestedEnumExtension)); - Assert.AreEqual(ForeignEnum.FOREIGN_BAZ, + Assert.Equal(ForeignEnum.FOREIGN_BAZ, message.GetExtension(Unittest.OptionalForeignEnumExtension)); - Assert.AreEqual(ImportEnum.IMPORT_BAZ, message.GetExtension(Unittest.OptionalImportEnumExtension)); + Assert.Equal(ImportEnum.IMPORT_BAZ, message.GetExtension(Unittest.OptionalImportEnumExtension)); - Assert.AreEqual("124", message.GetExtension(Unittest.OptionalStringPieceExtension)); - Assert.AreEqual("125", message.GetExtension(Unittest.OptionalCordExtension)); + Assert.Equal("124", message.GetExtension(Unittest.OptionalStringPieceExtension)); + Assert.Equal("125", message.GetExtension(Unittest.OptionalCordExtension)); // ----------------------------------------------------------------- - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedInt32Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedInt64Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedUint32Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedUint64Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedSint32Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedSint64Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedFixed32Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedFixed64Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedSfixed32Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedSfixed64Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedFloatExtension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedDoubleExtension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedBoolExtension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedStringExtension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedBytesExtension)); - - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedGroupExtension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedNestedMessageExtension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedForeignMessageExtension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedImportMessageExtension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedNestedEnumExtension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedForeignEnumExtension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedImportEnumExtension)); - - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedStringPieceExtension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedCordExtension)); - - Assert.AreEqual(201, message.GetExtension(Unittest.RepeatedInt32Extension, 0)); - Assert.AreEqual(202L, message.GetExtension(Unittest.RepeatedInt64Extension, 0)); - Assert.AreEqual(203U, message.GetExtension(Unittest.RepeatedUint32Extension, 0)); - Assert.AreEqual(204UL, message.GetExtension(Unittest.RepeatedUint64Extension, 0)); - Assert.AreEqual(205, message.GetExtension(Unittest.RepeatedSint32Extension, 0)); - Assert.AreEqual(206L, message.GetExtension(Unittest.RepeatedSint64Extension, 0)); - Assert.AreEqual(207U, message.GetExtension(Unittest.RepeatedFixed32Extension, 0)); - Assert.AreEqual(208UL, message.GetExtension(Unittest.RepeatedFixed64Extension, 0)); - Assert.AreEqual(209, message.GetExtension(Unittest.RepeatedSfixed32Extension, 0)); - Assert.AreEqual(210L, message.GetExtension(Unittest.RepeatedSfixed64Extension, 0)); - Assert.AreEqual(211F, message.GetExtension(Unittest.RepeatedFloatExtension, 0)); - Assert.AreEqual(212D, message.GetExtension(Unittest.RepeatedDoubleExtension, 0)); - Assert.AreEqual(true, message.GetExtension(Unittest.RepeatedBoolExtension, 0)); - Assert.AreEqual("215", message.GetExtension(Unittest.RepeatedStringExtension, 0)); - Assert.AreEqual(ToBytes("216"), message.GetExtension(Unittest.RepeatedBytesExtension, 0)); - - Assert.AreEqual(217, message.GetExtension(Unittest.RepeatedGroupExtension, 0).A); - Assert.AreEqual(218, message.GetExtension(Unittest.RepeatedNestedMessageExtension, 0).Bb); - Assert.AreEqual(219, message.GetExtension(Unittest.RepeatedForeignMessageExtension, 0).C); - Assert.AreEqual(220, message.GetExtension(Unittest.RepeatedImportMessageExtension, 0).D); - - Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedInt32Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedInt64Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedUint32Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedUint64Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedSint32Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedSint64Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedFixed32Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedFixed64Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedSfixed32Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedSfixed64Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedFloatExtension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedDoubleExtension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedBoolExtension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedStringExtension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedBytesExtension)); + + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedGroupExtension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedNestedMessageExtension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedForeignMessageExtension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedImportMessageExtension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedNestedEnumExtension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedForeignEnumExtension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedImportEnumExtension)); + + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedStringPieceExtension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedCordExtension)); + + Assert.Equal(201, message.GetExtension(Unittest.RepeatedInt32Extension, 0)); + Assert.Equal(202L, message.GetExtension(Unittest.RepeatedInt64Extension, 0)); + Assert.Equal(203U, message.GetExtension(Unittest.RepeatedUint32Extension, 0)); + Assert.Equal(204UL, message.GetExtension(Unittest.RepeatedUint64Extension, 0)); + Assert.Equal(205, message.GetExtension(Unittest.RepeatedSint32Extension, 0)); + Assert.Equal(206L, message.GetExtension(Unittest.RepeatedSint64Extension, 0)); + Assert.Equal(207U, message.GetExtension(Unittest.RepeatedFixed32Extension, 0)); + Assert.Equal(208UL, message.GetExtension(Unittest.RepeatedFixed64Extension, 0)); + Assert.Equal(209, message.GetExtension(Unittest.RepeatedSfixed32Extension, 0)); + Assert.Equal(210L, message.GetExtension(Unittest.RepeatedSfixed64Extension, 0)); + Assert.Equal(211F, message.GetExtension(Unittest.RepeatedFloatExtension, 0)); + Assert.Equal(212D, message.GetExtension(Unittest.RepeatedDoubleExtension, 0)); + Assert.Equal(true, message.GetExtension(Unittest.RepeatedBoolExtension, 0)); + Assert.Equal("215", message.GetExtension(Unittest.RepeatedStringExtension, 0)); + Assert.Equal(ToBytes("216"), message.GetExtension(Unittest.RepeatedBytesExtension, 0)); + + Assert.Equal(217, message.GetExtension(Unittest.RepeatedGroupExtension, 0).A); + Assert.Equal(218, message.GetExtension(Unittest.RepeatedNestedMessageExtension, 0).Bb); + Assert.Equal(219, message.GetExtension(Unittest.RepeatedForeignMessageExtension, 0).C); + Assert.Equal(220, message.GetExtension(Unittest.RepeatedImportMessageExtension, 0).D); + + Assert.Equal(TestAllTypes.Types.NestedEnum.BAR, message.GetExtension(Unittest.RepeatedNestedEnumExtension, 0)); - Assert.AreEqual(ForeignEnum.FOREIGN_BAR, + Assert.Equal(ForeignEnum.FOREIGN_BAR, message.GetExtension(Unittest.RepeatedForeignEnumExtension, 0)); - Assert.AreEqual(ImportEnum.IMPORT_BAR, + Assert.Equal(ImportEnum.IMPORT_BAR, message.GetExtension(Unittest.RepeatedImportEnumExtension, 0)); - Assert.AreEqual("224", message.GetExtension(Unittest.RepeatedStringPieceExtension, 0)); - Assert.AreEqual("225", message.GetExtension(Unittest.RepeatedCordExtension, 0)); - - Assert.AreEqual(301, message.GetExtension(Unittest.RepeatedInt32Extension, 1)); - Assert.AreEqual(302L, message.GetExtension(Unittest.RepeatedInt64Extension, 1)); - Assert.AreEqual(303U, message.GetExtension(Unittest.RepeatedUint32Extension, 1)); - Assert.AreEqual(304UL, message.GetExtension(Unittest.RepeatedUint64Extension, 1)); - Assert.AreEqual(305, message.GetExtension(Unittest.RepeatedSint32Extension, 1)); - Assert.AreEqual(306L, message.GetExtension(Unittest.RepeatedSint64Extension, 1)); - Assert.AreEqual(307U, message.GetExtension(Unittest.RepeatedFixed32Extension, 1)); - Assert.AreEqual(308UL, message.GetExtension(Unittest.RepeatedFixed64Extension, 1)); - Assert.AreEqual(309, message.GetExtension(Unittest.RepeatedSfixed32Extension, 1)); - Assert.AreEqual(310L, message.GetExtension(Unittest.RepeatedSfixed64Extension, 1)); - Assert.AreEqual(311F, message.GetExtension(Unittest.RepeatedFloatExtension, 1)); - Assert.AreEqual(312D, message.GetExtension(Unittest.RepeatedDoubleExtension, 1)); - Assert.AreEqual(false, message.GetExtension(Unittest.RepeatedBoolExtension, 1)); - Assert.AreEqual("315", message.GetExtension(Unittest.RepeatedStringExtension, 1)); - Assert.AreEqual(ToBytes("316"), message.GetExtension(Unittest.RepeatedBytesExtension, 1)); - - Assert.AreEqual(317, message.GetExtension(Unittest.RepeatedGroupExtension, 1).A); - Assert.AreEqual(318, message.GetExtension(Unittest.RepeatedNestedMessageExtension, 1).Bb); - Assert.AreEqual(319, message.GetExtension(Unittest.RepeatedForeignMessageExtension, 1).C); - Assert.AreEqual(320, message.GetExtension(Unittest.RepeatedImportMessageExtension, 1).D); - - Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAZ, + Assert.Equal("224", message.GetExtension(Unittest.RepeatedStringPieceExtension, 0)); + Assert.Equal("225", message.GetExtension(Unittest.RepeatedCordExtension, 0)); + + Assert.Equal(301, message.GetExtension(Unittest.RepeatedInt32Extension, 1)); + Assert.Equal(302L, message.GetExtension(Unittest.RepeatedInt64Extension, 1)); + Assert.Equal(303U, message.GetExtension(Unittest.RepeatedUint32Extension, 1)); + Assert.Equal(304UL, message.GetExtension(Unittest.RepeatedUint64Extension, 1)); + Assert.Equal(305, message.GetExtension(Unittest.RepeatedSint32Extension, 1)); + Assert.Equal(306L, message.GetExtension(Unittest.RepeatedSint64Extension, 1)); + Assert.Equal(307U, message.GetExtension(Unittest.RepeatedFixed32Extension, 1)); + Assert.Equal(308UL, message.GetExtension(Unittest.RepeatedFixed64Extension, 1)); + Assert.Equal(309, message.GetExtension(Unittest.RepeatedSfixed32Extension, 1)); + Assert.Equal(310L, message.GetExtension(Unittest.RepeatedSfixed64Extension, 1)); + Assert.Equal(311F, message.GetExtension(Unittest.RepeatedFloatExtension, 1)); + Assert.Equal(312D, message.GetExtension(Unittest.RepeatedDoubleExtension, 1)); + Assert.Equal(false, message.GetExtension(Unittest.RepeatedBoolExtension, 1)); + Assert.Equal("315", message.GetExtension(Unittest.RepeatedStringExtension, 1)); + Assert.Equal(ToBytes("316"), message.GetExtension(Unittest.RepeatedBytesExtension, 1)); + + Assert.Equal(317, message.GetExtension(Unittest.RepeatedGroupExtension, 1).A); + Assert.Equal(318, message.GetExtension(Unittest.RepeatedNestedMessageExtension, 1).Bb); + Assert.Equal(319, message.GetExtension(Unittest.RepeatedForeignMessageExtension, 1).C); + Assert.Equal(320, message.GetExtension(Unittest.RepeatedImportMessageExtension, 1).D); + + Assert.Equal(TestAllTypes.Types.NestedEnum.BAZ, message.GetExtension(Unittest.RepeatedNestedEnumExtension, 1)); - Assert.AreEqual(ForeignEnum.FOREIGN_BAZ, + Assert.Equal(ForeignEnum.FOREIGN_BAZ, message.GetExtension(Unittest.RepeatedForeignEnumExtension, 1)); - Assert.AreEqual(ImportEnum.IMPORT_BAZ, + Assert.Equal(ImportEnum.IMPORT_BAZ, message.GetExtension(Unittest.RepeatedImportEnumExtension, 1)); - Assert.AreEqual("324", message.GetExtension(Unittest.RepeatedStringPieceExtension, 1)); - Assert.AreEqual("325", message.GetExtension(Unittest.RepeatedCordExtension, 1)); + Assert.Equal("324", message.GetExtension(Unittest.RepeatedStringPieceExtension, 1)); + Assert.Equal("325", message.GetExtension(Unittest.RepeatedCordExtension, 1)); // ----------------------------------------------------------------- - Assert.IsTrue(message.HasExtension(Unittest.DefaultInt32Extension)); - Assert.IsTrue(message.HasExtension(Unittest.DefaultInt64Extension)); - Assert.IsTrue(message.HasExtension(Unittest.DefaultUint32Extension)); - Assert.IsTrue(message.HasExtension(Unittest.DefaultUint64Extension)); - Assert.IsTrue(message.HasExtension(Unittest.DefaultSint32Extension)); - Assert.IsTrue(message.HasExtension(Unittest.DefaultSint64Extension)); - Assert.IsTrue(message.HasExtension(Unittest.DefaultFixed32Extension)); - Assert.IsTrue(message.HasExtension(Unittest.DefaultFixed64Extension)); - Assert.IsTrue(message.HasExtension(Unittest.DefaultSfixed32Extension)); - Assert.IsTrue(message.HasExtension(Unittest.DefaultSfixed64Extension)); - Assert.IsTrue(message.HasExtension(Unittest.DefaultFloatExtension)); - Assert.IsTrue(message.HasExtension(Unittest.DefaultDoubleExtension)); - Assert.IsTrue(message.HasExtension(Unittest.DefaultBoolExtension)); - Assert.IsTrue(message.HasExtension(Unittest.DefaultStringExtension)); - Assert.IsTrue(message.HasExtension(Unittest.DefaultBytesExtension)); - - Assert.IsTrue(message.HasExtension(Unittest.DefaultNestedEnumExtension)); - Assert.IsTrue(message.HasExtension(Unittest.DefaultForeignEnumExtension)); - Assert.IsTrue(message.HasExtension(Unittest.DefaultImportEnumExtension)); - - Assert.IsTrue(message.HasExtension(Unittest.DefaultStringPieceExtension)); - Assert.IsTrue(message.HasExtension(Unittest.DefaultCordExtension)); - - Assert.AreEqual(401, message.GetExtension(Unittest.DefaultInt32Extension)); - Assert.AreEqual(402L, message.GetExtension(Unittest.DefaultInt64Extension)); - Assert.AreEqual(403U, message.GetExtension(Unittest.DefaultUint32Extension)); - Assert.AreEqual(404UL, message.GetExtension(Unittest.DefaultUint64Extension)); - Assert.AreEqual(405, message.GetExtension(Unittest.DefaultSint32Extension)); - Assert.AreEqual(406L, message.GetExtension(Unittest.DefaultSint64Extension)); - Assert.AreEqual(407U, message.GetExtension(Unittest.DefaultFixed32Extension)); - Assert.AreEqual(408UL, message.GetExtension(Unittest.DefaultFixed64Extension)); - Assert.AreEqual(409, message.GetExtension(Unittest.DefaultSfixed32Extension)); - Assert.AreEqual(410L, message.GetExtension(Unittest.DefaultSfixed64Extension)); - Assert.AreEqual(411F, message.GetExtension(Unittest.DefaultFloatExtension)); - Assert.AreEqual(412D, message.GetExtension(Unittest.DefaultDoubleExtension)); - Assert.AreEqual(false, message.GetExtension(Unittest.DefaultBoolExtension)); - Assert.AreEqual("415", message.GetExtension(Unittest.DefaultStringExtension)); - Assert.AreEqual(ToBytes("416"), message.GetExtension(Unittest.DefaultBytesExtension)); - - Assert.AreEqual(TestAllTypes.Types.NestedEnum.FOO, + Assert.True(message.HasExtension(Unittest.DefaultInt32Extension)); + Assert.True(message.HasExtension(Unittest.DefaultInt64Extension)); + Assert.True(message.HasExtension(Unittest.DefaultUint32Extension)); + Assert.True(message.HasExtension(Unittest.DefaultUint64Extension)); + Assert.True(message.HasExtension(Unittest.DefaultSint32Extension)); + Assert.True(message.HasExtension(Unittest.DefaultSint64Extension)); + Assert.True(message.HasExtension(Unittest.DefaultFixed32Extension)); + Assert.True(message.HasExtension(Unittest.DefaultFixed64Extension)); + Assert.True(message.HasExtension(Unittest.DefaultSfixed32Extension)); + Assert.True(message.HasExtension(Unittest.DefaultSfixed64Extension)); + Assert.True(message.HasExtension(Unittest.DefaultFloatExtension)); + Assert.True(message.HasExtension(Unittest.DefaultDoubleExtension)); + Assert.True(message.HasExtension(Unittest.DefaultBoolExtension)); + Assert.True(message.HasExtension(Unittest.DefaultStringExtension)); + Assert.True(message.HasExtension(Unittest.DefaultBytesExtension)); + + Assert.True(message.HasExtension(Unittest.DefaultNestedEnumExtension)); + Assert.True(message.HasExtension(Unittest.DefaultForeignEnumExtension)); + Assert.True(message.HasExtension(Unittest.DefaultImportEnumExtension)); + + Assert.True(message.HasExtension(Unittest.DefaultStringPieceExtension)); + Assert.True(message.HasExtension(Unittest.DefaultCordExtension)); + + Assert.Equal(401, message.GetExtension(Unittest.DefaultInt32Extension)); + Assert.Equal(402L, message.GetExtension(Unittest.DefaultInt64Extension)); + Assert.Equal(403U, message.GetExtension(Unittest.DefaultUint32Extension)); + Assert.Equal(404UL, message.GetExtension(Unittest.DefaultUint64Extension)); + Assert.Equal(405, message.GetExtension(Unittest.DefaultSint32Extension)); + Assert.Equal(406L, message.GetExtension(Unittest.DefaultSint64Extension)); + Assert.Equal(407U, message.GetExtension(Unittest.DefaultFixed32Extension)); + Assert.Equal(408UL, message.GetExtension(Unittest.DefaultFixed64Extension)); + Assert.Equal(409, message.GetExtension(Unittest.DefaultSfixed32Extension)); + Assert.Equal(410L, message.GetExtension(Unittest.DefaultSfixed64Extension)); + Assert.Equal(411F, message.GetExtension(Unittest.DefaultFloatExtension)); + Assert.Equal(412D, message.GetExtension(Unittest.DefaultDoubleExtension)); + Assert.Equal(false, message.GetExtension(Unittest.DefaultBoolExtension)); + Assert.Equal("415", message.GetExtension(Unittest.DefaultStringExtension)); + Assert.Equal(ToBytes("416"), message.GetExtension(Unittest.DefaultBytesExtension)); + + Assert.Equal(TestAllTypes.Types.NestedEnum.FOO, message.GetExtension(Unittest.DefaultNestedEnumExtension)); - Assert.AreEqual(ForeignEnum.FOREIGN_FOO, message.GetExtension(Unittest.DefaultForeignEnumExtension)); - Assert.AreEqual(ImportEnum.IMPORT_FOO, message.GetExtension(Unittest.DefaultImportEnumExtension)); + Assert.Equal(ForeignEnum.FOREIGN_FOO, message.GetExtension(Unittest.DefaultForeignEnumExtension)); + Assert.Equal(ImportEnum.IMPORT_FOO, message.GetExtension(Unittest.DefaultImportEnumExtension)); - Assert.AreEqual("424", message.GetExtension(Unittest.DefaultStringPieceExtension)); - Assert.AreEqual("425", message.GetExtension(Unittest.DefaultCordExtension)); + Assert.Equal("424", message.GetExtension(Unittest.DefaultStringPieceExtension)); + Assert.Equal("425", message.GetExtension(Unittest.DefaultCordExtension)); } /// @@ -1215,242 +1215,242 @@ namespace Google.ProtocolBuffers // ModifyRepeatedFields only sets the second repeated element of each // field. In addition to verifying this, we also verify that the first // element and size were *not* modified. - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedInt32Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedInt64Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedUint32Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedUint64Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedSint32Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedSint64Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedFixed32Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedFixed64Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedSfixed32Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedSfixed64Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedFloatExtension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedDoubleExtension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedBoolExtension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedStringExtension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedBytesExtension)); - - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedGroupExtension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedNestedMessageExtension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedForeignMessageExtension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedImportMessageExtension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedNestedEnumExtension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedForeignEnumExtension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedImportEnumExtension)); - - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedStringPieceExtension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.RepeatedCordExtension)); - - Assert.AreEqual(201, message.GetExtension(Unittest.RepeatedInt32Extension, 0)); - Assert.AreEqual(202L, message.GetExtension(Unittest.RepeatedInt64Extension, 0)); - Assert.AreEqual(203U, message.GetExtension(Unittest.RepeatedUint32Extension, 0)); - Assert.AreEqual(204UL, message.GetExtension(Unittest.RepeatedUint64Extension, 0)); - Assert.AreEqual(205, message.GetExtension(Unittest.RepeatedSint32Extension, 0)); - Assert.AreEqual(206L, message.GetExtension(Unittest.RepeatedSint64Extension, 0)); - Assert.AreEqual(207U, message.GetExtension(Unittest.RepeatedFixed32Extension, 0)); - Assert.AreEqual(208UL, message.GetExtension(Unittest.RepeatedFixed64Extension, 0)); - Assert.AreEqual(209, message.GetExtension(Unittest.RepeatedSfixed32Extension, 0)); - Assert.AreEqual(210L, message.GetExtension(Unittest.RepeatedSfixed64Extension, 0)); - Assert.AreEqual(211F, message.GetExtension(Unittest.RepeatedFloatExtension, 0)); - Assert.AreEqual(212D, message.GetExtension(Unittest.RepeatedDoubleExtension, 0)); - Assert.AreEqual(true, message.GetExtension(Unittest.RepeatedBoolExtension, 0)); - Assert.AreEqual("215", message.GetExtension(Unittest.RepeatedStringExtension, 0)); - Assert.AreEqual(ToBytes("216"), message.GetExtension(Unittest.RepeatedBytesExtension, 0)); - - Assert.AreEqual(217, message.GetExtension(Unittest.RepeatedGroupExtension, 0).A); - Assert.AreEqual(218, message.GetExtension(Unittest.RepeatedNestedMessageExtension, 0).Bb); - Assert.AreEqual(219, message.GetExtension(Unittest.RepeatedForeignMessageExtension, 0).C); - Assert.AreEqual(220, message.GetExtension(Unittest.RepeatedImportMessageExtension, 0).D); - - Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedInt32Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedInt64Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedUint32Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedUint64Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedSint32Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedSint64Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedFixed32Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedFixed64Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedSfixed32Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedSfixed64Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedFloatExtension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedDoubleExtension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedBoolExtension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedStringExtension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedBytesExtension)); + + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedGroupExtension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedNestedMessageExtension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedForeignMessageExtension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedImportMessageExtension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedNestedEnumExtension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedForeignEnumExtension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedImportEnumExtension)); + + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedStringPieceExtension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.RepeatedCordExtension)); + + Assert.Equal(201, message.GetExtension(Unittest.RepeatedInt32Extension, 0)); + Assert.Equal(202L, message.GetExtension(Unittest.RepeatedInt64Extension, 0)); + Assert.Equal(203U, message.GetExtension(Unittest.RepeatedUint32Extension, 0)); + Assert.Equal(204UL, message.GetExtension(Unittest.RepeatedUint64Extension, 0)); + Assert.Equal(205, message.GetExtension(Unittest.RepeatedSint32Extension, 0)); + Assert.Equal(206L, message.GetExtension(Unittest.RepeatedSint64Extension, 0)); + Assert.Equal(207U, message.GetExtension(Unittest.RepeatedFixed32Extension, 0)); + Assert.Equal(208UL, message.GetExtension(Unittest.RepeatedFixed64Extension, 0)); + Assert.Equal(209, message.GetExtension(Unittest.RepeatedSfixed32Extension, 0)); + Assert.Equal(210L, message.GetExtension(Unittest.RepeatedSfixed64Extension, 0)); + Assert.Equal(211F, message.GetExtension(Unittest.RepeatedFloatExtension, 0)); + Assert.Equal(212D, message.GetExtension(Unittest.RepeatedDoubleExtension, 0)); + Assert.Equal(true, message.GetExtension(Unittest.RepeatedBoolExtension, 0)); + Assert.Equal("215", message.GetExtension(Unittest.RepeatedStringExtension, 0)); + Assert.Equal(ToBytes("216"), message.GetExtension(Unittest.RepeatedBytesExtension, 0)); + + Assert.Equal(217, message.GetExtension(Unittest.RepeatedGroupExtension, 0).A); + Assert.Equal(218, message.GetExtension(Unittest.RepeatedNestedMessageExtension, 0).Bb); + Assert.Equal(219, message.GetExtension(Unittest.RepeatedForeignMessageExtension, 0).C); + Assert.Equal(220, message.GetExtension(Unittest.RepeatedImportMessageExtension, 0).D); + + Assert.Equal(TestAllTypes.Types.NestedEnum.BAR, message.GetExtension(Unittest.RepeatedNestedEnumExtension, 0)); - Assert.AreEqual(ForeignEnum.FOREIGN_BAR, + Assert.Equal(ForeignEnum.FOREIGN_BAR, message.GetExtension(Unittest.RepeatedForeignEnumExtension, 0)); - Assert.AreEqual(ImportEnum.IMPORT_BAR, + Assert.Equal(ImportEnum.IMPORT_BAR, message.GetExtension(Unittest.RepeatedImportEnumExtension, 0)); - Assert.AreEqual("224", message.GetExtension(Unittest.RepeatedStringPieceExtension, 0)); - Assert.AreEqual("225", message.GetExtension(Unittest.RepeatedCordExtension, 0)); + Assert.Equal("224", message.GetExtension(Unittest.RepeatedStringPieceExtension, 0)); + Assert.Equal("225", message.GetExtension(Unittest.RepeatedCordExtension, 0)); // Actually verify the second (modified) elements now. - Assert.AreEqual(501, message.GetExtension(Unittest.RepeatedInt32Extension, 1)); - Assert.AreEqual(502L, message.GetExtension(Unittest.RepeatedInt64Extension, 1)); - Assert.AreEqual(503U, message.GetExtension(Unittest.RepeatedUint32Extension, 1)); - Assert.AreEqual(504UL, message.GetExtension(Unittest.RepeatedUint64Extension, 1)); - Assert.AreEqual(505, message.GetExtension(Unittest.RepeatedSint32Extension, 1)); - Assert.AreEqual(506L, message.GetExtension(Unittest.RepeatedSint64Extension, 1)); - Assert.AreEqual(507U, message.GetExtension(Unittest.RepeatedFixed32Extension, 1)); - Assert.AreEqual(508UL, message.GetExtension(Unittest.RepeatedFixed64Extension, 1)); - Assert.AreEqual(509, message.GetExtension(Unittest.RepeatedSfixed32Extension, 1)); - Assert.AreEqual(510L, message.GetExtension(Unittest.RepeatedSfixed64Extension, 1)); - Assert.AreEqual(511F, message.GetExtension(Unittest.RepeatedFloatExtension, 1)); - Assert.AreEqual(512D, message.GetExtension(Unittest.RepeatedDoubleExtension, 1)); - Assert.AreEqual(true, message.GetExtension(Unittest.RepeatedBoolExtension, 1)); - Assert.AreEqual("515", message.GetExtension(Unittest.RepeatedStringExtension, 1)); - Assert.AreEqual(ToBytes("516"), message.GetExtension(Unittest.RepeatedBytesExtension, 1)); - - Assert.AreEqual(517, message.GetExtension(Unittest.RepeatedGroupExtension, 1).A); - Assert.AreEqual(518, message.GetExtension(Unittest.RepeatedNestedMessageExtension, 1).Bb); - Assert.AreEqual(519, message.GetExtension(Unittest.RepeatedForeignMessageExtension, 1).C); - Assert.AreEqual(520, message.GetExtension(Unittest.RepeatedImportMessageExtension, 1).D); - - Assert.AreEqual(TestAllTypes.Types.NestedEnum.FOO, + Assert.Equal(501, message.GetExtension(Unittest.RepeatedInt32Extension, 1)); + Assert.Equal(502L, message.GetExtension(Unittest.RepeatedInt64Extension, 1)); + Assert.Equal(503U, message.GetExtension(Unittest.RepeatedUint32Extension, 1)); + Assert.Equal(504UL, message.GetExtension(Unittest.RepeatedUint64Extension, 1)); + Assert.Equal(505, message.GetExtension(Unittest.RepeatedSint32Extension, 1)); + Assert.Equal(506L, message.GetExtension(Unittest.RepeatedSint64Extension, 1)); + Assert.Equal(507U, message.GetExtension(Unittest.RepeatedFixed32Extension, 1)); + Assert.Equal(508UL, message.GetExtension(Unittest.RepeatedFixed64Extension, 1)); + Assert.Equal(509, message.GetExtension(Unittest.RepeatedSfixed32Extension, 1)); + Assert.Equal(510L, message.GetExtension(Unittest.RepeatedSfixed64Extension, 1)); + Assert.Equal(511F, message.GetExtension(Unittest.RepeatedFloatExtension, 1)); + Assert.Equal(512D, message.GetExtension(Unittest.RepeatedDoubleExtension, 1)); + Assert.Equal(true, message.GetExtension(Unittest.RepeatedBoolExtension, 1)); + Assert.Equal("515", message.GetExtension(Unittest.RepeatedStringExtension, 1)); + Assert.Equal(ToBytes("516"), message.GetExtension(Unittest.RepeatedBytesExtension, 1)); + + Assert.Equal(517, message.GetExtension(Unittest.RepeatedGroupExtension, 1).A); + Assert.Equal(518, message.GetExtension(Unittest.RepeatedNestedMessageExtension, 1).Bb); + Assert.Equal(519, message.GetExtension(Unittest.RepeatedForeignMessageExtension, 1).C); + Assert.Equal(520, message.GetExtension(Unittest.RepeatedImportMessageExtension, 1).D); + + Assert.Equal(TestAllTypes.Types.NestedEnum.FOO, message.GetExtension(Unittest.RepeatedNestedEnumExtension, 1)); - Assert.AreEqual(ForeignEnum.FOREIGN_FOO, + Assert.Equal(ForeignEnum.FOREIGN_FOO, message.GetExtension(Unittest.RepeatedForeignEnumExtension, 1)); - Assert.AreEqual(ImportEnum.IMPORT_FOO, + Assert.Equal(ImportEnum.IMPORT_FOO, message.GetExtension(Unittest.RepeatedImportEnumExtension, 1)); - Assert.AreEqual("524", message.GetExtension(Unittest.RepeatedStringPieceExtension, 1)); - Assert.AreEqual("525", message.GetExtension(Unittest.RepeatedCordExtension, 1)); + Assert.Equal("524", message.GetExtension(Unittest.RepeatedStringPieceExtension, 1)); + Assert.Equal("525", message.GetExtension(Unittest.RepeatedCordExtension, 1)); } internal static void AssertExtensionsClear(TestAllExtensions message) { // HasBlah() should initially be false for all optional fields. - Assert.IsFalse(message.HasExtension(Unittest.OptionalInt32Extension)); - Assert.IsFalse(message.HasExtension(Unittest.OptionalInt64Extension)); - Assert.IsFalse(message.HasExtension(Unittest.OptionalUint32Extension)); - Assert.IsFalse(message.HasExtension(Unittest.OptionalUint64Extension)); - Assert.IsFalse(message.HasExtension(Unittest.OptionalSint32Extension)); - Assert.IsFalse(message.HasExtension(Unittest.OptionalSint64Extension)); - Assert.IsFalse(message.HasExtension(Unittest.OptionalFixed32Extension)); - Assert.IsFalse(message.HasExtension(Unittest.OptionalFixed64Extension)); - Assert.IsFalse(message.HasExtension(Unittest.OptionalSfixed32Extension)); - Assert.IsFalse(message.HasExtension(Unittest.OptionalSfixed64Extension)); - Assert.IsFalse(message.HasExtension(Unittest.OptionalFloatExtension)); - Assert.IsFalse(message.HasExtension(Unittest.OptionalDoubleExtension)); - Assert.IsFalse(message.HasExtension(Unittest.OptionalBoolExtension)); - Assert.IsFalse(message.HasExtension(Unittest.OptionalStringExtension)); - Assert.IsFalse(message.HasExtension(Unittest.OptionalBytesExtension)); - - Assert.IsFalse(message.HasExtension(Unittest.OptionalGroupExtension)); - Assert.IsFalse(message.HasExtension(Unittest.OptionalNestedMessageExtension)); - Assert.IsFalse(message.HasExtension(Unittest.OptionalForeignMessageExtension)); - Assert.IsFalse(message.HasExtension(Unittest.OptionalImportMessageExtension)); - - Assert.IsFalse(message.HasExtension(Unittest.OptionalNestedEnumExtension)); - Assert.IsFalse(message.HasExtension(Unittest.OptionalForeignEnumExtension)); - Assert.IsFalse(message.HasExtension(Unittest.OptionalImportEnumExtension)); - - Assert.IsFalse(message.HasExtension(Unittest.OptionalStringPieceExtension)); - Assert.IsFalse(message.HasExtension(Unittest.OptionalCordExtension)); + Assert.False(message.HasExtension(Unittest.OptionalInt32Extension)); + Assert.False(message.HasExtension(Unittest.OptionalInt64Extension)); + Assert.False(message.HasExtension(Unittest.OptionalUint32Extension)); + Assert.False(message.HasExtension(Unittest.OptionalUint64Extension)); + Assert.False(message.HasExtension(Unittest.OptionalSint32Extension)); + Assert.False(message.HasExtension(Unittest.OptionalSint64Extension)); + Assert.False(message.HasExtension(Unittest.OptionalFixed32Extension)); + Assert.False(message.HasExtension(Unittest.OptionalFixed64Extension)); + Assert.False(message.HasExtension(Unittest.OptionalSfixed32Extension)); + Assert.False(message.HasExtension(Unittest.OptionalSfixed64Extension)); + Assert.False(message.HasExtension(Unittest.OptionalFloatExtension)); + Assert.False(message.HasExtension(Unittest.OptionalDoubleExtension)); + Assert.False(message.HasExtension(Unittest.OptionalBoolExtension)); + Assert.False(message.HasExtension(Unittest.OptionalStringExtension)); + Assert.False(message.HasExtension(Unittest.OptionalBytesExtension)); + + Assert.False(message.HasExtension(Unittest.OptionalGroupExtension)); + Assert.False(message.HasExtension(Unittest.OptionalNestedMessageExtension)); + Assert.False(message.HasExtension(Unittest.OptionalForeignMessageExtension)); + Assert.False(message.HasExtension(Unittest.OptionalImportMessageExtension)); + + Assert.False(message.HasExtension(Unittest.OptionalNestedEnumExtension)); + Assert.False(message.HasExtension(Unittest.OptionalForeignEnumExtension)); + Assert.False(message.HasExtension(Unittest.OptionalImportEnumExtension)); + + Assert.False(message.HasExtension(Unittest.OptionalStringPieceExtension)); + Assert.False(message.HasExtension(Unittest.OptionalCordExtension)); // Optional fields without defaults are set to zero or something like it. - Assert.AreEqual(0, message.GetExtension(Unittest.OptionalInt32Extension)); - Assert.AreEqual(0L, message.GetExtension(Unittest.OptionalInt64Extension)); - Assert.AreEqual(0U, message.GetExtension(Unittest.OptionalUint32Extension)); - Assert.AreEqual(0UL, message.GetExtension(Unittest.OptionalUint64Extension)); - Assert.AreEqual(0, message.GetExtension(Unittest.OptionalSint32Extension)); - Assert.AreEqual(0L, message.GetExtension(Unittest.OptionalSint64Extension)); - Assert.AreEqual(0U, message.GetExtension(Unittest.OptionalFixed32Extension)); - Assert.AreEqual(0UL, message.GetExtension(Unittest.OptionalFixed64Extension)); - Assert.AreEqual(0, message.GetExtension(Unittest.OptionalSfixed32Extension)); - Assert.AreEqual(0L, message.GetExtension(Unittest.OptionalSfixed64Extension)); - Assert.AreEqual(0F, message.GetExtension(Unittest.OptionalFloatExtension)); - Assert.AreEqual(0D, message.GetExtension(Unittest.OptionalDoubleExtension)); - Assert.AreEqual(false, message.GetExtension(Unittest.OptionalBoolExtension)); - Assert.AreEqual("", message.GetExtension(Unittest.OptionalStringExtension)); - Assert.AreEqual(ByteString.Empty, message.GetExtension(Unittest.OptionalBytesExtension)); + Assert.Equal(0, message.GetExtension(Unittest.OptionalInt32Extension)); + Assert.Equal(0L, message.GetExtension(Unittest.OptionalInt64Extension)); + Assert.Equal(0U, message.GetExtension(Unittest.OptionalUint32Extension)); + Assert.Equal(0UL, message.GetExtension(Unittest.OptionalUint64Extension)); + Assert.Equal(0, message.GetExtension(Unittest.OptionalSint32Extension)); + Assert.Equal(0L, message.GetExtension(Unittest.OptionalSint64Extension)); + Assert.Equal(0U, message.GetExtension(Unittest.OptionalFixed32Extension)); + Assert.Equal(0UL, message.GetExtension(Unittest.OptionalFixed64Extension)); + Assert.Equal(0, message.GetExtension(Unittest.OptionalSfixed32Extension)); + Assert.Equal(0L, message.GetExtension(Unittest.OptionalSfixed64Extension)); + Assert.Equal(0F, message.GetExtension(Unittest.OptionalFloatExtension)); + Assert.Equal(0D, message.GetExtension(Unittest.OptionalDoubleExtension)); + Assert.Equal(false, message.GetExtension(Unittest.OptionalBoolExtension)); + Assert.Equal("", message.GetExtension(Unittest.OptionalStringExtension)); + Assert.Equal(ByteString.Empty, message.GetExtension(Unittest.OptionalBytesExtension)); // Embedded messages should also be clear. - Assert.IsFalse(message.GetExtension(Unittest.OptionalGroupExtension).HasA); - Assert.IsFalse(message.GetExtension(Unittest.OptionalNestedMessageExtension).HasBb); - Assert.IsFalse(message.GetExtension(Unittest.OptionalForeignMessageExtension).HasC); - Assert.IsFalse(message.GetExtension(Unittest.OptionalImportMessageExtension).HasD); + Assert.False(message.GetExtension(Unittest.OptionalGroupExtension).HasA); + Assert.False(message.GetExtension(Unittest.OptionalNestedMessageExtension).HasBb); + Assert.False(message.GetExtension(Unittest.OptionalForeignMessageExtension).HasC); + Assert.False(message.GetExtension(Unittest.OptionalImportMessageExtension).HasD); - Assert.AreEqual(0, message.GetExtension(Unittest.OptionalGroupExtension).A); - Assert.AreEqual(0, message.GetExtension(Unittest.OptionalNestedMessageExtension).Bb); - Assert.AreEqual(0, message.GetExtension(Unittest.OptionalForeignMessageExtension).C); - Assert.AreEqual(0, message.GetExtension(Unittest.OptionalImportMessageExtension).D); + Assert.Equal(0, message.GetExtension(Unittest.OptionalGroupExtension).A); + Assert.Equal(0, message.GetExtension(Unittest.OptionalNestedMessageExtension).Bb); + Assert.Equal(0, message.GetExtension(Unittest.OptionalForeignMessageExtension).C); + Assert.Equal(0, message.GetExtension(Unittest.OptionalImportMessageExtension).D); // Enums without defaults are set to the first value in the enum. - Assert.AreEqual(TestAllTypes.Types.NestedEnum.FOO, + Assert.Equal(TestAllTypes.Types.NestedEnum.FOO, message.GetExtension(Unittest.OptionalNestedEnumExtension)); - Assert.AreEqual(ForeignEnum.FOREIGN_FOO, + Assert.Equal(ForeignEnum.FOREIGN_FOO, message.GetExtension(Unittest.OptionalForeignEnumExtension)); - Assert.AreEqual(ImportEnum.IMPORT_FOO, message.GetExtension(Unittest.OptionalImportEnumExtension)); + Assert.Equal(ImportEnum.IMPORT_FOO, message.GetExtension(Unittest.OptionalImportEnumExtension)); - Assert.AreEqual("", message.GetExtension(Unittest.OptionalStringPieceExtension)); - Assert.AreEqual("", message.GetExtension(Unittest.OptionalCordExtension)); + Assert.Equal("", message.GetExtension(Unittest.OptionalStringPieceExtension)); + Assert.Equal("", message.GetExtension(Unittest.OptionalCordExtension)); // Repeated fields are empty. - Assert.AreEqual(0, message.GetExtensionCount(Unittest.RepeatedInt32Extension)); - Assert.AreEqual(0, message.GetExtensionCount(Unittest.RepeatedInt64Extension)); - Assert.AreEqual(0, message.GetExtensionCount(Unittest.RepeatedUint32Extension)); - Assert.AreEqual(0, message.GetExtensionCount(Unittest.RepeatedUint64Extension)); - Assert.AreEqual(0, message.GetExtensionCount(Unittest.RepeatedSint32Extension)); - Assert.AreEqual(0, message.GetExtensionCount(Unittest.RepeatedSint64Extension)); - Assert.AreEqual(0, message.GetExtensionCount(Unittest.RepeatedFixed32Extension)); - Assert.AreEqual(0, message.GetExtensionCount(Unittest.RepeatedFixed64Extension)); - Assert.AreEqual(0, message.GetExtensionCount(Unittest.RepeatedSfixed32Extension)); - Assert.AreEqual(0, message.GetExtensionCount(Unittest.RepeatedSfixed64Extension)); - Assert.AreEqual(0, message.GetExtensionCount(Unittest.RepeatedFloatExtension)); - Assert.AreEqual(0, message.GetExtensionCount(Unittest.RepeatedDoubleExtension)); - Assert.AreEqual(0, message.GetExtensionCount(Unittest.RepeatedBoolExtension)); - Assert.AreEqual(0, message.GetExtensionCount(Unittest.RepeatedStringExtension)); - Assert.AreEqual(0, message.GetExtensionCount(Unittest.RepeatedBytesExtension)); - - Assert.AreEqual(0, message.GetExtensionCount(Unittest.RepeatedGroupExtension)); - Assert.AreEqual(0, message.GetExtensionCount(Unittest.RepeatedNestedMessageExtension)); - Assert.AreEqual(0, message.GetExtensionCount(Unittest.RepeatedForeignMessageExtension)); - Assert.AreEqual(0, message.GetExtensionCount(Unittest.RepeatedImportMessageExtension)); - Assert.AreEqual(0, message.GetExtensionCount(Unittest.RepeatedNestedEnumExtension)); - Assert.AreEqual(0, message.GetExtensionCount(Unittest.RepeatedForeignEnumExtension)); - Assert.AreEqual(0, message.GetExtensionCount(Unittest.RepeatedImportEnumExtension)); - - Assert.AreEqual(0, message.GetExtensionCount(Unittest.RepeatedStringPieceExtension)); - Assert.AreEqual(0, message.GetExtensionCount(Unittest.RepeatedCordExtension)); + Assert.Equal(0, message.GetExtensionCount(Unittest.RepeatedInt32Extension)); + Assert.Equal(0, message.GetExtensionCount(Unittest.RepeatedInt64Extension)); + Assert.Equal(0, message.GetExtensionCount(Unittest.RepeatedUint32Extension)); + Assert.Equal(0, message.GetExtensionCount(Unittest.RepeatedUint64Extension)); + Assert.Equal(0, message.GetExtensionCount(Unittest.RepeatedSint32Extension)); + Assert.Equal(0, message.GetExtensionCount(Unittest.RepeatedSint64Extension)); + Assert.Equal(0, message.GetExtensionCount(Unittest.RepeatedFixed32Extension)); + Assert.Equal(0, message.GetExtensionCount(Unittest.RepeatedFixed64Extension)); + Assert.Equal(0, message.GetExtensionCount(Unittest.RepeatedSfixed32Extension)); + Assert.Equal(0, message.GetExtensionCount(Unittest.RepeatedSfixed64Extension)); + Assert.Equal(0, message.GetExtensionCount(Unittest.RepeatedFloatExtension)); + Assert.Equal(0, message.GetExtensionCount(Unittest.RepeatedDoubleExtension)); + Assert.Equal(0, message.GetExtensionCount(Unittest.RepeatedBoolExtension)); + Assert.Equal(0, message.GetExtensionCount(Unittest.RepeatedStringExtension)); + Assert.Equal(0, message.GetExtensionCount(Unittest.RepeatedBytesExtension)); + + Assert.Equal(0, message.GetExtensionCount(Unittest.RepeatedGroupExtension)); + Assert.Equal(0, message.GetExtensionCount(Unittest.RepeatedNestedMessageExtension)); + Assert.Equal(0, message.GetExtensionCount(Unittest.RepeatedForeignMessageExtension)); + Assert.Equal(0, message.GetExtensionCount(Unittest.RepeatedImportMessageExtension)); + Assert.Equal(0, message.GetExtensionCount(Unittest.RepeatedNestedEnumExtension)); + Assert.Equal(0, message.GetExtensionCount(Unittest.RepeatedForeignEnumExtension)); + Assert.Equal(0, message.GetExtensionCount(Unittest.RepeatedImportEnumExtension)); + + Assert.Equal(0, message.GetExtensionCount(Unittest.RepeatedStringPieceExtension)); + Assert.Equal(0, message.GetExtensionCount(Unittest.RepeatedCordExtension)); // HasBlah() should also be false for all default fields. - Assert.IsFalse(message.HasExtension(Unittest.DefaultInt32Extension)); - Assert.IsFalse(message.HasExtension(Unittest.DefaultInt64Extension)); - Assert.IsFalse(message.HasExtension(Unittest.DefaultUint32Extension)); - Assert.IsFalse(message.HasExtension(Unittest.DefaultUint64Extension)); - Assert.IsFalse(message.HasExtension(Unittest.DefaultSint32Extension)); - Assert.IsFalse(message.HasExtension(Unittest.DefaultSint64Extension)); - Assert.IsFalse(message.HasExtension(Unittest.DefaultFixed32Extension)); - Assert.IsFalse(message.HasExtension(Unittest.DefaultFixed64Extension)); - Assert.IsFalse(message.HasExtension(Unittest.DefaultSfixed32Extension)); - Assert.IsFalse(message.HasExtension(Unittest.DefaultSfixed64Extension)); - Assert.IsFalse(message.HasExtension(Unittest.DefaultFloatExtension)); - Assert.IsFalse(message.HasExtension(Unittest.DefaultDoubleExtension)); - Assert.IsFalse(message.HasExtension(Unittest.DefaultBoolExtension)); - Assert.IsFalse(message.HasExtension(Unittest.DefaultStringExtension)); - Assert.IsFalse(message.HasExtension(Unittest.DefaultBytesExtension)); - - Assert.IsFalse(message.HasExtension(Unittest.DefaultNestedEnumExtension)); - Assert.IsFalse(message.HasExtension(Unittest.DefaultForeignEnumExtension)); - Assert.IsFalse(message.HasExtension(Unittest.DefaultImportEnumExtension)); - - Assert.IsFalse(message.HasExtension(Unittest.DefaultStringPieceExtension)); - Assert.IsFalse(message.HasExtension(Unittest.DefaultCordExtension)); + Assert.False(message.HasExtension(Unittest.DefaultInt32Extension)); + Assert.False(message.HasExtension(Unittest.DefaultInt64Extension)); + Assert.False(message.HasExtension(Unittest.DefaultUint32Extension)); + Assert.False(message.HasExtension(Unittest.DefaultUint64Extension)); + Assert.False(message.HasExtension(Unittest.DefaultSint32Extension)); + Assert.False(message.HasExtension(Unittest.DefaultSint64Extension)); + Assert.False(message.HasExtension(Unittest.DefaultFixed32Extension)); + Assert.False(message.HasExtension(Unittest.DefaultFixed64Extension)); + Assert.False(message.HasExtension(Unittest.DefaultSfixed32Extension)); + Assert.False(message.HasExtension(Unittest.DefaultSfixed64Extension)); + Assert.False(message.HasExtension(Unittest.DefaultFloatExtension)); + Assert.False(message.HasExtension(Unittest.DefaultDoubleExtension)); + Assert.False(message.HasExtension(Unittest.DefaultBoolExtension)); + Assert.False(message.HasExtension(Unittest.DefaultStringExtension)); + Assert.False(message.HasExtension(Unittest.DefaultBytesExtension)); + + Assert.False(message.HasExtension(Unittest.DefaultNestedEnumExtension)); + Assert.False(message.HasExtension(Unittest.DefaultForeignEnumExtension)); + Assert.False(message.HasExtension(Unittest.DefaultImportEnumExtension)); + + Assert.False(message.HasExtension(Unittest.DefaultStringPieceExtension)); + Assert.False(message.HasExtension(Unittest.DefaultCordExtension)); // Fields with defaults have their default values (duh). - Assert.AreEqual(41, message.GetExtension(Unittest.DefaultInt32Extension)); - Assert.AreEqual(42L, message.GetExtension(Unittest.DefaultInt64Extension)); - Assert.AreEqual(43U, message.GetExtension(Unittest.DefaultUint32Extension)); - Assert.AreEqual(44UL, message.GetExtension(Unittest.DefaultUint64Extension)); - Assert.AreEqual(-45, message.GetExtension(Unittest.DefaultSint32Extension)); - Assert.AreEqual(46L, message.GetExtension(Unittest.DefaultSint64Extension)); - Assert.AreEqual(47U, message.GetExtension(Unittest.DefaultFixed32Extension)); - Assert.AreEqual(48UL, message.GetExtension(Unittest.DefaultFixed64Extension)); - Assert.AreEqual(49, message.GetExtension(Unittest.DefaultSfixed32Extension)); - Assert.AreEqual(-50L, message.GetExtension(Unittest.DefaultSfixed64Extension)); - Assert.AreEqual(51.5F, message.GetExtension(Unittest.DefaultFloatExtension)); - Assert.AreEqual(52e3D, message.GetExtension(Unittest.DefaultDoubleExtension)); - Assert.AreEqual(true, message.GetExtension(Unittest.DefaultBoolExtension)); - Assert.AreEqual("hello", message.GetExtension(Unittest.DefaultStringExtension)); - Assert.AreEqual(ToBytes("world"), message.GetExtension(Unittest.DefaultBytesExtension)); - - Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, + Assert.Equal(41, message.GetExtension(Unittest.DefaultInt32Extension)); + Assert.Equal(42L, message.GetExtension(Unittest.DefaultInt64Extension)); + Assert.Equal(43U, message.GetExtension(Unittest.DefaultUint32Extension)); + Assert.Equal(44UL, message.GetExtension(Unittest.DefaultUint64Extension)); + Assert.Equal(-45, message.GetExtension(Unittest.DefaultSint32Extension)); + Assert.Equal(46L, message.GetExtension(Unittest.DefaultSint64Extension)); + Assert.Equal(47U, message.GetExtension(Unittest.DefaultFixed32Extension)); + Assert.Equal(48UL, message.GetExtension(Unittest.DefaultFixed64Extension)); + Assert.Equal(49, message.GetExtension(Unittest.DefaultSfixed32Extension)); + Assert.Equal(-50L, message.GetExtension(Unittest.DefaultSfixed64Extension)); + Assert.Equal(51.5F, message.GetExtension(Unittest.DefaultFloatExtension)); + Assert.Equal(52e3D, message.GetExtension(Unittest.DefaultDoubleExtension)); + Assert.Equal(true, message.GetExtension(Unittest.DefaultBoolExtension)); + Assert.Equal("hello", message.GetExtension(Unittest.DefaultStringExtension)); + Assert.Equal(ToBytes("world"), message.GetExtension(Unittest.DefaultBytesExtension)); + + Assert.Equal(TestAllTypes.Types.NestedEnum.BAR, message.GetExtension(Unittest.DefaultNestedEnumExtension)); - Assert.AreEqual(ForeignEnum.FOREIGN_BAR, message.GetExtension(Unittest.DefaultForeignEnumExtension)); - Assert.AreEqual(ImportEnum.IMPORT_BAR, message.GetExtension(Unittest.DefaultImportEnumExtension)); + Assert.Equal(ForeignEnum.FOREIGN_BAR, message.GetExtension(Unittest.DefaultForeignEnumExtension)); + Assert.Equal(ImportEnum.IMPORT_BAR, message.GetExtension(Unittest.DefaultImportEnumExtension)); - Assert.AreEqual("abc", message.GetExtension(Unittest.DefaultStringPieceExtension)); - Assert.AreEqual("123", message.GetExtension(Unittest.DefaultCordExtension)); + Assert.Equal("abc", message.GetExtension(Unittest.DefaultStringPieceExtension)); + Assert.Equal("123", message.GetExtension(Unittest.DefaultCordExtension)); } /// @@ -1495,48 +1495,48 @@ namespace Google.ProtocolBuffers /// public static void AssertPackedFieldsSet(TestPackedTypes message) { - Assert.AreEqual(2, message.PackedInt32Count); - Assert.AreEqual(2, message.PackedInt64Count); - Assert.AreEqual(2, message.PackedUint32Count); - Assert.AreEqual(2, message.PackedUint64Count); - Assert.AreEqual(2, message.PackedSint32Count); - Assert.AreEqual(2, message.PackedSint64Count); - Assert.AreEqual(2, message.PackedFixed32Count); - Assert.AreEqual(2, message.PackedFixed64Count); - Assert.AreEqual(2, message.PackedSfixed32Count); - Assert.AreEqual(2, message.PackedSfixed64Count); - Assert.AreEqual(2, message.PackedFloatCount); - Assert.AreEqual(2, message.PackedDoubleCount); - Assert.AreEqual(2, message.PackedBoolCount); - Assert.AreEqual(2, message.PackedEnumCount); - Assert.AreEqual(601, message.GetPackedInt32(0)); - Assert.AreEqual(602, message.GetPackedInt64(0)); - Assert.AreEqual(603u, message.GetPackedUint32(0)); - Assert.AreEqual(604u, message.GetPackedUint64(0)); - Assert.AreEqual(605, message.GetPackedSint32(0)); - Assert.AreEqual(606, message.GetPackedSint64(0)); - Assert.AreEqual(607u, message.GetPackedFixed32(0)); - Assert.AreEqual(608u, message.GetPackedFixed64(0)); - Assert.AreEqual(609, message.GetPackedSfixed32(0)); - Assert.AreEqual(610, message.GetPackedSfixed64(0)); - Assert.AreEqual(611, message.GetPackedFloat(0), 0.0); - Assert.AreEqual(612, message.GetPackedDouble(0), 0.0); - Assert.AreEqual(true, message.GetPackedBool(0)); - Assert.AreEqual(ForeignEnum.FOREIGN_BAR, message.GetPackedEnum(0)); - Assert.AreEqual(701, message.GetPackedInt32(1)); - Assert.AreEqual(702, message.GetPackedInt64(1)); - Assert.AreEqual(703u, message.GetPackedUint32(1)); - Assert.AreEqual(704u, message.GetPackedUint64(1)); - Assert.AreEqual(705, message.GetPackedSint32(1)); - Assert.AreEqual(706, message.GetPackedSint64(1)); - Assert.AreEqual(707u, message.GetPackedFixed32(1)); - Assert.AreEqual(708u, message.GetPackedFixed64(1)); - Assert.AreEqual(709, message.GetPackedSfixed32(1)); - Assert.AreEqual(710, message.GetPackedSfixed64(1)); - Assert.AreEqual(711, message.GetPackedFloat(1), 0.0); - Assert.AreEqual(712, message.GetPackedDouble(1), 0.0); - Assert.AreEqual(false, message.GetPackedBool(1)); - Assert.AreEqual(ForeignEnum.FOREIGN_BAZ, message.GetPackedEnum(1)); + Assert.Equal(2, message.PackedInt32Count); + Assert.Equal(2, message.PackedInt64Count); + Assert.Equal(2, message.PackedUint32Count); + Assert.Equal(2, message.PackedUint64Count); + Assert.Equal(2, message.PackedSint32Count); + Assert.Equal(2, message.PackedSint64Count); + Assert.Equal(2, message.PackedFixed32Count); + Assert.Equal(2, message.PackedFixed64Count); + Assert.Equal(2, message.PackedSfixed32Count); + Assert.Equal(2, message.PackedSfixed64Count); + Assert.Equal(2, message.PackedFloatCount); + Assert.Equal(2, message.PackedDoubleCount); + Assert.Equal(2, message.PackedBoolCount); + Assert.Equal(2, message.PackedEnumCount); + Assert.Equal(601, message.GetPackedInt32(0)); + Assert.Equal(602, message.GetPackedInt64(0)); + Assert.Equal(603u, message.GetPackedUint32(0)); + Assert.Equal(604u, message.GetPackedUint64(0)); + Assert.Equal(605, message.GetPackedSint32(0)); + Assert.Equal(606, message.GetPackedSint64(0)); + Assert.Equal(607u, message.GetPackedFixed32(0)); + Assert.Equal(608u, message.GetPackedFixed64(0)); + Assert.Equal(609, message.GetPackedSfixed32(0)); + Assert.Equal(610, message.GetPackedSfixed64(0)); + Assert.Equal(611f, message.GetPackedFloat(0)); + Assert.Equal(612d, message.GetPackedDouble(0)); + Assert.Equal(true, message.GetPackedBool(0)); + Assert.Equal(ForeignEnum.FOREIGN_BAR, message.GetPackedEnum(0)); + Assert.Equal(701, message.GetPackedInt32(1)); + Assert.Equal(702, message.GetPackedInt64(1)); + Assert.Equal(703u, message.GetPackedUint32(1)); + Assert.Equal(704u, message.GetPackedUint64(1)); + Assert.Equal(705, message.GetPackedSint32(1)); + Assert.Equal(706, message.GetPackedSint64(1)); + Assert.Equal(707u, message.GetPackedFixed32(1)); + Assert.Equal(708u, message.GetPackedFixed64(1)); + Assert.Equal(709, message.GetPackedSfixed32(1)); + Assert.Equal(710, message.GetPackedSfixed64(1)); + Assert.Equal(711f, message.GetPackedFloat(1)); + Assert.Equal(712d, message.GetPackedDouble(1)); + Assert.Equal(false, message.GetPackedBool(1)); + Assert.Equal(ForeignEnum.FOREIGN_BAZ, message.GetPackedEnum(1)); } /// /// Asserts that all the fields of the specified message are set to the values assigned @@ -1544,48 +1544,48 @@ namespace Google.ProtocolBuffers /// public static void AssertUnpackedFieldsSet(TestUnpackedTypes message) { - Assert.AreEqual(2, message.UnpackedInt32Count); - Assert.AreEqual(2, message.UnpackedInt64Count); - Assert.AreEqual(2, message.UnpackedUint32Count); - Assert.AreEqual(2, message.UnpackedUint64Count); - Assert.AreEqual(2, message.UnpackedSint32Count); - Assert.AreEqual(2, message.UnpackedSint64Count); - Assert.AreEqual(2, message.UnpackedFixed32Count); - Assert.AreEqual(2, message.UnpackedFixed64Count); - Assert.AreEqual(2, message.UnpackedSfixed32Count); - Assert.AreEqual(2, message.UnpackedSfixed64Count); - Assert.AreEqual(2, message.UnpackedFloatCount); - Assert.AreEqual(2, message.UnpackedDoubleCount); - Assert.AreEqual(2, message.UnpackedBoolCount); - Assert.AreEqual(2, message.UnpackedEnumCount); - Assert.AreEqual(601, message.GetUnpackedInt32(0)); - Assert.AreEqual(602, message.GetUnpackedInt64(0)); - Assert.AreEqual(603u, message.GetUnpackedUint32(0)); - Assert.AreEqual(604u, message.GetUnpackedUint64(0)); - Assert.AreEqual(605, message.GetUnpackedSint32(0)); - Assert.AreEqual(606, message.GetUnpackedSint64(0)); - Assert.AreEqual(607u, message.GetUnpackedFixed32(0)); - Assert.AreEqual(608u, message.GetUnpackedFixed64(0)); - Assert.AreEqual(609, message.GetUnpackedSfixed32(0)); - Assert.AreEqual(610, message.GetUnpackedSfixed64(0)); - Assert.AreEqual(611, message.GetUnpackedFloat(0), 0.0); - Assert.AreEqual(612, message.GetUnpackedDouble(0), 0.0); - Assert.AreEqual(true, message.GetUnpackedBool(0)); - Assert.AreEqual(ForeignEnum.FOREIGN_BAR, message.GetUnpackedEnum(0)); - Assert.AreEqual(701, message.GetUnpackedInt32(1)); - Assert.AreEqual(702, message.GetUnpackedInt64(1)); - Assert.AreEqual(703u, message.GetUnpackedUint32(1)); - Assert.AreEqual(704u, message.GetUnpackedUint64(1)); - Assert.AreEqual(705, message.GetUnpackedSint32(1)); - Assert.AreEqual(706, message.GetUnpackedSint64(1)); - Assert.AreEqual(707u, message.GetUnpackedFixed32(1)); - Assert.AreEqual(708u, message.GetUnpackedFixed64(1)); - Assert.AreEqual(709, message.GetUnpackedSfixed32(1)); - Assert.AreEqual(710, message.GetUnpackedSfixed64(1)); - Assert.AreEqual(711, message.GetUnpackedFloat(1), 0.0); - Assert.AreEqual(712, message.GetUnpackedDouble(1), 0.0); - Assert.AreEqual(false, message.GetUnpackedBool(1)); - Assert.AreEqual(ForeignEnum.FOREIGN_BAZ, message.GetUnpackedEnum(1)); + Assert.Equal(2, message.UnpackedInt32Count); + Assert.Equal(2, message.UnpackedInt64Count); + Assert.Equal(2, message.UnpackedUint32Count); + Assert.Equal(2, message.UnpackedUint64Count); + Assert.Equal(2, message.UnpackedSint32Count); + Assert.Equal(2, message.UnpackedSint64Count); + Assert.Equal(2, message.UnpackedFixed32Count); + Assert.Equal(2, message.UnpackedFixed64Count); + Assert.Equal(2, message.UnpackedSfixed32Count); + Assert.Equal(2, message.UnpackedSfixed64Count); + Assert.Equal(2, message.UnpackedFloatCount); + Assert.Equal(2, message.UnpackedDoubleCount); + Assert.Equal(2, message.UnpackedBoolCount); + Assert.Equal(2, message.UnpackedEnumCount); + Assert.Equal(601, message.GetUnpackedInt32(0)); + Assert.Equal(602, message.GetUnpackedInt64(0)); + Assert.Equal(603u, message.GetUnpackedUint32(0)); + Assert.Equal(604u, message.GetUnpackedUint64(0)); + Assert.Equal(605, message.GetUnpackedSint32(0)); + Assert.Equal(606, message.GetUnpackedSint64(0)); + Assert.Equal(607u, message.GetUnpackedFixed32(0)); + Assert.Equal(608u, message.GetUnpackedFixed64(0)); + Assert.Equal(609, message.GetUnpackedSfixed32(0)); + Assert.Equal(610, message.GetUnpackedSfixed64(0)); + Assert.Equal(611f, message.GetUnpackedFloat(0)); + Assert.Equal(612d, message.GetUnpackedDouble(0)); + Assert.Equal(true, message.GetUnpackedBool(0)); + Assert.Equal(ForeignEnum.FOREIGN_BAR, message.GetUnpackedEnum(0)); + Assert.Equal(701, message.GetUnpackedInt32(1)); + Assert.Equal(702, message.GetUnpackedInt64(1)); + Assert.Equal(703u, message.GetUnpackedUint32(1)); + Assert.Equal(704u, message.GetUnpackedUint64(1)); + Assert.Equal(705, message.GetUnpackedSint32(1)); + Assert.Equal(706, message.GetUnpackedSint64(1)); + Assert.Equal(707u, message.GetUnpackedFixed32(1)); + Assert.Equal(708u, message.GetUnpackedFixed64(1)); + Assert.Equal(709, message.GetUnpackedSfixed32(1)); + Assert.Equal(710, message.GetUnpackedSfixed64(1)); + Assert.Equal(711f, message.GetUnpackedFloat(1)); + Assert.Equal(712d, message.GetUnpackedDouble(1)); + Assert.Equal(false, message.GetUnpackedBool(1)); + Assert.Equal(ForeignEnum.FOREIGN_BAZ, message.GetUnpackedEnum(1)); } public static void SetPackedExtensions(TestPackedExtensions.Builder message) @@ -1623,95 +1623,95 @@ namespace Google.ProtocolBuffers public static void AssertPackedExtensionsSet(TestPackedExtensions message) { - Assert.AreEqual(2, message.GetExtensionCount(Unittest.PackedInt32Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.PackedInt64Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.PackedUint32Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.PackedUint64Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.PackedSint32Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.PackedSint64Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.PackedFixed32Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.PackedFixed64Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.PackedSfixed32Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.PackedSfixed64Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.PackedFloatExtension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.PackedDoubleExtension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.PackedBoolExtension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.PackedEnumExtension)); - Assert.AreEqual(601, message.GetExtension(Unittest.PackedInt32Extension, 0)); - Assert.AreEqual(602L, message.GetExtension(Unittest.PackedInt64Extension, 0)); - Assert.AreEqual(603u, message.GetExtension(Unittest.PackedUint32Extension, 0)); - Assert.AreEqual(604uL, message.GetExtension(Unittest.PackedUint64Extension, 0)); - Assert.AreEqual(605, message.GetExtension(Unittest.PackedSint32Extension, 0)); - Assert.AreEqual(606L, message.GetExtension(Unittest.PackedSint64Extension, 0)); - Assert.AreEqual(607u, message.GetExtension(Unittest.PackedFixed32Extension, 0)); - Assert.AreEqual(608uL, message.GetExtension(Unittest.PackedFixed64Extension, 0)); - Assert.AreEqual(609, message.GetExtension(Unittest.PackedSfixed32Extension, 0)); - Assert.AreEqual(610L, message.GetExtension(Unittest.PackedSfixed64Extension, 0)); - Assert.AreEqual(611F, message.GetExtension(Unittest.PackedFloatExtension, 0)); - Assert.AreEqual(612D, message.GetExtension(Unittest.PackedDoubleExtension, 0)); - Assert.AreEqual(true, message.GetExtension(Unittest.PackedBoolExtension, 0)); - Assert.AreEqual(ForeignEnum.FOREIGN_BAR, + Assert.Equal(2, message.GetExtensionCount(Unittest.PackedInt32Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.PackedInt64Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.PackedUint32Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.PackedUint64Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.PackedSint32Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.PackedSint64Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.PackedFixed32Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.PackedFixed64Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.PackedSfixed32Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.PackedSfixed64Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.PackedFloatExtension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.PackedDoubleExtension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.PackedBoolExtension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.PackedEnumExtension)); + Assert.Equal(601, message.GetExtension(Unittest.PackedInt32Extension, 0)); + Assert.Equal(602L, message.GetExtension(Unittest.PackedInt64Extension, 0)); + Assert.Equal(603u, message.GetExtension(Unittest.PackedUint32Extension, 0)); + Assert.Equal(604uL, message.GetExtension(Unittest.PackedUint64Extension, 0)); + Assert.Equal(605, message.GetExtension(Unittest.PackedSint32Extension, 0)); + Assert.Equal(606L, message.GetExtension(Unittest.PackedSint64Extension, 0)); + Assert.Equal(607u, message.GetExtension(Unittest.PackedFixed32Extension, 0)); + Assert.Equal(608uL, message.GetExtension(Unittest.PackedFixed64Extension, 0)); + Assert.Equal(609, message.GetExtension(Unittest.PackedSfixed32Extension, 0)); + Assert.Equal(610L, message.GetExtension(Unittest.PackedSfixed64Extension, 0)); + Assert.Equal(611F, message.GetExtension(Unittest.PackedFloatExtension, 0)); + Assert.Equal(612D, message.GetExtension(Unittest.PackedDoubleExtension, 0)); + Assert.Equal(true, message.GetExtension(Unittest.PackedBoolExtension, 0)); + Assert.Equal(ForeignEnum.FOREIGN_BAR, message.GetExtension(Unittest.PackedEnumExtension, 0)); - Assert.AreEqual(701, message.GetExtension(Unittest.PackedInt32Extension, 1)); - Assert.AreEqual(702L, message.GetExtension(Unittest.PackedInt64Extension, 1)); - Assert.AreEqual(703u, message.GetExtension(Unittest.PackedUint32Extension, 1)); - Assert.AreEqual(704uL, message.GetExtension(Unittest.PackedUint64Extension, 1)); - Assert.AreEqual(705, message.GetExtension(Unittest.PackedSint32Extension, 1)); - Assert.AreEqual(706L, message.GetExtension(Unittest.PackedSint64Extension, 1)); - Assert.AreEqual(707u, message.GetExtension(Unittest.PackedFixed32Extension, 1)); - Assert.AreEqual(708uL, message.GetExtension(Unittest.PackedFixed64Extension, 1)); - Assert.AreEqual(709, message.GetExtension(Unittest.PackedSfixed32Extension, 1)); - Assert.AreEqual(710L, message.GetExtension(Unittest.PackedSfixed64Extension, 1)); - Assert.AreEqual(711F, message.GetExtension(Unittest.PackedFloatExtension, 1)); - Assert.AreEqual(712D, message.GetExtension(Unittest.PackedDoubleExtension, 1)); - Assert.AreEqual(false, message.GetExtension(Unittest.PackedBoolExtension, 1)); - Assert.AreEqual(ForeignEnum.FOREIGN_BAZ, message.GetExtension(Unittest.PackedEnumExtension, 1)); + Assert.Equal(701, message.GetExtension(Unittest.PackedInt32Extension, 1)); + Assert.Equal(702L, message.GetExtension(Unittest.PackedInt64Extension, 1)); + Assert.Equal(703u, message.GetExtension(Unittest.PackedUint32Extension, 1)); + Assert.Equal(704uL, message.GetExtension(Unittest.PackedUint64Extension, 1)); + Assert.Equal(705, message.GetExtension(Unittest.PackedSint32Extension, 1)); + Assert.Equal(706L, message.GetExtension(Unittest.PackedSint64Extension, 1)); + Assert.Equal(707u, message.GetExtension(Unittest.PackedFixed32Extension, 1)); + Assert.Equal(708uL, message.GetExtension(Unittest.PackedFixed64Extension, 1)); + Assert.Equal(709, message.GetExtension(Unittest.PackedSfixed32Extension, 1)); + Assert.Equal(710L, message.GetExtension(Unittest.PackedSfixed64Extension, 1)); + Assert.Equal(711F, message.GetExtension(Unittest.PackedFloatExtension, 1)); + Assert.Equal(712D, message.GetExtension(Unittest.PackedDoubleExtension, 1)); + Assert.Equal(false, message.GetExtension(Unittest.PackedBoolExtension, 1)); + Assert.Equal(ForeignEnum.FOREIGN_BAZ, message.GetExtension(Unittest.PackedEnumExtension, 1)); } public static void AssertUnpackedExtensionsSet(TestUnpackedExtensions message) { - Assert.AreEqual(2, message.GetExtensionCount(Unittest.UnpackedInt32Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.UnpackedInt64Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.UnpackedUint32Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.UnpackedUint64Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.UnpackedSint32Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.UnpackedSint64Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.UnpackedFixed32Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.UnpackedFixed64Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.UnpackedSfixed32Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.UnpackedSfixed64Extension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.UnpackedFloatExtension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.UnpackedDoubleExtension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.UnpackedBoolExtension)); - Assert.AreEqual(2, message.GetExtensionCount(Unittest.UnpackedEnumExtension)); - Assert.AreEqual(601, message.GetExtension(Unittest.UnpackedInt32Extension, 0)); - Assert.AreEqual(602L, message.GetExtension(Unittest.UnpackedInt64Extension, 0)); - Assert.AreEqual(603u, message.GetExtension(Unittest.UnpackedUint32Extension, 0)); - Assert.AreEqual(604uL, message.GetExtension(Unittest.UnpackedUint64Extension, 0)); - Assert.AreEqual(605, message.GetExtension(Unittest.UnpackedSint32Extension, 0)); - Assert.AreEqual(606L, message.GetExtension(Unittest.UnpackedSint64Extension, 0)); - Assert.AreEqual(607u, message.GetExtension(Unittest.UnpackedFixed32Extension, 0)); - Assert.AreEqual(608uL, message.GetExtension(Unittest.UnpackedFixed64Extension, 0)); - Assert.AreEqual(609, message.GetExtension(Unittest.UnpackedSfixed32Extension, 0)); - Assert.AreEqual(610L, message.GetExtension(Unittest.UnpackedSfixed64Extension, 0)); - Assert.AreEqual(611F, message.GetExtension(Unittest.UnpackedFloatExtension, 0)); - Assert.AreEqual(612D, message.GetExtension(Unittest.UnpackedDoubleExtension, 0)); - Assert.AreEqual(true, message.GetExtension(Unittest.UnpackedBoolExtension, 0)); - Assert.AreEqual(ForeignEnum.FOREIGN_BAR, message.GetExtension(Unittest.UnpackedEnumExtension, 0)); - Assert.AreEqual(701, message.GetExtension(Unittest.UnpackedInt32Extension, 1)); - Assert.AreEqual(702L, message.GetExtension(Unittest.UnpackedInt64Extension, 1)); - Assert.AreEqual(703u, message.GetExtension(Unittest.UnpackedUint32Extension, 1)); - Assert.AreEqual(704uL, message.GetExtension(Unittest.UnpackedUint64Extension, 1)); - Assert.AreEqual(705, message.GetExtension(Unittest.UnpackedSint32Extension, 1)); - Assert.AreEqual(706L, message.GetExtension(Unittest.UnpackedSint64Extension, 1)); - Assert.AreEqual(707u, message.GetExtension(Unittest.UnpackedFixed32Extension, 1)); - Assert.AreEqual(708uL, message.GetExtension(Unittest.UnpackedFixed64Extension, 1)); - Assert.AreEqual(709, message.GetExtension(Unittest.UnpackedSfixed32Extension, 1)); - Assert.AreEqual(710L, message.GetExtension(Unittest.UnpackedSfixed64Extension, 1)); - Assert.AreEqual(711F, message.GetExtension(Unittest.UnpackedFloatExtension, 1)); - Assert.AreEqual(712D, message.GetExtension(Unittest.UnpackedDoubleExtension, 1)); - Assert.AreEqual(false, message.GetExtension(Unittest.UnpackedBoolExtension, 1)); - Assert.AreEqual(ForeignEnum.FOREIGN_BAZ, message.GetExtension(Unittest.UnpackedEnumExtension, 1)); + Assert.Equal(2, message.GetExtensionCount(Unittest.UnpackedInt32Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.UnpackedInt64Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.UnpackedUint32Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.UnpackedUint64Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.UnpackedSint32Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.UnpackedSint64Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.UnpackedFixed32Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.UnpackedFixed64Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.UnpackedSfixed32Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.UnpackedSfixed64Extension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.UnpackedFloatExtension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.UnpackedDoubleExtension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.UnpackedBoolExtension)); + Assert.Equal(2, message.GetExtensionCount(Unittest.UnpackedEnumExtension)); + Assert.Equal(601, message.GetExtension(Unittest.UnpackedInt32Extension, 0)); + Assert.Equal(602L, message.GetExtension(Unittest.UnpackedInt64Extension, 0)); + Assert.Equal(603u, message.GetExtension(Unittest.UnpackedUint32Extension, 0)); + Assert.Equal(604uL, message.GetExtension(Unittest.UnpackedUint64Extension, 0)); + Assert.Equal(605, message.GetExtension(Unittest.UnpackedSint32Extension, 0)); + Assert.Equal(606L, message.GetExtension(Unittest.UnpackedSint64Extension, 0)); + Assert.Equal(607u, message.GetExtension(Unittest.UnpackedFixed32Extension, 0)); + Assert.Equal(608uL, message.GetExtension(Unittest.UnpackedFixed64Extension, 0)); + Assert.Equal(609, message.GetExtension(Unittest.UnpackedSfixed32Extension, 0)); + Assert.Equal(610L, message.GetExtension(Unittest.UnpackedSfixed64Extension, 0)); + Assert.Equal(611F, message.GetExtension(Unittest.UnpackedFloatExtension, 0)); + Assert.Equal(612D, message.GetExtension(Unittest.UnpackedDoubleExtension, 0)); + Assert.Equal(true, message.GetExtension(Unittest.UnpackedBoolExtension, 0)); + Assert.Equal(ForeignEnum.FOREIGN_BAR, message.GetExtension(Unittest.UnpackedEnumExtension, 0)); + Assert.Equal(701, message.GetExtension(Unittest.UnpackedInt32Extension, 1)); + Assert.Equal(702L, message.GetExtension(Unittest.UnpackedInt64Extension, 1)); + Assert.Equal(703u, message.GetExtension(Unittest.UnpackedUint32Extension, 1)); + Assert.Equal(704uL, message.GetExtension(Unittest.UnpackedUint64Extension, 1)); + Assert.Equal(705, message.GetExtension(Unittest.UnpackedSint32Extension, 1)); + Assert.Equal(706L, message.GetExtension(Unittest.UnpackedSint64Extension, 1)); + Assert.Equal(707u, message.GetExtension(Unittest.UnpackedFixed32Extension, 1)); + Assert.Equal(708uL, message.GetExtension(Unittest.UnpackedFixed64Extension, 1)); + Assert.Equal(709, message.GetExtension(Unittest.UnpackedSfixed32Extension, 1)); + Assert.Equal(710L, message.GetExtension(Unittest.UnpackedSfixed64Extension, 1)); + Assert.Equal(711F, message.GetExtension(Unittest.UnpackedFloatExtension, 1)); + Assert.Equal(712D, message.GetExtension(Unittest.UnpackedDoubleExtension, 1)); + Assert.Equal(false, message.GetExtension(Unittest.UnpackedBoolExtension, 1)); + Assert.Equal(ForeignEnum.FOREIGN_BAZ, message.GetExtension(Unittest.UnpackedEnumExtension, 1)); } private static readonly string[] TestCultures = {"en-US", "en-GB", "fr-FR", "de-DE"}; @@ -1751,61 +1751,5 @@ namespace Google.ProtocolBuffers } return bytes; } - - - internal delegate void Action(); - - internal static void AssertNotSupported(Action action) - { - try - { - action(); - Assert.Fail("Expected NotSupportedException"); - } - catch (NotSupportedException) - { - // Expected - } - } - - internal static void AssertArgumentNullException(Action action) - { - try - { - action(); - Assert.Fail("Exception was not thrown"); - } - // Not a general case, however, Compact Framework v2 does use Invoke - catch (System.Reflection.TargetInvocationException te) - { - if (te.InnerException.GetType() != typeof(ArgumentNullException)) - throw; - } - // Normally expected exception - catch (ArgumentNullException) - { - // We expect this exception. - } - } - - internal static void AssertBytesEqual(byte[] a, byte[]b) - { - if (a == null || b == null) - { - Assert.AreEqual(a, b); - } - else - { - Assert.AreEqual(a.Length, b.Length, "The byte[] is not of the expected length."); - - for (int i = 0; i < a.Length; i++) - { - if (a[i] != b[i]) - { - Assert.AreEqual(a[i], b[i], "Byte[] differs at index " + i); - } - } - } - } } } \ No newline at end of file diff --git a/csharp/src/ProtocolBuffers.Test/TestWriterFormatJson.cs b/csharp/src/ProtocolBuffers.Test/TestWriterFormatJson.cs index b4472a60..ad5c052e 100644 --- a/csharp/src/ProtocolBuffers.Test/TestWriterFormatJson.cs +++ b/csharp/src/ProtocolBuffers.Test/TestWriterFormatJson.cs @@ -1,18 +1,18 @@ using System; using System.IO; +using System.Runtime.InteropServices; using System.Text; +using EnumOptions = Google.ProtocolBuffers.TestProtos.EnumOptions; using Google.ProtocolBuffers.DescriptorProtos; using Google.ProtocolBuffers.Serialization; -using Microsoft.VisualStudio.TestTools.UnitTesting; using Google.ProtocolBuffers.TestProtos; -using EnumOptions = Google.ProtocolBuffers.TestProtos.EnumOptions; +using Xunit; namespace Google.ProtocolBuffers { - [TestClass] public class TestWriterFormatJson { - [TestMethod] + [Fact] public void Example_FromJson() { TestXmlMessage.Builder builder = TestXmlMessage.CreateBuilder(); @@ -21,10 +21,10 @@ namespace Google.ProtocolBuffers Extensions.MergeFromJson(builder, @"{""valid"":true}"); TestXmlMessage message = builder.Build(); - Assert.AreEqual(true, message.Valid); + Assert.Equal(true, message.Valid); } - [TestMethod] + [Fact] public void Example_ToJson() { TestXmlMessage message = @@ -35,10 +35,10 @@ namespace Google.ProtocolBuffers //3.5: string json = message.ToJson(); string json = Extensions.ToJson(message); - Assert.AreEqual(@"{""valid"":true}", json); + Assert.Equal(@"{""valid"":true}", json); } - [TestMethod] + [Fact] public void Example_WriteJsonUsingICodedOutputStream() { TestXmlMessage message = @@ -52,20 +52,20 @@ namespace Google.ProtocolBuffers writer.WriteMessageStart(); //manually begin the message, output is '{' writer.Flush(); - Assert.AreEqual("{", output.ToString()); + Assert.Equal("{", output.ToString()); ICodedOutputStream stream = writer; message.WriteTo(stream); //write the message normally writer.Flush(); - Assert.AreEqual(@"{""valid"":true", output.ToString()); + Assert.Equal(@"{""valid"":true", output.ToString()); writer.WriteMessageEnd(); //manually write the end message '}' - Assert.AreEqual(@"{""valid"":true}", output.ToString()); + Assert.Equal(@"{""valid"":true}", output.ToString()); } } - [TestMethod] + [Fact] public void Example_ReadJsonUsingICodedInputStream() { TestXmlMessage.Builder builder = TestXmlMessage.CreateBuilder(); @@ -94,35 +94,37 @@ namespace Google.ProtocolBuffers JsonFormatReader.CreateInstance(Content) .Merge(message.WeakCreateBuilderForType(), registry).WeakBuild(); - Assert.AreEqual(typeof(TMessage), copy.GetType()); - Assert.AreEqual(message, copy); + Assert.Equal(typeof(TMessage), copy.GetType()); + Assert.Equal(message, copy); foreach (string expect in expecting) - Assert.IsTrue(Content.IndexOf(expect) >= 0, "Expected to find content '{0}' in: \r\n{1}", expect, Content); + { + Assert.True(Content.IndexOf(expect) >= 0); + } } - [TestMethod] + [Fact] public void TestToJsonParseFromJson() { TestAllTypes msg = new TestAllTypes.Builder().SetDefaultBool(true).Build(); string json = Extensions.ToJson(msg); - Assert.AreEqual("{\"default_bool\":true}", json); + Assert.Equal("{\"default_bool\":true}", json); TestAllTypes copy = Extensions.MergeFromJson(new TestAllTypes.Builder(), json).Build(); - Assert.IsTrue(copy.HasDefaultBool && copy.DefaultBool); - Assert.AreEqual(msg, copy); + Assert.True(copy.HasDefaultBool && copy.DefaultBool); + Assert.Equal(msg, copy); } - [TestMethod] + [Fact] public void TestToJsonParseFromJsonReader() { TestAllTypes msg = new TestAllTypes.Builder().SetDefaultBool(true).Build(); string json = Extensions.ToJson(msg); - Assert.AreEqual("{\"default_bool\":true}", json); + Assert.Equal("{\"default_bool\":true}", json); TestAllTypes copy = Extensions.MergeFromJson(new TestAllTypes.Builder(), new StringReader(json)).Build(); - Assert.IsTrue(copy.HasDefaultBool && copy.DefaultBool); - Assert.AreEqual(msg, copy); + Assert.True(copy.HasDefaultBool && copy.DefaultBool); + Assert.Equal(msg, copy); } - [TestMethod] + [Fact] public void TestJsonFormatted() { TestXmlMessage message = TestXmlMessage.CreateBuilder() @@ -142,10 +144,10 @@ namespace Google.ProtocolBuffers TestXmlMessage copy = JsonFormatReader.CreateInstance(json) .Merge(TestXmlMessage.CreateBuilder()).Build(); - Assert.AreEqual(message, copy); + Assert.Equal(message, copy); } - [TestMethod] + [Fact] public void TestEmptyMessage() { FormatterAssert( @@ -155,7 +157,7 @@ namespace Google.ProtocolBuffers ); } - [TestMethod] + [Fact] public void TestRepeatedField() { FormatterAssert( @@ -167,7 +169,7 @@ namespace Google.ProtocolBuffers ); } - [TestMethod] + [Fact] public void TestNestedEmptyMessage() { FormatterAssert( @@ -178,7 +180,7 @@ namespace Google.ProtocolBuffers ); } - [TestMethod] + [Fact] public void TestNestedMessage() { FormatterAssert( @@ -189,7 +191,7 @@ namespace Google.ProtocolBuffers ); } - [TestMethod] + [Fact] public void TestBooleanTypes() { FormatterAssert( @@ -200,7 +202,7 @@ namespace Google.ProtocolBuffers ); } - [TestMethod] + [Fact] public void TestFullMessage() { FormatterAssert( @@ -230,7 +232,7 @@ namespace Google.ProtocolBuffers ); } - [TestMethod] + [Fact] public void TestMessageWithXmlText() { FormatterAssert( @@ -241,7 +243,7 @@ namespace Google.ProtocolBuffers ); } - [TestMethod] + [Fact] public void TestWithEscapeChars() { FormatterAssert( @@ -252,7 +254,7 @@ namespace Google.ProtocolBuffers ); } - [TestMethod] + [Fact] public void TestWithExtensionText() { FormatterAssert( @@ -264,7 +266,7 @@ namespace Google.ProtocolBuffers ); } - [TestMethod] + [Fact] public void TestWithExtensionNumber() { FormatterAssert( @@ -276,7 +278,7 @@ namespace Google.ProtocolBuffers ); } - [TestMethod] + [Fact] public void TestWithExtensionArray() { FormatterAssert( @@ -289,7 +291,7 @@ namespace Google.ProtocolBuffers ); } - [TestMethod] + [Fact] public void TestWithExtensionEnum() { FormatterAssert( @@ -300,7 +302,7 @@ namespace Google.ProtocolBuffers ); } - [TestMethod] + [Fact] public void TestMessageWithExtensions() { FormatterAssert( @@ -323,7 +325,7 @@ namespace Google.ProtocolBuffers ); } - [TestMethod] + [Fact] public void TestMessageMissingExtensions() { TestXmlMessage original = TestXmlMessage.CreateBuilder() @@ -351,23 +353,23 @@ namespace Google.ProtocolBuffers IMessageLite copy = JsonFormatReader.CreateInstance(Content) .Merge(message.CreateBuilderForType()).Build(); - Assert.AreNotEqual(original, message); - Assert.AreNotEqual(original, copy); - Assert.AreEqual(message, copy); + Assert.NotEqual(original, message); + Assert.NotEqual(original, copy); + Assert.Equal(message, copy); } - [TestMethod] + [Fact] public void TestMergeFields() { TestXmlMessage.Builder builder = TestXmlMessage.CreateBuilder(); builder.MergeFrom(JsonFormatReader.CreateInstance("\"valid\": true")); builder.MergeFrom(JsonFormatReader.CreateInstance("\"text\": \"text\", \"number\": \"411\"")); - Assert.AreEqual(true, builder.Valid); - Assert.AreEqual("text", builder.Text); - Assert.AreEqual(411, builder.Number); + Assert.Equal(true, builder.Valid); + Assert.Equal("text", builder.Text); + Assert.Equal(411, builder.Number); } - [TestMethod] + [Fact] public void TestMessageArray() { JsonFormatWriter writer = JsonFormatWriter.CreateInstance().Formatted(); @@ -386,13 +388,13 @@ namespace Google.ProtocolBuffers foreach (JsonFormatReader r in reader.EnumerateArray()) { r.Merge(builder); - Assert.AreEqual(++ordinal, builder.Number); + Assert.Equal(++ordinal, builder.Number); } - Assert.AreEqual(3, ordinal); - Assert.AreEqual(3, builder.TextlinesCount); + Assert.Equal(3, ordinal); + Assert.Equal(3, builder.TextlinesCount); } - [TestMethod] + [Fact] public void TestNestedMessageArray() { JsonFormatWriter writer = JsonFormatWriter.CreateInstance(); @@ -416,13 +418,13 @@ namespace Google.ProtocolBuffers foreach (JsonFormatReader r2 in r.EnumerateArray()) { r2.Merge(builder); - Assert.AreEqual(++ordinal, builder.Number); + Assert.Equal(++ordinal, builder.Number); } - Assert.AreEqual(3, ordinal); - Assert.AreEqual(3, builder.TextlinesCount); + Assert.Equal(3, ordinal); + Assert.Equal(3, builder.TextlinesCount); } - [TestMethod] + [Fact] public void TestReadWriteJsonWithoutRoot() { TestXmlMessage.Builder builder = TestXmlMessage.CreateBuilder(); @@ -437,53 +439,51 @@ namespace Google.ProtocolBuffers output.Flush(); Json = sw.ToString(); } - Assert.AreEqual(@"""text"":""abc"",""number"":123", Json); + Assert.Equal(@"""text"":""abc"",""number"":123", Json); ICodedInputStream input = JsonFormatReader.CreateInstance(Json); TestXmlMessage copy = TestXmlMessage.CreateBuilder().MergeFrom(input).Build(); - Assert.AreEqual(message, copy); + Assert.Equal(message, copy); } - [TestMethod,ExpectedException(typeof(RecursionLimitExceededException))] + [Fact] public void TestRecursiveLimit() { StringBuilder sb = new StringBuilder(8192); for (int i = 0; i < 80; i++) + { sb.Append("{\"child\":"); - TestXmlRescursive msg = Extensions.MergeFromJson(new TestXmlRescursive.Builder(), sb.ToString()).Build(); + } + Assert.Throws(() => Extensions.MergeFromJson(new TestXmlRescursive.Builder(), sb.ToString()).Build()); } - [TestMethod, ExpectedException(typeof(FormatException))] + [Fact] public void FailWithEmptyText() { - JsonFormatReader.CreateInstance("") - .Merge(TestXmlMessage.CreateBuilder()); + Assert.Throws(() => JsonFormatReader.CreateInstance("").Merge(TestXmlMessage.CreateBuilder())); } - [TestMethod, ExpectedException(typeof(FormatException))] + [Fact] public void FailWithUnexpectedValue() { - JsonFormatReader.CreateInstance("{{}}") - .Merge(TestXmlMessage.CreateBuilder()); + Assert.Throws(() => JsonFormatReader.CreateInstance("{{}}").Merge(TestXmlMessage.CreateBuilder())); } - [TestMethod, ExpectedException(typeof(FormatException))] + [Fact] public void FailWithUnQuotedName() { - JsonFormatReader.CreateInstance("{name:{}}") - .Merge(TestXmlMessage.CreateBuilder()); + Assert.Throws(() => JsonFormatReader.CreateInstance("{name:{}}").Merge(TestXmlMessage.CreateBuilder())); } - [TestMethod, ExpectedException(typeof(FormatException))] + [Fact] public void FailWithUnexpectedType() { - JsonFormatReader.CreateInstance("{\"valid\":{}}") - .Merge(TestXmlMessage.CreateBuilder()); + Assert.Throws(() => JsonFormatReader.CreateInstance("{\"valid\":{}}").Merge(TestXmlMessage.CreateBuilder())); } // See issue 64 for background. - [TestMethod] + [Fact] public void ToJsonRequiringBufferExpansion() { string s = new string('.', 4086); @@ -492,7 +492,7 @@ namespace Google.ProtocolBuffers .SetPackage("package") .BuildPartial(); - Assert.IsNotNull(Extensions.ToJson(opts)); + Assert.NotNull(Extensions.ToJson(opts)); } } } diff --git a/csharp/src/ProtocolBuffers.Test/TestWriterFormatXml.cs b/csharp/src/ProtocolBuffers.Test/TestWriterFormatXml.cs index 695daa84..78e6bb27 100644 --- a/csharp/src/ProtocolBuffers.Test/TestWriterFormatXml.cs +++ b/csharp/src/ProtocolBuffers.Test/TestWriterFormatXml.cs @@ -1,18 +1,16 @@ using System; -using System.Collections.Generic; using System.IO; using System.Text; using System.Xml; using Google.ProtocolBuffers.Serialization; -using Microsoft.VisualStudio.TestTools.UnitTesting; using Google.ProtocolBuffers.TestProtos; +using Xunit; namespace Google.ProtocolBuffers { - [TestClass] public class TestWriterFormatXml { - [TestMethod] + [Fact] public void Example_FromXml() { TestXmlMessage.Builder builder = TestXmlMessage.CreateBuilder(); @@ -22,10 +20,10 @@ namespace Google.ProtocolBuffers Extensions.MergeFromXml(builder, rdr); TestXmlMessage message = builder.Build(); - Assert.AreEqual(true, message.Valid); + Assert.Equal(true, message.Valid); } - [TestMethod] + [Fact] public void Example_ToXml() { TestXmlMessage message = @@ -36,10 +34,10 @@ namespace Google.ProtocolBuffers //3.5: string Xml = message.ToXml(); string Xml = Extensions.ToXml(message); - Assert.AreEqual(@"true", Xml); + Assert.Equal(@"true", Xml); } - [TestMethod] + [Fact] public void Example_WriteXmlUsingICodedOutputStream() { TestXmlMessage message = @@ -56,11 +54,11 @@ namespace Google.ProtocolBuffers message.WriteTo(stream); //write the message normally writer.WriteMessageEnd(); //manually write the end message '}' - Assert.AreEqual(@"true", output.ToString()); + Assert.Equal(@"true", output.ToString()); } } - [TestMethod] + [Fact] public void Example_ReadXmlUsingICodedInputStream() { TestXmlMessage.Builder builder = TestXmlMessage.CreateBuilder(); @@ -73,29 +71,29 @@ namespace Google.ProtocolBuffers reader.ReadMessageEnd(); //manually read the end message '}' } - [TestMethod] + [Fact] public void TestToXmlParseFromXml() { TestAllTypes msg = new TestAllTypes.Builder().SetDefaultBool(true).Build(); string xml = Extensions.ToXml(msg); - Assert.AreEqual("true", xml); + Assert.Equal("true", xml); TestAllTypes copy = Extensions.MergeFromXml(new TestAllTypes.Builder(), XmlReader.Create(new StringReader(xml))).Build(); - Assert.IsTrue(copy.HasDefaultBool && copy.DefaultBool); - Assert.AreEqual(msg, copy); + Assert.True(copy.HasDefaultBool && copy.DefaultBool); + Assert.Equal(msg, copy); } - [TestMethod] + [Fact] public void TestToXmlParseFromXmlWithRootName() { TestAllTypes msg = new TestAllTypes.Builder().SetDefaultBool(true).Build(); string xml = Extensions.ToXml(msg, "message"); - Assert.AreEqual("true", xml); + Assert.Equal("true", xml); TestAllTypes copy = Extensions.MergeFromXml(new TestAllTypes.Builder(), "message", XmlReader.Create(new StringReader(xml))).Build(); - Assert.IsTrue(copy.HasDefaultBool && copy.DefaultBool); - Assert.AreEqual(msg, copy); + Assert.True(copy.HasDefaultBool && copy.DefaultBool); + Assert.Equal(msg, copy); } - [TestMethod] + [Fact] public void TestEmptyMessage() { TestXmlChild message = TestXmlChild.CreateBuilder() @@ -113,9 +111,9 @@ namespace Google.ProtocolBuffers string xml = sw.ToString(); XmlFormatReader rdr = XmlFormatReader.CreateInstance(xml); TestXmlChild copy = rdr.Merge(TestXmlChild.CreateBuilder()).Build(); - Assert.AreEqual(message, copy); + Assert.Equal(message, copy); } - [TestMethod] + [Fact] public void TestRepeatedField() { TestXmlChild message = TestXmlChild.CreateBuilder() @@ -130,9 +128,10 @@ namespace Google.ProtocolBuffers string xml = sw.ToString(); XmlFormatReader rdr = XmlFormatReader.CreateInstance(xml); TestXmlChild copy = rdr.Merge(TestXmlChild.CreateBuilder()).Build(); - Assert.AreEqual(message, copy); + Assert.Equal(message, copy); } - [TestMethod] + + [Fact] public void TestNestedEmptyMessage() { TestXmlMessage message = TestXmlMessage.CreateBuilder() @@ -145,9 +144,10 @@ namespace Google.ProtocolBuffers string xml = sw.ToString(); XmlFormatReader rdr = XmlFormatReader.CreateInstance(xml); TestXmlMessage copy = rdr.Merge(TestXmlMessage.CreateBuilder()).Build(); - Assert.AreEqual(message, copy); + Assert.Equal(message, copy); } - [TestMethod] + + [Fact] public void TestNestedMessage() { TestXmlMessage message = TestXmlMessage.CreateBuilder() @@ -160,9 +160,10 @@ namespace Google.ProtocolBuffers string xml = sw.ToString(); XmlFormatReader rdr = XmlFormatReader.CreateInstance(xml); TestXmlMessage copy = rdr.Merge(TestXmlMessage.CreateBuilder()).Build(); - Assert.AreEqual(message, copy); + Assert.Equal(message, copy); } - [TestMethod] + + [Fact] public void TestBooleanTypes() { TestXmlMessage message = TestXmlMessage.CreateBuilder() @@ -175,9 +176,10 @@ namespace Google.ProtocolBuffers string xml = sw.ToString(); XmlFormatReader rdr = XmlFormatReader.CreateInstance(xml); TestXmlMessage copy = rdr.Merge(TestXmlMessage.CreateBuilder()).Build(); - Assert.AreEqual(message, copy); + Assert.Equal(message, copy); } - [TestMethod] + + [Fact] public void TestFullMessage() { TestXmlMessage message = TestXmlMessage.CreateBuilder() @@ -204,9 +206,10 @@ namespace Google.ProtocolBuffers XmlFormatReader rdr = XmlFormatReader.CreateInstance(xml); TestXmlMessage copy = rdr.Merge(TestXmlMessage.CreateBuilder()).Build(); - Assert.AreEqual(message, copy); + Assert.Equal(message, copy); } - [TestMethod] + + [Fact] public void TestFullMessageWithRichTypes() { TestXmlMessage message = TestXmlMessage.CreateBuilder() @@ -236,9 +239,10 @@ namespace Google.ProtocolBuffers XmlFormatReader rdr = XmlFormatReader.CreateInstance(xml); rdr.Options = XmlReaderOptions.ReadNestedArrays; TestXmlMessage copy = rdr.Merge(TestXmlMessage.CreateBuilder()).Build(); - Assert.AreEqual(message, copy); + Assert.Equal(message, copy); } - [TestMethod] + + [Fact] public void TestFullMessageWithUnknownFields() { TestXmlMessage origial = TestXmlMessage.CreateBuilder() @@ -257,7 +261,7 @@ namespace Google.ProtocolBuffers .Build(); TestXmlNoFields message = TestXmlNoFields.CreateBuilder().MergeFrom(origial.ToByteArray()).Build(); - Assert.AreEqual(0, message.AllFields.Count); + Assert.Equal(0, message.AllFields.Count); StringWriter sw = new StringWriter(); XmlFormatWriter.CreateInstance(sw) @@ -269,9 +273,9 @@ namespace Google.ProtocolBuffers using (XmlReader x = XmlReader.Create(new StringReader(xml))) { x.MoveToContent(); - Assert.AreEqual(XmlNodeType.Element, x.NodeType); + Assert.Equal(XmlNodeType.Element, x.NodeType); //should always be empty - Assert.IsTrue(x.IsEmptyElement || + Assert.True(x.IsEmptyElement || (x.Read() && x.NodeType == XmlNodeType.EndElement) ); } @@ -279,9 +283,10 @@ namespace Google.ProtocolBuffers XmlFormatReader rdr = XmlFormatReader.CreateInstance(xml); rdr.Options = XmlReaderOptions.ReadNestedArrays; TestXmlMessage copy = rdr.Merge(TestXmlMessage.CreateBuilder()).Build(); - Assert.AreEqual(TestXmlMessage.DefaultInstance, copy); + Assert.Equal(TestXmlMessage.DefaultInstance, copy); } - [TestMethod] + + [Fact] public void TestMessageWithXmlText() { TestXmlMessage message = TestXmlMessage.CreateBuilder() @@ -294,9 +299,10 @@ namespace Google.ProtocolBuffers XmlFormatReader rdr = XmlFormatReader.CreateInstance(xml); TestXmlMessage copy = rdr.Merge(TestXmlMessage.CreateBuilder()).Build(); - Assert.AreEqual(message, copy); + Assert.Equal(message, copy); } - [TestMethod] + + [Fact] public void TestXmlWithWhitespace() { TestXmlMessage message = TestXmlMessage.CreateBuilder() @@ -309,9 +315,10 @@ namespace Google.ProtocolBuffers XmlFormatReader rdr = XmlFormatReader.CreateInstance(xml); TestXmlMessage copy = rdr.Merge(TestXmlMessage.CreateBuilder()).Build(); - Assert.AreEqual(message, copy); + Assert.Equal(message, copy); } - [TestMethod] + + [Fact] public void TestXmlWithExtensionText() { TestXmlMessage message = TestXmlMessage.CreateBuilder() @@ -328,9 +335,10 @@ namespace Google.ProtocolBuffers XmlFormatReader rdr = XmlFormatReader.CreateInstance(xml); TestXmlMessage copy = rdr.Merge(TestXmlMessage.CreateBuilder(), registry).Build(); - Assert.AreEqual(message, copy); + Assert.Equal(message, copy); } - [TestMethod] + + [Fact] public void TestXmlWithExtensionMessage() { TestXmlMessage message = TestXmlMessage.CreateBuilder() @@ -347,9 +355,10 @@ namespace Google.ProtocolBuffers XmlFormatReader rdr = XmlFormatReader.CreateInstance(xml); TestXmlMessage copy = rdr.Merge(TestXmlMessage.CreateBuilder(), registry).Build(); - Assert.AreEqual(message, copy); + Assert.Equal(message, copy); } - [TestMethod] + + [Fact] public void TestXmlWithExtensionArray() { TestXmlMessage message = TestXmlMessage.CreateBuilder() @@ -368,9 +377,10 @@ namespace Google.ProtocolBuffers XmlFormatReader rdr = XmlFormatReader.CreateInstance(xml); TestXmlMessage copy = rdr.Merge(TestXmlMessage.CreateBuilder(), registry).Build(); - Assert.AreEqual(message, copy); + Assert.Equal(message, copy); } - [TestMethod] + + [Fact] public void TestXmlWithExtensionEnum() { TestXmlMessage message = TestXmlMessage.CreateBuilder() @@ -387,9 +397,10 @@ namespace Google.ProtocolBuffers XmlFormatReader rdr = XmlFormatReader.CreateInstance(xml); TestXmlMessage copy = rdr.Merge(TestXmlMessage.CreateBuilder(), registry).Build(); - Assert.AreEqual(message, copy); + Assert.Equal(message, copy); } - [TestMethod] + + [Fact] public void TestXmlReadEmptyRoot() { TestXmlMessage.Builder builder = TestXmlMessage.CreateBuilder(); @@ -402,7 +413,7 @@ namespace Google.ProtocolBuffers reader.ReadMessageEnd(); //manually read the end message '}' } - [TestMethod] + [Fact] public void TestXmlReadEmptyChild() { TestXmlMessage.Builder builder = TestXmlMessage.CreateBuilder(); @@ -411,11 +422,11 @@ namespace Google.ProtocolBuffers reader.ReadMessageStart(); //manually read the begin the message '{' builder.MergeFrom(reader); //write the message normally - Assert.IsTrue(builder.HasText); - Assert.AreEqual(String.Empty, builder.Text); + Assert.True(builder.HasText); + Assert.Equal(String.Empty, builder.Text); } - [TestMethod] + [Fact] public void TestXmlReadWriteWithoutRoot() { TestXmlMessage.Builder builder = TestXmlMessage.CreateBuilder(); @@ -431,7 +442,7 @@ namespace Google.ProtocolBuffers output.Flush(); xml = sw.ToString(); } - Assert.AreEqual("abc123", xml); + Assert.Equal("abc123", xml); TestXmlMessage copy; using (XmlReader xr = XmlReader.Create(new StringReader(xml), new XmlReaderSettings() { ConformanceLevel = ConformanceLevel.Fragment })) @@ -440,16 +451,18 @@ namespace Google.ProtocolBuffers copy = TestXmlMessage.CreateBuilder().MergeFrom(input).Build(); } - Assert.AreEqual(message, copy); + Assert.Equal(message, copy); } - [TestMethod, ExpectedException(typeof(RecursionLimitExceededException))] + [Fact] public void TestRecursiveLimit() { StringBuilder sb = new StringBuilder(8192); for (int i = 0; i < 80; i++) + { sb.Append(""); - TestXmlRescursive msg = Extensions.MergeFromXml(new TestXmlRescursive.Builder(), "child", XmlReader.Create(new StringReader(sb.ToString()))).Build(); + } + Assert.Throws(() => Extensions.MergeFromXml(new TestXmlRescursive.Builder(), "child", XmlReader.Create(new StringReader(sb.ToString()))).Build()); } } } diff --git a/csharp/src/ProtocolBuffers.Test/TextFormatTest.cs b/csharp/src/ProtocolBuffers.Test/TextFormatTest.cs index 37a4192a..1e083c6b 100644 --- a/csharp/src/ProtocolBuffers.Test/TextFormatTest.cs +++ b/csharp/src/ProtocolBuffers.Test/TextFormatTest.cs @@ -36,15 +36,11 @@ using System; using System.IO; -using System.Text; using Google.ProtocolBuffers.TestProtos; -using Microsoft.VisualStudio.TestTools.UnitTesting; -using System.Globalization; -using System.Threading; +using Xunit; namespace Google.ProtocolBuffers { - [TestClass] public class TextFormatTest { private static readonly string AllFieldsSetText = TestResources.text_format_unittest_data; @@ -88,46 +84,46 @@ namespace Google.ProtocolBuffers /// /// Print TestAllTypes and compare with golden file. /// - [TestMethod] + [Fact] public void PrintMessage() { TestUtil.TestInMultipleCultures(() => - { - string text = TextFormat.PrintToString(TestUtil.GetAllSet()); - Assert.AreEqual(AllFieldsSetText.Replace("\r\n", "\n").Trim(), - text.Replace("\r\n", "\n").Trim()); - }); + { + string text = TextFormat.PrintToString(TestUtil.GetAllSet()); + Assert.Equal(AllFieldsSetText.Replace("\r\n", "\n").Trim(), + text.Replace("\r\n", "\n").Trim()); + }); } /// /// Tests that a builder prints the same way as a message. /// - [TestMethod] + [Fact] public void PrintBuilder() { TestUtil.TestInMultipleCultures(() => { string messageText = TextFormat.PrintToString(TestUtil.GetAllSet()); string builderText = TextFormat.PrintToString(TestUtil.GetAllSet().ToBuilder()); - Assert.AreEqual(messageText, builderText); + Assert.Equal(messageText, builderText); }); } /// /// Print TestAllExtensions and compare with golden file. /// - [TestMethod] + [Fact] public void PrintExtensions() { string text = TextFormat.PrintToString(TestUtil.GetAllExtensionsSet()); - Assert.AreEqual(AllExtensionsSetText.Replace("\r\n", "\n").Trim(), text.Replace("\r\n", "\n").Trim()); + Assert.Equal(AllExtensionsSetText.Replace("\r\n", "\n").Trim(), text.Replace("\r\n", "\n").Trim()); } /// /// Test printing of unknown fields in a message. /// - [TestMethod] + [Fact] public void PrintUnknownFields() { TestEmptyMessage message = @@ -163,7 +159,7 @@ namespace Google.ProtocolBuffers .Build()) .Build(); - Assert.AreEqual( + Assert.Equal( "5: 1\n" + "5: 0x00000002\n" + "5: 0x0000000000000003\n" + @@ -193,7 +189,7 @@ namespace Google.ProtocolBuffers return ByteString.CopyFrom(bytes); } - [TestMethod] + [Fact] public void PrintExotic() { IMessage message = TestAllTypes.CreateBuilder() @@ -224,10 +220,10 @@ namespace Google.ProtocolBuffers .AddRepeatedBytes(Bytes("\0\u0001\u0007\b\f\n\r\t\v\\\'\"\u00fe")) .Build(); - Assert.AreEqual(ExoticText, message.ToString()); + Assert.Equal(ExoticText, message.ToString()); } - [TestMethod] + [Fact] public void PrintMessageSet() { TestMessageSet messageSet = @@ -240,12 +236,12 @@ namespace Google.ProtocolBuffers TestMessageSetExtension2.CreateBuilder().SetStr("foo").Build()) .Build(); - Assert.AreEqual(MessageSetText, messageSet.ToString()); + Assert.Equal(MessageSetText, messageSet.ToString()); } // ================================================================= - [TestMethod] + [Fact] public void Parse() { TestUtil.TestInMultipleCultures(() => @@ -256,7 +252,7 @@ namespace Google.ProtocolBuffers }); } - [TestMethod] + [Fact] public void ParseReader() { TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); @@ -264,7 +260,7 @@ namespace Google.ProtocolBuffers TestUtil.AssertAllFieldsSet(builder.Build()); } - [TestMethod] + [Fact] public void ParseExtensions() { TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder(); @@ -274,7 +270,7 @@ namespace Google.ProtocolBuffers TestUtil.AssertAllExtensionsSet(builder.Build()); } - [TestMethod] + [Fact] public void ParseCompatibility() { string original = "repeated_float: inf\n" + @@ -303,10 +299,10 @@ namespace Google.ProtocolBuffers "repeated_double: NaN\n"; TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); TextFormat.Merge(original, builder); - Assert.AreEqual(canonical, builder.Build().ToString()); + Assert.Equal(canonical, builder.Build().ToString()); } - [TestMethod] + [Fact] public void ParseExotic() { TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); @@ -314,10 +310,10 @@ namespace Google.ProtocolBuffers // Too lazy to check things individually. Don't try to debug this // if testPrintExotic() is Assert.Failing. - Assert.AreEqual(ExoticText, builder.Build().ToString()); + Assert.Equal(ExoticText, builder.Build().ToString()); } - [TestMethod] + [Fact] public void ParseMessageSet() { ExtensionRegistry extensionRegistry = ExtensionRegistry.CreateInstance(); @@ -328,30 +324,30 @@ namespace Google.ProtocolBuffers TextFormat.Merge(MessageSetText, extensionRegistry, builder); TestMessageSet messageSet = builder.Build(); - Assert.IsTrue(messageSet.HasExtension(TestMessageSetExtension1.MessageSetExtension)); - Assert.AreEqual(123, messageSet.GetExtension(TestMessageSetExtension1.MessageSetExtension).I); - Assert.IsTrue(messageSet.HasExtension(TestMessageSetExtension2.MessageSetExtension)); - Assert.AreEqual("foo", messageSet.GetExtension(TestMessageSetExtension2.MessageSetExtension).Str); + Assert.True(messageSet.HasExtension(TestMessageSetExtension1.MessageSetExtension)); + Assert.Equal(123, messageSet.GetExtension(TestMessageSetExtension1.MessageSetExtension).I); + Assert.True(messageSet.HasExtension(TestMessageSetExtension2.MessageSetExtension)); + Assert.Equal("foo", messageSet.GetExtension(TestMessageSetExtension2.MessageSetExtension).Str); } - [TestMethod] + [Fact] public void ParseNumericEnum() { TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); TextFormat.Merge("optional_nested_enum: 2", builder); - Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, builder.OptionalNestedEnum); + Assert.Equal(TestAllTypes.Types.NestedEnum.BAR, builder.OptionalNestedEnum); } - [TestMethod] + [Fact] public void ParseAngleBrackets() { TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); TextFormat.Merge("OptionalGroup: < a: 1 >", builder); - Assert.IsTrue(builder.HasOptionalGroup); - Assert.AreEqual(1, builder.OptionalGroup.A); + Assert.True(builder.HasOptionalGroup); + Assert.Equal(1, builder.OptionalGroup.A); } - [TestMethod] + [Fact] public void ParseComment() { TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); @@ -360,26 +356,19 @@ namespace Google.ProtocolBuffers "optional_int32: 1 # another comment\n" + "optional_int64: 2\n" + "# EOF comment", builder); - Assert.AreEqual(1, builder.OptionalInt32); - Assert.AreEqual(2, builder.OptionalInt64); + Assert.Equal(1, builder.OptionalInt32); + Assert.Equal(2, builder.OptionalInt64); } private static void AssertParseError(string error, string text) { TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); - try - { - TextFormat.Merge(text, TestUtil.CreateExtensionRegistry(), builder); - Assert.Fail("Expected parse exception."); - } - catch (FormatException e) - { - Assert.AreEqual(error, e.Message); - } + Exception exception = Assert.Throws(() => TextFormat.Merge(text, TestUtil.CreateExtensionRegistry(), builder)); + Assert.Equal(error, exception.Message); } - [TestMethod] + [Fact] public void ParseErrors() { AssertParseError( @@ -454,111 +443,96 @@ namespace Google.ProtocolBuffers return ByteString.CopyFrom(bytes); } - private delegate void FormattingAction(); - - private static void AssertFormatException(FormattingAction action) - { - try - { - action(); - Assert.Fail("Should have thrown an exception."); - } - catch (FormatException) - { - // success - } - } - - [TestMethod] + [Fact] public void Escape() { // Escape sequences. - Assert.AreEqual("\\000\\001\\a\\b\\f\\n\\r\\t\\v\\\\\\'\\\"", + Assert.Equal("\\000\\001\\a\\b\\f\\n\\r\\t\\v\\\\\\'\\\"", TextFormat.EscapeBytes(Bytes("\0\u0001\u0007\b\f\n\r\t\v\\\'\""))); - Assert.AreEqual("\\000\\001\\a\\b\\f\\n\\r\\t\\v\\\\\\'\\\"", + Assert.Equal("\\000\\001\\a\\b\\f\\n\\r\\t\\v\\\\\\'\\\"", TextFormat.EscapeText("\0\u0001\u0007\b\f\n\r\t\v\\\'\"")); - Assert.AreEqual(Bytes("\0\u0001\u0007\b\f\n\r\t\v\\\'\""), + Assert.Equal(Bytes("\0\u0001\u0007\b\f\n\r\t\v\\\'\""), TextFormat.UnescapeBytes("\\000\\001\\a\\b\\f\\n\\r\\t\\v\\\\\\'\\\"")); - Assert.AreEqual("\0\u0001\u0007\b\f\n\r\t\v\\\'\"", + Assert.Equal("\0\u0001\u0007\b\f\n\r\t\v\\\'\"", TextFormat.UnescapeText("\\000\\001\\a\\b\\f\\n\\r\\t\\v\\\\\\'\\\"")); // Unicode handling. - Assert.AreEqual("\\341\\210\\264", TextFormat.EscapeText("\u1234")); - Assert.AreEqual("\\341\\210\\264", TextFormat.EscapeBytes(Bytes(0xe1, 0x88, 0xb4))); - Assert.AreEqual("\u1234", TextFormat.UnescapeText("\\341\\210\\264")); - Assert.AreEqual(Bytes(0xe1, 0x88, 0xb4), TextFormat.UnescapeBytes("\\341\\210\\264")); - Assert.AreEqual("\u1234", TextFormat.UnescapeText("\\xe1\\x88\\xb4")); - Assert.AreEqual(Bytes(0xe1, 0x88, 0xb4), TextFormat.UnescapeBytes("\\xe1\\x88\\xb4")); + Assert.Equal("\\341\\210\\264", TextFormat.EscapeText("\u1234")); + Assert.Equal("\\341\\210\\264", TextFormat.EscapeBytes(Bytes(0xe1, 0x88, 0xb4))); + Assert.Equal("\u1234", TextFormat.UnescapeText("\\341\\210\\264")); + Assert.Equal(Bytes(0xe1, 0x88, 0xb4), TextFormat.UnescapeBytes("\\341\\210\\264")); + Assert.Equal("\u1234", TextFormat.UnescapeText("\\xe1\\x88\\xb4")); + Assert.Equal(Bytes(0xe1, 0x88, 0xb4), TextFormat.UnescapeBytes("\\xe1\\x88\\xb4")); // Errors. - AssertFormatException(() => TextFormat.UnescapeText("\\x")); - AssertFormatException(() => TextFormat.UnescapeText("\\z")); - AssertFormatException(() => TextFormat.UnescapeText("\\")); + Assert.Throws(() => TextFormat.UnescapeText("\\x")); + Assert.Throws(() => TextFormat.UnescapeText("\\z")); + Assert.Throws(() => TextFormat.UnescapeText("\\")); } - [TestMethod] + [Fact] public void ParseInteger() { - Assert.AreEqual(0, TextFormat.ParseInt32("0")); - Assert.AreEqual(1, TextFormat.ParseInt32("1")); - Assert.AreEqual(-1, TextFormat.ParseInt32("-1")); - Assert.AreEqual(12345, TextFormat.ParseInt32("12345")); - Assert.AreEqual(-12345, TextFormat.ParseInt32("-12345")); - Assert.AreEqual(2147483647, TextFormat.ParseInt32("2147483647")); - Assert.AreEqual(-2147483648, TextFormat.ParseInt32("-2147483648")); - - Assert.AreEqual(0u, TextFormat.ParseUInt32("0")); - Assert.AreEqual(1u, TextFormat.ParseUInt32("1")); - Assert.AreEqual(12345u, TextFormat.ParseUInt32("12345")); - Assert.AreEqual(2147483647u, TextFormat.ParseUInt32("2147483647")); - Assert.AreEqual(2147483648U, TextFormat.ParseUInt32("2147483648")); - Assert.AreEqual(4294967295U, TextFormat.ParseUInt32("4294967295")); - - Assert.AreEqual(0L, TextFormat.ParseInt64("0")); - Assert.AreEqual(1L, TextFormat.ParseInt64("1")); - Assert.AreEqual(-1L, TextFormat.ParseInt64("-1")); - Assert.AreEqual(12345L, TextFormat.ParseInt64("12345")); - Assert.AreEqual(-12345L, TextFormat.ParseInt64("-12345")); - Assert.AreEqual(2147483647L, TextFormat.ParseInt64("2147483647")); - Assert.AreEqual(-2147483648L, TextFormat.ParseInt64("-2147483648")); - Assert.AreEqual(4294967295L, TextFormat.ParseInt64("4294967295")); - Assert.AreEqual(4294967296L, TextFormat.ParseInt64("4294967296")); - Assert.AreEqual(9223372036854775807L, TextFormat.ParseInt64("9223372036854775807")); - Assert.AreEqual(-9223372036854775808L, TextFormat.ParseInt64("-9223372036854775808")); - - Assert.AreEqual(0uL, TextFormat.ParseUInt64("0")); - Assert.AreEqual(1uL, TextFormat.ParseUInt64("1")); - Assert.AreEqual(12345uL, TextFormat.ParseUInt64("12345")); - Assert.AreEqual(2147483647uL, TextFormat.ParseUInt64("2147483647")); - Assert.AreEqual(4294967295uL, TextFormat.ParseUInt64("4294967295")); - Assert.AreEqual(4294967296uL, TextFormat.ParseUInt64("4294967296")); - Assert.AreEqual(9223372036854775807UL, TextFormat.ParseUInt64("9223372036854775807")); - Assert.AreEqual(9223372036854775808UL, TextFormat.ParseUInt64("9223372036854775808")); - Assert.AreEqual(18446744073709551615UL, TextFormat.ParseUInt64("18446744073709551615")); + Assert.Equal(0, TextFormat.ParseInt32("0")); + Assert.Equal(1, TextFormat.ParseInt32("1")); + Assert.Equal(-1, TextFormat.ParseInt32("-1")); + Assert.Equal(12345, TextFormat.ParseInt32("12345")); + Assert.Equal(-12345, TextFormat.ParseInt32("-12345")); + Assert.Equal(2147483647, TextFormat.ParseInt32("2147483647")); + Assert.Equal(-2147483648, TextFormat.ParseInt32("-2147483648")); + + Assert.Equal(0u, TextFormat.ParseUInt32("0")); + Assert.Equal(1u, TextFormat.ParseUInt32("1")); + Assert.Equal(12345u, TextFormat.ParseUInt32("12345")); + Assert.Equal(2147483647u, TextFormat.ParseUInt32("2147483647")); + Assert.Equal(2147483648U, TextFormat.ParseUInt32("2147483648")); + Assert.Equal(4294967295U, TextFormat.ParseUInt32("4294967295")); + + Assert.Equal(0L, TextFormat.ParseInt64("0")); + Assert.Equal(1L, TextFormat.ParseInt64("1")); + Assert.Equal(-1L, TextFormat.ParseInt64("-1")); + Assert.Equal(12345L, TextFormat.ParseInt64("12345")); + Assert.Equal(-12345L, TextFormat.ParseInt64("-12345")); + Assert.Equal(2147483647L, TextFormat.ParseInt64("2147483647")); + Assert.Equal(-2147483648L, TextFormat.ParseInt64("-2147483648")); + Assert.Equal(4294967295L, TextFormat.ParseInt64("4294967295")); + Assert.Equal(4294967296L, TextFormat.ParseInt64("4294967296")); + Assert.Equal(9223372036854775807L, TextFormat.ParseInt64("9223372036854775807")); + Assert.Equal(-9223372036854775808L, TextFormat.ParseInt64("-9223372036854775808")); + + Assert.Equal(0uL, TextFormat.ParseUInt64("0")); + Assert.Equal(1uL, TextFormat.ParseUInt64("1")); + Assert.Equal(12345uL, TextFormat.ParseUInt64("12345")); + Assert.Equal(2147483647uL, TextFormat.ParseUInt64("2147483647")); + Assert.Equal(4294967295uL, TextFormat.ParseUInt64("4294967295")); + Assert.Equal(4294967296uL, TextFormat.ParseUInt64("4294967296")); + Assert.Equal(9223372036854775807UL, TextFormat.ParseUInt64("9223372036854775807")); + Assert.Equal(9223372036854775808UL, TextFormat.ParseUInt64("9223372036854775808")); + Assert.Equal(18446744073709551615UL, TextFormat.ParseUInt64("18446744073709551615")); // Hex - Assert.AreEqual(0x1234abcd, TextFormat.ParseInt32("0x1234abcd")); - Assert.AreEqual(-0x1234abcd, TextFormat.ParseInt32("-0x1234abcd")); - Assert.AreEqual(0xffffffffffffffffUL, TextFormat.ParseUInt64("0xffffffffffffffff")); - Assert.AreEqual(0x7fffffffffffffffL, + Assert.Equal(0x1234abcd, TextFormat.ParseInt32("0x1234abcd")); + Assert.Equal(-0x1234abcd, TextFormat.ParseInt32("-0x1234abcd")); + Assert.Equal(0xffffffffffffffffUL, TextFormat.ParseUInt64("0xffffffffffffffff")); + Assert.Equal(0x7fffffffffffffffL, TextFormat.ParseInt64("0x7fffffffffffffff")); // Octal - Assert.AreEqual(342391, TextFormat.ParseInt32("01234567")); + Assert.Equal(342391, TextFormat.ParseInt32("01234567")); // Out-of-range - AssertFormatException(() => TextFormat.ParseInt32("2147483648")); - AssertFormatException(() => TextFormat.ParseInt32("-2147483649")); - AssertFormatException(() => TextFormat.ParseUInt32("4294967296")); - AssertFormatException(() => TextFormat.ParseUInt32("-1")); - AssertFormatException(() => TextFormat.ParseInt64("9223372036854775808")); - AssertFormatException(() => TextFormat.ParseInt64("-9223372036854775809")); - AssertFormatException(() => TextFormat.ParseUInt64("18446744073709551616")); - AssertFormatException(() => TextFormat.ParseUInt64("-1")); - AssertFormatException(() => TextFormat.ParseInt32("abcd")); + Assert.Throws(() => TextFormat.ParseInt32("2147483648")); + Assert.Throws(() => TextFormat.ParseInt32("-2147483649")); + Assert.Throws(() => TextFormat.ParseUInt32("4294967296")); + Assert.Throws(() => TextFormat.ParseUInt32("-1")); + Assert.Throws(() => TextFormat.ParseInt64("9223372036854775808")); + Assert.Throws(() => TextFormat.ParseInt64("-9223372036854775809")); + Assert.Throws(() => TextFormat.ParseUInt64("18446744073709551616")); + Assert.Throws(() => TextFormat.ParseUInt64("-1")); + Assert.Throws(() => TextFormat.ParseInt32("abcd")); } - [TestMethod] + [Fact] public void ParseLongString() { string longText = @@ -580,7 +554,7 @@ namespace Google.ProtocolBuffers "123456789012345678901234567890123456789012345678901234567890"; TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); TextFormat.Merge("optional_string: \"" + longText + "\"", builder); - Assert.AreEqual(longText, builder.OptionalString); + Assert.Equal(longText, builder.OptionalString); } } } \ No newline at end of file diff --git a/csharp/src/ProtocolBuffers.Test/UnknownFieldSetTest.cs b/csharp/src/ProtocolBuffers.Test/UnknownFieldSetTest.cs index b5fc606d..f20ba7cb 100644 --- a/csharp/src/ProtocolBuffers.Test/UnknownFieldSetTest.cs +++ b/csharp/src/ProtocolBuffers.Test/UnknownFieldSetTest.cs @@ -38,27 +38,25 @@ using System; using System.Collections.Generic; using Google.ProtocolBuffers.Descriptors; using Google.ProtocolBuffers.TestProtos; -using Microsoft.VisualStudio.TestTools.UnitTesting; +using Xunit; namespace Google.ProtocolBuffers { - [TestClass] public class UnknownFieldSetTest { - private MessageDescriptor descriptor; - private TestAllTypes allFields; - private ByteString allFieldsData; + private readonly MessageDescriptor descriptor; + private readonly TestAllTypes allFields; + private readonly ByteString allFieldsData; /// /// An empty message that has been parsed from allFieldsData. So, it has /// unknown fields of every type. /// - private TestEmptyMessage emptyMessage; + private readonly TestEmptyMessage emptyMessage; - private UnknownFieldSet unknownFields; + private readonly UnknownFieldSet unknownFields; - [TestInitialize] - public void SetUp() + public UnknownFieldSetTest() { descriptor = TestAllTypes.Descriptor; allFields = TestUtil.GetAllSet(); @@ -70,7 +68,7 @@ namespace Google.ProtocolBuffers private UnknownField GetField(String name) { FieldDescriptor field = descriptor.FindDescriptor(name); - Assert.IsNotNull(field); + Assert.NotNull(field); return unknownFields.FieldDictionary[field.FieldNumber]; } @@ -105,75 +103,75 @@ namespace Google.ProtocolBuffers // ================================================================= - [TestMethod] + [Fact] public void Varint() { UnknownField field = GetField("optional_int32"); - Assert.AreEqual(1, field.VarintList.Count); - Assert.AreEqual(allFields.OptionalInt32, (long) field.VarintList[0]); + Assert.Equal(1, field.VarintList.Count); + Assert.Equal(allFields.OptionalInt32, (long) field.VarintList[0]); } - [TestMethod] + [Fact] public void Fixed32() { UnknownField field = GetField("optional_fixed32"); - Assert.AreEqual(1, field.Fixed32List.Count); - Assert.AreEqual(allFields.OptionalFixed32, (int) field.Fixed32List[0]); + Assert.Equal(1, field.Fixed32List.Count); + Assert.Equal(allFields.OptionalFixed32, (int) field.Fixed32List[0]); } - [TestMethod] + [Fact] public void Fixed64() { UnknownField field = GetField("optional_fixed64"); - Assert.AreEqual(1, field.Fixed64List.Count); - Assert.AreEqual((long)allFields.OptionalFixed64, (long)field.Fixed64List[0]); + Assert.Equal(1, field.Fixed64List.Count); + Assert.Equal((long)allFields.OptionalFixed64, (long)field.Fixed64List[0]); } - [TestMethod] + [Fact] public void LengthDelimited() { UnknownField field = GetField("optional_bytes"); - Assert.AreEqual(1, field.LengthDelimitedList.Count); - Assert.AreEqual(allFields.OptionalBytes, field.LengthDelimitedList[0]); + Assert.Equal(1, field.LengthDelimitedList.Count); + Assert.Equal(allFields.OptionalBytes, field.LengthDelimitedList[0]); } - [TestMethod] + [Fact] public void Group() { FieldDescriptor nestedFieldDescriptor = TestAllTypes.Types.OptionalGroup.Descriptor.FindDescriptor("a"); - Assert.IsNotNull(nestedFieldDescriptor); + Assert.NotNull(nestedFieldDescriptor); UnknownField field = GetField("optionalgroup"); - Assert.AreEqual(1, field.GroupList.Count); + Assert.Equal(1, field.GroupList.Count); UnknownFieldSet group = field.GroupList[0]; - Assert.AreEqual(1, group.FieldDictionary.Count); - Assert.IsTrue(group.HasField(nestedFieldDescriptor.FieldNumber)); + Assert.Equal(1, group.FieldDictionary.Count); + Assert.True(group.HasField(nestedFieldDescriptor.FieldNumber)); UnknownField nestedField = group[nestedFieldDescriptor.FieldNumber]; - Assert.AreEqual(1, nestedField.VarintList.Count); - Assert.AreEqual(allFields.OptionalGroup.A, (long) nestedField.VarintList[0]); + Assert.Equal(1, nestedField.VarintList.Count); + Assert.Equal(allFields.OptionalGroup.A, (long) nestedField.VarintList[0]); } - [TestMethod] + [Fact] public void Serialize() { // Check that serializing the UnknownFieldSet produces the original data again. ByteString data = emptyMessage.ToByteString(); - Assert.AreEqual(allFieldsData, data); + Assert.Equal(allFieldsData, data); } - [TestMethod] + [Fact] public void CopyFrom() { TestEmptyMessage message = TestEmptyMessage.CreateBuilder().MergeFrom(emptyMessage).Build(); - Assert.AreEqual(emptyMessage.ToString(), message.ToString()); + Assert.Equal(emptyMessage.ToString(), message.ToString()); } - [TestMethod] + [Fact] public void MergeFrom() { TestEmptyMessage source = @@ -202,7 +200,7 @@ namespace Google.ProtocolBuffers .MergeFrom(source) .Build(); - Assert.AreEqual( + Assert.Equal( "1: 1\n" + "2: 2\n" + "3: 3\n" + @@ -210,23 +208,23 @@ namespace Google.ProtocolBuffers destination.ToString()); } - [TestMethod] + [Fact] public void Clear() { UnknownFieldSet fields = UnknownFieldSet.CreateBuilder().MergeFrom(unknownFields).Clear().Build(); - Assert.AreEqual(0, fields.FieldDictionary.Count); + Assert.Equal(0, fields.FieldDictionary.Count); } - [TestMethod] + [Fact] public void ClearMessage() { TestEmptyMessage message = TestEmptyMessage.CreateBuilder().MergeFrom(emptyMessage).Clear().Build(); - Assert.AreEqual(0, message.SerializedSize); + Assert.Equal(0, message.SerializedSize); } - [TestMethod] + [Fact] public void ParseKnownAndUnknown() { // Test mixing known and unknown fields when parsing. @@ -241,14 +239,14 @@ namespace Google.ProtocolBuffers TestAllTypes destination = TestAllTypes.ParseFrom(data); TestUtil.AssertAllFieldsSet(destination); - Assert.AreEqual(1, destination.UnknownFields.FieldDictionary.Count); + Assert.Equal(1, destination.UnknownFields.FieldDictionary.Count); UnknownField field = destination.UnknownFields[123456]; - Assert.AreEqual(1, field.VarintList.Count); - Assert.AreEqual(654321, (long) field.VarintList[0]); + Assert.Equal(1, field.VarintList.Count); + Assert.Equal(654321, (long) field.VarintList[0]); } - [TestMethod] + [Fact] public void WrongTypeTreatedAsUnknown() { // Test that fields of the wrong wire type are treated like unknown fields @@ -260,10 +258,10 @@ namespace Google.ProtocolBuffers // All fields should have been interpreted as unknown, so the debug strings // should be the same. - Assert.AreEqual(emptyMessage.ToString(), allTypesMessage.ToString()); + Assert.Equal(emptyMessage.ToString(), allTypesMessage.ToString()); } - [TestMethod] + [Fact] public void UnknownExtensions() { // Make sure fields are properly parsed to the UnknownFieldSet even when @@ -272,12 +270,12 @@ namespace Google.ProtocolBuffers TestEmptyMessageWithExtensions message = TestEmptyMessageWithExtensions.ParseFrom(allFieldsData); - Assert.AreEqual(unknownFields.FieldDictionary.Count, + Assert.Equal(unknownFields.FieldDictionary.Count, message.UnknownFields.FieldDictionary.Count); - Assert.AreEqual(allFieldsData, message.ToByteString()); + Assert.Equal(allFieldsData, message.ToByteString()); } - [TestMethod] + [Fact] public void WrongExtensionTypeTreatedAsUnknown() { // Test that fields of the wrong wire type are treated like unknown fields @@ -289,19 +287,19 @@ namespace Google.ProtocolBuffers // All fields should have been interpreted as unknown, so the debug strings // should be the same. - Assert.AreEqual(emptyMessage.ToString(), + Assert.Equal(emptyMessage.ToString(), allExtensionsMessage.ToString()); } - [TestMethod] + [Fact] public void ParseUnknownEnumValue() { FieldDescriptor singularField = TestAllTypes.Descriptor.FindDescriptor("optional_nested_enum"); FieldDescriptor repeatedField = TestAllTypes.Descriptor.FindDescriptor("repeated_nested_enum"); - Assert.IsNotNull(singularField); - Assert.IsNotNull(repeatedField); + Assert.NotNull(singularField); + Assert.NotNull(repeatedField); ByteString data = UnknownFieldSet.CreateBuilder() @@ -322,7 +320,7 @@ namespace Google.ProtocolBuffers { TestAllTypes message = TestAllTypes.ParseFrom(data); - Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, + Assert.Equal(TestAllTypes.Types.NestedEnum.BAR, message.OptionalNestedEnum); TestUtil.AssertEqual(new[] {TestAllTypes.Types.NestedEnum.FOO, TestAllTypes.Types.NestedEnum.BAZ}, message.RepeatedNestedEnumList); @@ -333,7 +331,7 @@ namespace Google.ProtocolBuffers { TestAllExtensions message = TestAllExtensions.ParseFrom(data, TestUtil.CreateExtensionRegistry()); - Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, + Assert.Equal(TestAllTypes.Types.NestedEnum.BAR, message.GetExtension(Unittest.OptionalNestedEnumExtension)); TestUtil.AssertEqual(new[] {TestAllTypes.Types.NestedEnum.FOO, TestAllTypes.Types.NestedEnum.BAZ}, message.GetExtension(Unittest.RepeatedNestedEnumExtension)); @@ -342,7 +340,7 @@ namespace Google.ProtocolBuffers } } - [TestMethod] + [Fact] public void LargeVarint() { ByteString data = @@ -355,11 +353,11 @@ namespace Google.ProtocolBuffers .ToByteString(); UnknownFieldSet parsed = UnknownFieldSet.ParseFrom(data); UnknownField field = parsed[1]; - Assert.AreEqual(1, field.VarintList.Count); - Assert.AreEqual(0x7FFFFFFFFFFFFFFFUL, field.VarintList[0]); + Assert.Equal(1, field.VarintList.Count); + Assert.Equal(0x7FFFFFFFFFFFFFFFUL, field.VarintList[0]); } - [TestMethod] + [Fact] public void EqualsAndHashCode() { UnknownField fixed32Field = UnknownField.CreateBuilder().AddFixed32(1).Build(); @@ -407,10 +405,10 @@ namespace Google.ProtocolBuffers private static void CheckNotEqual(UnknownFieldSet s1, UnknownFieldSet s2) { String equalsError = string.Format("{0} should not be equal to {1}", s1, s2); - Assert.IsFalse(s1.Equals(s2), equalsError); - Assert.IsFalse(s2.Equals(s1), equalsError); + Assert.False(s1.Equals(s2), equalsError); + Assert.False(s2.Equals(s1), equalsError); - Assert.IsFalse(s1.GetHashCode() == s2.GetHashCode(), + Assert.False(s1.GetHashCode() == s2.GetHashCode(), string.Format("{0} should have a different hash code from {1}", s1, s2)); } @@ -421,13 +419,13 @@ namespace Google.ProtocolBuffers private static void CheckEqualsIsConsistent(UnknownFieldSet set) { // Object should be equal to itself. - Assert.AreEqual(set, set); + Assert.Equal(set, set); // Object should be equal to a copy of itself. UnknownFieldSet copy = UnknownFieldSet.CreateBuilder(set).Build(); - Assert.AreEqual(set, copy); - Assert.AreEqual(copy, set); - Assert.AreEqual(set.GetHashCode(), copy.GetHashCode()); + Assert.Equal(set, copy); + Assert.Equal(copy, set); + Assert.Equal(set.GetHashCode(), copy.GetHashCode()); } } } \ No newline at end of file diff --git a/csharp/src/ProtocolBuffers.Test/WireFormatTest.cs b/csharp/src/ProtocolBuffers.Test/WireFormatTest.cs index 05241965..12a9d236 100644 --- a/csharp/src/ProtocolBuffers.Test/WireFormatTest.cs +++ b/csharp/src/ProtocolBuffers.Test/WireFormatTest.cs @@ -38,17 +38,16 @@ using System.IO; using System.Reflection; using Google.ProtocolBuffers.Descriptors; using Google.ProtocolBuffers.TestProtos; -using Microsoft.VisualStudio.TestTools.UnitTesting; +using Xunit; namespace Google.ProtocolBuffers { - [TestClass] public class WireFormatTest { /// /// Keeps the attributes on FieldType and the switch statement in WireFormat in sync. /// - [TestMethod] + [Fact] public void FieldTypeToWireTypeMapping() { foreach (FieldInfo field in typeof(FieldType).GetFields(BindingFlags.Static | BindingFlags.Public)) @@ -56,34 +55,34 @@ namespace Google.ProtocolBuffers FieldType fieldType = (FieldType) field.GetValue(null); FieldMappingAttribute mapping = (FieldMappingAttribute) field.GetCustomAttributes(typeof(FieldMappingAttribute), false)[0]; - Assert.AreEqual(mapping.WireType, WireFormat.GetWireType(fieldType)); + Assert.Equal(mapping.WireType, WireFormat.GetWireType(fieldType)); } } - [TestMethod] + [Fact] public void Serialization() { TestAllTypes message = TestUtil.GetAllSet(); ByteString rawBytes = message.ToByteString(); - Assert.AreEqual(rawBytes.Length, message.SerializedSize); + Assert.Equal(rawBytes.Length, message.SerializedSize); TestAllTypes message2 = TestAllTypes.ParseFrom(rawBytes); TestUtil.AssertAllFieldsSet(message2); } - [TestMethod] + [Fact] public void SerializationPacked() { TestPackedTypes message = TestUtil.GetPackedSet(); ByteString rawBytes = message.ToByteString(); - Assert.AreEqual(rawBytes.Length, message.SerializedSize); + Assert.Equal(rawBytes.Length, message.SerializedSize); TestPackedTypes message2 = TestPackedTypes.ParseFrom(rawBytes); TestUtil.AssertPackedFieldsSet(message2); } - [TestMethod] + [Fact] public void SerializeExtensions() { // TestAllTypes and TestAllExtensions should have compatible wire formats, @@ -91,14 +90,14 @@ namespace Google.ProtocolBuffers // it should work. TestAllExtensions message = TestUtil.GetAllExtensionsSet(); ByteString rawBytes = message.ToByteString(); - Assert.AreEqual(rawBytes.Length, message.SerializedSize); + Assert.Equal(rawBytes.Length, message.SerializedSize); TestAllTypes message2 = TestAllTypes.ParseFrom(rawBytes); TestUtil.AssertAllFieldsSet(message2); } - [TestMethod] + [Fact] public void SerializePackedExtensions() { // TestPackedTypes and TestPackedExtensions should have compatible wire @@ -109,10 +108,10 @@ namespace Google.ProtocolBuffers TestPackedTypes message2 = TestUtil.GetPackedSet(); ByteString rawBytes2 = message2.ToByteString(); - Assert.AreEqual(rawBytes, rawBytes2); + Assert.Equal(rawBytes, rawBytes2); } - [TestMethod] + [Fact] public void SerializeDelimited() { MemoryStream stream = new MemoryStream(); @@ -124,13 +123,13 @@ namespace Google.ProtocolBuffers stream.Position = 0; TestUtil.AssertAllFieldsSet(TestAllTypes.ParseDelimitedFrom(stream)); - Assert.AreEqual(12, stream.ReadByte()); + Assert.Equal(12, stream.ReadByte()); TestUtil.AssertPackedFieldsSet(TestPackedTypes.ParseDelimitedFrom(stream)); - Assert.AreEqual(34, stream.ReadByte()); - Assert.AreEqual(-1, stream.ReadByte()); + Assert.Equal(34, stream.ReadByte()); + Assert.Equal(-1, stream.ReadByte()); } - [TestMethod] + [Fact] public void ParseExtensions() { // TestAllTypes and TestAllExtensions should have compatible wire formats, @@ -149,7 +148,7 @@ namespace Google.ProtocolBuffers TestUtil.AssertAllExtensionsSet(message2); } - [TestMethod] + [Fact] public void ParsePackedExtensions() { // Ensure that packed extensions can be properly parsed. @@ -162,10 +161,10 @@ namespace Google.ProtocolBuffers TestUtil.AssertPackedExtensionsSet(message2); } - [TestMethod] + [Fact] public void ExtensionsSerializedSize() { - Assert.AreEqual(TestUtil.GetAllSet().SerializedSize, TestUtil.GetAllExtensionsSet().SerializedSize); + Assert.Equal(TestUtil.GetAllSet().SerializedSize, TestUtil.GetAllExtensionsSet().SerializedSize); } private static void AssertFieldsInOrder(ByteString data) @@ -177,13 +176,13 @@ namespace Google.ProtocolBuffers string name; while (input.ReadTag(out tag, out name)) { - Assert.IsTrue(tag > previousTag); + Assert.True(tag > previousTag); previousTag = tag; input.SkipField(); } } - [TestMethod] + [Fact] public void InterleavedFieldsAndExtensions() { // Tests that fields are written in order even when extension ranges @@ -214,7 +213,7 @@ namespace Google.ProtocolBuffers private static readonly int TypeId1 = TestMessageSetExtension1.Descriptor.Extensions[0].FieldNumber; private static readonly int TypeId2 = TestMessageSetExtension2.Descriptor.Extensions[0].FieldNumber; - [TestMethod] + [Fact] public void SerializeMessageSet() { // Set up a TestMessageSet with two known messages and an unknown one. @@ -240,23 +239,23 @@ namespace Google.ProtocolBuffers // Parse back using RawMessageSet and check the contents. RawMessageSet raw = RawMessageSet.ParseFrom(data); - Assert.AreEqual(0, raw.UnknownFields.FieldDictionary.Count); + Assert.Equal(0, raw.UnknownFields.FieldDictionary.Count); - Assert.AreEqual(3, raw.ItemCount); - Assert.AreEqual(TypeId1, raw.ItemList[0].TypeId); - Assert.AreEqual(TypeId2, raw.ItemList[1].TypeId); - Assert.AreEqual(UnknownTypeId, raw.ItemList[2].TypeId); + Assert.Equal(3, raw.ItemCount); + Assert.Equal(TypeId1, raw.ItemList[0].TypeId); + Assert.Equal(TypeId2, raw.ItemList[1].TypeId); + Assert.Equal(UnknownTypeId, raw.ItemList[2].TypeId); TestMessageSetExtension1 message1 = TestMessageSetExtension1.ParseFrom(raw.GetItem(0).Message.ToByteArray()); - Assert.AreEqual(123, message1.I); + Assert.Equal(123, message1.I); TestMessageSetExtension2 message2 = TestMessageSetExtension2.ParseFrom(raw.GetItem(1).Message.ToByteArray()); - Assert.AreEqual("foo", message2.Str); + Assert.Equal("foo", message2.Str); - Assert.AreEqual("bar", raw.GetItem(2).Message.ToStringUtf8()); + Assert.Equal("bar", raw.GetItem(2).Message.ToStringUtf8()); } - [TestMethod] + [Fact] public void ParseMessageSet() { ExtensionRegistry extensionRegistry = ExtensionRegistry.CreateInstance(); @@ -295,18 +294,18 @@ namespace Google.ProtocolBuffers TestMessageSet messageSet = TestMessageSet.ParseFrom(data, extensionRegistry); - Assert.AreEqual(123, messageSet.GetExtension(TestMessageSetExtension1.MessageSetExtension).I); - Assert.AreEqual("foo", messageSet.GetExtension(TestMessageSetExtension2.MessageSetExtension).Str); + Assert.Equal(123, messageSet.GetExtension(TestMessageSetExtension1.MessageSetExtension).I); + Assert.Equal("foo", messageSet.GetExtension(TestMessageSetExtension2.MessageSetExtension).Str); // Check for unknown field with type LENGTH_DELIMITED, // number UNKNOWN_TYPE_ID, and contents "bar". UnknownFieldSet unknownFields = messageSet.UnknownFields; - Assert.AreEqual(1, unknownFields.FieldDictionary.Count); - Assert.IsTrue(unknownFields.HasField(UnknownTypeId)); + Assert.Equal(1, unknownFields.FieldDictionary.Count); + Assert.True(unknownFields.HasField(UnknownTypeId)); UnknownField field = unknownFields[UnknownTypeId]; - Assert.AreEqual(1, field.LengthDelimitedList.Count); - Assert.AreEqual("bar", field.LengthDelimitedList[0].ToStringUtf8()); + Assert.Equal(1, field.LengthDelimitedList.Count); + Assert.Equal("bar", field.LengthDelimitedList[0].ToStringUtf8()); } } } \ No newline at end of file diff --git a/csharp/src/ProtocolBuffers.Test/packages.config b/csharp/src/ProtocolBuffers.Test/packages.config new file mode 100644 index 00000000..6f1fb7f5 --- /dev/null +++ b/csharp/src/ProtocolBuffers.Test/packages.config @@ -0,0 +1,9 @@ + + + + + + + + + \ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/AbstractBuilderLiteTest.cs b/csharp/src/ProtocolBuffersLite.Test/AbstractBuilderLiteTest.cs index f3a7789e..e0199202 100644 --- a/csharp/src/ProtocolBuffersLite.Test/AbstractBuilderLiteTest.cs +++ b/csharp/src/ProtocolBuffersLite.Test/AbstractBuilderLiteTest.cs @@ -34,19 +34,15 @@ #endregion -using System; -using System.Collections.Generic; using System.IO; -using Google.ProtocolBuffers; using Google.ProtocolBuffers.TestProtos; -using Microsoft.VisualStudio.TestTools.UnitTesting; +using Xunit; namespace Google.ProtocolBuffers { - [TestClass] public class AbstractBuilderLiteTest { - [TestMethod] + [Fact] public void TestMergeFromCodedInputStream() { TestAllTypesLite copy, @@ -54,7 +50,7 @@ namespace Google.ProtocolBuffers .SetOptionalUint32(uint.MaxValue).Build(); copy = TestAllTypesLite.DefaultInstance; - Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray()); + Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray()); using (MemoryStream ms = new MemoryStream(msg.ToByteArray())) { @@ -62,22 +58,22 @@ namespace Google.ProtocolBuffers copy = copy.ToBuilder().MergeFrom(ci).Build(); } - TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray()); + Assert.Equal(msg.ToByteArray(), copy.ToByteArray()); } - [TestMethod] + [Fact] public void TestIBuilderLiteWeakClear() { TestAllTypesLite copy, msg = TestAllTypesLite.DefaultInstance; copy = msg.ToBuilder().SetOptionalString("Should be removed.").Build(); - Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray()); + Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray()); copy = (TestAllTypesLite) ((IBuilderLite) copy.ToBuilder()).WeakClear().WeakBuild(); - TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray()); + Assert.Equal(msg.ToByteArray(), copy.ToByteArray()); } - [TestMethod] + [Fact] public void TestBuilderLiteMergeFromCodedInputStream() { TestAllTypesLite copy, @@ -85,14 +81,14 @@ namespace Google.ProtocolBuffers .SetOptionalString("Should be merged.").Build(); copy = TestAllTypesLite.DefaultInstance; - Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray()); + Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray()); copy = copy.ToBuilder().MergeFrom(CodedInputStream.CreateInstance(new MemoryStream(msg.ToByteArray()))).Build(); - TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray()); + Assert.Equal(msg.ToByteArray(), copy.ToByteArray()); } - [TestMethod] + [Fact] public void TestBuilderLiteMergeDelimitedFrom() { TestAllTypesLite copy, @@ -100,15 +96,15 @@ namespace Google.ProtocolBuffers .SetOptionalString("Should be merged.").Build(); copy = TestAllTypesLite.DefaultInstance; - Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray()); + Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray()); Stream s = new MemoryStream(); msg.WriteDelimitedTo(s); s.Position = 0; copy = copy.ToBuilder().MergeDelimitedFrom(s).Build(); - TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray()); + Assert.Equal(msg.ToByteArray(), copy.ToByteArray()); } - [TestMethod] + [Fact] public void TestBuilderLiteMergeDelimitedFromExtensions() { TestAllExtensionsLite copy, @@ -117,7 +113,7 @@ namespace Google.ProtocolBuffers "Should be merged.").Build(); copy = TestAllExtensionsLite.DefaultInstance; - Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray()); + Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray()); Stream s = new MemoryStream(); msg.WriteDelimitedTo(s); @@ -127,11 +123,11 @@ namespace Google.ProtocolBuffers UnittestLite.RegisterAllExtensions(registry); copy = copy.ToBuilder().MergeDelimitedFrom(s, registry).Build(); - TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray()); - Assert.AreEqual("Should be merged.", copy.GetExtension(UnittestLite.OptionalStringExtensionLite)); + Assert.Equal(msg.ToByteArray(), copy.ToByteArray()); + Assert.Equal("Should be merged.", copy.GetExtension(UnittestLite.OptionalStringExtensionLite)); } - [TestMethod] + [Fact] public void TestBuilderLiteMergeFromStream() { TestAllTypesLite copy, @@ -139,15 +135,15 @@ namespace Google.ProtocolBuffers .SetOptionalString("Should be merged.").Build(); copy = TestAllTypesLite.DefaultInstance; - Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray()); + Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray()); Stream s = new MemoryStream(); msg.WriteTo(s); s.Position = 0; copy = copy.ToBuilder().MergeFrom(s).Build(); - TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray()); + Assert.Equal(msg.ToByteArray(), copy.ToByteArray()); } - [TestMethod] + [Fact] public void TestBuilderLiteMergeFromStreamExtensions() { TestAllExtensionsLite copy, @@ -156,7 +152,7 @@ namespace Google.ProtocolBuffers "Should be merged.").Build(); copy = TestAllExtensionsLite.DefaultInstance; - Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray()); + Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray()); Stream s = new MemoryStream(); msg.WriteTo(s); @@ -166,11 +162,11 @@ namespace Google.ProtocolBuffers UnittestLite.RegisterAllExtensions(registry); copy = copy.ToBuilder().MergeFrom(s, registry).Build(); - TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray()); - Assert.AreEqual("Should be merged.", copy.GetExtension(UnittestLite.OptionalStringExtensionLite)); + Assert.Equal(msg.ToByteArray(), copy.ToByteArray()); + Assert.Equal("Should be merged.", copy.GetExtension(UnittestLite.OptionalStringExtensionLite)); } - [TestMethod] + [Fact] public void TestIBuilderLiteWeakMergeFromIMessageLite() { TestAllTypesLite copy, @@ -178,13 +174,13 @@ namespace Google.ProtocolBuffers .SetOptionalString("Should be merged.").Build(); copy = TestAllTypesLite.DefaultInstance; - Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray()); + Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray()); copy = (TestAllTypesLite) ((IBuilderLite) copy.ToBuilder()).WeakMergeFrom((IMessageLite) msg).WeakBuild(); - TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray()); + Assert.Equal(msg.ToByteArray(), copy.ToByteArray()); } - [TestMethod] + [Fact] public void TestIBuilderLiteWeakMergeFromByteString() { TestAllTypesLite copy, @@ -192,13 +188,13 @@ namespace Google.ProtocolBuffers .SetOptionalString("Should be merged.").Build(); copy = TestAllTypesLite.DefaultInstance; - Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray()); + Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray()); copy = (TestAllTypesLite) ((IBuilderLite) copy.ToBuilder()).WeakMergeFrom(msg.ToByteString()).WeakBuild(); - TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray()); + Assert.Equal(msg.ToByteArray(), copy.ToByteArray()); } - [TestMethod] + [Fact] public void TestIBuilderLiteWeakMergeFromByteStringExtensions() { TestAllExtensionsLite copy, @@ -207,12 +203,12 @@ namespace Google.ProtocolBuffers "Should be merged.").Build(); copy = TestAllExtensionsLite.DefaultInstance; - Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray()); + Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray()); copy = (TestAllExtensionsLite) ((IBuilderLite) copy.ToBuilder()).WeakMergeFrom(msg.ToByteString(), ExtensionRegistry.Empty).WeakBuild(); - Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray()); + Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray()); ExtensionRegistry registry = ExtensionRegistry.CreateInstance(); UnittestLite.RegisterAllExtensions(registry); @@ -220,11 +216,11 @@ namespace Google.ProtocolBuffers copy = (TestAllExtensionsLite) ((IBuilderLite) copy.ToBuilder()).WeakMergeFrom(msg.ToByteString(), registry).WeakBuild(); - TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray()); - Assert.AreEqual("Should be merged.", copy.GetExtension(UnittestLite.OptionalStringExtensionLite)); + Assert.Equal(msg.ToByteArray(), copy.ToByteArray()); + Assert.Equal("Should be merged.", copy.GetExtension(UnittestLite.OptionalStringExtensionLite)); } - [TestMethod] + [Fact] public void TestIBuilderLiteWeakMergeFromCodedInputStream() { TestAllTypesLite copy, @@ -232,7 +228,7 @@ namespace Google.ProtocolBuffers .SetOptionalUint32(uint.MaxValue).Build(); copy = TestAllTypesLite.DefaultInstance; - Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray()); + Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray()); using (MemoryStream ms = new MemoryStream(msg.ToByteArray())) { @@ -240,58 +236,58 @@ namespace Google.ProtocolBuffers copy = (TestAllTypesLite) ((IBuilderLite) copy.ToBuilder()).WeakMergeFrom(ci).WeakBuild(); } - TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray()); + Assert.Equal(msg.ToByteArray(), copy.ToByteArray()); } - [TestMethod] + [Fact] public void TestIBuilderLiteWeakBuildPartial() { IBuilderLite builder = TestRequiredLite.CreateBuilder(); - Assert.IsFalse(builder.IsInitialized); + Assert.False(builder.IsInitialized); IMessageLite msg = builder.WeakBuildPartial(); - Assert.IsFalse(msg.IsInitialized); + Assert.False(msg.IsInitialized); - TestUtil.AssertBytesEqual(msg.ToByteArray(), TestRequiredLite.DefaultInstance.ToByteArray()); + Assert.Equal(msg.ToByteArray(), TestRequiredLite.DefaultInstance.ToByteArray()); } - [TestMethod, ExpectedException(typeof(UninitializedMessageException))] + [Fact] public void TestIBuilderLiteWeakBuildUninitialized() { IBuilderLite builder = TestRequiredLite.CreateBuilder(); - Assert.IsFalse(builder.IsInitialized); - builder.WeakBuild(); + Assert.False(builder.IsInitialized); + Assert.Throws(() => builder.WeakBuild()); } - [TestMethod] + [Fact] public void TestIBuilderLiteWeakBuild() { IBuilderLite builder = TestRequiredLite.CreateBuilder() .SetD(0) .SetEn(ExtraEnum.EXLITE_BAZ); - Assert.IsTrue(builder.IsInitialized); + Assert.True(builder.IsInitialized); builder.WeakBuild(); } - [TestMethod] + [Fact] public void TestIBuilderLiteWeakClone() { TestRequiredLite msg = TestRequiredLite.CreateBuilder() .SetD(1).SetEn(ExtraEnum.EXLITE_BAR).Build(); - Assert.IsTrue(msg.IsInitialized); + Assert.True(msg.IsInitialized); IMessageLite copy = ((IBuilderLite) msg.ToBuilder()).WeakClone().WeakBuild(); - TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray()); + Assert.Equal(msg.ToByteArray(), copy.ToByteArray()); } - [TestMethod] + [Fact] public void TestIBuilderLiteWeakDefaultInstance() { - Assert.IsTrue(ReferenceEquals(TestRequiredLite.DefaultInstance, + Assert.True(ReferenceEquals(TestRequiredLite.DefaultInstance, ((IBuilderLite) TestRequiredLite.CreateBuilder()).WeakDefaultInstanceForType)); } - [TestMethod] + [Fact] public void TestGeneratedBuilderLiteAddRange() { TestAllTypesLite copy, @@ -303,11 +299,11 @@ namespace Google.ProtocolBuffers .Build(); copy = msg.DefaultInstanceForType.ToBuilder().MergeFrom(msg).Build(); - TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray()); + Assert.Equal(msg.ToByteArray(), copy.ToByteArray()); } // ROK 5/7/2013 Issue #54: should retire all bytes in buffer (bufferSize) - [TestMethod] + [Fact] public void TestBufferRefillIssue() { var ms = new MemoryStream(); @@ -326,15 +322,15 @@ namespace Google.ProtocolBuffers var input = CodedInputStream.CreateInstance(ms); var builder = BucketOfBytes.CreateBuilder(); input.ReadMessage(builder, ExtensionRegistry.Empty); - Assert.AreEqual(3005L, input.Position); - Assert.AreEqual(3000, builder.Value.Length); + Assert.Equal(3005L, input.Position); + Assert.Equal(3000, builder.Value.Length); input.ReadMessage(builder, ExtensionRegistry.Empty); - Assert.AreEqual(5114, input.Position); - Assert.AreEqual(1000, builder.Value.Length); + Assert.Equal(5114, input.Position); + Assert.Equal(1000, builder.Value.Length); input.ReadMessage(builder, ExtensionRegistry.Empty); - Assert.AreEqual(5217L, input.Position); - Assert.AreEqual(input.Position, ms.Length); - Assert.AreEqual(100, builder.Value.Length); + Assert.Equal(5217L, input.Position); + Assert.Equal(input.Position, ms.Length); + Assert.Equal(100, builder.Value.Length); } } } \ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/AbstractMessageLiteTest.cs b/csharp/src/ProtocolBuffersLite.Test/AbstractMessageLiteTest.cs index bead60fb..f6a4e94b 100644 --- a/csharp/src/ProtocolBuffersLite.Test/AbstractMessageLiteTest.cs +++ b/csharp/src/ProtocolBuffersLite.Test/AbstractMessageLiteTest.cs @@ -35,18 +35,15 @@ #endregion using System; -using System.Collections.Generic; using System.IO; -using Google.ProtocolBuffers; using Google.ProtocolBuffers.TestProtos; -using Microsoft.VisualStudio.TestTools.UnitTesting; +using Xunit; namespace Google.ProtocolBuffers { - [TestClass] public class AbstractMessageLiteTest { - [TestMethod] + [Fact] public void TestMessageLiteToByteString() { TestRequiredLite msg = TestRequiredLite.CreateBuilder() @@ -55,14 +52,14 @@ namespace Google.ProtocolBuffers .Build(); ByteString b = msg.ToByteString(); - Assert.AreEqual(4, b.Length); - Assert.AreEqual(TestRequiredLite.DFieldNumber << 3, b[0]); - Assert.AreEqual(42, b[1]); - Assert.AreEqual(TestRequiredLite.EnFieldNumber << 3, b[2]); - Assert.AreEqual((int) ExtraEnum.EXLITE_BAZ, b[3]); + Assert.Equal(4, b.Length); + Assert.Equal(TestRequiredLite.DFieldNumber << 3, b[0]); + Assert.Equal(42, b[1]); + Assert.Equal(TestRequiredLite.EnFieldNumber << 3, b[2]); + Assert.Equal((int) ExtraEnum.EXLITE_BAZ, b[3]); } - [TestMethod] + [Fact] public void TestMessageLiteToByteArray() { TestRequiredLite msg = TestRequiredLite.CreateBuilder() @@ -72,10 +69,10 @@ namespace Google.ProtocolBuffers ByteString b = msg.ToByteString(); ByteString copy = ByteString.CopyFrom(msg.ToByteArray()); - Assert.AreEqual(b, copy); + Assert.Equal(b, copy); } - [TestMethod] + [Fact] public void TestMessageLiteWriteTo() { TestRequiredLite msg = TestRequiredLite.CreateBuilder() @@ -85,10 +82,10 @@ namespace Google.ProtocolBuffers MemoryStream ms = new MemoryStream(); msg.WriteTo(ms); - TestUtil.AssertBytesEqual(msg.ToByteArray(), ms.ToArray()); + Assert.Equal(msg.ToByteArray(), ms.ToArray()); } - [TestMethod] + [Fact] public void TestMessageLiteWriteDelimitedTo() { TestRequiredLite msg = TestRequiredLite.CreateBuilder() @@ -100,21 +97,21 @@ namespace Google.ProtocolBuffers msg.WriteDelimitedTo(ms); byte[] buffer = ms.ToArray(); - Assert.AreEqual(5, buffer.Length); - Assert.AreEqual(4, buffer[0]); + Assert.Equal(5, buffer.Length); + Assert.Equal(4, buffer[0]); byte[] msgBytes = new byte[4]; Array.Copy(buffer, 1, msgBytes, 0, 4); - TestUtil.AssertBytesEqual(msg.ToByteArray(), msgBytes); + Assert.Equal(msg.ToByteArray(), msgBytes); } - [TestMethod] + [Fact] public void TestIMessageLiteWeakCreateBuilderForType() { IMessageLite msg = TestRequiredLite.DefaultInstance; - Assert.AreEqual(typeof(TestRequiredLite.Builder), msg.WeakCreateBuilderForType().GetType()); + Assert.Equal(typeof(TestRequiredLite.Builder), msg.WeakCreateBuilderForType().GetType()); } - [TestMethod] + [Fact] public void TestMessageLiteWeakToBuilder() { IMessageLite msg = TestRequiredLite.CreateBuilder() @@ -123,14 +120,14 @@ namespace Google.ProtocolBuffers .Build(); IMessageLite copy = msg.WeakToBuilder().WeakBuild(); - TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray()); + Assert.Equal(msg.ToByteArray(), copy.ToByteArray()); } - [TestMethod] + [Fact] public void TestMessageLiteWeakDefaultInstanceForType() { IMessageLite msg = TestRequiredLite.DefaultInstance; - Assert.IsTrue(Object.ReferenceEquals(TestRequiredLite.DefaultInstance, msg.WeakDefaultInstanceForType)); + Assert.True(Object.ReferenceEquals(TestRequiredLite.DefaultInstance, msg.WeakDefaultInstanceForType)); } } } \ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/ExtendableBuilderLiteTest.cs b/csharp/src/ProtocolBuffersLite.Test/ExtendableBuilderLiteTest.cs index 0430c4a1..5377ea6a 100644 --- a/csharp/src/ProtocolBuffersLite.Test/ExtendableBuilderLiteTest.cs +++ b/csharp/src/ProtocolBuffersLite.Test/ExtendableBuilderLiteTest.cs @@ -35,34 +35,31 @@ #endregion using System; -using System.Collections; using System.Collections.Generic; -using Google.ProtocolBuffers; using Google.ProtocolBuffers.TestProtos; -using Microsoft.VisualStudio.TestTools.UnitTesting; +using Xunit; namespace Google.ProtocolBuffers { - [TestClass] public class ExtendableBuilderLiteTest { - [TestMethod] + [Fact] public void TestHasExtensionT() { TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder() .SetExtension(UnittestLite.OptionalInt32ExtensionLite, 123); - Assert.IsTrue(builder.HasExtension(UnittestLite.OptionalInt32ExtensionLite)); + Assert.True(builder.HasExtension(UnittestLite.OptionalInt32ExtensionLite)); } - [TestMethod] + [Fact] public void TestHasExtensionTMissing() { TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder(); - Assert.IsFalse(builder.HasExtension(UnittestLite.OptionalInt32ExtensionLite)); + Assert.False(builder.HasExtension(UnittestLite.OptionalInt32ExtensionLite)); } - [TestMethod] + [Fact] public void TestGetExtensionCountT() { TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder() @@ -70,41 +67,41 @@ namespace Google.ProtocolBuffers .AddExtension(UnittestLite.RepeatedInt32ExtensionLite, 2) .AddExtension(UnittestLite.RepeatedInt32ExtensionLite, 3); - Assert.AreEqual(3, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite)); + Assert.Equal(3, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite)); } - [TestMethod] + [Fact] public void TestGetExtensionCountTEmpty() { TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder(); - Assert.AreEqual(0, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite)); + Assert.Equal(0, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite)); } - [TestMethod] + [Fact] public void TestGetExtensionTNull() { TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder(); string value = builder.GetExtension(UnittestLite.OptionalStringExtensionLite); - Assert.IsNull(value); + Assert.Null(value); } - [TestMethod] + [Fact] public void TestGetExtensionTValue() { TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder() .SetExtension(UnittestLite.OptionalInt32ExtensionLite, 3); - Assert.AreEqual(3, builder.GetExtension(UnittestLite.OptionalInt32ExtensionLite)); + Assert.Equal(3, builder.GetExtension(UnittestLite.OptionalInt32ExtensionLite)); } - [TestMethod] + [Fact] public void TestGetExtensionTEmpty() { TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder(); - Assert.AreEqual(0, builder.GetExtension(UnittestLite.RepeatedInt32ExtensionLite).Count); + Assert.Equal(0, builder.GetExtension(UnittestLite.RepeatedInt32ExtensionLite).Count); } - [TestMethod] + [Fact] public void TestGetExtensionTList() { TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder() @@ -113,10 +110,10 @@ namespace Google.ProtocolBuffers .AddExtension(UnittestLite.RepeatedInt32ExtensionLite, 3); IList values = builder.GetExtension(UnittestLite.RepeatedInt32ExtensionLite); - Assert.AreEqual(3, values.Count); + Assert.Equal(3, values.Count); } - [TestMethod] + [Fact] public void TestGetExtensionTIndex() { TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder() @@ -125,17 +122,17 @@ namespace Google.ProtocolBuffers .AddExtension(UnittestLite.RepeatedInt32ExtensionLite, 2); for (int i = 0; i < 3; i++) - Assert.AreEqual(i, builder.GetExtension(UnittestLite.RepeatedInt32ExtensionLite, i)); + Assert.Equal(i, builder.GetExtension(UnittestLite.RepeatedInt32ExtensionLite, i)); } - [TestMethod, ExpectedException(typeof(ArgumentOutOfRangeException))] + [Fact] public void TestGetExtensionTIndexOutOfRange() { TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder(); - builder.GetExtension(UnittestLite.RepeatedInt32ExtensionLite, 0); + Assert.Throws(() => builder.GetExtension(UnittestLite.RepeatedInt32ExtensionLite, 0)); } - [TestMethod] + [Fact] public void TestSetExtensionTIndex() { TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder() @@ -144,107 +141,107 @@ namespace Google.ProtocolBuffers .AddExtension(UnittestLite.RepeatedInt32ExtensionLite, 2); for (int i = 0; i < 3; i++) - Assert.AreEqual(i, builder.GetExtension(UnittestLite.RepeatedInt32ExtensionLite, i)); + Assert.Equal(i, builder.GetExtension(UnittestLite.RepeatedInt32ExtensionLite, i)); builder.SetExtension(UnittestLite.RepeatedInt32ExtensionLite, 0, 5); builder.SetExtension(UnittestLite.RepeatedInt32ExtensionLite, 1, 6); builder.SetExtension(UnittestLite.RepeatedInt32ExtensionLite, 2, 7); for (int i = 0; i < 3; i++) - Assert.AreEqual(5 + i, builder.GetExtension(UnittestLite.RepeatedInt32ExtensionLite, i)); + Assert.Equal(5 + i, builder.GetExtension(UnittestLite.RepeatedInt32ExtensionLite, i)); } - [TestMethod, ExpectedException(typeof(ArgumentOutOfRangeException))] + [Fact] public void TestSetExtensionTIndexOutOfRange() { TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder(); - builder.SetExtension(UnittestLite.RepeatedInt32ExtensionLite, 0, -1); + Assert.Throws(() => builder.SetExtension(UnittestLite.RepeatedInt32ExtensionLite, 0, -1)); } - [TestMethod] + [Fact] public void TestClearExtensionTList() { TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder() .AddExtension(UnittestLite.RepeatedInt32ExtensionLite, 0); - Assert.AreEqual(1, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite)); + Assert.Equal(1, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite)); builder.ClearExtension(UnittestLite.RepeatedInt32ExtensionLite); - Assert.AreEqual(0, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite)); + Assert.Equal(0, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite)); } - [TestMethod] + [Fact] public void TestClearExtensionTValue() { TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder() .SetExtension(UnittestLite.OptionalInt32ExtensionLite, 0); - Assert.IsTrue(builder.HasExtension(UnittestLite.OptionalInt32ExtensionLite)); + Assert.True(builder.HasExtension(UnittestLite.OptionalInt32ExtensionLite)); builder.ClearExtension(UnittestLite.OptionalInt32ExtensionLite); - Assert.IsFalse(builder.HasExtension(UnittestLite.OptionalInt32ExtensionLite)); + Assert.False(builder.HasExtension(UnittestLite.OptionalInt32ExtensionLite)); } - [TestMethod] + [Fact] public void TestIndexedByDescriptor() { TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder(); - Assert.IsFalse(builder.HasExtension(UnittestLite.OptionalInt32ExtensionLite)); + Assert.False(builder.HasExtension(UnittestLite.OptionalInt32ExtensionLite)); builder[UnittestLite.OptionalInt32ExtensionLite.Descriptor] = 123; - Assert.IsTrue(builder.HasExtension(UnittestLite.OptionalInt32ExtensionLite)); - Assert.AreEqual(123, builder.GetExtension(UnittestLite.OptionalInt32ExtensionLite)); + Assert.True(builder.HasExtension(UnittestLite.OptionalInt32ExtensionLite)); + Assert.Equal(123, builder.GetExtension(UnittestLite.OptionalInt32ExtensionLite)); } - [TestMethod] + [Fact] public void TestIndexedByDescriptorAndOrdinal() { TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder() .AddExtension(UnittestLite.RepeatedInt32ExtensionLite, 0); - Assert.AreEqual(1, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite)); + Assert.Equal(1, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite)); IFieldDescriptorLite f = UnittestLite.RepeatedInt32ExtensionLite.Descriptor; builder[f, 0] = 123; - Assert.AreEqual(1, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite)); - Assert.AreEqual(123, builder.GetExtension(UnittestLite.RepeatedInt32ExtensionLite, 0)); + Assert.Equal(1, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite)); + Assert.Equal(123, builder.GetExtension(UnittestLite.RepeatedInt32ExtensionLite, 0)); } - [TestMethod, ExpectedException(typeof(ArgumentOutOfRangeException))] + [Fact] public void TestIndexedByDescriptorAndOrdinalOutOfRange() { TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder(); - Assert.AreEqual(0, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite)); + Assert.Equal(0, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite)); IFieldDescriptorLite f = UnittestLite.RepeatedInt32ExtensionLite.Descriptor; - builder[f, 0] = 123; + Assert.Throws(() => builder[f, 0] = 123); } - [TestMethod] + [Fact] public void TestClearFieldByDescriptor() { TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder() .AddExtension(UnittestLite.RepeatedInt32ExtensionLite, 0); - Assert.AreEqual(1, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite)); + Assert.Equal(1, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite)); IFieldDescriptorLite f = UnittestLite.RepeatedInt32ExtensionLite.Descriptor; builder.ClearField(f); - Assert.AreEqual(0, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite)); + Assert.Equal(0, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite)); } - [TestMethod] + [Fact] public void TestAddRepeatedFieldByDescriptor() { TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder() .AddExtension(UnittestLite.RepeatedInt32ExtensionLite, 0); - Assert.AreEqual(1, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite)); + Assert.Equal(1, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite)); IFieldDescriptorLite f = UnittestLite.RepeatedInt32ExtensionLite.Descriptor; builder.AddRepeatedField(f, 123); - Assert.AreEqual(2, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite)); - Assert.AreEqual(123, builder.GetExtension(UnittestLite.RepeatedInt32ExtensionLite, 1)); + Assert.Equal(2, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite)); + Assert.Equal(123, builder.GetExtension(UnittestLite.RepeatedInt32ExtensionLite, 1)); } - [TestMethod] + [Fact] public void TestMissingExtensionsLite() { const int optionalInt32 = 12345678; @@ -255,21 +252,21 @@ namespace Google.ProtocolBuffers builder.AddExtension(UnittestLite.RepeatedDoubleExtensionLite, 1.3); TestAllExtensionsLite msg = builder.Build(); - Assert.IsTrue(msg.HasExtension(UnittestLite.OptionalInt32ExtensionLite)); - Assert.AreEqual(3, msg.GetExtensionCount(UnittestLite.RepeatedDoubleExtensionLite)); + Assert.True(msg.HasExtension(UnittestLite.OptionalInt32ExtensionLite)); + Assert.Equal(3, msg.GetExtensionCount(UnittestLite.RepeatedDoubleExtensionLite)); byte[] bits = msg.ToByteArray(); TestAllExtensionsLite copy = TestAllExtensionsLite.ParseFrom(bits); - Assert.IsFalse(copy.HasExtension(UnittestLite.OptionalInt32ExtensionLite)); - Assert.AreEqual(0, copy.GetExtensionCount(UnittestLite.RepeatedDoubleExtensionLite)); - Assert.AreNotEqual(msg, copy); + Assert.False(copy.HasExtension(UnittestLite.OptionalInt32ExtensionLite)); + Assert.Equal(0, copy.GetExtensionCount(UnittestLite.RepeatedDoubleExtensionLite)); + Assert.NotEqual(msg, copy); //The lite runtime removes all unknown fields and extensions byte[] copybits = copy.ToByteArray(); - Assert.AreEqual(0, copybits.Length); + Assert.Equal(0, copybits.Length); } - [TestMethod] + [Fact] public void TestMissingFieldsLite() { TestAllTypesLite msg = TestAllTypesLite.CreateBuilder() @@ -278,12 +275,14 @@ namespace Google.ProtocolBuffers .Build(); byte[] bits = msg.ToByteArray(); - TestAllExtensionsLite copy = TestAllExtensionsLite.ParseFrom(bits); - Assert.AreNotEqual(msg, copy); + IMessageLite copy = TestAllExtensionsLite.ParseFrom(bits); + // Use explicit call to Equals to avoid xUnit checking for type equality. + Assert.False(msg.Equals(copy)); + Assert.False(copy.Equals(msg)); //The lite runtime removes all unknown fields and extensions byte[] copybits = copy.ToByteArray(); - Assert.AreEqual(0, copybits.Length); + Assert.Equal(0, copybits.Length); } } } \ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/ExtendableMessageLiteTest.cs b/csharp/src/ProtocolBuffersLite.Test/ExtendableMessageLiteTest.cs index b31fb754..78127445 100644 --- a/csharp/src/ProtocolBuffersLite.Test/ExtendableMessageLiteTest.cs +++ b/csharp/src/ProtocolBuffersLite.Test/ExtendableMessageLiteTest.cs @@ -39,11 +39,10 @@ using System.Collections.Generic; using System.Text; using Google.ProtocolBuffers; using Google.ProtocolBuffers.TestProtos; -using Microsoft.VisualStudio.TestTools.UnitTesting; +using Xunit; namespace Google.ProtocolBuffers { - [TestClass] public class ExtendableMessageLiteTest { //The lite framework does not make this assertion @@ -55,7 +54,7 @@ namespace Google.ProtocolBuffers // ForeignMessageLite.DefaultInstance; //} - [TestMethod] + [Fact] public void ExtensionWriterTestMessages() { TestAllExtensionsLite.Builder b = TestAllExtensionsLite.CreateBuilder().SetExtension( @@ -67,20 +66,20 @@ namespace Google.ProtocolBuffers UnittestLite.RegisterAllExtensions(registry); copy = TestAllExtensionsLite.ParseFrom(msg.ToByteArray(), registry); - TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray()); + Assert.Equal(msg.ToByteArray(), copy.ToByteArray()); } - [TestMethod] + [Fact] public void ExtensionWriterIsInitialized() { - Assert.IsTrue(ForeignMessageLite.DefaultInstance.IsInitialized); - Assert.IsTrue(TestPackedExtensionsLite.CreateBuilder().IsInitialized); - Assert.IsTrue(TestAllExtensionsLite.CreateBuilder().SetExtension( + Assert.True(ForeignMessageLite.DefaultInstance.IsInitialized); + Assert.True(TestPackedExtensionsLite.CreateBuilder().IsInitialized); + Assert.True(TestAllExtensionsLite.CreateBuilder().SetExtension( UnittestLite.OptionalForeignMessageExtensionLite, ForeignMessageLite.DefaultInstance) .IsInitialized); } - [TestMethod] + [Fact] public void ExtensionWriterTestSetExtensionLists() { TestAllExtensionsLite msg, copy; @@ -96,13 +95,13 @@ namespace Google.ProtocolBuffers UnittestLite.RegisterAllExtensions(registry); copy = TestAllExtensionsLite.ParseFrom(msg.ToByteArray(), registry); - TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray()); + Assert.Equal(msg.ToByteArray(), copy.ToByteArray()); - Assert.AreEqual(ForeignEnumLite.FOREIGN_LITE_FOO, + Assert.Equal(ForeignEnumLite.FOREIGN_LITE_FOO, copy.GetExtension(UnittestLite.RepeatedForeignEnumExtensionLite, 1)); } - [TestMethod] + [Fact] public void ExtensionWriterTest() { TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder() @@ -181,82 +180,82 @@ namespace Google.ProtocolBuffers TestAllExtensionsLite.CreateBuilder().MergeFrom(msg.ToByteArray(), registry); TestAllExtensionsLite copy = copyBuilder.Build(); - TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray()); + Assert.Equal(msg.ToByteArray(), copy.ToByteArray()); - Assert.AreEqual(true, copy.GetExtension(UnittestLite.DefaultBoolExtensionLite)); - Assert.AreEqual(ByteString.CopyFromUtf8("123"), + Assert.Equal(true, copy.GetExtension(UnittestLite.DefaultBoolExtensionLite)); + Assert.Equal(ByteString.CopyFromUtf8("123"), copy.GetExtension(UnittestLite.DefaultBytesExtensionLite)); - Assert.AreEqual("123", copy.GetExtension(UnittestLite.DefaultCordExtensionLite)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.DefaultDoubleExtensionLite)); - Assert.AreEqual(123u, copy.GetExtension(UnittestLite.DefaultFixed32ExtensionLite)); - Assert.AreEqual(123u, copy.GetExtension(UnittestLite.DefaultFixed64ExtensionLite)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.DefaultFloatExtensionLite)); - Assert.AreEqual(ForeignEnumLite.FOREIGN_LITE_BAZ, + Assert.Equal("123", copy.GetExtension(UnittestLite.DefaultCordExtensionLite)); + Assert.Equal(123, copy.GetExtension(UnittestLite.DefaultDoubleExtensionLite)); + Assert.Equal(123u, copy.GetExtension(UnittestLite.DefaultFixed32ExtensionLite)); + Assert.Equal(123u, copy.GetExtension(UnittestLite.DefaultFixed64ExtensionLite)); + Assert.Equal(123, copy.GetExtension(UnittestLite.DefaultFloatExtensionLite)); + Assert.Equal(ForeignEnumLite.FOREIGN_LITE_BAZ, copy.GetExtension(UnittestLite.DefaultForeignEnumExtensionLite)); - Assert.AreEqual(ImportEnumLite.IMPORT_LITE_BAZ, + Assert.Equal(ImportEnumLite.IMPORT_LITE_BAZ, copy.GetExtension(UnittestLite.DefaultImportEnumExtensionLite)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.DefaultInt32ExtensionLite)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.DefaultInt64ExtensionLite)); - Assert.AreEqual(TestAllTypesLite.Types.NestedEnum.FOO, + Assert.Equal(123, copy.GetExtension(UnittestLite.DefaultInt32ExtensionLite)); + Assert.Equal(123, copy.GetExtension(UnittestLite.DefaultInt64ExtensionLite)); + Assert.Equal(TestAllTypesLite.Types.NestedEnum.FOO, copy.GetExtension(UnittestLite.DefaultNestedEnumExtensionLite)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.DefaultSfixed32ExtensionLite)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.DefaultSfixed64ExtensionLite)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.DefaultSint32ExtensionLite)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.DefaultSint64ExtensionLite)); - Assert.AreEqual("123", copy.GetExtension(UnittestLite.DefaultStringExtensionLite)); - Assert.AreEqual("123", copy.GetExtension(UnittestLite.DefaultStringPieceExtensionLite)); - Assert.AreEqual(123u, copy.GetExtension(UnittestLite.DefaultUint32ExtensionLite)); - Assert.AreEqual(123u, copy.GetExtension(UnittestLite.DefaultUint64ExtensionLite)); - - Assert.AreEqual(true, copy.GetExtension(UnittestLite.OptionalBoolExtensionLite)); - Assert.AreEqual(ByteString.CopyFromUtf8("123"), + Assert.Equal(123, copy.GetExtension(UnittestLite.DefaultSfixed32ExtensionLite)); + Assert.Equal(123, copy.GetExtension(UnittestLite.DefaultSfixed64ExtensionLite)); + Assert.Equal(123, copy.GetExtension(UnittestLite.DefaultSint32ExtensionLite)); + Assert.Equal(123, copy.GetExtension(UnittestLite.DefaultSint64ExtensionLite)); + Assert.Equal("123", copy.GetExtension(UnittestLite.DefaultStringExtensionLite)); + Assert.Equal("123", copy.GetExtension(UnittestLite.DefaultStringPieceExtensionLite)); + Assert.Equal(123u, copy.GetExtension(UnittestLite.DefaultUint32ExtensionLite)); + Assert.Equal(123u, copy.GetExtension(UnittestLite.DefaultUint64ExtensionLite)); + + Assert.Equal(true, copy.GetExtension(UnittestLite.OptionalBoolExtensionLite)); + Assert.Equal(ByteString.CopyFromUtf8("123"), copy.GetExtension(UnittestLite.OptionalBytesExtensionLite)); - Assert.AreEqual("123", copy.GetExtension(UnittestLite.OptionalCordExtensionLite)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.OptionalDoubleExtensionLite)); - Assert.AreEqual(123u, copy.GetExtension(UnittestLite.OptionalFixed32ExtensionLite)); - Assert.AreEqual(123u, copy.GetExtension(UnittestLite.OptionalFixed64ExtensionLite)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.OptionalFloatExtensionLite)); - Assert.AreEqual(ForeignEnumLite.FOREIGN_LITE_BAZ, + Assert.Equal("123", copy.GetExtension(UnittestLite.OptionalCordExtensionLite)); + Assert.Equal(123, copy.GetExtension(UnittestLite.OptionalDoubleExtensionLite)); + Assert.Equal(123u, copy.GetExtension(UnittestLite.OptionalFixed32ExtensionLite)); + Assert.Equal(123u, copy.GetExtension(UnittestLite.OptionalFixed64ExtensionLite)); + Assert.Equal(123, copy.GetExtension(UnittestLite.OptionalFloatExtensionLite)); + Assert.Equal(ForeignEnumLite.FOREIGN_LITE_BAZ, copy.GetExtension(UnittestLite.OptionalForeignEnumExtensionLite)); - Assert.AreEqual(ImportEnumLite.IMPORT_LITE_BAZ, + Assert.Equal(ImportEnumLite.IMPORT_LITE_BAZ, copy.GetExtension(UnittestLite.OptionalImportEnumExtensionLite)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.OptionalInt32ExtensionLite)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.OptionalInt64ExtensionLite)); - Assert.AreEqual(TestAllTypesLite.Types.NestedEnum.FOO, + Assert.Equal(123, copy.GetExtension(UnittestLite.OptionalInt32ExtensionLite)); + Assert.Equal(123, copy.GetExtension(UnittestLite.OptionalInt64ExtensionLite)); + Assert.Equal(TestAllTypesLite.Types.NestedEnum.FOO, copy.GetExtension(UnittestLite.OptionalNestedEnumExtensionLite)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.OptionalSfixed32ExtensionLite)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.OptionalSfixed64ExtensionLite)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.OptionalSint32ExtensionLite)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.OptionalSint64ExtensionLite)); - Assert.AreEqual("123", copy.GetExtension(UnittestLite.OptionalStringExtensionLite)); - Assert.AreEqual("123", copy.GetExtension(UnittestLite.OptionalStringPieceExtensionLite)); - Assert.AreEqual(123u, copy.GetExtension(UnittestLite.OptionalUint32ExtensionLite)); - Assert.AreEqual(123u, copy.GetExtension(UnittestLite.OptionalUint64ExtensionLite)); - - Assert.AreEqual(true, copy.GetExtension(UnittestLite.RepeatedBoolExtensionLite, 0)); - Assert.AreEqual(ByteString.CopyFromUtf8("123"), + Assert.Equal(123, copy.GetExtension(UnittestLite.OptionalSfixed32ExtensionLite)); + Assert.Equal(123, copy.GetExtension(UnittestLite.OptionalSfixed64ExtensionLite)); + Assert.Equal(123, copy.GetExtension(UnittestLite.OptionalSint32ExtensionLite)); + Assert.Equal(123, copy.GetExtension(UnittestLite.OptionalSint64ExtensionLite)); + Assert.Equal("123", copy.GetExtension(UnittestLite.OptionalStringExtensionLite)); + Assert.Equal("123", copy.GetExtension(UnittestLite.OptionalStringPieceExtensionLite)); + Assert.Equal(123u, copy.GetExtension(UnittestLite.OptionalUint32ExtensionLite)); + Assert.Equal(123u, copy.GetExtension(UnittestLite.OptionalUint64ExtensionLite)); + + Assert.Equal(true, copy.GetExtension(UnittestLite.RepeatedBoolExtensionLite, 0)); + Assert.Equal(ByteString.CopyFromUtf8("123"), copy.GetExtension(UnittestLite.RepeatedBytesExtensionLite, 0)); - Assert.AreEqual("123", copy.GetExtension(UnittestLite.RepeatedCordExtensionLite, 0)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.RepeatedDoubleExtensionLite, 0)); - Assert.AreEqual(123u, copy.GetExtension(UnittestLite.RepeatedFixed32ExtensionLite, 0)); - Assert.AreEqual(123u, copy.GetExtension(UnittestLite.RepeatedFixed64ExtensionLite, 0)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.RepeatedFloatExtensionLite, 0)); - Assert.AreEqual(ForeignEnumLite.FOREIGN_LITE_BAZ, + Assert.Equal("123", copy.GetExtension(UnittestLite.RepeatedCordExtensionLite, 0)); + Assert.Equal(123, copy.GetExtension(UnittestLite.RepeatedDoubleExtensionLite, 0)); + Assert.Equal(123u, copy.GetExtension(UnittestLite.RepeatedFixed32ExtensionLite, 0)); + Assert.Equal(123u, copy.GetExtension(UnittestLite.RepeatedFixed64ExtensionLite, 0)); + Assert.Equal(123, copy.GetExtension(UnittestLite.RepeatedFloatExtensionLite, 0)); + Assert.Equal(ForeignEnumLite.FOREIGN_LITE_BAZ, copy.GetExtension(UnittestLite.RepeatedForeignEnumExtensionLite, 0)); - Assert.AreEqual(ImportEnumLite.IMPORT_LITE_BAZ, + Assert.Equal(ImportEnumLite.IMPORT_LITE_BAZ, copy.GetExtension(UnittestLite.RepeatedImportEnumExtensionLite, 0)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.RepeatedInt32ExtensionLite, 0)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.RepeatedInt64ExtensionLite, 0)); - Assert.AreEqual(TestAllTypesLite.Types.NestedEnum.FOO, + Assert.Equal(123, copy.GetExtension(UnittestLite.RepeatedInt32ExtensionLite, 0)); + Assert.Equal(123, copy.GetExtension(UnittestLite.RepeatedInt64ExtensionLite, 0)); + Assert.Equal(TestAllTypesLite.Types.NestedEnum.FOO, copy.GetExtension(UnittestLite.RepeatedNestedEnumExtensionLite, 0)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.RepeatedSfixed32ExtensionLite, 0)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.RepeatedSfixed64ExtensionLite, 0)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.RepeatedSint32ExtensionLite, 0)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.RepeatedSint64ExtensionLite, 0)); - Assert.AreEqual("123", copy.GetExtension(UnittestLite.RepeatedStringExtensionLite, 0)); - Assert.AreEqual("123", copy.GetExtension(UnittestLite.RepeatedStringPieceExtensionLite, 0)); - Assert.AreEqual(123u, copy.GetExtension(UnittestLite.RepeatedUint32ExtensionLite, 0)); - Assert.AreEqual(123u, copy.GetExtension(UnittestLite.RepeatedUint64ExtensionLite, 0)); + Assert.Equal(123, copy.GetExtension(UnittestLite.RepeatedSfixed32ExtensionLite, 0)); + Assert.Equal(123, copy.GetExtension(UnittestLite.RepeatedSfixed64ExtensionLite, 0)); + Assert.Equal(123, copy.GetExtension(UnittestLite.RepeatedSint32ExtensionLite, 0)); + Assert.Equal(123, copy.GetExtension(UnittestLite.RepeatedSint64ExtensionLite, 0)); + Assert.Equal("123", copy.GetExtension(UnittestLite.RepeatedStringExtensionLite, 0)); + Assert.Equal("123", copy.GetExtension(UnittestLite.RepeatedStringPieceExtensionLite, 0)); + Assert.Equal(123u, copy.GetExtension(UnittestLite.RepeatedUint32ExtensionLite, 0)); + Assert.Equal(123u, copy.GetExtension(UnittestLite.RepeatedUint64ExtensionLite, 0)); } private TestPackedExtensionsLite BuildPackedExtensions() @@ -295,36 +294,36 @@ namespace Google.ProtocolBuffers private void AssertPackedExtensions(TestPackedExtensionsLite copy) { - Assert.AreEqual(true, copy.GetExtension(UnittestLite.PackedBoolExtensionLite, 0)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.PackedDoubleExtensionLite, 0)); - Assert.AreEqual(123u, copy.GetExtension(UnittestLite.PackedFixed32ExtensionLite, 0)); - Assert.AreEqual(123u, copy.GetExtension(UnittestLite.PackedFixed64ExtensionLite, 0)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.PackedFloatExtensionLite, 0)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.PackedInt32ExtensionLite, 0)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.PackedInt64ExtensionLite, 0)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.PackedSfixed32ExtensionLite, 0)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.PackedSfixed64ExtensionLite, 0)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.PackedSint32ExtensionLite, 0)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.PackedSint64ExtensionLite, 0)); - Assert.AreEqual(123u, copy.GetExtension(UnittestLite.PackedUint32ExtensionLite, 0)); - Assert.AreEqual(123u, copy.GetExtension(UnittestLite.PackedUint64ExtensionLite, 0)); - - Assert.AreEqual(true, copy.GetExtension(UnittestLite.PackedBoolExtensionLite, 1)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.PackedDoubleExtensionLite, 1)); - Assert.AreEqual(123u, copy.GetExtension(UnittestLite.PackedFixed32ExtensionLite, 1)); - Assert.AreEqual(123u, copy.GetExtension(UnittestLite.PackedFixed64ExtensionLite, 1)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.PackedFloatExtensionLite, 1)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.PackedInt32ExtensionLite, 1)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.PackedInt64ExtensionLite, 1)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.PackedSfixed32ExtensionLite, 1)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.PackedSfixed64ExtensionLite, 1)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.PackedSint32ExtensionLite, 1)); - Assert.AreEqual(123, copy.GetExtension(UnittestLite.PackedSint64ExtensionLite, 1)); - Assert.AreEqual(123u, copy.GetExtension(UnittestLite.PackedUint32ExtensionLite, 1)); - Assert.AreEqual(123u, copy.GetExtension(UnittestLite.PackedUint64ExtensionLite, 1)); + Assert.Equal(true, copy.GetExtension(UnittestLite.PackedBoolExtensionLite, 0)); + Assert.Equal(123, copy.GetExtension(UnittestLite.PackedDoubleExtensionLite, 0)); + Assert.Equal(123u, copy.GetExtension(UnittestLite.PackedFixed32ExtensionLite, 0)); + Assert.Equal(123u, copy.GetExtension(UnittestLite.PackedFixed64ExtensionLite, 0)); + Assert.Equal(123, copy.GetExtension(UnittestLite.PackedFloatExtensionLite, 0)); + Assert.Equal(123, copy.GetExtension(UnittestLite.PackedInt32ExtensionLite, 0)); + Assert.Equal(123, copy.GetExtension(UnittestLite.PackedInt64ExtensionLite, 0)); + Assert.Equal(123, copy.GetExtension(UnittestLite.PackedSfixed32ExtensionLite, 0)); + Assert.Equal(123, copy.GetExtension(UnittestLite.PackedSfixed64ExtensionLite, 0)); + Assert.Equal(123, copy.GetExtension(UnittestLite.PackedSint32ExtensionLite, 0)); + Assert.Equal(123, copy.GetExtension(UnittestLite.PackedSint64ExtensionLite, 0)); + Assert.Equal(123u, copy.GetExtension(UnittestLite.PackedUint32ExtensionLite, 0)); + Assert.Equal(123u, copy.GetExtension(UnittestLite.PackedUint64ExtensionLite, 0)); + + Assert.Equal(true, copy.GetExtension(UnittestLite.PackedBoolExtensionLite, 1)); + Assert.Equal(123, copy.GetExtension(UnittestLite.PackedDoubleExtensionLite, 1)); + Assert.Equal(123u, copy.GetExtension(UnittestLite.PackedFixed32ExtensionLite, 1)); + Assert.Equal(123u, copy.GetExtension(UnittestLite.PackedFixed64ExtensionLite, 1)); + Assert.Equal(123, copy.GetExtension(UnittestLite.PackedFloatExtensionLite, 1)); + Assert.Equal(123, copy.GetExtension(UnittestLite.PackedInt32ExtensionLite, 1)); + Assert.Equal(123, copy.GetExtension(UnittestLite.PackedInt64ExtensionLite, 1)); + Assert.Equal(123, copy.GetExtension(UnittestLite.PackedSfixed32ExtensionLite, 1)); + Assert.Equal(123, copy.GetExtension(UnittestLite.PackedSfixed64ExtensionLite, 1)); + Assert.Equal(123, copy.GetExtension(UnittestLite.PackedSint32ExtensionLite, 1)); + Assert.Equal(123, copy.GetExtension(UnittestLite.PackedSint64ExtensionLite, 1)); + Assert.Equal(123u, copy.GetExtension(UnittestLite.PackedUint32ExtensionLite, 1)); + Assert.Equal(123u, copy.GetExtension(UnittestLite.PackedUint64ExtensionLite, 1)); } - [TestMethod] + [Fact] public void ExtensionWriterTestPacked() { TestPackedExtensionsLite msg = BuildPackedExtensions(); @@ -336,12 +335,12 @@ namespace Google.ProtocolBuffers TestPackedExtensionsLite.CreateBuilder().MergeFrom(msg.ToByteArray(), registry); TestPackedExtensionsLite copy = copyBuilder.Build(); - TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray()); + Assert.Equal(msg.ToByteArray(), copy.ToByteArray()); AssertPackedExtensions(copy); } - [TestMethod] + [Fact] public void TestUnpackedAndPackedExtensions() { TestPackedExtensionsLite original = BuildPackedExtensions(); @@ -355,19 +354,19 @@ namespace Google.ProtocolBuffers TestPackedExtensionsLite packed = TestPackedExtensionsLite.ParseFrom(unpacked.ToByteArray(), registry); - Assert.AreEqual(original, packed); - TestUtil.AssertBytesEqual(original.ToByteArray(), packed.ToByteArray()); + Assert.Equal(original, packed); + Assert.Equal(original.ToByteArray(), packed.ToByteArray()); AssertPackedExtensions(packed); } - [TestMethod] + [Fact] public void TestUnpackedFromPackedInput() { byte[] packedData = BuildPackedExtensions().ToByteArray(); TestUnpackedTypesLite unpacked = TestUnpackedTypesLite.ParseFrom(packedData); TestPackedTypesLite packed = TestPackedTypesLite.ParseFrom(unpacked.ToByteArray()); - TestUtil.AssertBytesEqual(packedData, packed.ToByteArray()); + Assert.Equal(packedData, packed.ToByteArray()); unpacked = TestUnpackedTypesLite.ParseFrom(packed.ToByteArray()); diff --git a/csharp/src/ProtocolBuffersLite.Test/InteropLiteTest.cs b/csharp/src/ProtocolBuffersLite.Test/InteropLiteTest.cs index 0640a445..7feb0448 100644 --- a/csharp/src/ProtocolBuffersLite.Test/InteropLiteTest.cs +++ b/csharp/src/ProtocolBuffersLite.Test/InteropLiteTest.cs @@ -35,31 +35,28 @@ #endregion using System; -using System.Collections.Generic; -using Google.ProtocolBuffers; using Google.ProtocolBuffers.TestProtos; -using Microsoft.VisualStudio.TestTools.UnitTesting; +using Xunit; namespace Google.ProtocolBuffers { - [TestClass] public class InteropLiteTest { - [TestMethod] + [Fact] public void TestConvertFromFullMinimal() { TestInteropPerson person = TestInteropPerson.CreateBuilder() .SetId(123) .SetName("abc") .Build(); - Assert.IsTrue(person.IsInitialized); + Assert.True(person.IsInitialized); TestInteropPersonLite copy = TestInteropPersonLite.ParseFrom(person.ToByteArray()); - TestUtil.AssertBytesEqual(person.ToByteArray(), copy.ToByteArray()); + Assert.Equal(person.ToByteArray(), copy.ToByteArray()); } - [TestMethod] + [Fact] public void TestConvertFromFullComplete() { TestInteropPerson person = TestInteropPerson.CreateBuilder() @@ -75,7 +72,7 @@ namespace Google.ProtocolBuffers .SetExtension(UnittestExtrasFull.EmployeeId, TestInteropEmployeeId.CreateBuilder().SetNumber("123").Build()) .Build(); - Assert.IsTrue(person.IsInitialized); + Assert.True(person.IsInitialized); ExtensionRegistry registry = ExtensionRegistry.CreateInstance(); UnittestExtrasLite.RegisterAllExtensions(registry); @@ -84,24 +81,24 @@ namespace Google.ProtocolBuffers TestInteropPersonLite copy = TestInteropPersonLite.ParseFrom(fullBytes, registry); byte[] liteBytes = copy.ToByteArray(); - TestUtil.AssertBytesEqual(fullBytes, liteBytes); + Assert.Equal(fullBytes, liteBytes); } - [TestMethod] + [Fact] public void TestConvertFromLiteMinimal() { TestInteropPersonLite person = TestInteropPersonLite.CreateBuilder() .SetId(123) .SetName("abc") .Build(); - Assert.IsTrue(person.IsInitialized); + Assert.True(person.IsInitialized); TestInteropPerson copy = TestInteropPerson.ParseFrom(person.ToByteArray()); - TestUtil.AssertBytesEqual(person.ToByteArray(), copy.ToByteArray()); + Assert.Equal(person.ToByteArray(), copy.ToByteArray()); } - [TestMethod] + [Fact] public void TestConvertFromLiteComplete() { TestInteropPersonLite person = TestInteropPersonLite.CreateBuilder() @@ -117,14 +114,14 @@ namespace Google.ProtocolBuffers .SetExtension(UnittestExtrasLite.EmployeeIdLite, TestInteropEmployeeIdLite.CreateBuilder().SetNumber("123").Build()) .Build(); - Assert.IsTrue(person.IsInitialized); + Assert.True(person.IsInitialized); ExtensionRegistry registry = ExtensionRegistry.CreateInstance(); UnittestExtrasFull.RegisterAllExtensions(registry); TestInteropPerson copy = TestInteropPerson.ParseFrom(person.ToByteArray(), registry); - TestUtil.AssertBytesEqual(person.ToByteArray(), copy.ToByteArray()); + Assert.Equal(person.ToByteArray(), copy.ToByteArray()); } public ByteString AllBytes @@ -138,7 +135,7 @@ namespace Google.ProtocolBuffers } } - [TestMethod] + [Fact] public void TestCompareStringValues() { TestInteropPersonLite person = TestInteropPersonLite.CreateBuilder() @@ -156,14 +153,14 @@ namespace Google.ProtocolBuffers .SetExtension(UnittestExtrasLite.EmployeeIdLite, TestInteropEmployeeIdLite.CreateBuilder().SetNumber("123").Build()) .Build(); - Assert.IsTrue(person.IsInitialized); + Assert.True(person.IsInitialized); ExtensionRegistry registry = ExtensionRegistry.CreateInstance(); UnittestExtrasFull.RegisterAllExtensions(registry); TestInteropPerson copy = TestInteropPerson.ParseFrom(person.ToByteArray(), registry); - TestUtil.AssertBytesEqual(person.ToByteArray(), copy.ToByteArray()); + Assert.Equal(person.ToByteArray(), copy.ToByteArray()); TestInteropPerson.Builder copyBuilder = TestInteropPerson.CreateBuilder(); TextFormat.Merge( @@ -171,7 +168,7 @@ namespace Google.ProtocolBuffers "[protobuf_unittest_extra.employee_id]"), registry, copyBuilder); copy = copyBuilder.Build(); - TestUtil.AssertBytesEqual(person.ToByteArray(), copy.ToByteArray()); + Assert.Equal(person.ToByteArray(), copy.ToByteArray()); string liteText = person.ToString().TrimEnd().Replace("\r", ""); string fullText = copy.ToString().TrimEnd().Replace("\r", ""); @@ -179,10 +176,10 @@ namespace Google.ProtocolBuffers liteText = liteText.Replace("[protobuf_unittest_extra.employee_id_lite]", "[protobuf_unittest_extra.employee_id]"); //lite version does not indent - while (fullText.IndexOf("\n ") >= 0) + while (fullText.IndexOf("\n ", StringComparison.Ordinal) >= 0) fullText = fullText.Replace("\n ", "\n"); - Assert.AreEqual(fullText, liteText); + Assert.Equal(fullText, liteText); } } } \ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/LiteTest.cs b/csharp/src/ProtocolBuffersLite.Test/LiteTest.cs index 9ef5cc84..8ffd3ee2 100644 --- a/csharp/src/ProtocolBuffersLite.Test/LiteTest.cs +++ b/csharp/src/ProtocolBuffersLite.Test/LiteTest.cs @@ -34,12 +34,8 @@ #endregion -using System; -using System.Collections.Generic; -using System.IO; -using Google.ProtocolBuffers.Descriptors; using Google.ProtocolBuffers.TestProtos; -using Microsoft.VisualStudio.TestTools.UnitTesting; +using Xunit; namespace Google.ProtocolBuffers { @@ -47,10 +43,9 @@ namespace Google.ProtocolBuffers /// Miscellaneous tests for message operations that apply to both /// generated and dynamic messages. /// - [TestClass] public class LiteTest { - [TestMethod] + [Fact] public void TestLite() { // Since lite messages are a subset of regular messages, we can mostly @@ -73,13 +68,13 @@ namespace Google.ProtocolBuffers TestAllTypesLite message2 = TestAllTypesLite.ParseFrom(data); - Assert.AreEqual(123, message2.OptionalInt32); - Assert.AreEqual(1, message2.RepeatedStringCount); - Assert.AreEqual("hello", message2.RepeatedStringList[0]); - Assert.AreEqual(7, message2.OptionalNestedMessage.Bb); + Assert.Equal(123, message2.OptionalInt32); + Assert.Equal(1, message2.RepeatedStringCount); + Assert.Equal("hello", message2.RepeatedStringList[0]); + Assert.Equal(7, message2.OptionalNestedMessage.Bb); } - [TestMethod] + [Fact] public void TestLiteExtensions() { // TODO(kenton): Unlike other features of the lite library, extensions are @@ -101,17 +96,17 @@ namespace Google.ProtocolBuffers // writing, parsing hasn't been implemented yet. TestAllExtensionsLite message2 = message.ToBuilder().Build(); - Assert.AreEqual(123, (int) message2.GetExtension( + Assert.Equal(123, (int) message2.GetExtension( UnittestLite.OptionalInt32ExtensionLite)); - Assert.AreEqual(1, message2.GetExtensionCount( + Assert.Equal(1, message2.GetExtensionCount( UnittestLite.RepeatedStringExtensionLite)); - Assert.AreEqual(1, message2.GetExtension( + Assert.Equal(1, message2.GetExtension( UnittestLite.RepeatedStringExtensionLite).Count); - Assert.AreEqual("hello", message2.GetExtension( + Assert.Equal("hello", message2.GetExtension( UnittestLite.RepeatedStringExtensionLite, 0)); - Assert.AreEqual(TestAllTypesLite.Types.NestedEnum.BAZ, message2.GetExtension( + Assert.Equal(TestAllTypesLite.Types.NestedEnum.BAZ, message2.GetExtension( UnittestLite.OptionalNestedEnumExtensionLite)); - Assert.AreEqual(7, message2.GetExtension( + Assert.Equal(7, message2.GetExtension( UnittestLite.OptionalNestedMessageExtensionLite).Bb); } } diff --git a/csharp/src/ProtocolBuffersLite.Test/MissingFieldAndExtensionTest.cs b/csharp/src/ProtocolBuffersLite.Test/MissingFieldAndExtensionTest.cs index b70635d5..b9680e68 100644 --- a/csharp/src/ProtocolBuffersLite.Test/MissingFieldAndExtensionTest.cs +++ b/csharp/src/ProtocolBuffersLite.Test/MissingFieldAndExtensionTest.cs @@ -34,17 +34,14 @@ #endregion -using System.IO; -using Microsoft.VisualStudio.TestTools.UnitTesting; -using System.Collections.Generic; using Google.ProtocolBuffers.TestProtos; +using Xunit; namespace Google.ProtocolBuffers { - [TestClass] public class MissingFieldAndExtensionTest { - [TestMethod] + [Fact] public void TestRecoverMissingExtensions() { const int optionalInt32 = 12345678; @@ -55,42 +52,42 @@ namespace Google.ProtocolBuffers builder.AddExtension(Unittest.RepeatedDoubleExtension, 1.3); TestAllExtensions msg = builder.Build(); - Assert.IsTrue(msg.HasExtension(Unittest.OptionalInt32Extension)); - Assert.AreEqual(3, msg.GetExtensionCount(Unittest.RepeatedDoubleExtension)); + Assert.True(msg.HasExtension(Unittest.OptionalInt32Extension)); + Assert.Equal(3, msg.GetExtensionCount(Unittest.RepeatedDoubleExtension)); byte[] bits = msg.ToByteArray(); TestAllExtensions copy = TestAllExtensions.ParseFrom(bits); - Assert.IsFalse(copy.HasExtension(Unittest.OptionalInt32Extension)); - Assert.AreEqual(0, copy.GetExtensionCount(Unittest.RepeatedDoubleExtension)); - Assert.AreNotEqual(msg, copy); + Assert.False(copy.HasExtension(Unittest.OptionalInt32Extension)); + Assert.Equal(0, copy.GetExtensionCount(Unittest.RepeatedDoubleExtension)); + Assert.NotEqual(msg, copy); //Even though copy does not understand the typees they serialize correctly byte[] copybits = copy.ToByteArray(); - TestUtil.AssertBytesEqual(bits, copybits); + Assert.Equal(bits, copybits); ExtensionRegistry registry = ExtensionRegistry.CreateInstance(); Unittest.RegisterAllExtensions(registry); //Now we can take those copy bits and restore the full message with extensions copy = TestAllExtensions.ParseFrom(copybits, registry); - Assert.IsTrue(copy.HasExtension(Unittest.OptionalInt32Extension)); - Assert.AreEqual(3, copy.GetExtensionCount(Unittest.RepeatedDoubleExtension)); + Assert.True(copy.HasExtension(Unittest.OptionalInt32Extension)); + Assert.Equal(3, copy.GetExtensionCount(Unittest.RepeatedDoubleExtension)); - Assert.AreEqual(msg, copy); - TestUtil.AssertBytesEqual(bits, copy.ToByteArray()); + Assert.Equal(msg, copy); + Assert.Equal(bits, copy.ToByteArray()); //If we modify the object this should all continue to work as before copybits = copy.ToBuilder().Build().ToByteArray(); - TestUtil.AssertBytesEqual(bits, copybits); + Assert.Equal(bits, copybits); //If we replace extension the object this should all continue to work as before copybits = copy.ToBuilder() .SetExtension(Unittest.OptionalInt32Extension, optionalInt32) .Build().ToByteArray(); - TestUtil.AssertBytesEqual(bits, copybits); + Assert.Equal(bits, copybits); } - [TestMethod] + [Fact] public void TestRecoverMissingFields() { TestMissingFieldsA msga = TestMissingFieldsA.CreateBuilder() @@ -101,53 +98,53 @@ namespace Google.ProtocolBuffers //serialize to type B and verify all fields exist TestMissingFieldsB msgb = TestMissingFieldsB.ParseFrom(msga.ToByteArray()); - Assert.AreEqual(1001, msgb.Id); - Assert.AreEqual("Name", msgb.Name); - Assert.IsFalse(msgb.HasWebsite); - Assert.AreEqual(1, msgb.UnknownFields.FieldDictionary.Count); - Assert.AreEqual("missing@field.value", + Assert.Equal(1001, msgb.Id); + Assert.Equal("Name", msgb.Name); + Assert.False(msgb.HasWebsite); + Assert.Equal(1, msgb.UnknownFields.FieldDictionary.Count); + Assert.Equal("missing@field.value", msgb.UnknownFields[TestMissingFieldsA.EmailFieldNumber].LengthDelimitedList[0].ToStringUtf8()); //serializes exactly the same (at least for this simple example) - TestUtil.AssertBytesEqual(msga.ToByteArray(), msgb.ToByteArray()); - Assert.AreEqual(msga, TestMissingFieldsA.ParseFrom(msgb.ToByteArray())); + Assert.Equal(msga.ToByteArray(), msgb.ToByteArray()); + Assert.Equal(msga, TestMissingFieldsA.ParseFrom(msgb.ToByteArray())); //now re-create an exact copy of A from serialized B TestMissingFieldsA copya = TestMissingFieldsA.ParseFrom(msgb.ToByteArray()); - Assert.AreEqual(msga, copya); - Assert.AreEqual(1001, copya.Id); - Assert.AreEqual("Name", copya.Name); - Assert.AreEqual("missing@field.value", copya.Email); + Assert.Equal(msga, copya); + Assert.Equal(1001, copya.Id); + Assert.Equal("Name", copya.Name); + Assert.Equal("missing@field.value", copya.Email); //Now we modify B... and try again msgb = msgb.ToBuilder().SetWebsite("http://new.missing.field").Build(); //Does B still have the missing field? - Assert.AreEqual(1, msgb.UnknownFields.FieldDictionary.Count); + Assert.Equal(1, msgb.UnknownFields.FieldDictionary.Count); //Convert back to A and see if all fields are there? copya = TestMissingFieldsA.ParseFrom(msgb.ToByteArray()); - Assert.AreNotEqual(msga, copya); - Assert.AreEqual(1001, copya.Id); - Assert.AreEqual("Name", copya.Name); - Assert.AreEqual("missing@field.value", copya.Email); - Assert.AreEqual(1, copya.UnknownFields.FieldDictionary.Count); - Assert.AreEqual("http://new.missing.field", + Assert.NotEqual(msga, copya); + Assert.Equal(1001, copya.Id); + Assert.Equal("Name", copya.Name); + Assert.Equal("missing@field.value", copya.Email); + Assert.Equal(1, copya.UnknownFields.FieldDictionary.Count); + Assert.Equal("http://new.missing.field", copya.UnknownFields[TestMissingFieldsB.WebsiteFieldNumber].LengthDelimitedList[0]. ToStringUtf8()); //Lastly we can even still trip back to type B and see all fields: TestMissingFieldsB copyb = TestMissingFieldsB.ParseFrom(copya.ToByteArray()); - Assert.AreEqual(copya.ToByteArray().Length, copyb.ToByteArray().Length); //not exact order. - Assert.AreEqual(1001, copyb.Id); - Assert.AreEqual("Name", copyb.Name); - Assert.AreEqual("http://new.missing.field", copyb.Website); - Assert.AreEqual(1, copyb.UnknownFields.FieldDictionary.Count); - Assert.AreEqual("missing@field.value", + Assert.Equal(copya.ToByteArray().Length, copyb.ToByteArray().Length); //not exact order. + Assert.Equal(1001, copyb.Id); + Assert.Equal("Name", copyb.Name); + Assert.Equal("http://new.missing.field", copyb.Website); + Assert.Equal(1, copyb.UnknownFields.FieldDictionary.Count); + Assert.Equal("missing@field.value", copyb.UnknownFields[TestMissingFieldsA.EmailFieldNumber].LengthDelimitedList[0].ToStringUtf8 ()); } - [TestMethod] + [Fact] public void TestRecoverMissingMessage() { TestMissingFieldsA.Types.SubA suba = @@ -161,52 +158,52 @@ namespace Google.ProtocolBuffers //serialize to type B and verify all fields exist TestMissingFieldsB msgb = TestMissingFieldsB.ParseFrom(msga.ToByteArray()); - Assert.AreEqual(1001, msgb.Id); - Assert.AreEqual("Name", msgb.Name); - Assert.AreEqual(1, msgb.UnknownFields.FieldDictionary.Count); - Assert.AreEqual(suba.ToString(), + Assert.Equal(1001, msgb.Id); + Assert.Equal("Name", msgb.Name); + Assert.Equal(1, msgb.UnknownFields.FieldDictionary.Count); + Assert.Equal(suba.ToString(), TestMissingFieldsA.Types.SubA.ParseFrom( msgb.UnknownFields[TestMissingFieldsA.TestAFieldNumber].LengthDelimitedList[0]).ToString ()); //serializes exactly the same (at least for this simple example) - TestUtil.AssertBytesEqual(msga.ToByteArray(), msgb.ToByteArray()); - Assert.AreEqual(msga, TestMissingFieldsA.ParseFrom(msgb.ToByteArray())); + Assert.Equal(msga.ToByteArray(), msgb.ToByteArray()); + Assert.Equal(msga, TestMissingFieldsA.ParseFrom(msgb.ToByteArray())); //now re-create an exact copy of A from serialized B TestMissingFieldsA copya = TestMissingFieldsA.ParseFrom(msgb.ToByteArray()); - Assert.AreEqual(msga, copya); - Assert.AreEqual(1001, copya.Id); - Assert.AreEqual("Name", copya.Name); - Assert.AreEqual(suba, copya.TestA); + Assert.Equal(msga, copya); + Assert.Equal(1001, copya.Id); + Assert.Equal("Name", copya.Name); + Assert.Equal(suba, copya.TestA); //Now we modify B... and try again TestMissingFieldsB.Types.SubB subb = TestMissingFieldsB.Types.SubB.CreateBuilder().AddValues("test-b").Build(); msgb = msgb.ToBuilder().SetTestB(subb).Build(); //Does B still have the missing field? - Assert.AreEqual(1, msgb.UnknownFields.FieldDictionary.Count); + Assert.Equal(1, msgb.UnknownFields.FieldDictionary.Count); //Convert back to A and see if all fields are there? copya = TestMissingFieldsA.ParseFrom(msgb.ToByteArray()); - Assert.AreNotEqual(msga, copya); - Assert.AreEqual(1001, copya.Id); - Assert.AreEqual("Name", copya.Name); - Assert.AreEqual(suba, copya.TestA); - Assert.AreEqual(1, copya.UnknownFields.FieldDictionary.Count); - TestUtil.AssertBytesEqual(subb.ToByteArray(), + Assert.NotEqual(msga, copya); + Assert.Equal(1001, copya.Id); + Assert.Equal("Name", copya.Name); + Assert.Equal(suba, copya.TestA); + Assert.Equal(1, copya.UnknownFields.FieldDictionary.Count); + Assert.Equal(subb.ToByteArray(), copya.UnknownFields[TestMissingFieldsB.TestBFieldNumber].LengthDelimitedList[0].ToByteArray()); //Lastly we can even still trip back to type B and see all fields: TestMissingFieldsB copyb = TestMissingFieldsB.ParseFrom(copya.ToByteArray()); - Assert.AreEqual(copya.ToByteArray().Length, copyb.ToByteArray().Length); //not exact order. - Assert.AreEqual(1001, copyb.Id); - Assert.AreEqual("Name", copyb.Name); - Assert.AreEqual(subb, copyb.TestB); - Assert.AreEqual(1, copyb.UnknownFields.FieldDictionary.Count); + Assert.Equal(copya.ToByteArray().Length, copyb.ToByteArray().Length); //not exact order. + Assert.Equal(1001, copyb.Id); + Assert.Equal("Name", copyb.Name); + Assert.Equal(subb, copyb.TestB); + Assert.Equal(1, copyb.UnknownFields.FieldDictionary.Count); } - [TestMethod] + [Fact] public void TestRestoreFromOtherType() { TestInteropPerson person = TestInteropPerson.CreateBuilder() @@ -222,19 +219,19 @@ namespace Google.ProtocolBuffers .SetExtension(UnittestExtrasFull.EmployeeId, TestInteropEmployeeId.CreateBuilder().SetNumber("123").Build()) .Build(); - Assert.IsTrue(person.IsInitialized); + Assert.True(person.IsInitialized); TestEmptyMessage temp = TestEmptyMessage.ParseFrom(person.ToByteArray()); - Assert.AreEqual(7, temp.UnknownFields.FieldDictionary.Count); + Assert.Equal(7, temp.UnknownFields.FieldDictionary.Count); temp = temp.ToBuilder().Build(); - Assert.AreEqual(7, temp.UnknownFields.FieldDictionary.Count); + Assert.Equal(7, temp.UnknownFields.FieldDictionary.Count); ExtensionRegistry registry = ExtensionRegistry.CreateInstance(); UnittestExtrasFull.RegisterAllExtensions(registry); TestInteropPerson copy = TestInteropPerson.ParseFrom(temp.ToByteArray(), registry); - Assert.AreEqual(person, copy); - TestUtil.AssertBytesEqual(person.ToByteArray(), copy.ToByteArray()); + Assert.Equal(person, copy); + Assert.Equal(person.ToByteArray(), copy.ToByteArray()); } } } \ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.csproj b/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.csproj index 12315442..8acc1fb1 100644 --- a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.csproj +++ b/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.csproj @@ -1,9 +1,8 @@  + + - CLIENTPROFILE - NET35 - TEST Debug AnyCPU 9.0.30729 @@ -13,12 +12,13 @@ Properties Google.ProtocolBuffers Google.ProtocolBuffersLite.Test - v4.0 + v4.5 512 true ..\..\keys\Google.ProtocolBuffers.snk 3.5 - Client + + true @@ -32,6 +32,7 @@ true true Off + false pdbonly @@ -44,32 +45,23 @@ true true Off + false - - - - False - ..\..\lib\NUnit\lib\nunit.framework.dll + + ..\packages\xunit.abstractions.2.0.0\lib\net35\xunit.abstractions.dll - - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.Silverlight.Testing.dll + + ..\packages\xunit.assert.2.0.0\lib\portable-net45+win+wpa81+wp80+monotouch+monoandroid+Xamarin.iOS\xunit.assert.dll - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight.dll + + ..\packages\xunit.extensibility.core.2.0.0\lib\portable-net45+win+wpa81+wp80+monotouch+monoandroid+Xamarin.iOS\xunit.core.dll - - Microsoft.VisualStudio.TestTools.cs - Properties\AssemblyInfo.cs @@ -83,7 +75,6 @@ - @@ -96,7 +87,9 @@ True - + + + - - Program - $(ProjectDir)..\..\lib\NUnit\tools\nunit-console.exe - /nologo /noshadow /labels /wait $(AssemblyName).dll - $(ProjectDir)$(OutputPath) - + + + This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them. For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}. + + + + \ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.csproj b/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.csproj index f7772f39..5f1a7ba3 100644 --- a/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.csproj +++ b/csharp/src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.csproj @@ -1,9 +1,8 @@  + + - CLIENTPROFILE - NET35 - TEST Debug AnyCPU 9.0.30729 @@ -13,12 +12,13 @@ Properties Google.ProtocolBuffers Google.ProtocolBuffersMixedLite.Test - v4.0 + v4.5 512 true ..\..\keys\Google.ProtocolBuffers.snk 3.5 - Client + + true @@ -32,6 +32,7 @@ true true Off + false pdbonly @@ -44,32 +45,23 @@ true true Off + false - - - - False - ..\..\lib\NUnit\lib\nunit.framework.dll + + ..\packages\xunit.abstractions.2.0.0\lib\net35\xunit.abstractions.dll - - - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.Silverlight.Testing.dll + + ..\packages\xunit.assert.2.0.0\lib\portable-net45+win+wpa81+wp80+monotouch+monoandroid+Xamarin.iOS\xunit.assert.dll - - False - ..\..\lib\Microsoft.Silverlight.Testing\April2010\Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight.dll + + ..\packages\xunit.extensibility.core.2.0.0\lib\portable-net45+win+wpa81+wp80+monotouch+monoandroid+Xamarin.iOS\xunit.core.dll - - Microsoft.VisualStudio.TestTools.cs - Properties\AssemblyInfo.cs @@ -90,7 +82,6 @@ - @@ -98,7 +89,9 @@ ProtocolBuffers - + + + - - Program - $(ProjectDir)..\..\lib\NUnit\tools\nunit-console.exe - /nologo /noshadow /labels /wait $(AssemblyName).dll - $(ProjectDir)$(OutputPath) - + + + This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them. For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}. + + + + \ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/TestLiteByApi.cs b/csharp/src/ProtocolBuffersLite.Test/TestLiteByApi.cs index e44a72a8..e4f9acff 100644 --- a/csharp/src/ProtocolBuffersLite.Test/TestLiteByApi.cs +++ b/csharp/src/ProtocolBuffersLite.Test/TestLiteByApi.cs @@ -35,67 +35,66 @@ #endregion using Google.ProtocolBuffers.TestProtos; -using Microsoft.VisualStudio.TestTools.UnitTesting; +using Xunit; namespace Google.ProtocolBuffers { - [TestClass] public class TestLiteByApi { - [TestMethod] + [Fact] public void TestAllTypesEquality() { TestAllTypesLite msg = TestAllTypesLite.DefaultInstance; TestAllTypesLite copy = msg.ToBuilder().Build(); - Assert.AreEqual(msg.GetHashCode(), copy.GetHashCode()); - Assert.IsTrue(msg.Equals(copy)); + Assert.Equal(msg.GetHashCode(), copy.GetHashCode()); + Assert.True(msg.Equals(copy)); msg = msg.ToBuilder().SetOptionalString("Hi").Build(); - Assert.AreNotEqual(msg.GetHashCode(), copy.GetHashCode()); - Assert.IsFalse(msg.Equals(copy)); + Assert.NotEqual(msg.GetHashCode(), copy.GetHashCode()); + Assert.False(msg.Equals(copy)); copy = copy.ToBuilder().SetOptionalString("Hi").Build(); - Assert.AreEqual(msg.GetHashCode(), copy.GetHashCode()); - Assert.IsTrue(msg.Equals(copy)); + Assert.Equal(msg.GetHashCode(), copy.GetHashCode()); + Assert.True(msg.Equals(copy)); } - [TestMethod] + [Fact] public void TestEqualityOnExtensions() { TestAllExtensionsLite msg = TestAllExtensionsLite.DefaultInstance; TestAllExtensionsLite copy = msg.ToBuilder().Build(); - Assert.AreEqual(msg.GetHashCode(), copy.GetHashCode()); - Assert.IsTrue(msg.Equals(copy)); + Assert.Equal(msg.GetHashCode(), copy.GetHashCode()); + Assert.True(msg.Equals(copy)); msg = msg.ToBuilder().SetExtension(UnittestLite.OptionalStringExtensionLite, "Hi").Build(); - Assert.AreNotEqual(msg.GetHashCode(), copy.GetHashCode()); - Assert.IsFalse(msg.Equals(copy)); + Assert.NotEqual(msg.GetHashCode(), copy.GetHashCode()); + Assert.False(msg.Equals(copy)); copy = copy.ToBuilder().SetExtension(UnittestLite.OptionalStringExtensionLite, "Hi").Build(); - Assert.AreEqual(msg.GetHashCode(), copy.GetHashCode()); - Assert.IsTrue(msg.Equals(copy)); + Assert.Equal(msg.GetHashCode(), copy.GetHashCode()); + Assert.True(msg.Equals(copy)); } - [TestMethod] + [Fact] public void TestAllTypesToString() { TestAllTypesLite msg = TestAllTypesLite.DefaultInstance; TestAllTypesLite copy = msg.ToBuilder().Build(); - Assert.AreEqual(msg.ToString(), copy.ToString()); - Assert.AreEqual(0, msg.ToString().Length); + Assert.Equal(msg.ToString(), copy.ToString()); + Assert.Equal(0, msg.ToString().Length); msg = msg.ToBuilder().SetOptionalInt32(-1).Build(); - Assert.AreEqual("optional_int32: -1", msg.ToString().TrimEnd()); + Assert.Equal("optional_int32: -1", msg.ToString().TrimEnd()); msg = msg.ToBuilder().SetOptionalString("abc123").Build(); - Assert.AreEqual("optional_int32: -1\noptional_string: \"abc123\"", + Assert.Equal("optional_int32: -1\noptional_string: \"abc123\"", msg.ToString().Replace("\r", "").TrimEnd()); } - [TestMethod] + [Fact] public void TestAllTypesDefaultedRoundTrip() { TestAllTypesLite msg = TestAllTypesLite.DefaultInstance; - Assert.IsTrue(msg.IsInitialized); + Assert.True(msg.IsInitialized); TestAllTypesLite copy = TestAllTypesLite.CreateBuilder().MergeFrom(msg.ToByteArray()).Build(); - TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray()); + Assert.Equal(msg.ToByteArray(), copy.ToByteArray()); } - [TestMethod] + [Fact] public void TestAllTypesModifiedRoundTrip() { TestAllTypesLite msg = TestAllTypesLite.DefaultInstance; @@ -115,7 +114,7 @@ namespace Google.ProtocolBuffers .AddRepeatedGroup(TestAllTypesLite.Types.RepeatedGroup.CreateBuilder().SetA('A').Build()) ; TestAllTypesLite copy = TestAllTypesLite.CreateBuilder().MergeFrom(msg.ToByteArray()).Build(); - TestUtil.AssertBytesEqual(msg.ToByteArray(), copy.ToByteArray()); + Assert.Equal(msg.ToByteArray(), copy.ToByteArray()); } } } \ No newline at end of file diff --git a/csharp/src/ProtocolBuffersLite.Test/TestUtil.cs b/csharp/src/ProtocolBuffersLite.Test/TestUtil.cs deleted file mode 100644 index 44c09b9c..00000000 --- a/csharp/src/ProtocolBuffersLite.Test/TestUtil.cs +++ /dev/null @@ -1,31 +0,0 @@ -using System; -using System.Collections.Generic; -using System.Text; -using Microsoft.VisualStudio.TestTools.UnitTesting; - -namespace Google.ProtocolBuffers -{ - class TestUtil - { - internal static void AssertBytesEqual(byte[] a, byte[] b) - { - if (a == null || b == null) - { - Assert.AreEqual(a, b); - } - else - { - Assert.AreEqual(a.Length, b.Length, "The byte[] is not of the expected length."); - - for (int i = 0; i < a.Length; i++) - { - if (a[i] != b[i]) - { - Assert.AreEqual(a[i], b[i], "Byte[] differs at index " + i); - } - } - } - } - - } -} diff --git a/csharp/src/ProtocolBuffersLite.Test/packages.config b/csharp/src/ProtocolBuffersLite.Test/packages.config new file mode 100644 index 00000000..6f1fb7f5 --- /dev/null +++ b/csharp/src/ProtocolBuffersLite.Test/packages.config @@ -0,0 +1,9 @@ + + + + + + + + + \ No newline at end of file diff --git a/csharp/src/packages/repositories.config b/csharp/src/packages/repositories.config new file mode 100644 index 00000000..0117aa7c --- /dev/null +++ b/csharp/src/packages/repositories.config @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file -- cgit v1.2.3