diff --git a/csharp/ProtocolBuffers.Test/ByteStringTest.cs b/csharp/ProtocolBuffers.Test/ByteStringTest.cs
new file mode 100644
index 000000000..5f701731f
--- /dev/null
+++ b/csharp/ProtocolBuffers.Test/ByteStringTest.cs
@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using NUnit.Framework;
+
+namespace Google.ProtocolBuffers {
+ [TestFixture]
+ public class ByteStringTest {
+ [Test]
+ public void EmptyByteStringHasZeroSize() {
+ Assert.AreEqual(0, ByteString.Empty.Length);
+ }
+
+ [Test]
+ 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]);
+ }
+
+ [Test]
+ public void IsEmptyWhenEmpty() {
+ Assert.IsTrue(ByteString.CopyFromUtf8("").IsEmpty);
+ }
+
+ [Test]
+ public void IsEmptyWhenNotEmpty() {
+ Assert.IsFalse(ByteString.CopyFromUtf8("X").IsEmpty);
+ }
+
+ [Test]
+ public void CopyFromByteArrayCopiesContents() {
+ byte[] data = new byte[1];
+ data[0] = 10;
+ ByteString bs = ByteString.CopyFrom(data);
+ Assert.AreEqual(10, bs[0]);
+ data[0] = 5;
+ Assert.AreEqual(10, bs[0]);
+ }
+
+ [Test]
+ public void ToByteArrayCopiesContents() {
+ ByteString bs = ByteString.CopyFromUtf8("Hello");
+ byte[] data = bs.ToByteArray();
+ Assert.AreEqual('H', data[0]);
+ Assert.AreEqual('H', bs[0]);
+ data[0] = 0;
+ Assert.AreEqual(0, data[0]);
+ Assert.AreEqual('H', bs[0]);
+ }
+
+ [Test]
+ 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]);
+ }
+
+ [Test]
+ 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]);
+ }
+
+ [Test]
+ public void ToStringUtf8() {
+ ByteString bs = ByteString.CopyFromUtf8("\u20ac");
+ Assert.AreEqual("\u20ac", bs.ToStringUtf8());
+ }
+
+ [Test]
+ public void ToStringWithExplicitEncoding() {
+ ByteString bs = ByteString.CopyFrom("\u20ac", Encoding.Unicode);
+ Assert.AreEqual("\u20ac", bs.ToString(Encoding.Unicode));
+ }
+ }
+}
diff --git a/csharp/ProtocolBuffers.Test/CodedInputStreamTest.cs b/csharp/ProtocolBuffers.Test/CodedInputStreamTest.cs
new file mode 100644
index 000000000..56b17a35f
--- /dev/null
+++ b/csharp/ProtocolBuffers.Test/CodedInputStreamTest.cs
@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using NUnit.Framework;
+
+namespace Google.ProtocolBuffers {
+ [TestFixture]
+ public class CodedInputStreamTest {
+
+ [Test]
+ 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));
+ }
+
+ [Test]
+ 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));
+ }
+ }
+}
diff --git a/csharp/ProtocolBuffers.Test/CodedOutputStreamTest.cs b/csharp/ProtocolBuffers.Test/CodedOutputStreamTest.cs
new file mode 100644
index 000000000..c2042d9e4
--- /dev/null
+++ b/csharp/ProtocolBuffers.Test/CodedOutputStreamTest.cs
@@ -0,0 +1,237 @@
+using NUnit.Framework;
+using System.IO;
+
+namespace Google.ProtocolBuffers {
+ [TestFixture]
+ public class CodedOutputStreamTest {
+
+ ///
+ /// Helper to construct a byte array from a bunch of bytes. The inputs are
+ /// actually ints so that I can use hex notation and not get stupid errors
+ /// about precision.
+ ///
+ private static byte[] Bytes(params int[] bytesAsInts) {
+ byte[] bytes = new byte[bytesAsInts.Length];
+ for (int i = 0; i < bytesAsInts.Length; i++) {
+ bytes[i] = (byte) bytesAsInts[i];
+ }
+ return bytes;
+ }
+
+ ///
+ /// Writes the given value using WriteRawVarint32() and WriteRawVarint64() and
+ /// checks that the result matches the given bytes
+ ///
+ private static void AssertWriteVarint(byte[] data, ulong value) {
+ // Only do 32-bit write if the value fits in 32 bits.
+ if ((value >> 32) == 0) {
+ MemoryStream rawOutput = new MemoryStream();
+ CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput);
+ output.WriteRawVarint32((uint) value);
+ output.Flush();
+ Assert.AreEqual(data, rawOutput.ToArray());
+ // Also try computing size.
+ Assert.AreEqual(data.Length, CodedOutputStream.ComputeRawVarint32Size((uint) value));
+ }
+
+ {
+ MemoryStream rawOutput = new MemoryStream();
+ CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput);
+ output.WriteRawVarint64(value);
+ output.Flush();
+ Assert.AreEqual(data, rawOutput.ToArray());
+
+ // Also try computing size.
+ Assert.AreEqual(data.Length, CodedOutputStream.ComputeRawVarint64Size(value));
+ }
+
+ // Try different buffer sizes.
+ for (int bufferSize = 1; bufferSize <= 16; bufferSize *= 2) {
+ // Only do 32-bit write if the value fits in 32 bits.
+ if ((value >> 32) == 0) {
+ MemoryStream rawOutput = new MemoryStream();
+ CodedOutputStream output =
+ CodedOutputStream.CreateInstance(rawOutput, bufferSize);
+ output.WriteRawVarint32((uint) value);
+ output.Flush();
+ Assert.AreEqual(data, rawOutput.ToArray());
+ }
+
+ {
+ MemoryStream rawOutput = new MemoryStream();
+ CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput, bufferSize);
+ output.WriteRawVarint64(value);
+ output.Flush();
+ Assert.AreEqual(data, rawOutput.ToArray());
+ }
+ }
+ }
+
+ ///
+ /// Tests WriteRawVarint32() and WriteRawVarint64()
+ ///
+ [Test]
+ public void WriteVarint() {
+ AssertWriteVarint(Bytes(0x00), 0);
+ AssertWriteVarint(Bytes(0x01), 1);
+ AssertWriteVarint(Bytes(0x7f), 127);
+ // 14882
+ AssertWriteVarint(Bytes(0xa2, 0x74), (0x22 << 0) | (0x74 << 7));
+ // 2961488830
+ AssertWriteVarint(Bytes(0xbe, 0xf7, 0x92, 0x84, 0x0b),
+ (0x3e << 0) | (0x77 << 7) | (0x12 << 14) | (0x04 << 21) |
+ (0x0bL << 28));
+
+ // 64-bit
+ // 7256456126
+ AssertWriteVarint(Bytes(0xbe, 0xf7, 0x92, 0x84, 0x1b),
+ (0x3e << 0) | (0x77 << 7) | (0x12 << 14) | (0x04 << 21) |
+ (0x1bL << 28));
+ // 41256202580718336
+ AssertWriteVarint(
+ Bytes(0x80, 0xe6, 0xeb, 0x9c, 0xc3, 0xc9, 0xa4, 0x49),
+ (0x00 << 0) | (0x66 << 7) | (0x6b << 14) | (0x1c << 21) |
+ (0x43L << 28) | (0x49L << 35) | (0x24L << 42) | (0x49L << 49));
+ // 11964378330978735131
+ AssertWriteVarint(
+ Bytes(0x9b, 0xa8, 0xf9, 0xc2, 0xbb, 0xd6, 0x80, 0x85, 0xa6, 0x01),
+ unchecked((ulong)
+ ((0x1b << 0) | (0x28 << 7) | (0x79 << 14) | (0x42 << 21) |
+ (0x3bL << 28) | (0x56L << 35) | (0x00L << 42) |
+ (0x05L << 49) | (0x26L << 56) | (0x01L << 63))));
+ }
+
+ ///
+ /// Parses the given bytes using WriteRawLittleEndian32() and checks
+ /// that the result matches the given value.
+ ///
+ private static void AssertWriteLittleEndian32(byte[] data, int value) {
+ MemoryStream rawOutput = new MemoryStream();
+ CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput);
+ output.WriteRawLittleEndian32(value);
+ output.Flush();
+ Assert.AreEqual(data, rawOutput.ToArray());
+
+ // Try different buffer sizes.
+ for (int bufferSize = 1; bufferSize <= 16; bufferSize *= 2) {
+ rawOutput = new MemoryStream();
+ output = CodedOutputStream.CreateInstance(rawOutput, bufferSize);
+ output.WriteRawLittleEndian32(value);
+ output.Flush();
+ Assert.AreEqual(data, rawOutput.ToArray());
+ }
+ }
+
+ ///
+ /// Parses the given bytes using WriteRawLittleEndian64() and checks
+ /// that the result matches the given value.
+ ///
+ private static void AssertWriteLittleEndian64(byte[] data, long value) {
+ MemoryStream rawOutput = new MemoryStream();
+ CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput);
+ output.WriteRawLittleEndian64(value);
+ output.Flush();
+ Assert.AreEqual(data, rawOutput.ToArray());
+
+ // Try different block sizes.
+ for (int blockSize = 1; blockSize <= 16; blockSize *= 2) {
+ rawOutput = new MemoryStream();
+ output = CodedOutputStream.CreateInstance(rawOutput, blockSize);
+ output.WriteRawLittleEndian64(value);
+ output.Flush();
+ Assert.AreEqual(data, rawOutput.ToArray());
+ }
+ }
+
+ ///
+ /// Tests writeRawLittleEndian32() and writeRawLittleEndian64().
+ ///
+ [Test]
+ public void WriteLittleEndian() {
+ AssertWriteLittleEndian32(Bytes(0x78, 0x56, 0x34, 0x12), 0x12345678);
+ AssertWriteLittleEndian32(Bytes(0xf0, 0xde, 0xbc, 0x9a), unchecked((int)0x9abcdef0));
+
+ AssertWriteLittleEndian64(
+ Bytes(0xf0, 0xde, 0xbc, 0x9a, 0x78, 0x56, 0x34, 0x12),
+ 0x123456789abcdef0L);
+ AssertWriteLittleEndian64(
+ Bytes(0x78, 0x56, 0x34, 0x12, 0xf0, 0xde, 0xbc, 0x9a),
+ unchecked((long)0x9abcdef012345678L));
+ }
+
+ /* TODO(jonskeet): Put this back when we've got the rest working!
+ [Test]
+ public void testWriteWholeMessage() throws Exception {
+ TestAllTypes message = TestUtil.getAllSet();
+
+ byte[] rawBytes = message.toByteArray();
+ assertEqualBytes(TestUtil.getGoldenMessage().toByteArray(), rawBytes);
+
+ // Try different block sizes.
+ for (int blockSize = 1; blockSize < 256; blockSize *= 2) {
+ MemoryStream rawOutput = new MemoryStream();
+ CodedOutputStream output =
+ CodedOutputStream.newInstance(rawOutput, blockSize);
+ message.writeTo(output);
+ output.flush();
+ assertEqualBytes(rawBytes, rawOutput.toByteArray());
+ }
+ } */
+
+
+ [Test]
+ public void EncodeZigZag32() {
+ Assert.AreEqual(0, CodedOutputStream.EncodeZigZag32( 0));
+ Assert.AreEqual(1, CodedOutputStream.EncodeZigZag32(-1));
+ Assert.AreEqual(2, CodedOutputStream.EncodeZigZag32( 1));
+ Assert.AreEqual(3, CodedOutputStream.EncodeZigZag32(-2));
+ Assert.AreEqual(0x7FFFFFFE, CodedOutputStream.EncodeZigZag32(0x3FFFFFFF));
+ Assert.AreEqual(0x7FFFFFFF, CodedOutputStream.EncodeZigZag32(unchecked((int)0xC0000000)));
+ Assert.AreEqual(0xFFFFFFFE, CodedOutputStream.EncodeZigZag32(0x7FFFFFFF));
+ Assert.AreEqual(0xFFFFFFFF, CodedOutputStream.EncodeZigZag32(unchecked((int)0x80000000)));
+ }
+
+ [Test]
+ public void EncodeZigZag64() {
+ Assert.AreEqual(0, CodedOutputStream.EncodeZigZag64( 0));
+ Assert.AreEqual(1, CodedOutputStream.EncodeZigZag64(-1));
+ Assert.AreEqual(2, CodedOutputStream.EncodeZigZag64( 1));
+ Assert.AreEqual(3, CodedOutputStream.EncodeZigZag64(-2));
+ Assert.AreEqual(0x000000007FFFFFFEL,
+ CodedOutputStream.EncodeZigZag64(unchecked((long)0x000000003FFFFFFFUL)));
+ Assert.AreEqual(0x000000007FFFFFFFL,
+ CodedOutputStream.EncodeZigZag64(unchecked((long)0xFFFFFFFFC0000000UL)));
+ Assert.AreEqual(0x00000000FFFFFFFEL,
+ CodedOutputStream.EncodeZigZag64(unchecked((long)0x000000007FFFFFFFUL)));
+ Assert.AreEqual(0x00000000FFFFFFFFL,
+ CodedOutputStream.EncodeZigZag64(unchecked((long)0xFFFFFFFF80000000UL)));
+ Assert.AreEqual(0xFFFFFFFFFFFFFFFEL,
+ CodedOutputStream.EncodeZigZag64(unchecked((long)0x7FFFFFFFFFFFFFFFUL)));
+ Assert.AreEqual(0xFFFFFFFFFFFFFFFFL,
+ CodedOutputStream.EncodeZigZag64(unchecked((long)0x8000000000000000UL)));
+ }
+
+ [Test]
+ 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)));
+ }
+
+ [Test]
+ 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.AreEqual(856912304801416L, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(856912304801416L)));
+ Assert.AreEqual(-75123905439571256L, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-75123905439571256L)));
+ }
+ }
+}
diff --git a/csharp/ProtocolBuffers.Test/Properties/AssemblyInfo.cs b/csharp/ProtocolBuffers.Test/Properties/AssemblyInfo.cs
new file mode 100644
index 000000000..93ff802f0
--- /dev/null
+++ b/csharp/ProtocolBuffers.Test/Properties/AssemblyInfo.cs
@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("ProtocolBuffers.Test")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("ProtocolBuffers.Test")]
+[assembly: AssemblyCopyright("Copyright © 2008")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components. If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("54e627c3-daaa-4850-82cf-f25b7f097e78")]
+
+// Version information for an assembly consists of the following four values:
+//
+// Major Version
+// Minor Version
+// Build Number
+// Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/csharp/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj b/csharp/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj
new file mode 100644
index 000000000..89c5507af
--- /dev/null
+++ b/csharp/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj
@@ -0,0 +1,66 @@
+
+
+
+ Debug
+ AnyCPU
+ 9.0.21022
+ 2.0
+ {DD01ED24-3750-4567-9A23-1DB676A15610}
+ Library
+ Properties
+ Google.ProtocolBuffers
+ Google.ProtocolBuffers.Test
+ v2.0
+ 512
+
+
+ true
+ full
+ false
+ bin\Debug\
+ DEBUG;TRACE
+ prompt
+ 4
+
+
+ pdbonly
+ true
+ bin\Release\
+ TRACE
+ prompt
+ 4
+
+
+
+ False
+ lib\nunit.framework.dll
+
+
+ False
+ lib\Rhino.Mocks.dll
+
+
+
+
+
+
+
+
+
+
+
+
+
+ {6908BDCE-D925-43F3-94AC-A531E6DF2591}
+ ProtocolBuffers
+
+
+
+
+
\ No newline at end of file
diff --git a/csharp/ProtocolBuffers.Test/lib/Rhino.Mocks.dll b/csharp/ProtocolBuffers.Test/lib/Rhino.Mocks.dll
new file mode 100644
index 000000000..16ff5e82d
Binary files /dev/null and b/csharp/ProtocolBuffers.Test/lib/Rhino.Mocks.dll differ
diff --git a/csharp/ProtocolBuffers.Test/lib/Rhino.Mocks.xml b/csharp/ProtocolBuffers.Test/lib/Rhino.Mocks.xml
new file mode 100644
index 000000000..caace138f
--- /dev/null
+++ b/csharp/ProtocolBuffers.Test/lib/Rhino.Mocks.xml
@@ -0,0 +1,5062 @@
+
+
+
+ Rhino.Mocks
+
+
+
+
+ Interface for constraints
+
+
+
+
+ determains if the object pass the constraints
+
+
+
+
+ And operator for constraints
+
+
+
+
+ Not operator for constraints
+
+
+
+
+ Or operator for constraints
+
+
+
+
+ Allow overriding of || or &&
+
+
+
+
+
+
+ Allow overriding of || or &&
+
+
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Initializes a new constraint object.
+
+ The expected object, The actual object is passed in as a parameter to the method
+
+
+
+ Evaluate this constraint.
+
+ The actual object that was passed in the method call to the mock.
+ True when the constraint is met, else false.
+
+
+
+ Checks if the properties of the object
+ are the same as the properies of the object.
+
+ The expected object
+ The actual object
+ True when both objects have the same values, else False.
+
+
+
+
+
+
+
+
+ This is the real heart of the beast.
+
+
+
+ Used by CheckReferenceType to check all properties of the reference type.
+
+ The expected object
+ The actual object
+ True when both objects have the same values, else False.
+
+
+
+ Used by CheckReferenceType to check all fields of the reference type.
+
+ The expected object
+ The actual object
+ True when both objects have the same values, else False.
+
+
+
+ Checks the items of both collections
+
+ The expected collection
+
+ True if both collections contain the same items in the same order.
+
+
+
+ Builds a propertyname from the Stack _properties like 'Order.Product.Price'
+ to be used in the error message.
+
+ A nested property name.
+
+
+
+ Rhino.Mocks uses this property to generate an error message.
+
+
+ A message telling the tester why the constraint failed.
+
+
+
+
+ Constrain that the public field has a specified value
+
+
+
+
+ Constrain that the public field matches another constraint.
+
+
+
+
+ Creates a new instance.
+
+ Name of the public field.
+ Constraint to place on the public field value.
+
+
+
+ Creates a new instance, specifying a disambiguating
+ for the public field.
+
+ The type that declares the public field, used to disambiguate between public fields.
+ Name of the public field.
+ Constraint to place on the public field value.
+
+
+
+ Determines if the object passes the constraint.
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Creates a new instance.
+
+ Name of the public field.
+ Expected value.
+
+
+
+ Creates a new instance, specifying a disambiguating
+ for the public field.
+
+ The type that declares the public field, used to disambiguate between public fields.
+ Name of the public field.
+ Expected value.
+
+
+
+ Constrain that the property has a specified value
+
+
+
+
+ Constrain that the property matches another constraint.
+
+
+
+
+ Creates a new instance.
+
+ Name of the property.
+ Constraint to place on the property value.
+
+
+
+ Creates a new instance, specifying a disambiguating
+ for the property.
+
+ The type that declares the property, used to disambiguate between properties.
+ Name of the property.
+ Constraint to place on the property value.
+
+
+
+ Determines if the object passes the constraint.
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Creates a new instance.
+
+ Name of the property.
+ Expected value.
+
+
+
+ Creates a new instance, specifying a disambiguating
+ for the property.
+
+ The type that declares the property, used to disambiguate between properties.
+ Name of the property.
+ Expected value.
+
+
+
+ Constrain that the parameter must be of the specified type
+
+
+
+
+ Creates a new instance.
+
+ Type.
+
+
+
+ determains if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constraint that determines whether an object is the same object as another.
+
+
+
+
+ Creates a new instance.
+
+ Obj.
+
+
+
+ Determines if the object passes the constraints.
+
+
+
+
+ Gets the message for this constraint.
+
+
+
+
+ Evaluate a parameter using constraints
+
+
+
+
+ Create new instance
+
+
+
+
+
+ determains if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ A constraint based on lambda expression, we are using Expression{T}
+ because we want to be able to get good error reporting on that.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The expr.
+
+
+
+ determains if the object pass the constraints
+
+
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constrain that the list contains the same items as the parameter list
+
+
+
+
+ Creates a new instance.
+
+ In list.
+
+
+
+ determains if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constrain that the parameter is one of the items in the list
+
+
+
+
+ Creates a new instance.
+
+ In list.
+
+
+
+ determains if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constrain that the object is inside the parameter list
+
+
+
+
+ Creates a new instance.
+
+ In list.
+
+
+
+ determains if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Applies another AbstractConstraint to the collection count.
+
+
+
+
+ Creates a new instance.
+
+ The constraint that should be applied to the collection count.
+
+
+
+ Determines if the parameter conforms to this constraint.
+
+
+
+
+ Gets the message for this constraint.
+
+
+
+
+ Applies another AbstractConstraint to a specific list element.
+
+
+
+
+ Creates a new instance.
+
+ The zero-based index of the list element.
+ The constraint that should be applied to the list element.
+
+
+
+ Determines if the parameter conforms to this constraint.
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constrains that all elements are in the parameter list
+
+
+
+
+ Initializes a new instance of the class.
+
+ The these.
+
+
+
+ determains if the object pass the constraints
+
+
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Combines two constraints, constraint pass if either is fine.
+
+
+
+
+ Creates a new instance.
+
+ C1.
+ C2.
+
+
+
+ determains if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Negate a constraint
+
+
+
+
+ Creates a new instance.
+
+ C1.
+
+
+
+ determains if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Combines two constraints
+
+
+
+
+
+ Creates a new instance.
+
+ C1.
+ C2.
+
+
+
+ determains if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constrain the argument to validate according to regex pattern
+
+
+
+
+ Creates a new instance.
+
+ Pattern.
+
+
+
+ determains if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constraint that evaluate whatever an argument contains the specified string.
+
+
+
+
+ Creates a new instance.
+
+ Inner string.
+
+
+
+ determains if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constraint that evaluate whatever an argument ends with the specified string
+
+
+
+
+ Creates a new instance.
+
+ End.
+
+
+
+ determains if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constraint that evaluate whatever an argument start with the specified string
+
+
+
+
+ Creates a new instance.
+
+ Start.
+
+
+
+ determains if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constraint that evaluate whatever an object equals another
+
+
+
+
+ Creates a new instance.
+
+ Obj.
+
+
+
+ determains if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constraint that always returns true
+
+
+
+
+ determains if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constraint that evaluate whatever a comparable is greater than another
+
+
+
+
+ Creates a new instance.
+
+
+
+
+ determains if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Central location for constraints
+
+
+
+
+ Evaluate a greater than constraint for .
+
+ The object the parameter should be greater than
+
+
+
+ Evaluate a less than constraint for .
+
+ The object the parameter should be less than
+
+
+
+ Evaluate a less than or equal constraint for .
+
+ The object the parameter should be less than or equal to
+
+
+
+ Evaluate a greater than or equal constraint for .
+
+ The object the parameter should be greater than or equal to
+
+
+
+ Evaluate an equal constraint for .
+
+ The object the parameter should equal to
+
+
+
+ Evaluate a not equal constraint for .
+
+ The object the parameter should not equal to
+
+
+
+ Evaluate a same as constraint.
+
+ The object the parameter should the same as.
+
+
+
+ Evaluate a not same as constraint.
+
+ The object the parameter should not be the same as.
+
+
+
+ A constraints that accept anything
+
+
+
+
+
+ A constraint that accept only nulls
+
+
+
+
+
+ A constraint that accept only non null values
+
+
+
+
+
+ A constraint that accept only value of the specified type
+
+
+
+
+ A constraint that accept only value of the specified type
+
+
+
+
+ Evaluate a parameter using a predicate
+
+ The predicate to use
+
+
+
+ Provides access to the constraintes defined in the class to be used in context
+ with the syntax.
+
+ The type of the argument
+
+
+
+ Evaluate a greater than constraint for .
+
+ The object the parameter should be greater than
+
+
+
+ Evaluate a less than constraint for .
+
+ The object the parameter should be less than
+
+
+
+ Evaluate a less than or equal constraint for .
+
+ The object the parameter should be less than or equal to
+
+
+
+ Evaluate a greater than or equal constraint for .
+
+ The object the parameter should be greater than or equal to
+
+
+
+ Evaluate an equal constraint for .
+
+ The object the parameter should equal to
+
+
+
+ Evaluate a not equal constraint for .
+
+ The object the parameter should not equal to
+
+
+
+ Evaluate a same as constraint.
+
+ The object the parameter should the same as.
+
+
+
+ Evaluate a not same as constraint.
+
+ The object the parameter should not be the same as.
+
+
+
+ Throws NotSupportedException. Don't use Equals to define constraints. Use Equal instead.
+
+
+
+
+
+
+ Serves as a hash function for a particular type.
+
+
+ A hash code for the current .
+
+
+
+
+ A constraints that accept anything
+
+
+
+
+
+ A constraint that accept only nulls
+
+
+
+
+
+ A constraint that accept only non null values
+
+
+
+
+
+ A constraint that accept only value of the specified type.
+ The check is performed on the type that has been defined
+ as the argument type.
+
+
+
+
+ Central location for constraints about lists and collections
+
+
+
+
+ Determines whether the specified obj is in the paramter.
+ The parameter must be IEnumerable.
+
+ Obj.
+
+
+
+
+ Determains whatever the parameter is in the collection.
+
+
+
+
+ Determains that the parameter collection is identical to the specified collection
+
+
+
+
+ Determines that the parameter collection has the specified number of elements.
+
+ The constraint that should be applied to the collection count.
+
+
+
+ Determines that an element of the parameter collections conforms to another AbstractConstraint.
+
+ The zero-based index of the list element.
+ The constraint which should be applied to the list element.
+
+
+
+ Determines that all elements of the specified collection are in the the parameter collection
+
+ The collection to compare against
+ The constraint which should be applied to the list parameter.
+
+
+
+ Provides access to the constraintes defined in the class to be used in context
+ with the syntax.
+
+
+
+
+ Determines whether the specified object is in the paramter.
+ The parameter must be IEnumerable.
+
+ Obj.
+
+
+
+
+ Determains whatever the parameter is in the collection.
+
+
+
+
+ Determains that the parameter collection is identical to the specified collection
+
+
+
+
+ Determines that the parameter collection has the specified number of elements.
+
+ The constraint that should be applied to the collection count.
+
+
+
+ Determines that an element of the parameter collections conforms to another AbstractConstraint.
+
+ The zero-based index of the list element.
+ The constraint which should be applied to the list element.
+
+
+
+ Determines that all elements of the specified collection are in the the parameter collection
+
+ The collection to compare against
+ The constraint which should be applied to the list parameter.
+
+
+
+ Throws NotSupportedException. Don't use Equals to define constraints. Use Equal instead.
+
+
+
+
+
+
+ Serves as a hash function for a particular type.
+
+
+ A hash code for the current .
+
+
+
+
+ Provides a dummy field to pass as out or ref argument.
+
+
+
+
+
+ Dummy field to satisfy the compiler. Used for out and ref arguments.
+
+
+
+
+ Central location for constraints for object's properties
+
+
+
+
+ Constrains the parameter to have property with the specified value
+
+ Name of the property.
+ Expected value.
+
+
+
+
+ Constrains the parameter to have property with the specified value.
+
+ The type that declares the property, used to disambiguate between properties.
+ Name of the property.
+ Expected value.
+
+
+
+
+ Constrains the parameter to have a property satisfying a specified constraint.
+
+ Name of the property.
+ Constraint for the property.
+
+
+
+ Constrains the parameter to have a property satisfying a specified constraint.
+
+ The type that declares the property, used to disambiguate between properties.
+ Name of the property.
+ Constraint for the property.
+
+
+
+ Determines whether the parameter has the specified property and that it is null.
+
+ Name of the property.
+
+
+
+
+ Determines whether the parameter has the specified property and that it is null.
+
+ The type that declares the property, used to disambiguate between properties.
+ Name of the property.
+
+
+
+
+ Determines whether the parameter has the specified property and that it is not null.
+
+ Name of the property.
+
+
+
+
+ Determines whether the parameter has the specified property and that it is not null.
+
+ The type that declares the property, used to disambiguate between properties.
+ Name of the property.
+
+
+
+
+ constraints the parameter to have the exact same property values as the expected object.
+
+ An object, of the same type as the parameter, whose properties are set with the expected values.
+ An instance of the constraint that will do the actual check.
+
+ The parameter's public property values and public field values will be matched against the expected object's
+ public property values and public field values. The first mismatch will be reported and no further matching is done.
+ The matching is recursive for any property or field that has properties or fields of it's own.
+ Collections are supported through IEnumerable, which means the constraint will check if the actual and expected
+ collection contain the same values in the same order, where the values contained by the collection can have properties
+ and fields of their own that will be checked as well because of the recursive nature of this constraint.
+
+
+
+
+ Central location for constraints for object's public fields
+
+
+
+
+ Constrains the parameter to have a public field with the specified value
+
+ Name of the public field.
+ Expected value.
+
+
+
+
+ Constrains the parameter to have a public field with the specified value.
+
+ The type that declares the public field, used to disambiguate between public fields.
+ Name of the public field.
+ Expected value.
+
+
+
+
+ Constrains the parameter to have a public field satisfying a specified constraint.
+
+ Name of the public field.
+ Constraint for the public field.
+
+
+
+ Constrains the parameter to have a public field satisfying a specified constraint.
+
+ The type that declares the public field, used to disambiguate between public fields.
+ Name of the public field.
+ Constraint for the public field.
+
+
+
+ Determines whether the parameter has the specified public field and that it is null.
+
+ Name of the public field.
+
+
+
+
+ Determines whether the parameter has the specified public field and that it is null.
+
+ The type that declares the public field, used to disambiguate between public fields.
+ Name of the public field.
+
+
+
+
+ Determines whether the parameter has the specified public field and that it is not null.
+
+ Name of the public field.
+
+
+
+
+ Determines whether the parameter has the specified public field and that it is not null.
+
+ The type that declares the public field, used to disambiguate between public fields.
+ Name of the public field.
+
+
+
+
+ Central location for all text related constraints
+
+
+
+
+ Constrain the argument to starts with the specified string
+
+
+
+
+ Constrain the argument to end with the specified string
+
+
+
+
+ Constrain the argument to contain the specified string
+
+
+
+
+ Constrain the argument to validate according to regex pattern
+
+
+
+
+ Provides access to the constraintes defined in the class to be used in context
+ with the syntax.
+
+
+
+
+ Constrain the argument to starts with the specified string
+
+
+
+
+
+ Constrain the argument to end with the specified string
+
+
+
+
+ Constrain the argument to contain the specified string
+
+
+
+
+ Constrain the argument to validate according to regex pattern
+
+
+
+
+ Throws NotSupportedException. Don't use Equals to define constraints. Use Equal instead.
+
+
+
+
+
+
+ Serves as a hash function for a particular type.
+
+
+ A hash code for the current .
+
+
+
+
+ An expectaton violation was detected.
+
+
+
+
+ Creates a new instance.
+
+ Message.
+
+
+
+ Serialization constructor
+
+
+
+
+ Signals that an object was call on a mock repostiroy which doesn't
+ belong to this mock repository or not a mock
+
+
+
+
+ Creates a new instance.
+
+ Message.
+
+
+
+ Serialization constructor
+
+
+
+
+ Abstract class that holds common information for
+ expectations.
+
+
+
+
+ Interface to validate that a method call is correct.
+
+
+
+
+ Validate the arguments for the method.
+ This method can be called numerous times, so be careful about side effects
+
+ The arguments with which the method was called
+
+
+
+ Add an actual method call to this expectation
+
+
+
+
+ Returns the return value or throw the exception and setup any output / ref parameters
+ that has been set.
+
+
+
+
+ Allow to set the return value in the future, if it was already set.
+
+
+
+
+ Gets the error message.
+
+
+
+
+
+ Range of expected calls
+
+
+
+
+ Number of call actually made for this method
+
+
+
+
+ If this expectation is still waiting for calls.
+
+
+
+
+ The return value for a method matching this expectation
+
+
+
+
+ Gets or sets the exception to throw on a method matching this expectation.
+
+
+
+
+ Gets a value indicating whether this instance's action is staisfied.
+ A staisfied instance means that there are no more requirements from
+ this method. A method with non void return value must register either
+ a return value or an exception to throw.
+
+
+
+
+ Gets the method this expectation is for.
+
+
+
+
+ Gets or sets what special condtions there are for this method
+ repeating.
+
+
+
+
+ Gets a value indicating whether this expectation was satisfied
+
+
+
+
+ Specify whatever this expectation has a return value set
+ You can't check ReturnValue for this because a valid return value include null.
+
+
+
+
+ An action to execute when the method is matched.
+
+
+
+
+ Set the out / ref parameters for the method call.
+ The indexing is zero based and ignores any non out/ref parameter.
+ It is possible not to pass all the parameters. This method can be called only once.
+
+
+
+
+ Documentation Message
+
+
+
+
+ Gets the invocation for this expectation
+
+ The invocation.
+
+
+
+ Number of actuall calls made that passed this expectation
+
+
+
+
+ Range of expected calls that should pass this expectation.
+
+
+
+
+ The return value for a method matching this expectation
+
+
+
+
+ The exception to throw on a method matching this expectation.
+
+
+
+
+ The method this expectation is for.
+
+
+
+
+ The return value for this method was set
+
+
+
+
+ Whether this method will repeat
+ unlimited number of times.
+
+
+
+
+ A delegate that will be run when the
+ expectation is matched.
+
+
+
+
+ The arguments that matched this expectation.
+
+
+
+
+ Documentation message
+
+
+
+
+ The method originalInvocation
+
+
+
+
+ Get the hash code
+
+
+
+
+ Add an actual actualMethodCall call to this expectation
+
+
+
+
+ Allow to set the return value in the future, if it was already set.
+
+
+
+
+ Returns the return value or throw the exception and setup output / ref parameters
+
+
+
+
+ Validate the arguments for the method on the child methods
+
+ The arguments with which the method was called
+
+
+
+ Creates a new instance.
+
+ The originalInvocation for this method, required because it contains the generic type infromation
+
+
+
+ Creates a new instance.
+
+ Expectation.
+
+
+
+ Validate the arguments for the method on the child methods
+
+ The arguments with which the method was called
+
+
+
+ Determines if this object equal to obj
+
+
+
+
+ The error message for these arguments
+
+
+
+
+ Asserts that the delegate has the same parameters as the expectation's method call
+
+
+
+
+ Setter for the outpur / ref parameters for this expecataion.
+ Can only be set once.
+
+
+
+
+ Specify whatever this expectation has a return value set
+ You can't check ReturnValue for this because a valid return value include null.
+
+
+
+
+ Gets the method this expectation is for.
+
+
+
+
+ Gets the originalInvocation for this expectation
+
+ The originalInvocation.
+
+
+
+ Gets or sets what special condtions there are for this method
+
+
+
+
+ Range of expected calls
+
+
+
+
+ Number of call actually made for this method
+
+
+
+
+ If this expectation is still waiting for calls.
+
+
+
+
+ Gets a value indicating whether this expectation was satisfied
+
+
+
+
+ The return value for a method matching this expectation
+
+
+
+
+ An action to execute when the method is matched.
+
+
+
+
+ Gets or sets the exception to throw on a method matching this expectation.
+
+
+
+
+ Gets a value indicating whether this instance's action is staisfied.
+ A staisfied instance means that there are no more requirements from
+ this method. A method with non void return value must register either
+ a return value or an exception to throw or an action to execute.
+
+
+
+
+ Documentation message
+
+
+
+
+ Gets the error message.
+
+
+
+
+
+ Expectation that matchs any arguments for the method.
+
+
+
+
+ Creates a new instance.
+
+ Invocation for this expectation
+
+
+
+ Creates a new instance.
+
+ Expectation.
+
+
+
+ Validate the arguments for the method.
+
+ The arguments with which the method was called
+
+
+
+ Determines if the object equal to expectation
+
+
+
+
+ Get the hash code
+
+
+
+
+ Gets the error message.
+
+
+
+
+
+ Summary description for ArgsEqualExpectation.
+
+
+
+
+ Creates a new instance.
+
+ Expected args.
+ The invocation for this expectation
+
+
+
+ Validate the arguments for the method.
+
+ The arguments with which the method was called
+
+
+
+ Determines if the object equal to expectation
+
+
+
+
+ Get the hash code
+
+
+
+
+ Gets the error message.
+
+
+
+
+
+ Get the expected args.
+
+
+
+
+ Call a specified callback to verify the expectation
+
+
+
+
+ Creates a new instance.
+
+ Expectation.
+ Callback.
+
+
+
+ Creates a new instance.
+
+ Invocation for this expectation
+ Callback.
+
+
+
+ Validate the arguments for the method on the child methods
+
+ The arguments with which the method was called
+
+
+
+ Determines if the object equal to expectation
+
+
+
+
+ Get the hash code
+
+
+
+
+ Gets the error message.
+
+
+
+
+
+ Expect the method's arguments to match the contraints
+
+
+
+
+ Creates a new instance.
+
+ Invocation for this expectation
+ Constraints.
+
+
+
+ Creates a new instance.
+
+ Expectation.
+ Constraints.
+
+
+
+ Validate the arguments for the method.
+
+ The arguments with which the method was called
+
+
+
+ Determines if the object equal to expectation
+
+
+
+
+ Get the hash code
+
+
+
+
+ Gets the error message.
+
+
+
+
+
+ ExpectationsList
+
+
+
+
+ Dictionary
+
+
+
+
+ Dictionary class
+
+
+
+
+ Create a new instance of ProxyStateDictionary
+
+
+
+
+ Operation on a remoting proxy
+
+
+ It is not possible to directly communicate to a real proxy via transparent proxy.
+ Transparent proxy impersonates a user type and only methods of that user type are callable.
+ The only methods that are guaranteed to exist on any transparent proxy are methods defined
+ in Object: namely ToString(), GetHashCode(), and Equals()).
+
+ These three methods are the only way to tell the real proxy to do something.
+ Equals() is the most suitable of all, since it accepts an arbitrary object parameter.
+ The RemotingProxy code is built so that if it is compared to an IRemotingProxyOperation,
+ transparentProxy.Equals(operation) will call operation.Process(realProxy).
+ This way we can retrieve a real proxy from transparent proxy and perform
+ arbitrary operation on it.
+
+
+
+
+ Implementation of IInvocation based on remoting proxy
+
+ Some methods are marked NotSupported since they either don't make sense
+ for remoting proxies, or they are never called by Rhino Mocks
+
+
+
+ Generates remoting proxies and provides utility functions
+
+
+
+
+ Create the proxy using remoting
+
+
+
+
+ Check whether an object is a transparent proxy with a RemotingProxy behind it
+
+ Object to check
+ true if the object is a transparent proxy with a RemotingProxy instance behind it, false otherwise
+ We use Equals() method to communicate with the real proxy behind the object.
+ See IRemotingProxyOperation for more details
+
+
+
+ Retrieve a mocked object from a transparent proxy
+
+ Transparent proxy with a RemotingProxy instance behind it
+ Mocked object associated with the proxy
+ We use Equals() method to communicate with the real proxy behind the object.
+ See IRemotingProxyOperation for more details
+
+
+
+ Allows to call a method and immediatly get it's options.
+
+
+
+
+ Interface to allows to call a method and immediatly get it's options.
+
+
+
+
+ Get the method options for the call
+
+ The method call should go here, the return value is ignored
+
+
+
+ Creates a new instance.
+
+
+
+
+ Get the method options for the call
+
+ The method call should go here, the return value is ignored
+
+
+
+ Allows to call a method and immediatly get it's options.
+ Set the expected number for the call to Any()
+
+
+
+
+ Creates a new instance.
+
+ Proxy.
+ Mocked instance.
+
+
+
+ Get the method options for the call
+
+ The method call should go here, the return value is ignored
+
+
+
+ This class is reponsible for taking a delegate and creating a wrapper
+ interface around it, so it can be mocked.
+
+
+
+
+ The scope for all the delegate interfaces create by this mock repositroy.
+
+
+
+
+ Gets a type with an "Invoke" method suitable for use as a target of the
+ specified delegate type.
+
+
+
+
+
+
+ Raise events for all subscribers for an event
+
+
+
+
+ Raise events for all subscribers for an event
+
+
+
+
+ Raise the event
+
+
+
+
+ The most common form for the event handler signature
+
+
+
+
+ Create an event raise for the specified event on this instance.
+
+
+
+
+ Creates a new instance of EventRaiser
+
+
+
+
+ Raise the event
+
+
+
+
+ The most common signature for events
+ Here to allow intellisense to make better guesses about how
+ it should suggest parameters.
+
+
+
+
+ Allows to define what would happen when a method
+ is called.
+
+
+
+
+ Allows to define what would happen when a method
+ is called.
+
+
+
+
+ Set the return value for the method.
+
+ The object the method will return
+ IRepeat that defines how many times the method will return this value
+
+
+
+ Allow to override this return value in the future
+
+ IRepeat that defines how many times the method will return this value
+
+
+
+ Throws the specified exception when the method is called.
+
+ Exception to throw
+
+
+
+ Ignores the arguments for this method. Any argument will be matched
+ againt this method.
+
+
+
+
+ Add constraints for the method's arguments.
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Call the original method on the class, bypassing the mocking layers.
+
+
+
+
+
+ Call the original method on the class, optionally bypassing the mocking layers.
+
+
+
+
+
+ Use the property as a simple property, getting/setting the values without
+ causing mock expectations.
+
+
+
+
+ Get an event raiser for the last subscribed event.
+
+
+
+
+ Set the parameter values for out and ref parameters.
+ This is done using zero based indexing, and _ignoring_ any non out/ref parameter.
+
+
+
+
+ Documentation message for the expectation
+
+ Message
+
+
+
+ Better syntax to define repeats.
+
+
+
+
+ Allows to specify the number of time for method calls
+
+
+
+
+ Repeat the method twice.
+
+
+
+
+ Repeat the method once.
+
+
+
+
+ Repeat the method at least once, then repeat as many time as it would like.
+
+
+
+
+ Repeat the method any number of times.
+ This has special affects in that this method would now ignore orderring.
+
+
+
+
+ Set the range to repeat an action.
+
+ Min.
+ Max.
+
+
+
+ Set the amount of times to repeat an action.
+
+
+
+
+ This method must not appear in the replay state.
+ This has special affects in that this method would now ignore orderring.
+
+
+
+
+ Creates a new instance.
+
+ the repository for this expectation
+ the recorder for this proxy
+ the proxy for this expectation
+ Expectation.
+ If the expectation still can be replaced by a Constraint call
+
+
+
+ Add constraints for the method's arguments.
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set the return value for the method.
+
+ The object the method will return
+ IRepeat that defines how many times the method will return this value
+
+
+
+ Set the return value for the method, but allow to override this return value in the future
+
+ IRepeat that defines how many times the method will return this value
+
+
+
+ Throws the specified exception when the method is called.
+
+ Exception to throw
+
+
+
+ Ignores the arguments for this method. Any argument will be matched
+ againt this method.
+
+
+
+
+ Call the original method on the class, bypassing the mocking layers.
+
+
+
+
+
+ Call the original method on the class, optionally bypassing the mocking layers
+
+
+
+
+
+ Use the property as a simple property, getting/setting the values without
+ causing mock expectations.
+
+
+
+
+ Gets the event raiser for the last event
+
+
+
+
+ Set the parameter values for out and ref parameters.
+ This is done using zero based indexing, and _ignoring_ any non out/ref parameter.
+
+
+
+
+ Repeat the method twice.
+
+
+
+
+ Repeat the method once.
+
+
+
+
+ Repeat the method at least once, then repeat as many time as it would like.
+
+
+
+
+ This method must not appear in the replay state.
+
+
+
+
+ Documentation message for the expectation
+
+ Message
+
+
+
+ Repeat the method any number of times.
+
+
+
+
+ Set the range to repeat an action.
+
+ Min.
+ Max.
+
+
+
+ Set the amount of times to repeat an action.
+
+
+
+
+ Better syntax to define repeats.
+
+
+
+
+ This class will provide hash code for hashtables without needing
+ to call the GetHashCode() on the object, which may very well be mocked.
+ This class has no state so it is a singelton to avoid creating a lot of objects
+ that does the exact same thing. See flyweight patterns.
+
+
+
+
+ Get the hash code for a proxy object without calling GetHashCode()
+ on the object.
+
+
+
+
+ Compares two instances of mocked objects
+
+
+
+
+ Compare two mocked objects
+
+
+
+
+ The next hash code value for a mock object.
+ This is safe for multi threading.
+
+
+
+
+ The sole instance of
+
+
+
+
+ Doesn't log anything, just makes happy noises
+
+
+
+
+ Log expectations - allows to see what is going on inside Rhino Mocks
+
+
+
+
+ Logs the expectation as is was recorded
+
+ The invocation.
+ The expectation.
+
+
+
+ Logs the expectation as it was recorded
+
+ The invocation.
+ The expectation.
+
+
+
+ Logs the unexpected method call.
+
+ The invocation.
+ The message.
+
+
+
+ Logs the expectation as is was recorded
+
+ The invocation.
+ The expectation.
+
+
+
+ Logs the expectation as it was recorded
+
+ The invocation.
+ The expectation.
+
+
+
+ Logs the unexpected method call.
+
+ The invocation.
+ The message.
+
+
+
+ This is a dummy type that is used merely to give DynamicProxy the proxy instance that
+ it needs to create IProxy's types.
+
+
+
+
+ Interface to find the repository of a mocked object
+
+
+
+
+ Return true if it should call the original method on the object
+ instead of pass it to the message chain.
+
+ The method to call
+
+
+
+ Register a method to be called on the object directly
+
+
+
+
+ Register a property on the object that will behave as a simple property
+
+
+
+
+ Check if the method was registered as a property method.
+
+
+
+
+ Do get/set on the property, according to need.
+
+
+
+
+ Do add/remove on the event
+
+
+
+
+ Get the subscribers of a spesific event
+
+
+
+
+ Gets the declaring type of the method, taking into acccount the possible generic
+ parameters that it was created with.
+
+
+
+
+ Clears the state of the object, remove original calls, property behavior, subscribed events, etc.
+
+
+
+
+ Get all the method calls arguments that were made against this object with the specificed
+ method.
+
+
+ Only method calls in replay mode are counted
+
+
+
+
+ Records the method call
+
+
+
+
+ The unique hash code of this mock, which is not related
+ to the value of the GetHashCode() call on the object.
+
+
+
+
+ Gets the repository.
+
+
+
+
+ Gets the implemented types by this mocked object
+
+ The implemented.
+
+
+
+ Gets or sets the constructor arguments.
+
+ The constructor arguments.
+
+
+
+ Create a new instance of
+
+
+
+
+ Return true if it should call the original method on the object
+ instead of pass it to the message chain.
+
+ The method to call
+
+
+
+ Register a method to be called on the object directly
+
+
+
+
+ Register a property on the object that will behave as a simple property
+
+
+
+
+ Check if the method was registered as a property method.
+
+
+
+
+ Do get/set on the property, according to need.
+
+
+
+
+ Do add/remove on the event
+
+
+
+
+ Get the subscribers of a spesific event
+
+
+
+
+ Gets the declaring type of the method, taking into acccount the possible generic
+ parameters that it was created with.
+
+
+
+
+ Get all the method calls arguments that were made against this object with the specificed
+ method.
+
+
+
+
+ Only method calls in replay mode are counted
+
+
+
+
+ Records the method call
+
+
+
+
+
+
+ Clears the state of the object, remove original calls, property behavior, subscribed events, etc.
+
+
+
+
+ The unique hash code of this proxy, which is not related
+ to the value of the GetHashCode() call on the object.
+
+
+
+
+ Gets the repository.
+
+
+
+
+ Gets or sets the constructor arguments.
+
+ The constructor arguments.
+
+
+
+ Gets the implemented types by this mocked object
+
+ The implemented.
+
+
+
+ Range for expected method calls
+
+
+
+
+ Creates a new instance.
+
+ Min.
+ Max.
+
+
+
+ Return the string representation of this range.
+
+
+
+
+ Gets or sets the min.
+
+
+
+
+
+ Gets or sets the max.
+
+
+
+
+
+ Records all the expectations for a mock and
+ return a ReplayDynamicMockState when Replay()
+ is called.
+
+
+
+
+ Records all the expectations for a mock
+
+
+
+
+ Different actions on this mock
+
+
+
+
+ Add a method call for this state' mock.
+
+ The invocation for this method
+ The method that was called
+ The arguments this method was called with
+
+
+
+ Verify that this mock expectations have passed.
+
+
+
+
+ Verify that we can move to replay state and move
+ to the reply state.
+
+
+
+
+ Gets a mock state that match the original mock state of the object.
+
+
+
+
+ Get the options for the last method call
+
+
+
+
+ Set the exception to throw when Verify is called.
+ This is used to report exception that may have happened but where caught in the code.
+ This way, they are reported anyway when Verify() is called.
+
+
+
+
+ Gets the matching verify state for this state
+
+
+
+
+ Get the options for the last method call
+
+
+
+
+ Get the options for the last method call
+
+
+
+
+ Set the exception to throw when Verify is called.
+ This is used to report exception that may have happened but where caught in the code.
+ This way, they are reported anyway when Verify() is called.
+
+
+
+
+ Creates a new instance.
+
+ Repository.
+ The proxy that generates the method calls
+
+
+
+ Add a method call for this state' mock.
+
+ The invocation for this method
+ The method that was called
+ The arguments this method was called with
+
+
+
+ Verify that we can move to replay state and move
+ to the reply state.
+
+
+
+
+ Verify that we can move to replay state and move
+ to the reply state.
+
+
+
+
+ Verify that this mock expectations have passed.
+
+
+
+
+ Gets a mock state that match the original mock state of the object.
+
+
+
+
+ Asserts the previous method is closed (had an expectation set on it so we can replay it correctly)
+
+
+
+
+ Gets the last expectation.
+
+
+
+
+ Gets the total method calls count.
+
+
+
+
+ Get the options for the last method call
+
+
+
+
+ Gets the matching verify state for this state
+
+
+
+
+ Creates a new instance.
+
+ Repository.
+ The proxy that generates the method calls
+
+
+
+ Verify that we can move to replay state and move
+ to the reply state.
+
+
+
+
+ Gets a mock state that match the original mock state of the object.
+
+
+
+
+ Records all the expectations for a mock and
+ return a ReplayPartialMockState when Replay()
+ is called.
+
+
+
+
+ Creates a new instance.
+
+ Repository.
+ The proxy that generates the method calls
+
+
+
+ Verify that we can move to replay state and move
+ to the reply state.
+
+
+
+
+ Gets a mock state that match the original mock state of the object.
+
+
+
+
+ Options for special repeat option
+
+
+
+
+ This method can be called only as many times as the IMethodOptions.Expect allows.
+
+
+
+
+ This method should never be called
+
+
+
+
+ This method can be call any number of times
+
+
+
+
+ This method will call the original method
+
+
+
+
+ This method will call the original method, bypassing the mocking layer
+
+
+
+
+ This method will simulate simple property behavior
+
+
+
+
+ Validate all expectations on a mock and ignores calls to
+ any method that was not setup properly.
+
+
+
+
+ Validate all expectations on a mock
+
+
+
+
+ The repository for this state
+
+
+
+
+ The proxy object for this state
+
+
+
+
+ Get the options for the last method call
+
+
+
+
+ Creates a new instance.
+
+ The previous state for this method
+
+
+
+ Add a method call for this state' mock.
+
+ The invocation for this method
+ The method that was called
+ The arguments this method was called with
+
+
+
+ Add a method call for this state' mock.
+ This allows derived method to cleanly get a the setupresult behavior while adding
+ their own.
+
+ The invocation for this method
+ The method that was called
+ The arguments this method was called with
+
+
+
+ Set the exception to throw when Verify is called.
+ This is used to report exception that may have happened but where caught in the code.
+ This way, they are reported anyway when Verify() is called.
+
+
+
+
+ Verify that this mock expectations have passed.
+
+
+
+
+ Verify that we can move to replay state and move
+ to the reply state.
+
+
+
+
+ Gets a mock state that match the original mock state of the object.
+
+
+
+
+ Get the options for the last method call
+
+
+
+
+ Gets the matching verify state for this state
+
+
+
+
+ Creates a new instance.
+
+ The previous state for this method
+
+
+
+ Add a method call for this state' mock.
+
+ The invocation for this method
+ The method that was called
+ The arguments this method was called with
+
+
+
+ Gets a mock state that match the original mock state of the object.
+
+
+
+
+ Validate all expectations on a mock and ignores calls to
+ any method that was not setup properly.
+
+
+
+
+ Creates a new instance.
+
+ The previous state for this method
+
+
+
+ Add a method call for this state' mock.
+
+ The invocation for this method
+ The method that was called
+ The arguments this method was called with
+
+
+
+ Gets a mock state that match the original mock state of the object.
+
+
+
+
+ Summary description for RhinoInterceptor.
+
+
+
+
+ Creates a new instance.
+
+
+
+
+ Intercept a method call and direct it to the repository.
+
+
+
+
+ Behave like a stub, all properties and events acts normally, methods calls
+ return default values by default (but can use expectations to set them up), etc.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The proxy that generates the method calls
+ Repository.
+
+
+
+ We don't care much about expectations here, so we will remove the exepctation if
+ it is not closed.
+
+
+
+
+ Verify that we can move to replay state and move
+ to the reply state.
+
+
+
+
+
+ Validate expectations on recorded methods, but in general completely ignoring them.
+ Similar to except that it would return a
+ when BackToRecord is called.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The previous state for this method
+
+
+
+ Add a method call for this state' mock.
+
+ The invocation for this method
+ The method that was called
+ The arguments this method was called with
+
+
+
+ Gets a mock state that match the original mock state of the object.
+
+
+
+
+ Rudimetry implementation that simply logs methods calls as text.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The writer.
+
+
+
+ Logs the expectation as is was recorded
+
+ The invocation.
+ The expectation.
+
+
+
+ Logs the expectation as it was recorded
+
+ The invocation.
+ The expectation.
+
+
+
+ Logs the unexpected method call.
+
+ The invocation.
+ The message.
+
+
+
+ Write rhino mocks log info to the trace
+
+
+
+
+ Initializes a new instance of the class.
+
+
+
+
+ Initializes a new instance of the class.
+
+ if set to true [log recorded].
+ if set to true [log replayed].
+ if set to true [log unexpected].
+
+
+
+ Logs the expectation as is was recorded
+
+ The invocation.
+ The expectation.
+
+
+
+ Logs the expectation as it was recorded
+
+ The invocation.
+ The expectation.
+
+
+
+ Logs the unexpected method call.
+
+ The invocation.
+ The message.
+
+
+
+ Writes log information as stack traces about rhino mocks activity
+
+
+
+
+ Allows to redirect output to a different location.
+
+
+
+
+ Logs the expectation as is was recorded
+
+ The invocation.
+ The expectation.
+
+
+
+ Logs the expectation as it was recorded
+
+ The invocation.
+ The expectation.
+
+
+
+ Logs the unexpected method call.
+
+ The invocation.
+ The message.
+
+
+
+ Validate arguments for methods
+
+
+
+
+ Validate that the passed argument is not null.
+
+ The object to validate
+ The name of the argument
+
+ If the obj is null, an ArgumentNullException with the passed name
+ is thrown.
+
+
+
+
+ Validate that the arguments are equal.
+
+ Expected args.
+ Actual Args.
+
+
+
+ Validate that the two argument are equals, including validation for
+ when the arguments are collections, in which case it will validate their values.
+
+
+
+
+ This method is safe for use even if any of the objects is a mocked object
+ that override equals.
+
+
+
+
+ Throw an object already verified when accessed
+
+
+
+
+ Create a new instance of VerifiedMockState
+
+ The previous mock state, used to get the initial record state
+
+
+
+ Add a method call for this state' mock.
+
+ The invocation for this method
+ The method that was called
+ The arguments this method was called with
+
+
+
+ Verify that this mock expectations have passed.
+
+
+
+
+ Verify that we can move to replay state and move
+ to the reply state.
+
+
+
+
+ Gets a mock state that match the original mock state of the object.
+
+
+
+
+ Get the options for the last method call
+
+
+
+
+ Set the exception to throw when Verify is called.
+ This is used to report exception that may have happened but where caught in the code.
+ This way, they are reported anyway when Verify() is called.
+
+
+
+
+ Gets the matching verify state for this state
+
+
+
+
+ Get the options for the last method call
+
+
+
+
+ Records the actions on all the mocks created by a repository.
+
+
+
+
+ Records the specified call with the specified args on the mocked object.
+
+
+
+
+ Get the expectation for this method on this object with this arguments
+
+
+
+
+ This check the methods that were setup using the SetupResult.For()
+ or LastCall.Repeat.Any() and that bypass the whole expectation model.
+
+
+
+
+ Gets the all expectations for a mocked object and method combination,
+ regardless of the expected arguments / callbacks / contraints.
+
+ Mocked object.
+ Method.
+ List of all relevant expectation
+
+
+
+ Gets the all expectations for proxy.
+
+ Mocked object.
+ List of all relevant expectation
+
+
+
+ Removes all the repeatable expectations for proxy.
+
+ Mocked object.
+
+
+
+ Replaces the old expectation with the new expectation for the specified proxy/method pair.
+ This replace ALL expectations that equal to old expectations.
+
+ Proxy.
+ Method.
+ Old expectation.
+ New expectation.
+
+
+
+ Adds the recorder and turn it into the active recorder.
+
+ Recorder.
+
+
+
+ Moves to previous recorder.
+
+
+
+
+ Gets the recorded expectation or null.
+
+
+
+
+ Gets the next expected calls string.
+
+
+
+
+ Moves to parent recorder.
+
+
+
+
+ Set the expectation so it can repeat any number of times.
+
+
+
+
+ Removes the expectation from the recorder
+
+
+
+
+ Clear the replayer to call (and all its chain of replayers)
+ This also removes it from the list of expectations, so it will never be considered again
+
+
+
+
+ Get the expectation for this method on this object with this arguments
+
+
+
+
+ Gets a value indicating whether this instance has expectations that weren't satisfied yet.
+
+
+ true if this instance has expectations; otherwise, false.
+
+
+
+
+ Marker interface used to indicate that this is a partial mock.
+
+
+
+
+ Options for CallOriginalMethod
+
+
+
+
+ No expectation is created, the method will be called directly
+
+
+
+
+ Normal expectation is created, but when the method is later called, it will also call the original method
+
+
+
+
+ Base class for method recorders, handle delegating to inner recorder if needed.
+
+
+
+
+ List of the expected actions on for this recorder
+ The legal values are:
+ * Expectations
+ * Method Recorders
+
+
+
+
+ The current recorder.
+
+
+
+
+ The current replayer;
+
+
+
+
+ The parent recorder of this one, may be null.
+
+
+
+
+ This contains a list of all the replayers that should be ignored
+ for a spesific method call. A replayer gets into this list by calling
+ ClearReplayerToCall() on its parent. This list is Clear()ed on each new invocation.
+
+
+
+
+ All the repeatable methods calls.
+
+
+
+
+ Counts the recursion depth of the current expectation search stack
+
+
+
+
+ Creates a new instance.
+
+
+
+
+ Creates a new instance.
+
+ Parent recorder.
+ Repeatable methods
+
+
+
+ Records the specified call with the specified args on the mocked object.
+
+
+
+
+ Get the expectation for this method on this object with this arguments
+
+
+
+
+ Gets the all expectations for a mocked object and method combination,
+ regardless of the expected arguments / callbacks / contraints.
+
+ Mocked object.
+ Method.
+ List of all relevant expectation
+
+
+
+ Gets the all expectations for proxy.
+
+ Mocked object.
+ List of all relevant expectation
+
+
+
+ Replaces the old expectation with the new expectation for the specified proxy/method pair.
+ This replace ALL expectations that equal to old expectations.
+
+ Proxy.
+ Method.
+ Old expectation.
+ New expectation.
+
+
+
+ Remove the all repeatable expectations for proxy.
+
+ Mocked object.
+
+
+
+ Set the expectation so it can repeat any number of times.
+
+
+
+
+ Removes the expectation from the recorder
+
+
+
+
+ Adds the recorder and turn it into the active recorder.
+
+ Recorder.
+
+
+
+ Moves to previous recorder.
+
+
+
+
+ Moves to parent recorder.
+
+
+
+
+ Gets the recorded expectation or null.
+
+
+
+
+ Clear the replayer to call (and all its chain of replayers).
+ This also removes it from the list of expectations, so it will never be considered again
+
+
+
+
+ Get the expectation for this method on this object with this arguments
+
+
+
+
+ Gets the next expected calls string.
+
+
+
+
+ Handles the real getting of the recorded expectation or null.
+
+
+
+
+ Handle the real execution of this method for the derived class
+
+
+
+
+ Handle the real execution of this method for the derived class
+
+
+
+
+ Handle the real execution of this method for the derived class
+
+
+
+
+ Handle the real execution of this method for the derived class
+
+
+
+
+ Handle the real execution of this method for the derived class
+
+
+
+
+ Handle the real execution of this method for the derived class
+
+
+
+
+ Should this replayer be considered valid for this call?
+
+
+
+
+ This check the methods that were setup using the SetupResult.For()
+ or LastCall.Repeat.Any() and that bypass the whole expectation model.
+
+
+
+
+ Gets a value indicating whether this instance has expectations that weren't satisfied yet.
+
+
+ true if this instance has expectations; otherwise, false.
+
+
+
+
+ Handle the real execution of this method for the derived class
+
+
+
+
+ Ordered collection of methods, methods must arrive in specified order
+ in order to pass.
+
+
+
+
+ Unordered collection of method records, any expectation that exist
+ will be matched.
+
+
+
+
+ The parent recorder we have redirected to.
+ Useful for certain edge cases in orderring.
+ See: FieldProblem_Entropy for the details.
+
+
+
+
+ Creates a new instance.
+
+ Parent recorder.
+ Repeatable methods
+
+
+
+ Creates a new instance.
+
+
+
+
+ Records the specified call with the specified args on the mocked object.
+
+ Mocked object.
+ Method.
+ Expectation.
+
+
+
+ Get the expectation for this method on this object with this arguments
+
+ Invocation for this method
+ Mocked object.
+ Method.
+ Args.
+ True is the call was recorded, false otherwise
+
+
+
+ Gets the all expectations for a mocked object and method combination,
+ regardless of the expected arguments / callbacks / contraints.
+
+ Mocked object.
+ Method.
+ List of all relevant expectation
+
+
+
+ Gets the all expectations for proxy.
+
+ Mocked object.
+ List of all relevant expectation
+
+
+
+ Replaces the old expectation with the new expectation for the specified proxy/method pair.
+ This replace ALL expectations that equal to old expectations.
+
+ Proxy.
+ Method.
+ Old expectation.
+ New expectation.
+
+
+
+ Handle the real execution of this method for the derived class
+
+
+
+
+ Handles the real getting of the recorded expectation or null.
+
+
+
+
+ Handle the real execution of this method for the derived class
+
+
+
+
+ Gets the next expected calls string.
+
+
+
+
+ Create an exception for an unexpected method call.
+
+
+
+
+ Gets a value indicating whether this instance has expectations that weren't satisfied yet.
+
+
+ true if this instance has expectations; otherwise, false.
+
+
+
+
+ Creates a new instance.
+
+ Parent recorder.
+ Repetable methods
+
+
+
+ Creates a new instance.
+
+
+
+
+ Handles the real getting of the recorded expectation or null.
+
+
+
+
+ Get the expectation for this method on this object with this arguments
+
+
+
+
+ Gets the next expected calls string.
+
+
+
+
+ Hold an expectation for a method call on an object
+
+
+
+
+ Creates a new instance.
+
+ Proxy.
+ Method.
+ Expectation.
+
+
+
+ Determains if the object equal to this instance
+
+ Obj.
+
+
+
+
+ Gets the hash code.
+
+
+
+
+
+ Gets the proxy.
+
+
+
+
+
+ Gets the method.
+
+
+
+
+
+ Gets the expectation.
+
+
+
+
+
+ Holds a pair of mocked object and a method
+ and allows to compare them against each other.
+ This allows us to have a distinction between mockOne.MyMethod() and
+ mockTwo.MyMethod()...
+
+
+
+
+ Creates a new instance.
+
+ Proxy.
+ Method.
+
+
+
+ Determains whatever obj equals to this instance.
+ ProxyMethodPairs are equals when they point to the same /instance/ of
+ an object, and to the same method.
+
+ Obj.
+
+
+
+
+ Gets the hash code.
+
+
+
+
+
+ Gets the proxy.
+
+
+
+
+
+ Gets the method.
+
+
+
+
+
+ Change the recorder from ordered to unordered and vice versa
+
+
+
+
+ Creates a new instance.
+
+
+
+
+ Disposes this instance.
+
+
+
+
+ Utility class for dealing with messing generics scenarios.
+
+
+
+
+ There are issues with trying to get this to work correctly with open generic types, since this is an edge case,
+ I am letting the runtime handle it.
+
+
+
+
+ Gets the real type, including de-constructing and constructing the type of generic
+ methods parameters.
+
+ The type.
+ The invocation.
+
+
+
+
+ Because we need to support complex types here (simple generics were handled above) we
+ need to be aware of the following scenarios:
+ List[T] and List[Foo[T]]
+
+
+
+
+ Utility class for working with method calls.
+
+
+
+
+ Return the string representation of a method call and its arguments.
+
+ The method
+ The method arguments
+ Invocation of the method, used to get the generics arguments
+ Delegate to format the parameter
+ The string representation of this method call
+
+
+
+ Return the string representation of a method call and its arguments.
+
+ The invocation of the method, used to get the generic parameters
+ The method
+ The method arguments
+ The string representation of this method call
+
+
+
+ Delegate to format the argument for the string representation of
+ the method call.
+
+
+
+
+ Utility to get the default value for a type
+
+
+
+
+ The default value for a type.
+ Null for reference types and void
+ 0 for value types.
+ First element for enums
+ Note that we need to get the value even for opened generic types, such as those from
+ generic methods.
+
+ Type.
+ The invocation.
+ the default value
+
+
+
+ Defines constraints and return values for arguments of a mock.
+ Only use Arg inside a method call on a mock that is recording.
+ Example:
+ ExpectCall(
+ mock.foo(
+ Arg<int>.Is.GreaterThan(2),
+ Arg<string>.Is.Anything
+ ));
+ Use Arg.Text for string specific constraints
+ Use Arg<ListClass>.List for list specific constraints
+
+
+
+
+
+ Register the predicate as a constraint for the current call.
+
+ The predicate.
+ default(T)
+
+ Allow you to use code to create constraints
+
+ demo.AssertWasCalled(x => x.Bar(Arg{string}.Matches(a => a.StartsWith("b") && a.Contains("ba"))));
+
+
+
+
+
+ Define a complex constraint for this argument by passing several constraints
+ combined with operators. (Use Is in simple cases.)
+ Example: Arg<string>.Matches(Is.Equal("Hello") || Text.EndsWith("u"));
+
+ Constraints using Is, Text and List
+ Dummy to satisfy the compiler
+
+
+
+ Define a Ref argument.
+
+ Constraints for this argument
+ value returned by the mock
+
+
+
+
+ Define a out parameter. Use it together with the keyword out and use the
+ Dummy field available by the return value.
+ Example: mock.foo( out Arg<string>.Out("hello").Dummy );
+
+
+
+
+
+
+ Define a simple constraint for this argument. (Use Matches in simple cases.)
+ Example:
+ Arg<int>.Is.Anthing
+ Arg<string>.Is.Equal("hello")
+
+
+
+
+ Define Constraints on list arguments.
+
+
+
+
+ Use the Arg class (without generic) to define Text constraints
+
+
+
+
+ Define constraints on text arguments.
+
+
+
+
+ Used to manage the static state of the Arg<T> class"/>
+
+
+
+
+ Resets the static state
+
+
+
+
+ Returns return values for the out and ref parameters
+ Note: the array returned has the size of the number of out and ref
+ argument definitions
+
+
+
+
+
+ Returns the constraints for all arguments.
+ Out arguments have an Is.Anything constraint and are also in the list.
+
+
+
+
+
+ What should BackToRecord clear
+
+
+
+
+ Retain all expectations and behaviors and return to mock
+
+
+
+
+ All expectations
+
+
+
+
+ Event subscribers for this instance
+
+
+
+
+ Methods that should be forwarded to the base class implementation
+
+
+
+
+ Properties that should behave like properties
+
+
+
+
+ Remove all the behavior of the object
+
+
+
+
+ This class defines a lot of method signatures, which we will use
+ to allow compatability on net-2.0
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ Allows expectations to be set on methods that should never be called.
+ For methods with void return value, you need to use LastCall or
+ DoNotExpect.Call() with a delegate.
+
+
+
+
+ Sets LastCall.Repeat.Never() on /any/ proxy on /any/ repository on the current thread.
+ This method if not safe for multi threading scenarios.
+
+
+
+
+ Accepts a delegate that will execute inside the method which
+ LastCall.Repeat.Never() will be applied to.
+ It is expected to be used with anonymous delegates / lambda expressions and only one
+ method should be called.
+
+
+ IService mockSrv = mocks.CreateMock(typeof(IService)) as IService;
+ DoNotExpect.Call(delegate{ mockSrv.Stop(); });
+ ...
+
+
+
+
+ Allows to set expectation on methods that has return values.
+ For methods with void return value, you need to use LastCall
+
+
+
+
+ The method options for the last call on /any/ proxy on /any/ repository on the current thread.
+ This method if not safe for multi threading scenarios, use .
+
+
+
+
+ Accepts a delegate that will execute inside the method, and then return the resulting
+ instance.
+ It is expected to be used with anonymous delegates / lambda expressions and only one
+ method should be called.
+
+
+ IService mockSrv = mocks.CreateMock(typeof(IService)) as IService;
+ Expect.Call(delegate{ mockSrv.Start(); }).Throw(new NetworkException());
+ ...
+
+
+
+
+ Get the method options for the last method call on the mockInstance.
+
+
+
+
+ A delegate that can be used to get better syntax on Expect.Call(delegate { foo.DoSomething(); });
+
+
+
+
+ Allows to set various options for the last method call on
+ a specified object.
+ If the method has a return value, it's recommended to use Expect
+
+
+
+
+ Allows to get an interface to work on the last call.
+
+ The mocked object
+ Interface that allows to set options for the last method call on this object
+
+
+
+ Set the return value for the method.
+
+ The object the method will return
+ IRepeat that defines how many times the method will return this value
+
+
+
+ Set the return value for the method. This overload is needed for LastCall.Return(null)
+
+ The object the method will return
+ IRepeat that defines how many times the method will return this value
+
+
+
+ Throws the specified exception when the method is called.
+
+ Exception to throw
+
+
+
+ Ignores the arguments for this method. Any argument will be matched
+ againt this method.
+
+
+
+
+ Add constraints for the method's arguments.
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Call the original method on the class, bypassing the mocking layers, for the last call.
+
+
+
+
+ Call the original method on the class, optionally bypassing the mocking layers, for the last call.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Gets an interface that will raise the last event when called.
+
+
+
+
+ Set the parameter values for out and ref parameters.
+ This is done using zero based indexing, and _ignoring_ any non out/ref parameter.
+
+
+
+
+ Documentation message for the expectation
+
+ Message
+
+
+
+ Use the property as a simple property, getting/setting the values without
+ causing mock expectations.
+
+
+
+
+ Better syntax to define repeats.
+
+
+
+
+ Accessor for the current mocker
+
+
+
+
+ The current mocker
+
+
+
+
+ Creates proxied instances of types.
+
+
+ Adds optional new usage:
+ using(mockRepository.Record()) {
+ Expect.Call(mock.Method()).Return(retVal);
+ }
+ using(mockRepository.Playback()) {
+ // Execute code
+ }
+ N.B. mockRepository.ReplayAll() and mockRepository.VerifyAll()
+ calls are taken care of by Record/Playback
+
+
+
+
+ This is a map of types to ProxyGenerators.
+
+
+
+
+ This is used to record the last repository that has a method called on it.
+
+
+
+
+ this is used to get to the last proxy on this repository.
+
+
+
+
+ For mock delegates, maps the proxy instance from intercepted invocations
+ back to the delegate that was originally returned to client code, if any.
+
+
+
+
+ All the proxies in the mock repositories
+
+
+
+
+ This is here because we can't put it in any of the recorders, since repeatable methods
+ have no orderring, and if we try to handle them using the usual manner, we would get into
+ wierd situations where repeatable method that was defined in an orderring block doesn't
+ exists until we enter this block.
+
+
+
+
+ Creates a new instance.
+
+
+
+
+ Move the repository to ordered mode
+
+
+
+
+ Move the repository to un-ordered mode
+
+
+
+
+ Creates a mock for the specified type.
+
+ Type.
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Creates a strict mock for the specified type.
+
+ Type.
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Creates a remoting mock for the specified type.
+
+ Type.
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Creates a strict remoting mock for the specified type.
+
+ Type.
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Creates a remoting mock for the specified type.
+
+
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+
+ Creates a strict remoting mock for the specified type.
+
+
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+
+ Creates a mock from several types, with strict semantics.
+ Only may be a class.
+
+
+
+
+ Creates a strict mock from several types, with strict semantics.
+ Only may be a class.
+
+
+
+
+ Creates a mock from several types, with strict semantics.
+ Only may be a class.
+
+ The main type to mock.
+ Extra interface types to mock.
+ Arguments for the class' constructor, if mocking a concrete class.
+
+
+
+ Creates a strict mock from several types, with strict semantics.
+ Only may be a class.
+
+ The main type to mock.
+ Extra interface types to mock.
+ Arguments for the class' constructor, if mocking a concrete class.
+
+
+
+ Creates a mock from several types, with dynamic semantics.
+ Only may be a class.
+
+ The main type to mock.
+ Extra interface types to mock.
+
+
+
+ Creates a mock from several types, with dynamic semantics.
+ Only may be a class.
+
+ The main type to mock.
+ Extra interface types to mock.
+ Arguments for the class' constructor, if mocking a concrete class.
+
+
+
+ Creates a dynamic mock for the specified type.
+
+ Type.
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Creates a dynamic mock for the specified type.
+
+ Type.
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Creates a dynamic mock for the specified type.
+
+
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+
+ Creates a mock object that defaults to calling the class methods.
+
+ Type.
+ Arguments for the class' constructor.
+
+
+
+ Creates a mock object that defaults to calling the class methods.
+
+ Type.
+ Extra interface types to mock.
+
+
+
+ Creates a mock object that defaults to calling the class methods.
+
+ Type.
+ Extra interface types to mock.
+ Arguments for the class' constructor.
+
+
+
+ Creates a mock object using remoting proxies
+
+ Type to mock - must be MarshalByRefObject
+ Mock object
+ Proxy mock can mock non-virtual methods, but not static methods
+ Creates the mock state for this proxy
+
+
+
+ Cause the mock state to change to replay, any further call is compared to the
+ ones that were called in the record state.
+
+ the object to move to replay state
+
+
+
+ Cause the mock state to change to replay, any further call is compared to the
+ ones that were called in the record state.
+
+ the object to move to replay state
+
+
+
+
+ Move the mocked object back to record state.
+ Will delete all current expectations!
+
+
+
+
+ Move the mocked object back to record state.
+ Optionally, can delete all current expectations, but allows more granularity about how
+ it would behave with regard to the object state.
+
+
+
+
+ Verify that all the expectations for this object were fulfilled.
+
+ the object to verify the expectations for
+
+
+
+ Get the method options for the last call on
+ mockedInstance.
+
+ The mock object
+ Method options for the last call
+
+
+
+ Maps an invocation proxy back to the mock object instance that was originally
+ returned to client code which might have been a delegate to this proxy.
+
+ The mock object proxy from the intercepted invocation
+ The mock object
+
+
+
+ This is provided to allow advance extention functionality, where Rhino Mocks standard
+ functionality is not enough.
+
+ The type to mock
+ Delegate that create the first state of the mocked object (usualy the record state).
+ Additional types to be implemented, this can be only interfaces
+ optional arguments for the constructor
+
+
+
+
+ Method: GetMockedObject
+ Get an IProxy from a mocked object instance, or throws if the
+ object is not a mock object.
+
+
+
+
+ Method: GetMockedObjectOrNull
+ Get an IProxy from a mocked object instance, or null if the
+ object is not a mock object.
+
+
+
+
+ Pops the recorder.
+
+
+
+
+ Pushes the recorder.
+
+ New recorder.
+
+
+
+ All the mock objects in this repository will be moved
+ to record state.
+
+
+
+
+ All the mock objects in this repository will be moved
+ to record state.
+
+
+
+
+ Replay all the mocks from this repository
+
+
+
+
+ Verify all the mocks from this repository
+
+
+
+
+ Gets the proxy generator for a specific type. Having a single ProxyGenerator
+ with multiple types linearly degrades the performance so this implementation
+ keeps one ProxyGenerator per type.
+
+
+
+
+ Set the exception to be thrown when verified is called.
+
+
+
+
+ Creates a mock for the spesified type.
+
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Creates a strict mock for the spesified type.
+
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Creates a dynamic mock for the specified type.
+
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Creates a mock object from several types.
+
+
+
+
+ Creates a strict mock object from several types.
+
+
+
+
+ Create a mock object from several types with dynamic semantics.
+
+
+
+
+ Create a mock object from several types with partial semantics.
+
+
+
+
+ Create a mock object from several types with strict semantics.
+
+ Extra interface types to mock.
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Create a strict mock object from several types with strict semantics.
+
+ Extra interface types to mock.
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Create a mock object from several types with dynamic semantics.
+
+ Extra interface types to mock.
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Create a mock object from several types with partial semantics.
+
+ Extra interface types to mock.
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Create a mock object with from a class that defaults to calling the class methods
+
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Create a stub object, one that has properties and events ready for use, and
+ can have methods called on it. It requires an explicit step in order to create
+ an expectation for a stub.
+
+ The arguments for constructor.
+
+
+
+ Create a stub object, one that has properties and events ready for use, and
+ can have methods called on it. It requires an explicit step in order to create
+ an expectation for a stub.
+
+ The type.
+ The arguments for constructor.
+
+
+
+
+ Generates a stub without mock repository
+
+ The arguments for constructor.
+
+
+
+
+ Generates the stub without mock repository
+
+ The type.
+ The arguments for constructor.
+
+
+
+ Returns true if the passed mock is currently in replay mode.
+
+ The mock to test.
+ True if the mock is in replay mode, false otherwise.
+
+
+
+ Generate a mock object without needing the mock repository
+
+
+
+
+ Determines whether the specified proxy is a stub.
+
+ The proxy.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Gets the recorder.
+
+
+
+
+
+ Gets the replayer for this repository.
+
+
+
+
+
+ Gets the last proxy which had a method call.
+
+
+
+
+ Delegate: CreateMockState
+ This is used internally to cleanly handle the creation of different
+ RecordMockStates.
+
+
+
+
+ Used for [assembly: InternalsVisibleTo(RhinoMocks.StrongName)]
+ Used for [assembly: InternalsVisibleTo(RhinoMocks.NormalName)]
+
+
+
+
+ Strong name for the Dynamic Proxy assemblies. Used for InternalsVisibleTo specification.
+
+
+
+
+ Normal name for dynamic proxy assemblies. Used for InternalsVisibleTo specification.
+
+
+
+
+ Logs all method calls for methods
+
+
+
+
+ A set of extension methods that adds Arrange Act Assert mode to Rhino Mocks
+
+
+
+
+ Create an expectation on this mock for this action to occur
+
+
+ The mock.
+ The action.
+
+
+
+
+ Reset all expectations on this mock object
+
+
+ The mock.
+
+
+
+ Reset the selected expectation on this mock object
+
+
+ The mock.
+ The options to reset the expectations on this mock.
+
+
+
+ Cause the mock state to change to replay, any further call is compared to the
+ ones that were called in the record state.
+
+ the mocked object to move to replay state
+
+
+
+ Gets the mock repository for this specificied mock object
+
+
+ The mock.
+
+
+
+
+ Create an expectation on this mock for this action to occur
+
+
+
+ The mock.
+ The action.
+
+
+
+
+ Tell the mock object to perform a certain action when a matching
+ method is called.
+ Does not create an expectation for this method.
+
+
+ The mock.
+ The action.
+
+
+
+
+ Tell the mock object to perform a certain action when a matching
+ method is called.
+ Does not create an expectation for this method.
+
+
+
+ The mock.
+ The action.
+
+
+
+
+ Gets the arguments for calls made on this mock object and the method that was called
+ in the action.
+
+
+ The mock.
+ The action.
+
+
+ Here we will get all the arguments for all the calls made to DoSomething(int)
+
+ var argsForCalls = foo54.GetArgumentsForCallsMadeOn(x => x.DoSomething(0))
+
+
+
+
+
+ Gets the arguments for calls made on this mock object and the method that was called
+ in the action and matches the given constraints
+
+
+ The mock.
+ The action.
+ The setup constraints.
+
+
+ Here we will get all the arguments for all the calls made to DoSomething(int)
+
+ var argsForCalls = foo54.GetArgumentsForCallsMadeOn(x => x.DoSomething(0))
+
+
+
+
+
+ Asserts that a particular method was called on this mock object
+
+
+ The mock.
+ The action.
+
+
+
+ Asserts that a particular method was called on this mock object that match
+ a particular constraint set.
+
+
+ The mock.
+ The action.
+ The setup constraints.
+
+
+
+ Asserts that a particular method was NOT called on this mock object
+
+
+ The mock.
+ The action.
+
+
+
+ Asserts that a particular method was NOT called on this mock object that match
+ a particular constraint set.
+
+
+ The mock.
+ The action.
+ The setup constraints.
+
+
+
+ Verifies all expectations on this mock object
+
+ The mock object.
+
+
+
+ Gets the event raiser for the event that was called in the action passed
+
+ The type of the event source.
+ The mock object.
+ The event subscription.
+
+
+
+
+ Raise the specified event using the passed arguments.
+ The even is extracted from the passed labmda
+
+ The type of the event source.
+ The mock object.
+ The event subscription.
+ The sender.
+ The instance containing the event data.
+
+
+
+ Raise the specified event using the passed arguments.
+ The even is extracted from the passed labmda
+
+ The type of the event source.
+ The mock object.
+ The event subscription.
+ The args.
+
+
+
+ Fake type that disallow creating it.
+ Should have been System.Type, but we can't use it.
+
+
+
+
+ Setup method calls to repeat any number of times.
+
+
+
+
+ Get the method options and set the last method call to repeat
+ any number of times.
+ This also means that the method would transcend ordering
+
+
+
+
+ Get the method options for the last method call on the mockInstance and set it
+ to repeat any number of times.
+ This also means that the method would transcend ordering
+
+
+
+
+ Allows easier access to MockRepository, works closely with Mocker.Current to
+ allow access to a context where the mock repository is automatially verified at
+ the end of the code block.
+
+
+
+
+ Initialize a code block where Mocker.Current is initialized.
+ At the end of the code block, all the expectation will be verified.
+ This overload will create a new MockRepository.
+
+ The code that will be executed under the mock context
+
+
+
+ Initialize a code block where Mocker.Current is initialized.
+ At the end of the code block, all the expectation will be verified.
+ This overload will create a new MockRepository.
+
+ The mock repository to use, at the end of the code block, VerifyAll() will be called on the repository.
+ The code that will be executed under the mock context
+
+
+
+ Create a FluentMocker
+
+ The mock repository to use.
+
+
+
+ A method with no arguments and no return value that will be called under the mock context.
+
+
+
+
+ FluentMocker implements some kind of fluent interface attempt
+ for saying "With the Mocks [mocks], Expecting (in same order) [things] verify [that]."
+
+
+
+
+ Interface to verify previously defined expectations
+
+
+
+
+ Verifies if a piece of code
+
+
+
+
+ Defines unordered expectations
+
+ A delegate describing the expectations
+ an IMockVerifier
+
+
+
+ Defines ordered expectations
+
+ A delegate describing the expectations
+ an IMockVerifier
+
+
+
+ Verifies previously defined expectations
+
+
+
+
diff --git a/csharp/ProtocolBuffers.Test/lib/nunit.framework.dll b/csharp/ProtocolBuffers.Test/lib/nunit.framework.dll
new file mode 100644
index 000000000..3c401e69e
Binary files /dev/null and b/csharp/ProtocolBuffers.Test/lib/nunit.framework.dll differ
diff --git a/csharp/ProtocolBuffers/ByteString.cs b/csharp/ProtocolBuffers/ByteString.cs
new file mode 100644
index 000000000..1ce2453e3
--- /dev/null
+++ b/csharp/ProtocolBuffers/ByteString.cs
@@ -0,0 +1,96 @@
+using System.Text;
+using System;
+
+namespace Google.ProtocolBuffers {
+ ///
+ /// Immutable array of bytes.
+ /// TODO(jonskeet): Implement the common collection interfaces?
+ ///
+ public sealed class ByteString {
+
+ private static readonly ByteString empty = new ByteString(new byte[0]);
+
+ private byte[] bytes;
+
+ ///
+ /// Constructs a new ByteString from the given byte array. The array is
+ /// *not* copied, and must not be modified after this constructor is called.
+ ///
+ private ByteString(byte[] bytes) {
+ this.bytes = bytes;
+ }
+
+ ///
+ /// Returns an empty ByteString.
+ ///
+ public static ByteString Empty {
+ get { return empty; }
+ }
+
+ ///
+ /// Returns the length of this ByteString in bytes.
+ ///
+ public int Length {
+ get { return bytes.Length; }
+ }
+
+ public bool IsEmpty {
+ get { return Length == 0; }
+ }
+
+ public byte[] ToByteArray() {
+ return (byte[])bytes.Clone();
+ }
+
+ ///
+ /// Constructs a ByteString from the given array. The contents
+ /// are copied, so further modifications to the array will not
+ /// be reflected in the returned ByteString.
+ ///
+ public static ByteString CopyFrom(byte[] bytes) {
+ return new ByteString((byte[]) bytes.Clone());
+ }
+
+ ///
+ /// Constructs a ByteString from a portion of a byte array.
+ ///
+ public static ByteString CopyFrom(byte[] bytes, int offset, int count) {
+ byte[] portion = new byte[count];
+ Array.Copy(bytes, offset, portion, 0, count);
+ return new ByteString(portion);
+ }
+
+ ///
+ /// Creates a new ByteString by encoding the specified text with
+ /// the given encoding.
+ ///
+ public static ByteString CopyFrom(string text, Encoding encoding) {
+ return new ByteString(encoding.GetBytes(text));
+ }
+
+ ///
+ /// Creates a new ByteString by encoding the specified text in UTF-8.
+ ///
+ public static ByteString CopyFromUtf8(string text) {
+ return CopyFrom(text, Encoding.UTF8);
+ }
+
+ ///
+ /// Retuns the byte at the given index.
+ ///
+ public byte this[int index] {
+ get { return bytes[index]; }
+ }
+
+ public string ToString(Encoding encoding) {
+ return encoding.GetString(bytes);
+ }
+
+ public string ToStringUtf8() {
+ return ToString(Encoding.UTF8);
+ }
+
+ // TODO(jonskeet): CopyTo, Equals, GetHashCode if they turn out to be required
+ // TODO(jonskeet): Input/Output stuff
+ }
+}
diff --git a/csharp/ProtocolBuffers/CodedInputStream.cs b/csharp/ProtocolBuffers/CodedInputStream.cs
new file mode 100644
index 000000000..66dae52c4
--- /dev/null
+++ b/csharp/ProtocolBuffers/CodedInputStream.cs
@@ -0,0 +1,31 @@
+
+namespace Google.ProtocolBuffers {
+ public sealed class CodedInputStream {
+
+ ///
+ /// Decode a 32-bit value with ZigZag encoding.
+ ///
+ ///
+ /// ZigZag encodes signed integers into values that can be efficiently
+ /// encoded with varint. (Otherwise, negative values must be
+ /// sign-extended to 64 bits to be varint encoded, thus always taking
+ /// 10 bytes on the wire.)
+ ///
+ public static int DecodeZigZag32(uint n) {
+ return (int)(n >> 1) ^ -(int)(n & 1);
+ }
+
+ ///
+ /// Decode a 32-bit value with ZigZag encoding.
+ ///
+ ///
+ /// ZigZag encodes signed integers into values that can be efficiently
+ /// encoded with varint. (Otherwise, negative values must be
+ /// sign-extended to 64 bits to be varint encoded, thus always taking
+ /// 10 bytes on the wire.)
+ ///
+ public static long DecodeZigZag64(ulong n) {
+ return (long)(n >> 1) ^ -(long)(n & 1);
+ }
+ }
+}
diff --git a/csharp/ProtocolBuffers/CodedOutputStream.cs b/csharp/ProtocolBuffers/CodedOutputStream.cs
new file mode 100644
index 000000000..51d5d6575
--- /dev/null
+++ b/csharp/ProtocolBuffers/CodedOutputStream.cs
@@ -0,0 +1,708 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.
+// http://code.google.com/p/protobuf/
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+using System;
+using System.IO;
+using System.Text;
+
+namespace Google.ProtocolBuffers {
+
+ ///
+ /// Encodes and writes protocol message fields.
+ ///
+ ///
+ /// This class contains two kinds of methods: methods that write specific
+ /// protocol message constructs and field types (e.g. WriteTag and
+ /// WriteInt32) and methods that write low-level values (e.g.
+ /// WriteRawVarint32 and WriteRawBytes). If you are writing encoded protocol
+ /// messages, you should use the former methods, but if you are writing some
+ /// other format of your own design, use the latter. The names of the former
+ /// methods are taken from the protocol buffer type names, not .NET types.
+ /// (Hence WriteFloat instead of WriteSingle, and WriteBool instead of WriteBoolean.)
+ ///
+ public sealed class CodedOutputStream {
+ ///
+ /// The buffer size used by CreateInstance(Stream).
+ ///
+ public static readonly int DefaultBufferSize = 4096;
+
+ private readonly byte[] buffer;
+ private readonly int limit;
+ private int position;
+ private readonly Stream output;
+
+ #region Construction
+ private CodedOutputStream(byte[] buffer, int offset, int length) {
+ this.output = null;
+ this.buffer = buffer;
+ this.position = offset;
+ this.limit = offset + length;
+ }
+
+ private CodedOutputStream(Stream output, byte[] buffer) {
+ this.output = output;
+ this.buffer = buffer;
+ this.position = 0;
+ this.limit = buffer.Length;
+ }
+
+ ///
+ /// Creates a new CodedOutputStream which write to the given stream.
+ ///
+ public static CodedOutputStream CreateInstance(Stream output) {
+ return CreateInstance(output, DefaultBufferSize);
+ }
+
+ ///
+ /// Creates a new CodedOutputStream which write to the given stream and uses
+ /// the specified buffer size.
+ ///
+ public static CodedOutputStream CreateInstance(Stream output, int bufferSize) {
+ return new CodedOutputStream(output, new byte[bufferSize]);
+ }
+
+ ///
+ /// Creates a new CodedOutputStream that writes directly to the given
+ /// byte array. If more bytes are written than fit in the array,
+ /// OutOfSpaceException will be thrown.
+ ///
+ public static CodedOutputStream CreateInstance(byte[] flatArray) {
+ return CreateInstance(flatArray, 0, flatArray.Length);
+ }
+
+ ///
+ /// Creates a new CodedOutputStream that writes directly to the given
+ /// byte array slice. If more bytes are written than fit in the array,
+ /// OutOfSpaceException will be thrown.
+ ///
+ public static CodedOutputStream CreateInstance(byte[] flatArray, int offset, int length) {
+ return new CodedOutputStream(flatArray, offset, length);
+ }
+ #endregion
+
+ #region Writing of tags etc
+ ///
+ /// Writes a double field value, including tag, to the stream.
+ ///
+ public void WriteDouble(int fieldNumber, double value) {
+ WriteTag(fieldNumber, WireFormat.WireType.Fixed64);
+ WriteRawLittleEndian64(BitConverter.DoubleToInt64Bits(value));
+ }
+
+ ///
+ /// Writes a float field value, including tag, to the stream.
+ ///
+ public void WriteFloat(int fieldNumber, float value) {
+ WriteTag(fieldNumber, WireFormat.WireType.Fixed32);
+ // FIXME: How do we convert a single to 32 bits? (Without unsafe code)
+ //WriteRawLittleEndian32(BitConverter.SingleT(value));
+ }
+
+ ///
+ /// Writes a uint64 field value, including tag, to the stream.
+ ///
+ public void WriteUInt64(int fieldNumber, ulong value) {
+ WriteTag(fieldNumber, WireFormat.WireType.Varint);
+ WriteRawVarint64(value);
+ }
+
+ ///
+ /// Writes an int64 field value, including tag, to the stream.
+ ///
+ public void WriteInt64(int fieldNumber, long value) {
+ WriteTag(fieldNumber, WireFormat.WireType.Varint);
+ WriteRawVarint64((ulong)value);
+ }
+
+ ///
+ /// Writes an int32 field value, including tag, to the stream.
+ ///
+ public void WriteInt32(int fieldNumber, int value) {
+ WriteTag(fieldNumber, WireFormat.WireType.Varint);
+ if (value >= 0) {
+ WriteRawVarint32((uint)value);
+ } else {
+ // Must sign-extend.
+ WriteRawVarint64((ulong)value);
+ }
+ }
+
+ ///
+ /// Writes a fixed64 field value, including tag, to the stream.
+ ///
+ public void WriteFixed64(int fieldNumber, long value) {
+ WriteTag(fieldNumber, WireFormat.WireType.Fixed64);
+ WriteRawLittleEndian64(value);
+ }
+
+ ///
+ /// Writes a fixed32 field value, including tag, to the stream.
+ ///
+ public void WriteFixed32(int fieldNumber, int value) {
+ WriteTag(fieldNumber, WireFormat.WireType.Fixed32);
+ WriteRawLittleEndian32(value);
+ }
+
+ ///
+ /// Writes a bool field value, including tag, to the stream.
+ ///
+ public void WriteBool(int fieldNumber, bool value) {
+ WriteTag(fieldNumber, WireFormat.WireType.Varint);
+ WriteRawByte(value ? (byte)1 : (byte)0);
+ }
+
+ ///
+ /// Writes a string field value, including tag, to the stream.
+ ///
+ public void WriteString(int fieldNumber, string value) {
+ WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
+ // TODO(jonskeet): Optimise this if possible
+ // Unfortunately there does not appear to be any way to tell Java to encode
+ // UTF-8 directly into our buffer, so we have to let it create its own byte
+ // array and then copy. In .NET we can do the same thing very easily,
+ // so we don't need to worry about only writing one buffer at a time.
+ // We can optimise later.
+ byte[] bytes = Encoding.UTF8.GetBytes(value);
+ WriteRawVarint32((uint)bytes.Length);
+ WriteRawBytes(bytes);
+ }
+
+ ///
+ /// Writes a group field value, including tag, to the stream.
+ ///
+ public void WriteGroup(int fieldNumber, IMessage value) {
+ WriteTag(fieldNumber, WireFormat.WireType.StartGroup);
+ value.WriteTo(this);
+ WriteTag(fieldNumber, WireFormat.WireType.EndGroup);
+ }
+
+ public void WriteUnknownGroup(int fieldNumber, UnknownFieldSet value) {
+ WriteTag(fieldNumber, WireFormat.WireType.StartGroup);
+ value.WriteTo(this);
+ WriteTag(fieldNumber, WireFormat.WireType.EndGroup);
+ }
+
+ public void WriteMessage(int fieldNumber, IMessage value) {
+ WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
+ WriteRawVarint32((uint)value.SerializedSize);
+ value.WriteTo(this);
+ }
+
+ public void WriteBytes(int fieldNumber, ByteString value) {
+ // TODO(jonskeet): Optimise this! (No need to copy the bytes twice.)
+ byte[] bytes = value.ToByteArray();
+ WriteRawVarint32((uint)bytes.Length);
+ WriteRawBytes(bytes);
+ }
+
+ public void WriteUInt32(int fieldNumber, uint value) {
+ WriteTag(fieldNumber, WireFormat.WireType.Varint);
+ WriteRawVarint32(value);
+ }
+
+ public void WriteEnum(int fieldNumber, int value) {
+ WriteTag(fieldNumber, WireFormat.WireType.Varint);
+ WriteRawVarint32((uint)value);
+ }
+
+ public void WriteSFixed32(int fieldNumber, int value) {
+ WriteTag(fieldNumber, WireFormat.WireType.Fixed32);
+ WriteRawVarint32((uint)value);
+ }
+
+ public void WriteSFixed64(int fieldNumber, long value) {
+ WriteTag(fieldNumber, WireFormat.WireType.Fixed64);
+ WriteRawVarint64((ulong)value);
+ }
+
+ public void WriteSInt32(int fieldNumber, int value) {
+ WriteTag(fieldNumber, WireFormat.WireType.Varint);
+ WriteRawVarint32(EncodeZigZag32(value));
+ }
+
+ public void WriteSInt64(int fieldNumber, long value) {
+ WriteTag(fieldNumber, WireFormat.WireType.Varint);
+ WriteRawVarint64(EncodeZigZag64(value));
+ }
+
+ public void WriteMessageSetExtension(int fieldNumber, IMessage value) {
+ WriteTag(WireFormat.MessageSetField.Item, WireFormat.WireType.StartGroup);
+ WriteUInt32(WireFormat.MessageSetField.TypeID, (uint)fieldNumber);
+ WriteMessage(WireFormat.MessageSetField.Message, value);
+ WriteTag(WireFormat.MessageSetField.Item, WireFormat.WireType.EndGroup);
+ }
+
+ public void WriteRawMessageSetExtension(int fieldNumber, ByteString value) {
+ WriteTag(WireFormat.MessageSetField.Item, WireFormat.WireType.StartGroup);
+ WriteUInt32(WireFormat.MessageSetField.TypeID, (uint)fieldNumber);
+ WriteBytes(WireFormat.MessageSetField.Message, value);
+ WriteTag(WireFormat.MessageSetField.Item, WireFormat.WireType.EndGroup);
+ }
+
+ public void WriteField(Descriptors.FieldDescriptor.Type fieldType, int fieldNumber, object value) {
+ switch (fieldType) {
+ case Descriptors.FieldDescriptor.Type.Double: WriteDouble(fieldNumber, (double)value); break;
+ case Descriptors.FieldDescriptor.Type.Float: WriteFloat(fieldNumber, (float)value); break;
+ case Descriptors.FieldDescriptor.Type.Int64: WriteInt64(fieldNumber, (long)value); break;
+ case Descriptors.FieldDescriptor.Type.UInt64: WriteUInt64(fieldNumber, (ulong)value); break;
+ case Descriptors.FieldDescriptor.Type.Int32: WriteInt32(fieldNumber, (int)value); break;
+ case Descriptors.FieldDescriptor.Type.Fixed64: WriteFixed64(fieldNumber, (long)value); break;
+ case Descriptors.FieldDescriptor.Type.Fixed32: WriteFixed32(fieldNumber, (int)value); break;
+ case Descriptors.FieldDescriptor.Type.Bool: WriteBool(fieldNumber, (bool)value); break;
+ case Descriptors.FieldDescriptor.Type.String: WriteString(fieldNumber, (string)value); break;
+ case Descriptors.FieldDescriptor.Type.Group: WriteGroup(fieldNumber, (IMessage)value); break;
+ case Descriptors.FieldDescriptor.Type.Message: WriteMessage(fieldNumber, (IMessage)value); break;
+ case Descriptors.FieldDescriptor.Type.Bytes: WriteBytes(fieldNumber, (ByteString)value); break;
+ case Descriptors.FieldDescriptor.Type.UInt32: WriteUInt32(fieldNumber, (uint)value); break;
+ case Descriptors.FieldDescriptor.Type.SFixed32: WriteSFixed32(fieldNumber, (int)value); break;
+ case Descriptors.FieldDescriptor.Type.SFixed64: WriteSFixed64(fieldNumber, (long)value); break;
+ case Descriptors.FieldDescriptor.Type.SInt32: WriteSInt32(fieldNumber, (int)value); break;
+ case Descriptors.FieldDescriptor.Type.SInt64: WriteSInt64(fieldNumber, (long)value); break;
+ case Descriptors.FieldDescriptor.Type.Enum: WriteEnum(fieldNumber, ((Descriptors.EnumValueDescriptor)value).Number);
+ break;
+ }
+ }
+
+ #endregion
+
+ #region Underlying writing primitives
+ ///
+ /// Encodes and writes a tag.
+ ///
+ public void WriteTag(int fieldNumber, WireFormat.WireType type) {
+ WriteRawVarint32(WireFormat.MakeTag(fieldNumber, type));
+ }
+
+ public void WriteRawVarint32(uint value) {
+ while (true) {
+ if ((value & ~0x7F) == 0) {
+ WriteRawByte(value);
+ return;
+ } else {
+ WriteRawByte((value & 0x7F) | 0x80);
+ value >>= 7;
+ }
+ }
+ }
+
+ public void WriteRawVarint64(ulong value) {
+ while (true) {
+ if ((value & ~0x7FUL) == 0) {
+ WriteRawByte((uint)value);
+ return;
+ } else {
+ WriteRawByte(((uint)value & 0x7F) | 0x80);
+ value >>= 7;
+ }
+ }
+ }
+
+ public void WriteRawLittleEndian32(int value) {
+ WriteRawByte((byte)value);
+ WriteRawByte((byte)(value >> 8));
+ WriteRawByte((byte)(value >> 16));
+ WriteRawByte((byte)(value >> 24));
+ }
+
+ public void WriteRawLittleEndian64(long value) {
+ WriteRawByte((byte)value);
+ WriteRawByte((byte)(value >> 8));
+ WriteRawByte((byte)(value >> 16));
+ WriteRawByte((byte)(value >> 24));
+ WriteRawByte((byte)(value >> 32));
+ WriteRawByte((byte)(value >> 40));
+ WriteRawByte((byte)(value >> 48));
+ WriteRawByte((byte)(value >> 56));
+ }
+
+ public void WriteRawByte(byte value) {
+ if (position == limit) {
+ RefreshBuffer();
+ }
+
+ buffer[position++] = value;
+ }
+
+ public void WriteRawByte(uint value) {
+ WriteRawByte((byte)value);
+ }
+
+ ///
+ /// Writes out an array of bytes.
+ ///
+ public void WriteRawBytes(byte[] value) {
+ WriteRawBytes(value, 0, value.Length);
+ }
+
+ ///
+ /// Writes out part of an array of bytes.
+ ///
+ public void WriteRawBytes(byte[] value, int offset, int length) {
+ if (limit - position >= length) {
+ Array.Copy(value, offset, buffer, position, length);
+ // We have room in the current buffer.
+ position += length;
+ } else {
+ // Write extends past current buffer. Fill the rest of this buffer and
+ // flush.
+ int bytesWritten = limit - position;
+ Array.Copy(value, offset, buffer, position, bytesWritten);
+ offset += bytesWritten;
+ length -= bytesWritten;
+ position = limit;
+ RefreshBuffer();
+
+ // Now deal with the rest.
+ // Since we have an output stream, this is our buffer
+ // and buffer offset == 0
+ if (length <= limit) {
+ // Fits in new buffer.
+ Array.Copy(value, offset, buffer, 0, length);
+ position = length;
+ } else {
+ // Write is very big. Let's do it all at once.
+ output.Write(value, offset, length);
+ }
+ }
+ }
+ #endregion
+
+ #region Size computations
+
+ const int LittleEndian64Size = 8;
+ const int LittleEndian32Size = 4;
+
+ ///
+ /// Compute the number of bytes that would be needed to encode a
+ /// double field, including the tag.
+ ///
+ public static int ComputeDoubleSize(int fieldNumber, double value) {
+ return ComputeTagSize(fieldNumber) + LittleEndian64Size;
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode a
+ /// float field, including the tag.
+ ///
+ public static int ComputeFloatSize(int fieldNumber, float value) {
+ return ComputeTagSize(fieldNumber) + LittleEndian32Size;
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode a
+ /// uint64 field, including the tag.
+ ///
+ public static int ComputeUInt64Size(int fieldNumber, ulong value) {
+ return ComputeTagSize(fieldNumber) + ComputeRawVarint64Size(value);
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode an
+ /// int64 field, including the tag.
+ ///
+ public static int ComputeInt64Size(int fieldNumber, long value) {
+ return ComputeTagSize(fieldNumber) + ComputeRawVarint64Size((ulong)value);
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode an
+ /// int32 field, including the tag.
+ ///
+ public static int ComputeInt32Size(int fieldNumber, int value) {
+ if (value >= 0) {
+ return ComputeTagSize(fieldNumber) + ComputeRawVarint32Size((uint)value);
+ } else {
+ // Must sign-extend.
+ return ComputeTagSize(fieldNumber) + 10;
+ }
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode a
+ /// fixed64 field, including the tag.
+ ///
+ public static int ComputeFixed64Size(int fieldNumber, long value) {
+ return ComputeTagSize(fieldNumber) + LittleEndian64Size;
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode a
+ /// fixed32 field, including the tag.
+ ///
+ public static int ComputeFixed32Size(int fieldNumber, int value) {
+ return ComputeTagSize(fieldNumber) + LittleEndian32Size;
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode a
+ /// bool field, including the tag.
+ ///
+ public static int ComputeBoolSize(int fieldNumber, bool value) {
+ return ComputeTagSize(fieldNumber) + 1;
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode a
+ /// string field, including the tag.
+ ///
+ public static int ComputeStringSize(int fieldNumber, String value) {
+ int byteArraySize = Encoding.UTF8.GetByteCount(value);
+ return ComputeTagSize(fieldNumber) +
+ ComputeRawVarint32Size((uint)byteArraySize) +
+ byteArraySize;
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode a
+ /// group field, including the tag.
+ ///
+ public static int ComputeGroupSize(int fieldNumber, IMessage value) {
+ return ComputeTagSize(fieldNumber) * 2 + value.SerializedSize;
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode a
+ /// group field represented by an UnknownFieldSet, including the tag.
+ ///
+ public static int ComputeUnknownGroupSize(int fieldNumber,
+ UnknownFieldSet value) {
+ return ComputeTagSize(fieldNumber) * 2 + value.SerializedSize;
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode an
+ /// embedded message field, including the tag.
+ ///
+ public static int ComputeMessageSize(int fieldNumber, IMessage value) {
+ int size = value.SerializedSize;
+ return ComputeTagSize(fieldNumber) + ComputeRawVarint32Size((uint)size) + size;
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode a
+ /// bytes field, including the tag.
+ ///
+ public static int ComputeBytesSize(int fieldNumber, ByteString value) {
+ return ComputeTagSize(fieldNumber) +
+ ComputeRawVarint32Size((uint)value.Length) +
+ value.Length;
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode a
+ /// uint32 field, including the tag.
+ ///
+ public static int ComputeUInt32Size(int fieldNumber, uint value) {
+ return ComputeTagSize(fieldNumber) + ComputeRawVarint32Size(value);
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode a
+ /// enum field, including the tag. The caller is responsible for
+ /// converting the enum value to its numeric value.
+ ///
+ public static int ComputeEnumSize(int fieldNumber, int value) {
+ return ComputeTagSize(fieldNumber) + ComputeRawVarint32Size((uint)value);
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode an
+ /// sfixed32 field, including the tag.
+ ///
+ public static int ComputeSFixed32Size(int fieldNumber, int value) {
+ return ComputeTagSize(fieldNumber) + LittleEndian32Size;
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode an
+ /// sfixed64 field, including the tag.
+ ///
+ public static int ComputeSFixed64Size(int fieldNumber, long value) {
+ return ComputeTagSize(fieldNumber) + LittleEndian64Size;
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode an
+ /// sint32 field, including the tag.
+ ///
+ public static int ComputeSInt32Size(int fieldNumber, int value) {
+ return ComputeTagSize(fieldNumber) +
+ ComputeRawVarint32Size(EncodeZigZag32(value));
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode an
+ /// sint64 field, including the tag.
+ ///
+ public static int ComputeSInt64Size(int fieldNumber, long value) {
+ return ComputeTagSize(fieldNumber) +
+ ComputeRawVarint64Size(EncodeZigZag64(value));
+ }
+
+ /*
+ * Compute the number of bytes that would be needed to encode a
+ * MessageSet extension to the stream. For historical reasons,
+ * the wire format differs from normal fields.
+ */
+ ///
+ /// Compute the number of bytes that would be needed to encode a
+ /// MessageSet extension to the stream. For historical reasons,
+ /// the wire format differs from normal fields.
+ ///
+ public static int ComputeMessageSetExtensionSize(int fieldNumber, IMessage value) {
+ return ComputeTagSize(WireFormat.MessageSetField.Item) * 2 +
+ ComputeUInt32Size(WireFormat.MessageSetField.TypeID, (uint) fieldNumber) +
+ ComputeMessageSize(WireFormat.MessageSetField.Message, value);
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode an
+ /// unparsed MessageSet extension field to the stream. For
+ /// historical reasons, the wire format differs from normal fields.
+ ///
+ public static int ComputeRawMessageSetExtensionSize(int fieldNumber, ByteString value) {
+ return ComputeTagSize(WireFormat.MessageSetField.Item) * 2 +
+ ComputeUInt32Size(WireFormat.MessageSetField.TypeID, (uint) fieldNumber) +
+ ComputeBytesSize(WireFormat.MessageSetField.Message, value);
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode a varint.
+ ///
+ public static int ComputeRawVarint32Size(uint value) {
+ if ((value & (0xffffffff << 7)) == 0) return 1;
+ if ((value & (0xffffffff << 14)) == 0) return 2;
+ if ((value & (0xffffffff << 21)) == 0) return 3;
+ if ((value & (0xffffffff << 28)) == 0) return 4;
+ return 5;
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode a varint.
+ ///
+ public static int ComputeRawVarint64Size(ulong value) {
+ if ((value & (0xffffffffffffffffL << 7)) == 0) return 1;
+ if ((value & (0xffffffffffffffffL << 14)) == 0) return 2;
+ if ((value & (0xffffffffffffffffL << 21)) == 0) return 3;
+ if ((value & (0xffffffffffffffffL << 28)) == 0) return 4;
+ if ((value & (0xffffffffffffffffL << 35)) == 0) return 5;
+ if ((value & (0xffffffffffffffffL << 42)) == 0) return 6;
+ if ((value & (0xffffffffffffffffL << 49)) == 0) return 7;
+ if ((value & (0xffffffffffffffffL << 56)) == 0) return 8;
+ if ((value & (0xffffffffffffffffL << 63)) == 0) return 9;
+ return 10;
+ }
+
+
+ /*
+ * Compute the number of bytes that would be needed to encode a
+ * field of arbitrary type, including tag, to the stream.
+ *
+ * @param type The field's type.
+ * @param number The field's number.
+ * @param value Object representing the field's value. Must be of the exact
+ * type which would be returned by
+ * {@link Message#getField(Descriptors.FieldDescriptor)} for
+ * this field.
+ */
+ public static int ComputeFieldSize(Descriptors.FieldDescriptor.Type fieldType, int fieldNumber, Object value) {
+ switch (fieldType) {
+ case Descriptors.FieldDescriptor.Type.Double: return ComputeDoubleSize(fieldNumber, (double)value);
+ case Descriptors.FieldDescriptor.Type.Float: return ComputeFloatSize(fieldNumber, (float)value);
+ case Descriptors.FieldDescriptor.Type.Int64: return ComputeInt64Size(fieldNumber, (long)value);
+ case Descriptors.FieldDescriptor.Type.UInt64: return ComputeUInt64Size(fieldNumber, (ulong)value);
+ case Descriptors.FieldDescriptor.Type.Int32: return ComputeInt32Size(fieldNumber, (int)value);
+ case Descriptors.FieldDescriptor.Type.Fixed64: return ComputeFixed64Size(fieldNumber, (long)value);
+ case Descriptors.FieldDescriptor.Type.Fixed32: return ComputeFixed32Size(fieldNumber, (int)value);
+ case Descriptors.FieldDescriptor.Type.Bool: return ComputeBoolSize(fieldNumber, (bool)value);
+ case Descriptors.FieldDescriptor.Type.String: return ComputeStringSize(fieldNumber, (string)value);
+ case Descriptors.FieldDescriptor.Type.Group: return ComputeGroupSize(fieldNumber, (IMessage)value);
+ case Descriptors.FieldDescriptor.Type.Message: return ComputeMessageSize(fieldNumber, (IMessage)value);
+ case Descriptors.FieldDescriptor.Type.Bytes: return ComputeBytesSize(fieldNumber, (ByteString)value);
+ case Descriptors.FieldDescriptor.Type.UInt32: return ComputeUInt32Size(fieldNumber, (uint)value);
+ case Descriptors.FieldDescriptor.Type.SFixed32: return ComputeSFixed32Size(fieldNumber, (int)value);
+ case Descriptors.FieldDescriptor.Type.SFixed64: return ComputeSFixed64Size(fieldNumber, (long)value);
+ case Descriptors.FieldDescriptor.Type.SInt32: return ComputeSInt32Size(fieldNumber, (int)value);
+ case Descriptors.FieldDescriptor.Type.SInt64: return ComputeSInt64Size(fieldNumber, (long)value);
+ case Descriptors.FieldDescriptor.Type.Enum: return ComputeEnumSize(fieldNumber, ((Descriptors.EnumValueDescriptor)value).Number);
+ default:
+ throw new ArgumentOutOfRangeException("Invalid field type " + fieldType);
+ }
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode a tag.
+ ///
+ public static int ComputeTagSize(int fieldNumber) {
+ return ComputeRawVarint32Size(WireFormat.MakeTag(fieldNumber, 0));
+ }
+ #endregion
+
+ ///
+ /// Encode a 32-bit value with ZigZag encoding.
+ ///
+ ///
+ /// ZigZag encodes signed integers into values that can be efficiently
+ /// encoded with varint. (Otherwise, negative values must be
+ /// sign-extended to 64 bits to be varint encoded, thus always taking
+ /// 10 bytes on the wire.)
+ ///
+ public static uint EncodeZigZag32(int n) {
+ // Note: the right-shift must be arithmetic
+ return (uint)((n << 1) ^ (n >> 31));
+ }
+
+ ///
+ /// Encode a 64-bit value with ZigZag encoding.
+ ///
+ ///
+ /// ZigZag encodes signed integers into values that can be efficiently
+ /// encoded with varint. (Otherwise, negative values must be
+ /// sign-extended to 64 bits to be varint encoded, thus always taking
+ /// 10 bytes on the wire.)
+ ///
+ public static ulong EncodeZigZag64(long n) {
+ return (ulong)((n << 1) ^ (n >> 63));
+ }
+
+ private void RefreshBuffer() {
+ if (output == null) {
+ // We're writing to a single buffer.
+ throw new OutOfSpaceException();
+ }
+
+ // Since we have an output stream, this is our buffer
+ // and buffer offset == 0
+ output.Write(buffer, 0, position);
+ position = 0;
+ }
+
+ ///
+ /// Indicates that a CodedOutputStream wrapping a flat byte array
+ /// ran out of space.
+ ///
+ public class OutOfSpaceException : IOException {
+ internal OutOfSpaceException()
+ : base("CodedOutputStream was writing to a flat byte array and ran out of space.") {
+ }
+ }
+
+ public void Flush() {
+ if (output != null) {
+ RefreshBuffer();
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/csharp/ProtocolBuffers/Descriptors.cs b/csharp/ProtocolBuffers/Descriptors.cs
new file mode 100644
index 000000000..ae09ee5a7
--- /dev/null
+++ b/csharp/ProtocolBuffers/Descriptors.cs
@@ -0,0 +1,39 @@
+
+using System;
+
+namespace Google.ProtocolBuffers {
+ public class Descriptors {
+ public class Descriptor {
+ }
+ public class FieldDescriptor {
+ public enum Type {
+ Double,
+ Float,
+ Int64,
+ UInt64,
+ Int32,
+ Fixed64,
+ Fixed32,
+ Bool,
+ String,
+ Group,
+ Message,
+ Bytes,
+ UInt32,
+ SFixed32,
+ SFixed64,
+ SInt32,
+ SInt64,
+ Enum
+ }
+ }
+
+ public class EnumValueDescriptor
+ {
+ public int Number
+ {
+ get { throw new NotImplementedException(); }
+ }
+ }
+ }
+}
diff --git a/csharp/ProtocolBuffers/ExtensionRegistry.cs b/csharp/ProtocolBuffers/ExtensionRegistry.cs
new file mode 100644
index 000000000..54d86ad70
--- /dev/null
+++ b/csharp/ProtocolBuffers/ExtensionRegistry.cs
@@ -0,0 +1,5 @@
+
+namespace Google.ProtocolBuffers {
+ public class ExtensionRegistry {
+ }
+}
diff --git a/csharp/ProtocolBuffers/IBuilder.cs b/csharp/ProtocolBuffers/IBuilder.cs
new file mode 100644
index 000000000..ebd6b4081
--- /dev/null
+++ b/csharp/ProtocolBuffers/IBuilder.cs
@@ -0,0 +1,227 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+
+namespace Google.ProtocolBuffers {
+
+ ///
+ /// Interface implemented by Protocol Message builders.
+ /// TODO(jonskeet): Consider "SetXXX" methods returning the builder, as well as the properties.
+ ///
+ /// Type of message
+ public interface IBuilder where T : IMessage {
+ ///
+ /// Resets all fields to their default values.
+ ///
+ IBuilder Clear();
+
+ ///
+ /// Merge the specified other message into the message being
+ /// built. Merging occurs as follows. For each field:
+ /// For singular primitive fields, if the field is set in ,
+ /// then 's value overwrites the value in this message.
+ /// For singular message fields, if the field is set in ,
+ /// it is merged into the corresponding sub-message of this message using the same
+ /// merging rules.
+ /// For repeated fields, the elements in are concatenated
+ /// with the elements in this message.
+ ///
+ ///
+ ///
+ IBuilder MergeFrom(IMessage other);
+
+ ///
+ /// Constructs the final message. Once this is called, this Builder instance
+ /// is no longer valid, and calling any other method may throw a
+ /// NullReferenceException. If you need to continue working with the builder
+ /// after calling Build, call Clone first.
+ ///
+ /// the message
+ /// is missing one or more required fields; use BuildPartial to bypass
+ /// this check
+ IMessage Build();
+
+ ///
+ /// Like Build(), but does not throw an exception if the message is missing
+ /// required fields. Instead, a partial message is returned.
+ ///
+ ///
+ IMessage BuildPartial();
+
+ ///
+ /// Clones this builder.
+ /// TODO(jonskeet): Explain depth of clone.
+ ///
+ IBuilder Clone();
+
+ ///
+ /// Returns true iff all required fields in the message and all
+ /// embedded messages are set.
+ ///
+ bool Initialized { get; }
+
+ ///
+ /// Parses a message of this type from the input and merges it with this
+ /// message, as if using MergeFrom(IMessage<T>).
+ ///
+ ///
+ /// Warning: This does not verify that all required fields are present
+ /// in the input message. If you call Build() without setting all
+ /// required fields, it will throw an UninitializedMessageException.
+ /// There are a few good ways to deal with this:
+ ///
+ /// - Call Initialized to verify to verify that all required fields are
+ /// set before building.
+ /// - Parse the message separately using one of the static ParseFrom
+ /// methods, then use MergeFrom(IMessage<T>) to merge it with
+ /// this one. ParseFrom will throw an InvalidProtocolBufferException
+ /// (an IOException) if some required fields are missing.
+ /// Use BuildPartial to build, which ignores missing required fields.
+ ///
+ ///
+ IBuilder MergeFrom(CodedInputStream input);
+
+ ///
+ /// Like MergeFrom(CodedInputStream), but also parses extensions.
+ /// The extensions that you want to be able to parse must be registered
+ /// in . Extensions not in the registry
+ /// will be treated as unknown fields.
+ ///
+ IBuilder MergeFrom(CodedInputStream input, ExtensionRegistry extensionRegistry);
+
+ ///
+ /// Get the message's type's descriptor.
+ ///
+ ///
+ Descriptors.Descriptor DescriptorForType { get; }
+
+ ///
+ /// Get's the message's type's default instance.
+ ///
+ ///
+ IMessage DefaultInstanceForType { get; }
+
+ ///
+ /// Behaves like the equivalent property in IMessage<T>.
+ /// The returned map may or may not reflect future changes to the builder.
+ /// Either way, the returned map is unmodifiable.
+ ///
+ IDictionary AllFields { get; }
+
+ ///
+ /// Create a builder for messages of the appropriate type for the given field.
+ /// Messages built with this can then be passed to the various mutation properties
+ /// and methods.
+ ///
+ ///
+ ///
+ ///
+ IBuilder NewBuilderForField(Descriptors.FieldDescriptor field)
+ where TField : IMessage;
+
+ ///
+ ///
+ ///
+ bool HasField(Descriptors.FieldDescriptor field);
+
+ ///
+ /// Allows getting and setting of a field.
+ ///
+ ///
+ ///
+ ///
+ object this[Descriptors.FieldDescriptor field] { get; set; }
+
+ ///
+ /// Clears the field. This is exactly equivalent to calling the generated
+ /// Clear method corresponding to the field.
+ ///
+ ///
+ ///
+ IBuilder ClearField(Descriptors.FieldDescriptor field);
+
+ ///
+ ///
+ ///
+ ///
+ ///
+ int GetRepeatedFieldCount(Descriptors.FieldDescriptor field);
+
+
+ ///
+ /// Allows getting and setting of a repeated field value.
+ ///
+ ///
+ object this[Descriptors.FieldDescriptor field, int index] { get; set; }
+
+ ///
+ /// Appends the given value as a new element for the specified repeated field.
+ ///
+ /// the field is not a repeated field,
+ /// the field does not belong to this builder's type, or the value is
+ /// of the incorrect type
+ ///
+ IBuilder AddRepeatedField(Descriptors.FieldDescriptor field, object value);
+
+ ///
+ ///
+ ///
+ UnknownFieldSet UnknownFields { get; set; }
+
+ ///
+ /// Merge some unknown fields into the set for this message.
+ ///
+ IBuilder MergeUnknownFields(UnknownFieldSet unknownFields);
+
+ #region Convenience methods
+ // TODO(jonskeet): Implement these as extension methods?
+
+ ///
+ /// Parse as a message of this type and merge
+ /// it with the message being built. This is just a small wrapper around
+ /// MergeFrom(CodedInputStream).
+ ///
+ IBuilder MergeFrom(ByteString data);
+
+ ///
+ /// Parse as a message of this type and merge
+ /// it with the message being built. This is just a small wrapper around
+ /// MergeFrom(CodedInputStream, ExtensionRegistry).
+ ///
+ IBuilder MergeFrom(ByteString data, ExtensionRegistry extensionRegistry);
+
+ ///
+ /// Parse as a message of this type and merge
+ /// it with the message being built. This is just a small wrapper around
+ /// MergeFrom(CodedInputStream).
+ ///
+ IBuilder MergeFrom(byte[] data);
+
+ ///
+ /// Parse as a message of this type and merge
+ /// it with the message being built. This is just a small wrapper around
+ /// MergeFrom(CodedInputStream, ExtensionRegistry).
+ ///
+ IBuilder MergeFrom(byte[] data, ExtensionRegistry extensionRegistry);
+
+ ///
+ /// Parse as a message of this type and merge
+ /// it with the message being built. This is just a small wrapper around
+ /// MergeFrom(CodedInputStream). Note that this method always reads
+ /// the entire input (unless it throws an exception). If you want it to
+ /// stop earlier, you will need to wrap the input in a wrapper
+ /// stream which limits reading. Despite usually reading the entire
+ /// stream, this method never closes the stream.
+ ///
+ IBuilder MergeFrom(Stream input);
+
+ ///
+ /// Parse as a message of this type and merge
+ /// it with the message being built. This is just a small wrapper around
+ /// MergeFrom(CodedInputStream, ExtensionRegistry).
+ ///
+ IBuilder MergeFrom(Stream input, ExtensionRegistry extensionRegistry);
+ #endregion
+ }
+}
diff --git a/csharp/ProtocolBuffers/IMessage.cs b/csharp/ProtocolBuffers/IMessage.cs
new file mode 100644
index 000000000..6a41d78e2
--- /dev/null
+++ b/csharp/ProtocolBuffers/IMessage.cs
@@ -0,0 +1,162 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+namespace Google.ProtocolBuffers {
+
+ ///
+ /// Non-generic interface.
+ /// TODO(jonskeet): Do we want or need this?
+ ///
+ public interface IMessage {
+ void WriteTo(CodedOutputStream output);
+ int SerializedSize { get; }
+ }
+
+ ///
+ /// Interface implemented by all Protocol Buffers messages.
+ ///
+ public interface IMessage where T : IMessage {
+ ///
+ /// Returns the message's type's descriptor. This differs from the
+ /// Descriptor property of each generated message class in that this
+ /// method is an abstract method of IMessage whereas Descriptor is
+ /// a static property of a specific class. They return the same thing.
+ ///
+ Descriptors.Descriptor DescriptorForType { get; }
+
+ ///
+ /// Returns an instance of this message type with all fields set to
+ /// their default values. This may or may not be a singleton. This differs
+ /// from the DefaultInstance property of each generated message class in that this
+ /// method is an abstract method of IMessage whereas DefaultInstance is
+ /// a static property of a specific class. They return the same thing.
+ ///
+ IMessage DefaultInstanceForType { get; }
+
+ ///
+ /// Returns a collection of all the fields in this message which are set
+ /// and their corresponding values. A singular ("required" or "optional")
+ /// field is set iff HasField() returns true for that field. A "repeated"
+ /// field is set iff GetRepeatedFieldSize() is greater than zero. The
+ /// values are exactly what would be returned by calling
+ /// GetField(Descriptors.FieldDescriptor) for each field. The map
+ /// is guaranteed to be a sorted map, so iterating over it will return fields
+ /// in order by field number.
+ ///
+ IDictionary AllFields { get; }
+
+ ///
+ /// Returns true if the given field is set. This is exactly equivalent
+ /// to calling the generated "Has" property corresponding to the field.
+ ///
+ /// the field is a repeated field,
+ /// or it's not a field of this type
+ bool HasField(Descriptors.FieldDescriptor field);
+
+ ///
+ /// Obtains the value of the given field, or the default value if
+ /// it isn't set. For value type fields including enums, the boxed
+ /// value is returned. For embedded message fields, the sub-message
+ /// is returned. For repeated fields, an IList<T> is returned.
+ ///
+ object this[Descriptors.FieldDescriptor field] { get; }
+
+ ///
+ /// Returns the number of elements of a repeated field. This is
+ /// exactly equivalent to calling the generated "Count" property
+ /// corresponding to the field.
+ ///
+ /// the field is not a repeated field,
+ /// or it's not a field of this type
+ int GetRepeatedFieldCount(Descriptors.FieldDescriptor field);
+
+ ///
+ /// Gets an element of a repeated field. For value type fields
+ /// including enums, the boxed value is returned. For embedded
+ /// message fields, the sub-message is returned.
+ ///
+ /// the field is not a repeated field,
+ /// or it's not a field of this type
+ /// the index is out of
+ /// range for the repeated field's value
+ object this[Descriptors.FieldDescriptor field, int index] { get; }
+
+ ///
+ /// Returns the unknown fields for this message.
+ ///
+ UnknownFieldSet UnknownFields { get; }
+
+ ///
+ /// Returns true iff all required fields in the message and all embedded
+ /// messages are set.
+ ///
+ bool Initialized { get; }
+
+ ///
+ /// Serializes the message and writes it to the given output stream.
+ /// This does not flush or close the stream.
+ ///
+ ///
+ void WriteTo(CodedOutputStream output);
+
+ ///
+ /// Returns the number of bytes required to encode this message.
+ /// The result is only computed on the first call and memoized after that.
+ ///
+ int SerializedSize { get; }
+
+ #region Comparison and hashing
+ ///
+ /// Compares the specified object with this message for equality.
+ /// Returns true iff the given object is a message of the same type
+ /// (as defined by DescriptorForType) and has identical values
+ /// for all its fields.
+ ///
+ bool Equals(object other);
+
+ ///
+ /// Returns the hash code value for this message.
+ /// TODO(jonskeet): Specify the hash algorithm, but better than the Java one!
+ ///
+ ///
+ int GetHashCode();
+ #endregion
+
+ #region Convenience methods
+ ///
+ /// Converts the message to a string in protocol buffer text format.
+ /// This is just a trivial wrapper around TextFormat.PrintToString.
+ ///
+ string ToString();
+
+ ///
+ /// Serializes the message to a ByteString. This is a trivial wrapper
+ /// around WriteTo(CodedOutputStream).
+ ///
+ ByteString ToByteString();
+
+ ///
+ /// Serializes the message to a byte array. This is a trivial wrapper
+ /// around WriteTo(CodedOutputStream).
+ ///
+ byte[] ToByteArray();
+
+ ///
+ /// Serializes the message and writes it to the given stream.
+ /// This is just a wrapper around WriteTo(CodedOutputStream). This
+ /// does not flush or close the stream.
+ ///
+ ///
+ void WriteTo(Stream output);
+ #endregion
+
+ #region Builders
+ ///
+ /// Constructs a new builder for a message of the same type as this message.
+ ///
+ IBuilder NewBuilderForType();
+ #endregion
+
+ }
+}
diff --git a/csharp/ProtocolBuffers/InvalidProtocolBufferException.cs b/csharp/ProtocolBuffers/InvalidProtocolBufferException.cs
new file mode 100644
index 000000000..8b61f9f17
--- /dev/null
+++ b/csharp/ProtocolBuffers/InvalidProtocolBufferException.cs
@@ -0,0 +1,7 @@
+using System;
+using System.IO;
+
+namespace Google.ProtocolBuffers {
+ public class InvalidProtocolBufferException : IOException {
+ }
+}
diff --git a/csharp/ProtocolBuffers/Properties/AssemblyInfo.cs b/csharp/ProtocolBuffers/Properties/AssemblyInfo.cs
new file mode 100644
index 000000000..4653dbe37
--- /dev/null
+++ b/csharp/ProtocolBuffers/Properties/AssemblyInfo.cs
@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("ProtocolBuffers")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("ProtocolBuffers")]
+[assembly: AssemblyCopyright("Copyright © 2008")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components. If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("279b643d-70e8-47ae-9eb1-500d1c48bab6")]
+
+// Version information for an assembly consists of the following four values:
+//
+// Major Version
+// Minor Version
+// Build Number
+// Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/csharp/ProtocolBuffers/ProtocolBuffers.csproj b/csharp/ProtocolBuffers/ProtocolBuffers.csproj
new file mode 100644
index 000000000..196f46d33
--- /dev/null
+++ b/csharp/ProtocolBuffers/ProtocolBuffers.csproj
@@ -0,0 +1,60 @@
+
+
+
+ Debug
+ AnyCPU
+ 9.0.21022
+ 2.0
+ {6908BDCE-D925-43F3-94AC-A531E6DF2591}
+ Library
+ Properties
+ Google.ProtocolBuffers
+ Google.ProtocolBuffers
+ v2.0
+ 512
+
+
+ true
+ full
+ false
+ bin\Debug\
+ DEBUG;TRACE
+ prompt
+ 4
+
+
+ pdbonly
+ true
+ bin\Release\
+ TRACE
+ prompt
+ 4
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/csharp/ProtocolBuffers/UninitializedMessageException.cs b/csharp/ProtocolBuffers/UninitializedMessageException.cs
new file mode 100644
index 000000000..a77499af7
--- /dev/null
+++ b/csharp/ProtocolBuffers/UninitializedMessageException.cs
@@ -0,0 +1,6 @@
+using System;
+
+namespace Google.ProtocolBuffers {
+ public class UninitializedMessageException : Exception {
+ }
+}
diff --git a/csharp/ProtocolBuffers/UnknownFieldSet.cs b/csharp/ProtocolBuffers/UnknownFieldSet.cs
new file mode 100644
index 000000000..a9602b3e3
--- /dev/null
+++ b/csharp/ProtocolBuffers/UnknownFieldSet.cs
@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Google.ProtocolBuffers {
+ public class UnknownFieldSet {
+ public void WriteTo(CodedOutputStream output) {
+ throw new NotImplementedException();
+ }
+
+ public int SerializedSize { get { return 0; } }
+ }
+}
diff --git a/csharp/ProtocolBuffers/WireFormat.cs b/csharp/ProtocolBuffers/WireFormat.cs
new file mode 100644
index 000000000..df15526a3
--- /dev/null
+++ b/csharp/ProtocolBuffers/WireFormat.cs
@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Google.ProtocolBuffers {
+ public class WireFormat {
+ public enum WireType {
+ Varint = 0,
+ Fixed64 = 1,
+ LengthDelimited = 2,
+ StartGroup = 3,
+ EndGroup = 4,
+ Fixed32 = 5
+ }
+
+ internal class MessageSetField {
+ internal const int Item = 1;
+ internal const int TypeID = 2;
+ internal const int Message = 3;
+ }
+
+ public static uint MakeTag(int fieldNumber, WireType type) {
+
+ // FIXME
+ return 0;
+ }
+ }
+}