First unit test reading a complete message\!

csharp/ProtocolBuffers.Test/CodedInputStreamTest.cs

@@ -15,6 +15,7 @@
 // limitations under the License.
 using System;
 using System.IO;
+using Google.ProtocolBuffers.TestProtos;
 using NUnit.Framework;
 
 namespace Google.ProtocolBuffers {
@@ -183,23 +184,22 @@ namespace Google.ProtocolBuffers {
       Assert.AreEqual(unchecked((long)0x8000000000000000L), CodedInputStream.DecodeZigZag64(0xFFFFFFFFFFFFFFFFL));
     }
 
-    /* TODO(jonskeet): Reinstate this when protoc is ready
-    public void testReadWholeMessage() throws Exception {
-      TestAllTypes message = TestUtil.getAllSet();
+    [Test]
+    public void ReadWholeMessage() {
+      TestAllTypes message = TestUtil.GetAllSet();
 
-      byte[] rawBytes = message.toByteArray();
-      assertEquals(rawBytes.length, message.getSerializedSize());
+      byte[] rawBytes = message.ToByteArray();
+      Assert.AreEqual(rawBytes.Length, message.SerializedSize);
 
-      TestAllTypes message2 = TestAllTypes.parseFrom(rawBytes);
-      TestUtil.assertAllFieldsSet(message2);
+      TestAllTypes message2 = TestAllTypes.ParseFrom(rawBytes);
+      TestUtil.AssertAllFieldsSet(message2);
 
       // Try different block sizes.
       for (int blockSize = 1; blockSize < 256; blockSize *= 2) {
-        message2 = TestAllTypes.parseFrom(
-          new SmallBlockInputStream(rawBytes, blockSize));
-        TestUtil.assertAllFieldsSet(message2);
+        message2 = TestAllTypes.ParseFrom(new SmallBlockInputStream(rawBytes, blockSize));
+        TestUtil.AssertAllFieldsSet(message2);
+      }
     }
-    }*/
 
     /* TODO(jonskeet): Reinstate this when protoc is ready
     public void testSkipWholeMessage() throws Exception {

csharp/ProtocolBuffers/AbstractBuilder.cs

@@ -104,16 +104,20 @@ namespace Google.ProtocolBuffers {
     }
 
     IBuilder IBuilder.MergeFrom(CodedInputStream input) {
-      return ((IBuilder)this).MergeFrom(input, ExtensionRegistry.Empty);
+      return MergeFromImpl(input, ExtensionRegistry.Empty);
     }
 
-    IBuilder IBuilder.MergeFrom(CodedInputStream input, ExtensionRegistry extensionRegistry) {
+    protected virtual IBuilder MergeFromImpl(CodedInputStream input, ExtensionRegistry extensionRegistry) {
       UnknownFieldSet.Builder unknownFields = UnknownFieldSet.CreateBuilder(UnknownFields);
       FieldSet.MergeFrom(input, unknownFields, extensionRegistry, this);
       UnknownFields = unknownFields.Build();
       return this;
     }
 
+    IBuilder IBuilder.MergeFrom(CodedInputStream input, ExtensionRegistry extensionRegistry) {
+      return MergeFromImpl(input, extensionRegistry);
+    }
+
     IBuilder IBuilder.MergeUnknownFields(UnknownFieldSet unknownFields) {
       UnknownFields = UnknownFieldSet.CreateBuilder(UnknownFields)
           .MergeFrom(unknownFields)
@@ -121,8 +125,6 @@ namespace Google.ProtocolBuffers {
       return this;
     }
 
-    public UnknownFieldSet UnknownFields { get; set; }
-
     IBuilder IBuilder.MergeFrom(ByteString data) {
       CodedInputStream input = data.CreateCodedInput();
       ((IBuilder)this).MergeFrom(input);
@@ -160,9 +162,11 @@ namespace Google.ProtocolBuffers {
 
     IBuilder IBuilder.MergeFrom(Stream input, ExtensionRegistry extensionRegistry) {
       CodedInputStream codedInput = CodedInputStream.CreateInstance(input);
-      ((IBuilder) this).MergeFrom(codedInput, extensionRegistry);
+      ((IBuilder)this).MergeFrom(codedInput, extensionRegistry);
       codedInput.CheckLastTagWas(0);
       return this;
     }
+
+    public abstract UnknownFieldSet UnknownFields { get; set; }
   }
 }

csharp/ProtocolBuffers/ByteString.cs

@@ -23,7 +23,7 @@ namespace Google.ProtocolBuffers {
   /// Immutable array of bytes.
   /// TODO(jonskeet): Implement the common collection interfaces?
   /// </summary>
-  public sealed class ByteString : IEnumerable<byte> {
+  public sealed class ByteString : IEnumerable<byte>, IEquatable<ByteString> {
 
     private static readonly ByteString empty = new ByteString(new byte[0]);
 
@@ -126,6 +126,34 @@ namespace Google.ProtocolBuffers {
 
     // TODO(jonskeet): CopyTo, Equals, GetHashCode if they turn out to be required
 
+    public override bool Equals(object obj) {
+      ByteString other = obj as ByteString;
+      if (obj == null) {
+        return false;
+      }
+      return Equals(other);
+    }
+
+    public override int GetHashCode() {
+      int ret = 23;
+      foreach (byte b in bytes) {
+        ret = (ret << 8) | b;
+      }
+      return ret;
+    }
+
+    public bool Equals(ByteString other) {
+      if (other.bytes.Length != bytes.Length) {
+        return false;
+      }
+      for (int i = 0; i < bytes.Length; i++) {
+        if (other.bytes[i] != bytes[i]) {
+          return false;
+        }
+      }
+      return true;
+    }
+
     /// <summary>
     /// Builder for ByteStrings which allows them to be created without extra
     /// copying being involved. This has to be a nested type in order to have access

csharp/ProtocolBuffers/CodedInputStream.cs

@@ -569,8 +569,8 @@ namespace Google.ProtocolBuffers {
       totalBytesRetired += bufferSize;
 
       bufferPos = 0;
-      bufferSize = (input == null) ? -1 : input.Read(buffer, 0, buffer.Length);
-      if (bufferSize == -1) {
+      bufferSize = (input == null) ? 0 : input.Read(buffer, 0, buffer.Length);
+      if (bufferSize == 0) {
         bufferSize = 0;
         if (mustSucceed) {
           throw InvalidProtocolBufferException.TruncatedMessage();

csharp/ProtocolBuffers/CodedOutputStream.cs

@@ -206,6 +206,7 @@ namespace Google.ProtocolBuffers {
 
     public void WriteBytes(int fieldNumber, ByteString value) {
       // TODO(jonskeet): Optimise this! (No need to copy the bytes twice.)
+      WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
       byte[] bytes = value.ToByteArray();
       WriteRawVarint32((uint)bytes.Length);
       WriteRawBytes(bytes);
@@ -223,12 +224,12 @@ namespace Google.ProtocolBuffers {
 
     public void WriteSFixed32(int fieldNumber, int value) {
       WriteTag(fieldNumber, WireFormat.WireType.Fixed32);
-      WriteRawVarint32((uint)value);
+      WriteRawLittleEndian32((uint)value);
     }
 
     public void WriteSFixed64(int fieldNumber, long value) {
       WriteTag(fieldNumber, WireFormat.WireType.Fixed64);
-      WriteRawVarint64((ulong)value);
+      WriteRawLittleEndian64((ulong)value);
     }
 
     public void WriteSInt32(int fieldNumber, int value) {

csharp/ProtocolBuffers/Descriptors/FieldDescriptor.cs

@@ -22,7 +22,7 @@ namespace Google.ProtocolBuffers.Descriptors {
       
       if (proto.HasType) {
         fieldType = GetFieldTypeFromProtoType(proto.Type);
-        //type = proto.Type;
+        mappedType = FieldTypeToMappedTypeMap[fieldType];
       }
       
       if (FieldNumber <= 0) {
@@ -244,8 +244,7 @@ namespace Google.ProtocolBuffers.Descriptors {
     /// Immutable mapping from field type to mapped type. Built using the attributes on
     /// FieldType values.
     /// </summary>
-    public static readonly IDictionary<FieldType, MappedType> FieldTypeToWireFormatMap = MapFieldTypes();
-
+    public static readonly IDictionary<FieldType, MappedType> FieldTypeToMappedTypeMap = MapFieldTypes();
 
     private static IDictionary<FieldType, MappedType> MapFieldTypes() {
       var map = new Dictionary<FieldType, MappedType>();

csharp/ProtocolBuffers/Descriptors/MessageDescriptor.cs

@@ -19,16 +19,16 @@ namespace Google.ProtocolBuffers.Descriptors {
       containingType = parent;
 
       nestedTypes = DescriptorUtil.ConvertAndMakeReadOnly(proto.NestedTypeList,
-          (type, index) => new MessageDescriptor(type, file, null, index));
+          (type, index) => new MessageDescriptor(type, file, this, index));
 
       enumTypes = DescriptorUtil.ConvertAndMakeReadOnly(proto.EnumTypeList,
-          (type, index) => new EnumDescriptor(type, file, null, index));
+          (type, index) => new EnumDescriptor(type, file, this, index));
 
       fields = DescriptorUtil.ConvertAndMakeReadOnly(proto.FieldList,
-          (field, index) => new FieldDescriptor(field, file, null, index, false));
+          (field, index) => new FieldDescriptor(field, file, this, index, false));
 
       extensions = DescriptorUtil.ConvertAndMakeReadOnly(proto.ExtensionList,
-          (field, index) => new FieldDescriptor(field, file, null, index, true));
+          (field, index) => new FieldDescriptor(field, file, this, index, true));
 
       file.DescriptorPool.AddSymbol(this);
     }

csharp/ProtocolBuffers/FieldAccess/RepeatedMessageAccessor.cs

@@ -21,7 +21,7 @@ namespace Google.ProtocolBuffers.FieldAccess {
 
     internal RepeatedMessageAccessor(string name, Type messageType, Type builderType)
         : base(name, messageType, builderType) {
-      createBuilderMethod = ClrType.GetMethod("CreateBuilder", BindingFlags.Public | BindingFlags.Static);
+      createBuilderMethod = ClrType.GetMethod("CreateBuilder", new Type[0]);
       if (createBuilderMethod == null) {
         throw new ArgumentException("No public static CreateBuilder method declared in " + ClrType.Name);
       }

csharp/ProtocolBuffers/FieldAccess/RepeatedPrimitiveAccessor.cs

@@ -11,7 +11,6 @@ namespace Google.ProtocolBuffers.FieldAccess {
 
     private readonly PropertyInfo messageProperty;
     private readonly PropertyInfo builderProperty;
-    private readonly PropertyInfo hasProperty;
     private readonly PropertyInfo countProperty;
     private readonly MethodInfo clearMethod;
     private readonly MethodInfo addMethod;
@@ -30,15 +29,13 @@ namespace Google.ProtocolBuffers.FieldAccess {
     internal RepeatedPrimitiveAccessor(string name, Type messageType, Type builderType) {      
       messageProperty = messageType.GetProperty(name + "List");
       builderProperty = builderType.GetProperty(name + "List");
-      hasProperty = messageType.GetProperty("Has" + name);
       countProperty = messageType.GetProperty(name + "Count");
       clearMethod = builderType.GetMethod("Clear" + name);
-      addMethod = builderType.GetMethod("Add" + name);
       getElementMethod = messageType.GetMethod("Get" + name, new Type[] { typeof(int) });
-      setElementMethod = builderType.GetMethod("Set" + name, new Type[] { typeof(int) });
+      addMethod = builderType.GetMethod("Add" + name, new Type[] { ClrType });
+      setElementMethod = builderType.GetMethod("Set" + name, new Type[] { typeof(int), ClrType });
       if (messageProperty == null 
           || builderProperty == null 
-          || hasProperty == null 
           || countProperty == null
           || clearMethod == null
           || addMethod == null

csharp/ProtocolBuffers/FieldAccess/SingleMessageAccessor.cs

@@ -19,7 +19,7 @@ namespace Google.ProtocolBuffers.FieldAccess {
     internal SingleMessageAccessor(string name, Type messageType, Type builderType) 
         : base(name, messageType, builderType) {
       
-      createBuilderMethod = ClrType.GetMethod("CreateBuilder", BindingFlags.Public | BindingFlags.Static);
+      createBuilderMethod = ClrType.GetMethod("CreateBuilder", new Type[0]);//BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly);
       if (createBuilderMethod == null) {
         throw new ArgumentException("No public static CreateBuilder method declared in " + ClrType.Name);
       }

csharp/ProtocolBuffers/FieldSet.cs

@@ -91,11 +91,8 @@ namespace Google.ProtocolBuffers {
     }
 
     // TODO(jonskeet): Should this be in UnknownFieldSet.Builder really? Or CodedInputStream?
-    internal static void MergeFrom(CodedInputStream input,
-         UnknownFieldSet.Builder unknownFields,
-         ExtensionRegistry extensionRegistry,
-         IBuilder builder) {
-
+    internal static void MergeFrom(CodedInputStream input, UnknownFieldSet.Builder unknownFields,
+         ExtensionRegistry extensionRegistry, IBuilder builder) {
       while (true) {
         uint tag = input.ReadTag();
         if (tag == 0) {
@@ -120,15 +117,10 @@ namespace Google.ProtocolBuffers {
     /// <param name="builder">Builder to merge field into, if it's a known field</param>
     /// <param name="tag">The tag, which should already have been read from the input</param>
     /// <returns>true unless the tag is an end-group tag</returns>
-    internal static bool MergeFieldFrom(CodedInputStream input,
-        UnknownFieldSet.Builder unknownFields,
-        ExtensionRegistry extensionRegistry,
-        IBuilder builder,
-        uint tag) {
+    internal static bool MergeFieldFrom(CodedInputStream input, UnknownFieldSet.Builder unknownFields,
+        ExtensionRegistry extensionRegistry, IBuilder builder, uint tag) {
       MessageDescriptor type = builder.DescriptorForType;
-
-      if (type.Options.MessageSetWireFormat
-          && tag == WireFormat.MessageSetTag.ItemStart) {
+      if (type.Options.MessageSetWireFormat && tag == WireFormat.MessageSetTag.ItemStart) {
         MergeMessageSetExtensionFromCodedStream(input, unknownFields, extensionRegistry, builder);
         return true;
       }

csharp/ProtocolBuffers/GeneratedBuilder.cs

@@ -200,6 +200,10 @@ namespace Google.ProtocolBuffers {
       return this;
     }
 
+    protected override IBuilder MergeFromImpl(CodedInputStream data, ExtensionRegistry extensionRegistry) {
+      return MergeFrom(data, extensionRegistry);
+    }
+    
     /// <summary>
     /// Like Build(), but will wrap UninitializedMessageException in
     /// InvalidProtocolBufferException.
@@ -223,6 +227,11 @@ namespace Google.ProtocolBuffers {
       return BuildPartial();
     }
 
+    public override UnknownFieldSet UnknownFields {
+      get { return MessageBeingBuilt.UnknownFields; }
+      set { MessageBeingBuilt.SetUnknownFields(value); }
+    }
+    
     public abstract TMessage BuildPartial();
     public abstract IBuilder<TMessage> Clone();
     public abstract new IBuilder<TMessage> Clear();

csharp/ProtocolBuffers/TextFormat.cs

@@ -187,15 +187,15 @@ namespace Google.ProtocolBuffers {
     }
 
     internal static ulong ParseUInt64(string text) {
-      return (ulong) ParseInteger(text, true, false);
+      return (ulong) ParseInteger(text, false, true);
     }
 
     internal static long ParseInt64(string text) {
-      return ParseInteger(text, true, false);
+      return ParseInteger(text, true, true);
     }
 
     internal static uint ParseUInt32(string text) {
-      return (uint) ParseInteger(text, true, false);
+      return (uint) ParseInteger(text, false, false);
     }
 
     internal static int ParseInt32(string text) {
@@ -229,7 +229,7 @@ namespace Google.ProtocolBuffers {
       ulong result = Convert.ToUInt64(text, radix);
 
       if (negative) {
-        ulong max = isLong ? 0x8000000UL : 0x8000L;
+        ulong max = isLong ? 0x8000000000000000UL : 0x80000000L;
         if (result > max) {
           throw new FormatException("Number of out range: " + original);
         }