Resolved merge conflicts

11 files changed, 4056 insertions, 0 deletions

diff --git a/src/csharp/Grpc.IntegrationTesting/.gitignore b/src/csharp/Grpc.IntegrationTesting/.gitignore
new file mode 100644
index 0000000000..8d4a6c08a8
--- /dev/null
+++ b/src/csharp/Grpc.IntegrationTesting/.gitignore
@@ -0,0 +1,2 @@
+bin
+obj
\ No newline at end of file
diff --git a/src/csharp/Grpc.IntegrationTesting/Client.cs b/src/csharp/Grpc.IntegrationTesting/Client.cs
new file mode 100644
index 0000000000..bb650a112d
--- /dev/null
+++ b/src/csharp/Grpc.IntegrationTesting/Client.cs
@@ -0,0 +1,338 @@
+#region Copyright notice and license
+
+// Copyright 2015, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+using Google.ProtocolBuffers;
+using Grpc.Core;
+using Grpc.Core.Utils;
+using NUnit.Framework;
+using grpc.testing;
+
+namespace Grpc.IntegrationTesting
+{
+    class Client
+    {
+        private class ClientOptions
+        {
+            public bool help;
+            public string serverHost;
+            public string serverHostOverride;
+            public int? serverPort;
+            public string testCase;
+            public bool useTls;
+            public bool useTestCa;
+        }
+
+        ClientOptions options;
+
+        private Client(ClientOptions options)
+        {
+            this.options = options;
+        }
+
+        public static void Main(string[] args)
+        {
+            Console.WriteLine("gRPC C# interop testing client");
+            ClientOptions options = ParseArguments(args);
+
+            if (options.serverHost == null || !options.serverPort.HasValue || options.testCase == null)
+            {
+                Console.WriteLine("Missing required argument.");
+                Console.WriteLine();
+                options.help = true;
+            }
+
+            if (options.help)
+            {
+                Console.WriteLine("Usage:");
+                Console.WriteLine("  --server_host=HOSTNAME");
+                Console.WriteLine("  --server_host_override=HOSTNAME");
+                Console.WriteLine("  --server_port=PORT");
+                Console.WriteLine("  --test_case=TESTCASE");
+                Console.WriteLine("  --use_tls=BOOLEAN");
+                Console.WriteLine("  --use_test_ca=BOOLEAN");
+                Console.WriteLine();
+                Environment.Exit(1);
+            }
+
+            var interopClient = new Client(options);
+            interopClient.Run();
+        }
+
+        private void Run()
+        {
+            GrpcEnvironment.Initialize();
+
+            string addr = string.Format("{0}:{1}", options.serverHost, options.serverPort);
+            using (Channel channel = new Channel(addr))
+            {
+                TestServiceGrpc.ITestServiceClient client = new TestServiceGrpc.TestServiceClientStub(channel);
+
+                RunTestCase(options.testCase, client);
+            }
+
+            GrpcEnvironment.Shutdown();
+        }
+
+        private void RunTestCase(string testCase, TestServiceGrpc.ITestServiceClient client)
+        {
+            switch (testCase)
+            {
+                case "empty_unary":
+                    RunEmptyUnary(client);
+                    break;
+                case "large_unary":
+                    RunLargeUnary(client);
+                    break;
+                case "client_streaming":
+                    RunClientStreaming(client);
+                    break;
+                case "server_streaming":
+                    RunServerStreaming(client);
+                    break;
+                case "ping_pong":
+                    RunPingPong(client);
+                    break;
+                case "empty_stream":
+                    RunEmptyStream(client);
+                    break;
+                default:
+                    throw new ArgumentException("Unknown test case " + testCase);
+            }
+        }
+
+        private void RunEmptyUnary(TestServiceGrpc.ITestServiceClient client)
+        {
+            Console.WriteLine("running empty_unary");
+            var response = client.EmptyCall(Empty.DefaultInstance);
+            Assert.IsNotNull(response);
+            Console.WriteLine("Passed!");
+        }
+
+        private void RunLargeUnary(TestServiceGrpc.ITestServiceClient client)
+        {
+            Console.WriteLine("running large_unary");
+            var request = SimpleRequest.CreateBuilder()
+                    .SetResponseType(PayloadType.COMPRESSABLE)
+                    .SetResponseSize(314159)
+                    .SetPayload(CreateZerosPayload(271828))
+                    .Build();
+
+            var response = client.UnaryCall(request);
+
+            Assert.AreEqual(PayloadType.COMPRESSABLE, response.Payload.Type);
+            Assert.AreEqual(314159, response.Payload.Body.Length);
+            Console.WriteLine("Passed!");
+        }
+
+        private void RunClientStreaming(TestServiceGrpc.ITestServiceClient client)
+        {
+            Console.WriteLine("running client_streaming");
+
+            var bodySizes = new List<int>{27182, 8, 1828, 45904};
+
+            var context = client.StreamingInputCall();
+            foreach (var size in bodySizes)
+            {
+                context.Inputs.OnNext(
+                    StreamingInputCallRequest.CreateBuilder().SetPayload(CreateZerosPayload(size)).Build());
+            }
+            context.Inputs.OnCompleted();
+
+            var response = context.Task.Result;
+            Assert.AreEqual(74922, response.AggregatedPayloadSize);
+            Console.WriteLine("Passed!");
+        }
+
+        private void RunServerStreaming(TestServiceGrpc.ITestServiceClient client)
+        {
+            Console.WriteLine("running server_streaming");
+
+            var bodySizes = new List<int>{31415, 9, 2653, 58979};
+
+            var request = StreamingOutputCallRequest.CreateBuilder()
+                .SetResponseType(PayloadType.COMPRESSABLE)
+                .AddRangeResponseParameters(bodySizes.ConvertAll(
+                        (size) => ResponseParameters.CreateBuilder().SetSize(size).Build()))
+                .Build();
+
+            var recorder = new RecordingObserver<StreamingOutputCallResponse>();
+            client.StreamingOutputCall(request, recorder);
+
+            var responseList = recorder.ToList().Result;
+
+            foreach (var res in responseList)
+            {
+                Assert.AreEqual(PayloadType.COMPRESSABLE, res.Payload.Type);
+            }
+            CollectionAssert.AreEqual(bodySizes, responseList.ConvertAll((item) => item.Payload.Body.Length));
+            Console.WriteLine("Passed!");
+        }
+
+        private void RunPingPong(TestServiceGrpc.ITestServiceClient client)
+        {
+            Console.WriteLine("running ping_pong");
+
+            var recorder = new RecordingQueue<StreamingOutputCallResponse>();
+            var inputs = client.FullDuplexCall(recorder);
+
+            StreamingOutputCallResponse response;
+
+            inputs.OnNext(StreamingOutputCallRequest.CreateBuilder()
+                .SetResponseType(PayloadType.COMPRESSABLE)
+                .AddResponseParameters(ResponseParameters.CreateBuilder().SetSize(31415))
+                .SetPayload(CreateZerosPayload(27182)).Build());
+
+            response = recorder.Queue.Take();
+            Assert.AreEqual(PayloadType.COMPRESSABLE, response.Payload.Type);
+            Assert.AreEqual(31415, response.Payload.Body.Length);
+
+            inputs.OnNext(StreamingOutputCallRequest.CreateBuilder()
+                          .SetResponseType(PayloadType.COMPRESSABLE)
+                          .AddResponseParameters(ResponseParameters.CreateBuilder().SetSize(9))
+                          .SetPayload(CreateZerosPayload(8)).Build());
+
+            response = recorder.Queue.Take();
+            Assert.AreEqual(PayloadType.COMPRESSABLE, response.Payload.Type);
+            Assert.AreEqual(9, response.Payload.Body.Length);
+
+            inputs.OnNext(StreamingOutputCallRequest.CreateBuilder()
+                          .SetResponseType(PayloadType.COMPRESSABLE)
+                          .AddResponseParameters(ResponseParameters.CreateBuilder().SetSize(2635))
+                          .SetPayload(CreateZerosPayload(1828)).Build());
+
+            response = recorder.Queue.Take();
+            Assert.AreEqual(PayloadType.COMPRESSABLE, response.Payload.Type);
+            Assert.AreEqual(2653, response.Payload.Body.Length);
+
+
+            inputs.OnNext(StreamingOutputCallRequest.CreateBuilder()
+                          .SetResponseType(PayloadType.COMPRESSABLE)
+                          .AddResponseParameters(ResponseParameters.CreateBuilder().SetSize(58979))
+                          .SetPayload(CreateZerosPayload(45904)).Build());
+
+            response = recorder.Queue.Take();
+            Assert.AreEqual(PayloadType.COMPRESSABLE, response.Payload.Type);
+            Assert.AreEqual(58979, response.Payload.Body.Length);
+
+            recorder.Finished.Wait();
+            Assert.AreEqual(0, recorder.Queue.Count);
+
+            Console.WriteLine("Passed!");
+        }
+
+        private void RunEmptyStream(TestServiceGrpc.ITestServiceClient client)
+        {
+            Console.WriteLine("running empty_stream");
+
+            var recorder = new RecordingObserver<StreamingOutputCallResponse>();
+            var inputs = client.FullDuplexCall(recorder);
+            inputs.OnCompleted();
+
+            var responseList = recorder.ToList().Result;
+            Assert.AreEqual(0, responseList.Count);
+
+            Console.WriteLine("Passed!");
+        }
+
+
+        private Payload CreateZerosPayload(int size) {
+            return Payload.CreateBuilder().SetBody(ByteString.CopyFrom(new byte[size])).Build();
+        }
+
+        private static ClientOptions ParseArguments(string[] args)
+        {
+            var options = new ClientOptions();
+            foreach(string arg in args)
+            {
+                ParseArgument(arg, options);
+                if (options.help)
+                {
+                    break;
+                }
+            }
+            return options;
+        }
+
+        private static void ParseArgument(string arg, ClientOptions options)
+        {
+            Match match;
+            match = Regex.Match(arg, "--server_host=(.*)");
+            if (match.Success)
+            {
+                options.serverHost = match.Groups[1].Value.Trim();
+                return;
+            }
+
+            match = Regex.Match(arg, "--server_host_override=(.*)");
+            if (match.Success)
+            {
+                options.serverHostOverride = match.Groups[1].Value.Trim();
+                return;
+            }
+
+            match = Regex.Match(arg, "--server_port=(.*)");
+            if (match.Success)
+            {
+                options.serverPort = int.Parse(match.Groups[1].Value.Trim());
+                return;
+            }
+
+            match = Regex.Match(arg, "--test_case=(.*)");
+            if (match.Success)
+            {
+                options.testCase = match.Groups[1].Value.Trim();
+                return;
+            }
+
+            match = Regex.Match(arg, "--use_tls=(.*)");
+            if (match.Success)
+            {
+                options.useTls = bool.Parse(match.Groups[1].Value.Trim());
+                return;
+            }
+
+            match = Regex.Match(arg, "--use_test_ca=(.*)");
+            if (match.Success)
+            {
+                options.useTestCa = bool.Parse(match.Groups[1].Value.Trim());
+                return;
+            }
+
+            Console.WriteLine(string.Format("Unrecognized argument \"{0}\"", arg));
+            options.help = true;
+        }
+    }
+}
diff --git a/src/csharp/Grpc.IntegrationTesting/Empty.cs b/src/csharp/Grpc.IntegrationTesting/Empty.cs
new file mode 100644
index 0000000000..7169ee2a4a
--- /dev/null
+++ b/src/csharp/Grpc.IntegrationTesting/Empty.cs
@@ -0,0 +1,282 @@
+// Generated by ProtoGen, Version=2.4.1.521, Culture=neutral, PublicKeyToken=17b3b1f090c3ea48.  DO NOT EDIT!
+#pragma warning disable 1591, 0612, 3021
+#region Designer generated code
+
+using pb = global::Google.ProtocolBuffers;
+using pbc = global::Google.ProtocolBuffers.Collections;
+using pbd = global::Google.ProtocolBuffers.Descriptors;
+using scg = global::System.Collections.Generic;
+namespace grpc.testing {
+
+  namespace Proto {
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    public static partial class Empty {
+
+      #region Extension registration
+      public static void RegisterAllExtensions(pb::ExtensionRegistry registry) {
+      }
+      #endregion
+      #region Static variables
+      internal static pbd::MessageDescriptor internal__static_grpc_testing_Empty__Descriptor;
+      internal static pb::FieldAccess.FieldAccessorTable<global::grpc.testing.Empty, global::grpc.testing.Empty.Builder> internal__static_grpc_testing_Empty__FieldAccessorTable;
+      #endregion
+      #region Descriptor
+      public static pbd::FileDescriptor Descriptor {
+        get { return descriptor; }
+      }
+      private static pbd::FileDescriptor descriptor;
+
+      static Empty() {
+        byte[] descriptorData = global::System.Convert.FromBase64String(
+            string.Concat(
+            "CgtlbXB0eS5wcm90bxIMZ3JwYy50ZXN0aW5nIgcKBUVtcHR5"));
+        pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) {
+          descriptor = root;
+          internal__static_grpc_testing_Empty__Descriptor = Descriptor.MessageTypes[0];
+          internal__static_grpc_testing_Empty__FieldAccessorTable =
+              new pb::FieldAccess.FieldAccessorTable<global::grpc.testing.Empty, global::grpc.testing.Empty.Builder>(internal__static_grpc_testing_Empty__Descriptor,
+                  new string[] { });
+          return null;
+        };
+        pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData,
+            new pbd::FileDescriptor[] {
+            }, assigner);
+      }
+      #endregion
+
+    }
+  }
+  #region Messages
+  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+  public sealed partial class Empty : pb::GeneratedMessage<Empty, Empty.Builder> {
+    private Empty() { }
+    private static readonly Empty defaultInstance = new Empty().MakeReadOnly();
+    private static readonly string[] _emptyFieldNames = new string[] {  };
+    private static readonly uint[] _emptyFieldTags = new uint[] {  };
+    public static Empty DefaultInstance {
+      get { return defaultInstance; }
+    }
+
+    public override Empty DefaultInstanceForType {
+      get { return DefaultInstance; }
+    }
+
+    protected override Empty ThisMessage {
+      get { return this; }
+    }
+
+    public static pbd::MessageDescriptor Descriptor {
+      get { return global::grpc.testing.Proto.Empty.internal__static_grpc_testing_Empty__Descriptor; }
+    }
+
+    protected override pb::FieldAccess.FieldAccessorTable<Empty, Empty.Builder> InternalFieldAccessors {
+      get { return global::grpc.testing.Proto.Empty.internal__static_grpc_testing_Empty__FieldAccessorTable; }
+    }
+
+    public override bool IsInitialized {
+      get {
+        return true;
+      }
+    }
+
+    public override void WriteTo(pb::ICodedOutputStream output) {
+      int size = SerializedSize;
+      string[] field_names = _emptyFieldNames;
+      UnknownFields.WriteTo(output);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public override int SerializedSize {
+      get {
+        int size = memoizedSerializedSize;
+        if (size != -1) return size;
+
+        size = 0;
+        size += UnknownFields.SerializedSize;
+        memoizedSerializedSize = size;
+        return size;
+      }
+    }
+
+    public static Empty ParseFrom(pb::ByteString data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static Empty ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static Empty ParseFrom(byte[] data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static Empty ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static Empty ParseFrom(global::System.IO.Stream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static Empty ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    public static Empty ParseDelimitedFrom(global::System.IO.Stream input) {
+      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
+    }
+    public static Empty ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
+    }
+    public static Empty ParseFrom(pb::ICodedInputStream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static Empty ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    private Empty MakeReadOnly() {
+      return this;
+    }
+
+    public static Builder CreateBuilder() { return new Builder(); }
+    public override Builder ToBuilder() { return CreateBuilder(this); }
+    public override Builder CreateBuilderForType() { return new Builder(); }
+    public static Builder CreateBuilder(Empty prototype) {
+      return new Builder(prototype);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    public sealed partial class Builder : pb::GeneratedBuilder<Empty, Builder> {
+      protected override Builder ThisBuilder {
+        get { return this; }
+      }
+      public Builder() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+      }
+      internal Builder(Empty cloneFrom) {
+        result = cloneFrom;
+        resultIsReadOnly = true;
+      }
+
+      private bool resultIsReadOnly;
+      private Empty result;
+
+      private Empty PrepareBuilder() {
+        if (resultIsReadOnly) {
+          Empty original = result;
+          result = new Empty();
+          resultIsReadOnly = false;
+          MergeFrom(original);
+        }
+        return result;
+      }
+
+      public override bool IsInitialized {
+        get { return result.IsInitialized; }
+      }
+
+      protected override Empty MessageBeingBuilt {
+        get { return PrepareBuilder(); }
+      }
+
+      public override Builder Clear() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+        return this;
+      }
+
+      public override Builder Clone() {
+        if (resultIsReadOnly) {
+          return new Builder(result);
+        } else {
+          return new Builder().MergeFrom(result);
+        }
+      }
+
+      public override pbd::MessageDescriptor DescriptorForType {
+        get { return global::grpc.testing.Empty.Descriptor; }
+      }
+
+      public override Empty DefaultInstanceForType {
+        get { return global::grpc.testing.Empty.DefaultInstance; }
+      }
+
+      public override Empty BuildPartial() {
+        if (resultIsReadOnly) {
+          return result;
+        }
+        resultIsReadOnly = true;
+        return result.MakeReadOnly();
+      }
+
+      public override Builder MergeFrom(pb::IMessage other) {
+        if (other is Empty) {
+          return MergeFrom((Empty) other);
+        } else {
+          base.MergeFrom(other);
+          return this;
+        }
+      }
+
+      public override Builder MergeFrom(Empty other) {
+        if (other == global::grpc.testing.Empty.DefaultInstance) return this;
+        PrepareBuilder();
+        this.MergeUnknownFields(other.UnknownFields);
+        return this;
+      }
+
+      public override Builder MergeFrom(pb::ICodedInputStream input) {
+        return MergeFrom(input, pb::ExtensionRegistry.Empty);
+      }
+
+      public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+        PrepareBuilder();
+        pb::UnknownFieldSet.Builder unknownFields = null;
+        uint tag;
+        string field_name;
+        while (input.ReadTag(out tag, out field_name)) {
+          if(tag == 0 && field_name != null) {
+            int field_ordinal = global::System.Array.BinarySearch(_emptyFieldNames, field_name, global::System.StringComparer.Ordinal);
+            if(field_ordinal >= 0)
+              tag = _emptyFieldTags[field_ordinal];
+            else {
+              if (unknownFields == null) {
+                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+              }
+              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
+              continue;
+            }
+          }
+          switch (tag) {
+            case 0: {
+              throw pb::InvalidProtocolBufferException.InvalidTag();
+            }
+            default: {
+              if (pb::WireFormat.IsEndGroupTag(tag)) {
+                if (unknownFields != null) {
+                  this.UnknownFields = unknownFields.Build();
+                }
+                return this;
+              }
+              if (unknownFields == null) {
+                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+              }
+              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
+              break;
+            }
+          }
+        }
+
+        if (unknownFields != null) {
+          this.UnknownFields = unknownFields.Build();
+        }
+        return this;
+      }
+
+    }
+    static Empty() {
+      object.ReferenceEquals(global::grpc.testing.Proto.Empty.Descriptor, null);
+    }
+  }
+
+  #endregion
+
+}
+
+#endregion Designer generated code
diff --git a/src/csharp/Grpc.IntegrationTesting/Grpc.IntegrationTesting.csproj b/src/csharp/Grpc.IntegrationTesting/Grpc.IntegrationTesting.csproj
new file mode 100644
index 0000000000..9b46a644bc
--- /dev/null
+++ b/src/csharp/Grpc.IntegrationTesting/Grpc.IntegrationTesting.csproj
@@ -0,0 +1,67 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
+    <ProductVersion>10.0.0</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{C61154BA-DD4A-4838-8420-0162A28925E0}</ProjectGuid>
+    <OutputType>Exe</OutputType>
+    <RootNamespace>Grpc.IntegrationTesting</RootNamespace>
+    <AssemblyName>Grpc.IntegrationTesting</AssemblyName>
+    <StartupObject>Grpc.IntegrationTesting.Client</StartupObject>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug</OutputPath>
+    <DefineConstants>DEBUG;</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <Externalconsole>true</Externalconsole>
+    <PlatformTarget>x86</PlatformTarget>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
+    <DebugType>full</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release</OutputPath>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <Externalconsole>true</Externalconsole>
+    <PlatformTarget>x86</PlatformTarget>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="nunit.framework">
+      <HintPath>..\packages\NUnit.2.6.4\lib\nunit.framework.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="Google.ProtocolBuffers">
+      <HintPath>..\packages\Google.ProtocolBuffers.2.4.1.521\lib\net40\Google.ProtocolBuffers.dll</HintPath>
+    </Reference>
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Client.cs" />
+    <Compile Include="TestServiceGrpc.cs" />
+    <Compile Include="Empty.cs" />
+    <Compile Include="Messages.cs" />
+  </ItemGroup>
+  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
+  <ItemGroup>
+    <ProjectReference Include="..\Grpc.Core\Grpc.Core.csproj">
+      <Project>{CCC4440E-49F7-4790-B0AF-FEABB0837AE7}</Project>
+      <Name>Grpc.Core</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+    <None Include="proto\test.proto" />
+    <None Include="proto\empty.proto" />
+    <None Include="proto\messages.proto" />
+  </ItemGroup>
+  <ItemGroup>
+    <Folder Include="proto\" />
+  </ItemGroup>
+</Project>
diff --git a/src/csharp/Grpc.IntegrationTesting/Messages.cs b/src/csharp/Grpc.IntegrationTesting/Messages.cs
new file mode 100644
index 0000000000..386f377f08
--- /dev/null
+++ b/src/csharp/Grpc.IntegrationTesting/Messages.cs
@@ -0,0 +1,2891 @@
+// Generated by ProtoGen, Version=2.4.1.521, Culture=neutral, PublicKeyToken=17b3b1f090c3ea48.  DO NOT EDIT!
+#pragma warning disable 1591, 0612, 3021
+#region Designer generated code
+
+using pb = global::Google.ProtocolBuffers;
+using pbc = global::Google.ProtocolBuffers.Collections;
+using pbd = global::Google.ProtocolBuffers.Descriptors;
+using scg = global::System.Collections.Generic;
+namespace grpc.testing {
+
+  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+  public static partial class Messages {
+
+    #region Extension registration
+    public static void RegisterAllExtensions(pb::ExtensionRegistry registry) {
+    }
+    #endregion
+    #region Static variables
+    internal static pbd::MessageDescriptor internal__static_grpc_testing_Payload__Descriptor;
+    internal static pb::FieldAccess.FieldAccessorTable<global::grpc.testing.Payload, global::grpc.testing.Payload.Builder> internal__static_grpc_testing_Payload__FieldAccessorTable;
+    internal static pbd::MessageDescriptor internal__static_grpc_testing_SimpleRequest__Descriptor;
+    internal static pb::FieldAccess.FieldAccessorTable<global::grpc.testing.SimpleRequest, global::grpc.testing.SimpleRequest.Builder> internal__static_grpc_testing_SimpleRequest__FieldAccessorTable;
+    internal static pbd::MessageDescriptor internal__static_grpc_testing_SimpleResponse__Descriptor;
+    internal static pb::FieldAccess.FieldAccessorTable<global::grpc.testing.SimpleResponse, global::grpc.testing.SimpleResponse.Builder> internal__static_grpc_testing_SimpleResponse__FieldAccessorTable;
+    internal static pbd::MessageDescriptor internal__static_grpc_testing_StreamingInputCallRequest__Descriptor;
+    internal static pb::FieldAccess.FieldAccessorTable<global::grpc.testing.StreamingInputCallRequest, global::grpc.testing.StreamingInputCallRequest.Builder> internal__static_grpc_testing_StreamingInputCallRequest__FieldAccessorTable;
+    internal static pbd::MessageDescriptor internal__static_grpc_testing_StreamingInputCallResponse__Descriptor;
+    internal static pb::FieldAccess.FieldAccessorTable<global::grpc.testing.StreamingInputCallResponse, global::grpc.testing.StreamingInputCallResponse.Builder> internal__static_grpc_testing_StreamingInputCallResponse__FieldAccessorTable;
+    internal static pbd::MessageDescriptor internal__static_grpc_testing_ResponseParameters__Descriptor;
+    internal static pb::FieldAccess.FieldAccessorTable<global::grpc.testing.ResponseParameters, global::grpc.testing.ResponseParameters.Builder> internal__static_grpc_testing_ResponseParameters__FieldAccessorTable;
+    internal static pbd::MessageDescriptor internal__static_grpc_testing_StreamingOutputCallRequest__Descriptor;
+    internal static pb::FieldAccess.FieldAccessorTable<global::grpc.testing.StreamingOutputCallRequest, global::grpc.testing.StreamingOutputCallRequest.Builder> internal__static_grpc_testing_StreamingOutputCallRequest__FieldAccessorTable;
+    internal static pbd::MessageDescriptor internal__static_grpc_testing_StreamingOutputCallResponse__Descriptor;
+    internal static pb::FieldAccess.FieldAccessorTable<global::grpc.testing.StreamingOutputCallResponse, global::grpc.testing.StreamingOutputCallResponse.Builder> internal__static_grpc_testing_StreamingOutputCallResponse__FieldAccessorTable;
+    #endregion
+    #region Descriptor
+    public static pbd::FileDescriptor Descriptor {
+      get { return descriptor; }
+    }
+    private static pbd::FileDescriptor descriptor;
+
+    static Messages() {
+      byte[] descriptorData = global::System.Convert.FromBase64String(
+          string.Concat(
+            "Cg5tZXNzYWdlcy5wcm90bxIMZ3JwYy50ZXN0aW5nIkAKB1BheWxvYWQSJwoE",
+            "dHlwZRgBIAEoDjIZLmdycGMudGVzdGluZy5QYXlsb2FkVHlwZRIMCgRib2R5",
+            "GAIgASgMIrEBCg1TaW1wbGVSZXF1ZXN0EjAKDXJlc3BvbnNlX3R5cGUYASAB",
+            "KA4yGS5ncnBjLnRlc3RpbmcuUGF5bG9hZFR5cGUSFQoNcmVzcG9uc2Vfc2l6",
+            "ZRgCIAEoBRImCgdwYXlsb2FkGAMgASgLMhUuZ3JwYy50ZXN0aW5nLlBheWxv",
+            "YWQSFQoNZmlsbF91c2VybmFtZRgEIAEoCBIYChBmaWxsX29hdXRoX3Njb3Bl",
+            "GAUgASgIIl8KDlNpbXBsZVJlc3BvbnNlEiYKB3BheWxvYWQYASABKAsyFS5n",
+            "cnBjLnRlc3RpbmcuUGF5bG9hZBIQCgh1c2VybmFtZRgCIAEoCRITCgtvYXV0",
+            "aF9zY29wZRgDIAEoCSJDChlTdHJlYW1pbmdJbnB1dENhbGxSZXF1ZXN0EiYK",
+            "B3BheWxvYWQYASABKAsyFS5ncnBjLnRlc3RpbmcuUGF5bG9hZCI9ChpTdHJl",
+            "YW1pbmdJbnB1dENhbGxSZXNwb25zZRIfChdhZ2dyZWdhdGVkX3BheWxvYWRf",
+            "c2l6ZRgBIAEoBSI3ChJSZXNwb25zZVBhcmFtZXRlcnMSDAoEc2l6ZRgBIAEo",
+            "BRITCgtpbnRlcnZhbF91cxgCIAEoBSK1AQoaU3RyZWFtaW5nT3V0cHV0Q2Fs",
+            "bFJlcXVlc3QSMAoNcmVzcG9uc2VfdHlwZRgBIAEoDjIZLmdycGMudGVzdGlu",
+            "Zy5QYXlsb2FkVHlwZRI9ChNyZXNwb25zZV9wYXJhbWV0ZXJzGAIgAygLMiAu",
+            "Z3JwYy50ZXN0aW5nLlJlc3BvbnNlUGFyYW1ldGVycxImCgdwYXlsb2FkGAMg",
+            "ASgLMhUuZ3JwYy50ZXN0aW5nLlBheWxvYWQiRQobU3RyZWFtaW5nT3V0cHV0",
+            "Q2FsbFJlc3BvbnNlEiYKB3BheWxvYWQYASABKAsyFS5ncnBjLnRlc3Rpbmcu",
+            "UGF5bG9hZCo/CgtQYXlsb2FkVHlwZRIQCgxDT01QUkVTU0FCTEUQABISCg5V",
+          "TkNPTVBSRVNTQUJMRRABEgoKBlJBTkRPTRAC"));
+      pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) {
+        descriptor = root;
+        internal__static_grpc_testing_Payload__Descriptor = Descriptor.MessageTypes[0];
+        internal__static_grpc_testing_Payload__FieldAccessorTable =
+            new pb::FieldAccess.FieldAccessorTable<global::grpc.testing.Payload, global::grpc.testing.Payload.Builder>(internal__static_grpc_testing_Payload__Descriptor,
+                new string[] { "Type", "Body", });
+        internal__static_grpc_testing_SimpleRequest__Descriptor = Descriptor.MessageTypes[1];
+        internal__static_grpc_testing_SimpleRequest__FieldAccessorTable =
+            new pb::FieldAccess.FieldAccessorTable<global::grpc.testing.SimpleRequest, global::grpc.testing.SimpleRequest.Builder>(internal__static_grpc_testing_SimpleRequest__Descriptor,
+                new string[] { "ResponseType", "ResponseSize", "Payload", "FillUsername", "FillOauthScope", });
+        internal__static_grpc_testing_SimpleResponse__Descriptor = Descriptor.MessageTypes[2];
+        internal__static_grpc_testing_SimpleResponse__FieldAccessorTable =
+            new pb::FieldAccess.FieldAccessorTable<global::grpc.testing.SimpleResponse, global::grpc.testing.SimpleResponse.Builder>(internal__static_grpc_testing_SimpleResponse__Descriptor,
+                new string[] { "Payload", "Username", "OauthScope", });
+        internal__static_grpc_testing_StreamingInputCallRequest__Descriptor = Descriptor.MessageTypes[3];
+        internal__static_grpc_testing_StreamingInputCallRequest__FieldAccessorTable =
+            new pb::FieldAccess.FieldAccessorTable<global::grpc.testing.StreamingInputCallRequest, global::grpc.testing.StreamingInputCallRequest.Builder>(internal__static_grpc_testing_StreamingInputCallRequest__Descriptor,
+                new string[] { "Payload", });
+        internal__static_grpc_testing_StreamingInputCallResponse__Descriptor = Descriptor.MessageTypes[4];
+        internal__static_grpc_testing_StreamingInputCallResponse__FieldAccessorTable =
+            new pb::FieldAccess.FieldAccessorTable<global::grpc.testing.StreamingInputCallResponse, global::grpc.testing.StreamingInputCallResponse.Builder>(internal__static_grpc_testing_StreamingInputCallResponse__Descriptor,
+                new string[] { "AggregatedPayloadSize", });
+        internal__static_grpc_testing_ResponseParameters__Descriptor = Descriptor.MessageTypes[5];
+        internal__static_grpc_testing_ResponseParameters__FieldAccessorTable =
+            new pb::FieldAccess.FieldAccessorTable<global::grpc.testing.ResponseParameters, global::grpc.testing.ResponseParameters.Builder>(internal__static_grpc_testing_ResponseParameters__Descriptor,
+                new string[] { "Size", "IntervalUs", });
+        internal__static_grpc_testing_StreamingOutputCallRequest__Descriptor = Descriptor.MessageTypes[6];
+        internal__static_grpc_testing_StreamingOutputCallRequest__FieldAccessorTable =
+            new pb::FieldAccess.FieldAccessorTable<global::grpc.testing.StreamingOutputCallRequest, global::grpc.testing.StreamingOutputCallRequest.Builder>(internal__static_grpc_testing_StreamingOutputCallRequest__Descriptor,
+                new string[] { "ResponseType", "ResponseParameters", "Payload", });
+        internal__static_grpc_testing_StreamingOutputCallResponse__Descriptor = Descriptor.MessageTypes[7];
+        internal__static_grpc_testing_StreamingOutputCallResponse__FieldAccessorTable =
+            new pb::FieldAccess.FieldAccessorTable<global::grpc.testing.StreamingOutputCallResponse, global::grpc.testing.StreamingOutputCallResponse.Builder>(internal__static_grpc_testing_StreamingOutputCallResponse__Descriptor,
+                new string[] { "Payload", });
+        return null;
+      };
+      pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData,
+          new pbd::FileDescriptor[] {
+          }, assigner);
+    }
+    #endregion
+
+  }
+  #region Enums
+  public enum PayloadType {
+    COMPRESSABLE = 0,
+    UNCOMPRESSABLE = 1,
+    RANDOM = 2,
+  }
+
+  #endregion
+
+  #region Messages
+  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+  public sealed partial class Payload : pb::GeneratedMessage<Payload, Payload.Builder> {
+    private Payload() { }
+    private static readonly Payload defaultInstance = new Payload().MakeReadOnly();
+    private static readonly string[] _payloadFieldNames = new string[] { "body", "type" };
+    private static readonly uint[] _payloadFieldTags = new uint[] { 18, 8 };
+    public static Payload DefaultInstance {
+      get { return defaultInstance; }
+    }
+
+    public override Payload DefaultInstanceForType {
+      get { return DefaultInstance; }
+    }
+
+    protected override Payload ThisMessage {
+      get { return this; }
+    }
+
+    public static pbd::MessageDescriptor Descriptor {
+      get { return global::grpc.testing.Messages.internal__static_grpc_testing_Payload__Descriptor; }
+    }
+
+    protected override pb::FieldAccess.FieldAccessorTable<Payload, Payload.Builder> InternalFieldAccessors {
+      get { return global::grpc.testing.Messages.internal__static_grpc_testing_Payload__FieldAccessorTable; }
+    }
+
+    public const int TypeFieldNumber = 1;
+    private bool hasType;
+    private global::grpc.testing.PayloadType type_ = global::grpc.testing.PayloadType.COMPRESSABLE;
+    public bool HasType {
+      get { return hasType; }
+    }
+    public global::grpc.testing.PayloadType Type {
+      get { return type_; }
+    }
+
+    public const int BodyFieldNumber = 2;
+    private bool hasBody;
+    private pb::ByteString body_ = pb::ByteString.Empty;
+    public bool HasBody {
+      get { return hasBody; }
+    }
+    public pb::ByteString Body {
+      get { return body_; }
+    }
+
+    public override bool IsInitialized {
+      get {
+        return true;
+      }
+    }
+
+    public override void WriteTo(pb::ICodedOutputStream output) {
+      int size = SerializedSize;
+      string[] field_names = _payloadFieldNames;
+      if (hasType) {
+        output.WriteEnum(1, field_names[1], (int) Type, Type);
+      }
+      if (hasBody) {
+        output.WriteBytes(2, field_names[0], Body);
+      }
+      UnknownFields.WriteTo(output);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public override int SerializedSize {
+      get {
+        int size = memoizedSerializedSize;
+        if (size != -1) return size;
+
+        size = 0;
+        if (hasType) {
+          size += pb::CodedOutputStream.ComputeEnumSize(1, (int) Type);
+        }
+        if (hasBody) {
+          size += pb::CodedOutputStream.ComputeBytesSize(2, Body);
+        }
+        size += UnknownFields.SerializedSize;
+        memoizedSerializedSize = size;
+        return size;
+      }
+    }
+
+    public static Payload ParseFrom(pb::ByteString data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static Payload ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static Payload ParseFrom(byte[] data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static Payload ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static Payload ParseFrom(global::System.IO.Stream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static Payload ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    public static Payload ParseDelimitedFrom(global::System.IO.Stream input) {
+      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
+    }
+    public static Payload ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
+    }
+    public static Payload ParseFrom(pb::ICodedInputStream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static Payload ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    private Payload MakeReadOnly() {
+      return this;
+    }
+
+    public static Builder CreateBuilder() { return new Builder(); }
+    public override Builder ToBuilder() { return CreateBuilder(this); }
+    public override Builder CreateBuilderForType() { return new Builder(); }
+    public static Builder CreateBuilder(Payload prototype) {
+      return new Builder(prototype);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    public sealed partial class Builder : pb::GeneratedBuilder<Payload, Builder> {
+      protected override Builder ThisBuilder {
+        get { return this; }
+      }
+      public Builder() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+      }
+      internal Builder(Payload cloneFrom) {
+        result = cloneFrom;
+        resultIsReadOnly = true;
+      }
+
+      private bool resultIsReadOnly;
+      private Payload result;
+
+      private Payload PrepareBuilder() {
+        if (resultIsReadOnly) {
+          Payload original = result;
+          result = new Payload();
+          resultIsReadOnly = false;
+          MergeFrom(original);
+        }
+        return result;
+      }
+
+      public override bool IsInitialized {
+        get { return result.IsInitialized; }
+      }
+
+      protected override Payload MessageBeingBuilt {
+        get { return PrepareBuilder(); }
+      }
+
+      public override Builder Clear() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+        return this;
+      }
+
+      public override Builder Clone() {
+        if (resultIsReadOnly) {
+          return new Builder(result);
+        } else {
+          return new Builder().MergeFrom(result);
+        }
+      }
+
+      public override pbd::MessageDescriptor DescriptorForType {
+        get { return global::grpc.testing.Payload.Descriptor; }
+      }
+
+      public override Payload DefaultInstanceForType {
+        get { return global::grpc.testing.Payload.DefaultInstance; }
+      }
+
+      public override Payload BuildPartial() {
+        if (resultIsReadOnly) {
+          return result;
+        }
+        resultIsReadOnly = true;
+        return result.MakeReadOnly();
+      }
+
+      public override Builder MergeFrom(pb::IMessage other) {
+        if (other is Payload) {
+          return MergeFrom((Payload) other);
+        } else {
+          base.MergeFrom(other);
+          return this;
+        }
+      }
+
+      public override Builder MergeFrom(Payload other) {
+        if (other == global::grpc.testing.Payload.DefaultInstance) return this;
+        PrepareBuilder();
+        if (other.HasType) {
+          Type = other.Type;
+        }
+        if (other.HasBody) {
+          Body = other.Body;
+        }
+        this.MergeUnknownFields(other.UnknownFields);
+        return this;
+      }
+
+      public override Builder MergeFrom(pb::ICodedInputStream input) {
+        return MergeFrom(input, pb::ExtensionRegistry.Empty);
+      }
+
+      public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+        PrepareBuilder();
+        pb::UnknownFieldSet.Builder unknownFields = null;
+        uint tag;
+        string field_name;
+        while (input.ReadTag(out tag, out field_name)) {
+          if(tag == 0 && field_name != null) {
+            int field_ordinal = global::System.Array.BinarySearch(_payloadFieldNames, field_name, global::System.StringComparer.Ordinal);
+            if(field_ordinal >= 0)
+              tag = _payloadFieldTags[field_ordinal];
+            else {
+              if (unknownFields == null) {
+                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+              }
+              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
+              continue;
+            }
+          }
+          switch (tag) {
+            case 0: {
+              throw pb::InvalidProtocolBufferException.InvalidTag();
+            }
+            default: {
+              if (pb::WireFormat.IsEndGroupTag(tag)) {
+                if (unknownFields != null) {
+                  this.UnknownFields = unknownFields.Build();
+                }
+                return this;
+              }
+              if (unknownFields == null) {
+                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+              }
+              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
+              break;
+            }
+            case 8: {
+              object unknown;
+              if(input.ReadEnum(ref result.type_, out unknown)) {
+                result.hasType = true;
+              } else if(unknown is int) {
+                if (unknownFields == null) {
+                  unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+                }
+                unknownFields.MergeVarintField(1, (ulong)(int)unknown);
+              }
+              break;
+            }
+            case 18: {
+              result.hasBody = input.ReadBytes(ref result.body_);
+              break;
+            }
+          }
+        }
+
+        if (unknownFields != null) {
+          this.UnknownFields = unknownFields.Build();
+        }
+        return this;
+      }
+
+
+      public bool HasType {
+       get { return result.hasType; }
+      }
+      public global::grpc.testing.PayloadType Type {
+        get { return result.Type; }
+        set { SetType(value); }
+      }
+      public Builder SetType(global::grpc.testing.PayloadType value) {
+        PrepareBuilder();
+        result.hasType = true;
+        result.type_ = value;
+        return this;
+      }
+      public Builder ClearType() {
+        PrepareBuilder();
+        result.hasType = false;
+        result.type_ = global::grpc.testing.PayloadType.COMPRESSABLE;
+        return this;
+      }
+
+      public bool HasBody {
+        get { return result.hasBody; }
+      }
+      public pb::ByteString Body {
+        get { return result.Body; }
+        set { SetBody(value); }
+      }
+      public Builder SetBody(pb::ByteString value) {
+        pb::ThrowHelper.ThrowIfNull(value, "value");
+        PrepareBuilder();
+        result.hasBody = true;
+        result.body_ = value;
+        return this;
+      }
+      public Builder ClearBody() {
+        PrepareBuilder();
+        result.hasBody = false;
+        result.body_ = pb::ByteString.Empty;
+        return this;
+      }
+    }
+    static Payload() {
+      object.ReferenceEquals(global::grpc.testing.Messages.Descriptor, null);
+    }
+  }
+
+  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+  public sealed partial class SimpleRequest : pb::GeneratedMessage<SimpleRequest, SimpleRequest.Builder> {
+    private SimpleRequest() { }
+    private static readonly SimpleRequest defaultInstance = new SimpleRequest().MakeReadOnly();
+    private static readonly string[] _simpleRequestFieldNames = new string[] { "fill_oauth_scope", "fill_username", "payload", "response_size", "response_type" };
+    private static readonly uint[] _simpleRequestFieldTags = new uint[] { 40, 32, 26, 16, 8 };
+    public static SimpleRequest DefaultInstance {
+      get { return defaultInstance; }
+    }
+
+    public override SimpleRequest DefaultInstanceForType {
+      get { return DefaultInstance; }
+    }
+
+    protected override SimpleRequest ThisMessage {
+      get { return this; }
+    }
+
+    public static pbd::MessageDescriptor Descriptor {
+      get { return global::grpc.testing.Messages.internal__static_grpc_testing_SimpleRequest__Descriptor; }
+    }
+
+    protected override pb::FieldAccess.FieldAccessorTable<SimpleRequest, SimpleRequest.Builder> InternalFieldAccessors {
+      get { return global::grpc.testing.Messages.internal__static_grpc_testing_SimpleRequest__FieldAccessorTable; }
+    }
+
+    public const int ResponseTypeFieldNumber = 1;
+    private bool hasResponseType;
+    private global::grpc.testing.PayloadType responseType_ = global::grpc.testing.PayloadType.COMPRESSABLE;
+    public bool HasResponseType {
+      get { return hasResponseType; }
+    }
+    public global::grpc.testing.PayloadType ResponseType {
+      get { return responseType_; }
+    }
+
+    public const int ResponseSizeFieldNumber = 2;
+    private bool hasResponseSize;
+    private int responseSize_;
+    public bool HasResponseSize {
+      get { return hasResponseSize; }
+    }
+    public int ResponseSize {
+      get { return responseSize_; }
+    }
+
+    public const int PayloadFieldNumber = 3;
+    private bool hasPayload;
+    private global::grpc.testing.Payload payload_;
+    public bool HasPayload {
+      get { return hasPayload; }
+    }
+    public global::grpc.testing.Payload Payload {
+      get { return payload_ ?? global::grpc.testing.Payload.DefaultInstance; }
+    }
+
+    public const int FillUsernameFieldNumber = 4;
+    private bool hasFillUsername;
+    private bool fillUsername_;
+    public bool HasFillUsername {
+      get { return hasFillUsername; }
+    }
+    public bool FillUsername {
+      get { return fillUsername_; }
+    }
+
+    public const int FillOauthScopeFieldNumber = 5;
+    private bool hasFillOauthScope;
+    private bool fillOauthScope_;
+    public bool HasFillOauthScope {
+      get { return hasFillOauthScope; }
+    }
+    public bool FillOauthScope {
+      get { return fillOauthScope_; }
+    }
+
+    public override bool IsInitialized {
+      get {
+        return true;
+      }
+    }
+
+    public override void WriteTo(pb::ICodedOutputStream output) {
+      int size = SerializedSize;
+      string[] field_names = _simpleRequestFieldNames;
+      if (hasResponseType) {
+        output.WriteEnum(1, field_names[4], (int) ResponseType, ResponseType);
+      }
+      if (hasResponseSize) {
+        output.WriteInt32(2, field_names[3], ResponseSize);
+      }
+      if (hasPayload) {
+        output.WriteMessage(3, field_names[2], Payload);
+      }
+      if (hasFillUsername) {
+        output.WriteBool(4, field_names[1], FillUsername);
+      }
+      if (hasFillOauthScope) {
+        output.WriteBool(5, field_names[0], FillOauthScope);
+      }
+      UnknownFields.WriteTo(output);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public override int SerializedSize {
+      get {
+        int size = memoizedSerializedSize;
+        if (size != -1) return size;
+
+        size = 0;
+        if (hasResponseType) {
+          size += pb::CodedOutputStream.ComputeEnumSize(1, (int) ResponseType);
+        }
+        if (hasResponseSize) {
+          size += pb::CodedOutputStream.ComputeInt32Size(2, ResponseSize);
+        }
+        if (hasPayload) {
+          size += pb::CodedOutputStream.ComputeMessageSize(3, Payload);
+        }
+        if (hasFillUsername) {
+          size += pb::CodedOutputStream.ComputeBoolSize(4, FillUsername);
+        }
+        if (hasFillOauthScope) {
+          size += pb::CodedOutputStream.ComputeBoolSize(5, FillOauthScope);
+        }
+        size += UnknownFields.SerializedSize;
+        memoizedSerializedSize = size;
+        return size;
+      }
+    }
+
+    public static SimpleRequest ParseFrom(pb::ByteString data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static SimpleRequest ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static SimpleRequest ParseFrom(byte[] data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static SimpleRequest ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static SimpleRequest ParseFrom(global::System.IO.Stream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static SimpleRequest ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    public static SimpleRequest ParseDelimitedFrom(global::System.IO.Stream input) {
+      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
+    }
+    public static SimpleRequest ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
+    }
+    public static SimpleRequest ParseFrom(pb::ICodedInputStream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static SimpleRequest ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    private SimpleRequest MakeReadOnly() {
+      return this;
+    }
+
+    public static Builder CreateBuilder() { return new Builder(); }
+    public override Builder ToBuilder() { return CreateBuilder(this); }
+    public override Builder CreateBuilderForType() { return new Builder(); }
+    public static Builder CreateBuilder(SimpleRequest prototype) {
+      return new Builder(prototype);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    public sealed partial class Builder : pb::GeneratedBuilder<SimpleRequest, Builder> {
+      protected override Builder ThisBuilder {
+        get { return this; }
+      }
+      public Builder() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+      }
+      internal Builder(SimpleRequest cloneFrom) {
+        result = cloneFrom;
+        resultIsReadOnly = true;
+      }
+
+      private bool resultIsReadOnly;
+      private SimpleRequest result;
+
+      private SimpleRequest PrepareBuilder() {
+        if (resultIsReadOnly) {
+          SimpleRequest original = result;
+          result = new SimpleRequest();
+          resultIsReadOnly = false;
+          MergeFrom(original);
+        }
+        return result;
+      }
+
+      public override bool IsInitialized {
+        get { return result.IsInitialized; }
+      }
+
+      protected override SimpleRequest MessageBeingBuilt {
+        get { return PrepareBuilder(); }
+      }
+
+      public override Builder Clear() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+        return this;
+      }
+
+      public override Builder Clone() {
+        if (resultIsReadOnly) {
+          return new Builder(result);
+        } else {
+          return new Builder().MergeFrom(result);
+        }
+      }
+
+      public override pbd::MessageDescriptor DescriptorForType {
+        get { return global::grpc.testing.SimpleRequest.Descriptor; }
+      }
+
+      public override SimpleRequest DefaultInstanceForType {
+        get { return global::grpc.testing.SimpleRequest.DefaultInstance; }
+      }
+
+      public override SimpleRequest BuildPartial() {
+        if (resultIsReadOnly) {
+          return result;
+        }
+        resultIsReadOnly = true;
+        return result.MakeReadOnly();
+      }
+
+      public override Builder MergeFrom(pb::IMessage other) {
+        if (other is SimpleRequest) {
+          return MergeFrom((SimpleRequest) other);
+        } else {
+          base.MergeFrom(other);
+          return this;
+        }
+      }
+
+      public override Builder MergeFrom(SimpleRequest other) {
+        if (other == global::grpc.testing.SimpleRequest.DefaultInstance) return this;
+        PrepareBuilder();
+        if (other.HasResponseType) {
+          ResponseType = other.ResponseType;
+        }
+        if (other.HasResponseSize) {
+          ResponseSize = other.ResponseSize;
+        }
+        if (other.HasPayload) {
+          MergePayload(other.Payload);
+        }
+        if (other.HasFillUsername) {
+          FillUsername = other.FillUsername;
+        }
+        if (other.HasFillOauthScope) {
+          FillOauthScope = other.FillOauthScope;
+        }
+        this.MergeUnknownFields(other.UnknownFields);
+        return this;
+      }
+
+      public override Builder MergeFrom(pb::ICodedInputStream input) {
+        return MergeFrom(input, pb::ExtensionRegistry.Empty);
+      }
+
+      public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+        PrepareBuilder();
+        pb::UnknownFieldSet.Builder unknownFields = null;
+        uint tag;
+        string field_name;
+        while (input.ReadTag(out tag, out field_name)) {
+          if(tag == 0 && field_name != null) {
+            int field_ordinal = global::System.Array.BinarySearch(_simpleRequestFieldNames, field_name, global::System.StringComparer.Ordinal);
+            if(field_ordinal >= 0)
+              tag = _simpleRequestFieldTags[field_ordinal];
+            else {
+              if (unknownFields == null) {
+                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+              }
+              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
+              continue;
+            }
+          }
+          switch (tag) {
+            case 0: {
+              throw pb::InvalidProtocolBufferException.InvalidTag();
+            }
+            default: {
+              if (pb::WireFormat.IsEndGroupTag(tag)) {
+                if (unknownFields != null) {
+                  this.UnknownFields = unknownFields.Build();
+                }
+                return this;
+              }
+              if (unknownFields == null) {
+                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+              }
+              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
+              break;
+            }
+            case 8: {
+              object unknown;
+              if(input.ReadEnum(ref result.responseType_, out unknown)) {
+                result.hasResponseType = true;
+              } else if(unknown is int) {
+                if (unknownFields == null) {
+                  unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+                }
+                unknownFields.MergeVarintField(1, (ulong)(int)unknown);
+              }
+              break;
+            }
+            case 16: {
+              result.hasResponseSize = input.ReadInt32(ref result.responseSize_);
+              break;
+            }
+            case 26: {
+              global::grpc.testing.Payload.Builder subBuilder = global::grpc.testing.Payload.CreateBuilder();
+              if (result.hasPayload) {
+                subBuilder.MergeFrom(Payload);
+              }
+              input.ReadMessage(subBuilder, extensionRegistry);
+              Payload = subBuilder.BuildPartial();
+              break;
+            }
+            case 32: {
+              result.hasFillUsername = input.ReadBool(ref result.fillUsername_);
+              break;
+            }
+            case 40: {
+              result.hasFillOauthScope = input.ReadBool(ref result.fillOauthScope_);
+              break;
+            }
+          }
+        }
+
+        if (unknownFields != null) {
+          this.UnknownFields = unknownFields.Build();
+        }
+        return this;
+      }
+
+
+      public bool HasResponseType {
+       get { return result.hasResponseType; }
+      }
+      public global::grpc.testing.PayloadType ResponseType {
+        get { return result.ResponseType; }
+        set { SetResponseType(value); }
+      }
+      public Builder SetResponseType(global::grpc.testing.PayloadType value) {
+        PrepareBuilder();
+        result.hasResponseType = true;
+        result.responseType_ = value;
+        return this;
+      }
+      public Builder ClearResponseType() {
+        PrepareBuilder();
+        result.hasResponseType = false;
+        result.responseType_ = global::grpc.testing.PayloadType.COMPRESSABLE;
+        return this;
+      }
+
+      public bool HasResponseSize {
+        get { return result.hasResponseSize; }
+      }
+      public int ResponseSize {
+        get { return result.ResponseSize; }
+        set { SetResponseSize(value); }
+      }
+      public Builder SetResponseSize(int value) {
+        PrepareBuilder();
+        result.hasResponseSize = true;
+        result.responseSize_ = value;
+        return this;
+      }
+      public Builder ClearResponseSize() {
+        PrepareBuilder();
+        result.hasResponseSize = false;
+        result.responseSize_ = 0;
+        return this;
+      }
+
+      public bool HasPayload {
+       get { return result.hasPayload; }
+      }
+      public global::grpc.testing.Payload Payload {
+        get { return result.Payload; }
+        set { SetPayload(value); }
+      }
+      public Builder SetPayload(global::grpc.testing.Payload value) {
+        pb::ThrowHelper.ThrowIfNull(value, "value");
+        PrepareBuilder();
+        result.hasPayload = true;
+        result.payload_ = value;
+        return this;
+      }
+      public Builder SetPayload(global::grpc.testing.Payload.Builder builderForValue) {
+        pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
+        PrepareBuilder();
+        result.hasPayload = true;
+        result.payload_ = builderForValue.Build();
+        return this;
+      }
+      public Builder MergePayload(global::grpc.testing.Payload value) {
+        pb::ThrowHelper.ThrowIfNull(value, "value");
+        PrepareBuilder();
+        if (result.hasPayload &&
+            result.payload_ != global::grpc.testing.Payload.DefaultInstance) {
+            result.payload_ = global::grpc.testing.Payload.CreateBuilder(result.payload_).MergeFrom(value).BuildPartial();
+        } else {
+          result.payload_ = value;
+        }
+        result.hasPayload = true;
+        return this;
+      }
+      public Builder ClearPayload() {
+        PrepareBuilder();
+        result.hasPayload = false;
+        result.payload_ = null;
+        return this;
+      }
+
+      public bool HasFillUsername {
+        get { return result.hasFillUsername; }
+      }
+      public bool FillUsername {
+        get { return result.FillUsername; }
+        set { SetFillUsername(value); }
+      }
+      public Builder SetFillUsername(bool value) {
+        PrepareBuilder();
+        result.hasFillUsername = true;
+        result.fillUsername_ = value;
+        return this;
+      }
+      public Builder ClearFillUsername() {
+        PrepareBuilder();
+        result.hasFillUsername = false;
+        result.fillUsername_ = false;
+        return this;
+      }
+
+      public bool HasFillOauthScope {
+        get { return result.hasFillOauthScope; }
+      }
+      public bool FillOauthScope {
+        get { return result.FillOauthScope; }
+        set { SetFillOauthScope(value); }
+      }
+      public Builder SetFillOauthScope(bool value) {
+        PrepareBuilder();
+        result.hasFillOauthScope = true;
+        result.fillOauthScope_ = value;
+        return this;
+      }
+      public Builder ClearFillOauthScope() {
+        PrepareBuilder();
+        result.hasFillOauthScope = false;
+        result.fillOauthScope_ = false;
+        return this;
+      }
+    }
+    static SimpleRequest() {
+      object.ReferenceEquals(global::grpc.testing.Messages.Descriptor, null);
+    }
+  }
+
+  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+  public sealed partial class SimpleResponse : pb::GeneratedMessage<SimpleResponse, SimpleResponse.Builder> {
+    private SimpleResponse() { }
+    private static readonly SimpleResponse defaultInstance = new SimpleResponse().MakeReadOnly();
+    private static readonly string[] _simpleResponseFieldNames = new string[] { "oauth_scope", "payload", "username" };
+    private static readonly uint[] _simpleResponseFieldTags = new uint[] { 26, 10, 18 };
+    public static SimpleResponse DefaultInstance {
+      get { return defaultInstance; }
+    }
+
+    public override SimpleResponse DefaultInstanceForType {
+      get { return DefaultInstance; }
+    }
+
+    protected override SimpleResponse ThisMessage {
+      get { return this; }
+    }
+
+    public static pbd::MessageDescriptor Descriptor {
+      get { return global::grpc.testing.Messages.internal__static_grpc_testing_SimpleResponse__Descriptor; }
+    }
+
+    protected override pb::FieldAccess.FieldAccessorTable<SimpleResponse, SimpleResponse.Builder> InternalFieldAccessors {
+      get { return global::grpc.testing.Messages.internal__static_grpc_testing_SimpleResponse__FieldAccessorTable; }
+    }
+
+    public const int PayloadFieldNumber = 1;
+    private bool hasPayload;
+    private global::grpc.testing.Payload payload_;
+    public bool HasPayload {
+      get { return hasPayload; }
+    }
+    public global::grpc.testing.Payload Payload {
+      get { return payload_ ?? global::grpc.testing.Payload.DefaultInstance; }
+    }
+
+    public const int UsernameFieldNumber = 2;
+    private bool hasUsername;
+    private string username_ = "";
+    public bool HasUsername {
+      get { return hasUsername; }
+    }
+    public string Username {
+      get { return username_; }
+    }
+
+    public const int OauthScopeFieldNumber = 3;
+    private bool hasOauthScope;
+    private string oauthScope_ = "";
+    public bool HasOauthScope {
+      get { return hasOauthScope; }
+    }
+    public string OauthScope {
+      get { return oauthScope_; }
+    }
+
+    public override bool IsInitialized {
+      get {
+        return true;
+      }
+    }
+
+    public override void WriteTo(pb::ICodedOutputStream output) {
+      int size = SerializedSize;
+      string[] field_names = _simpleResponseFieldNames;
+      if (hasPayload) {
+        output.WriteMessage(1, field_names[1], Payload);
+      }
+      if (hasUsername) {
+        output.WriteString(2, field_names[2], Username);
+      }
+      if (hasOauthScope) {
+        output.WriteString(3, field_names[0], OauthScope);
+      }
+      UnknownFields.WriteTo(output);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public override int SerializedSize {
+      get {
+        int size = memoizedSerializedSize;
+        if (size != -1) return size;
+
+        size = 0;
+        if (hasPayload) {
+          size += pb::CodedOutputStream.ComputeMessageSize(1, Payload);
+        }
+        if (hasUsername) {
+          size += pb::CodedOutputStream.ComputeStringSize(2, Username);
+        }
+        if (hasOauthScope) {
+          size += pb::CodedOutputStream.ComputeStringSize(3, OauthScope);
+        }
+        size += UnknownFields.SerializedSize;
+        memoizedSerializedSize = size;
+        return size;
+      }
+    }
+
+    public static SimpleResponse ParseFrom(pb::ByteString data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static SimpleResponse ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static SimpleResponse ParseFrom(byte[] data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static SimpleResponse ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static SimpleResponse ParseFrom(global::System.IO.Stream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static SimpleResponse ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    public static SimpleResponse ParseDelimitedFrom(global::System.IO.Stream input) {
+      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
+    }
+    public static SimpleResponse ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
+    }
+    public static SimpleResponse ParseFrom(pb::ICodedInputStream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static SimpleResponse ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    private SimpleResponse MakeReadOnly() {
+      return this;
+    }
+
+    public static Builder CreateBuilder() { return new Builder(); }
+    public override Builder ToBuilder() { return CreateBuilder(this); }
+    public override Builder CreateBuilderForType() { return new Builder(); }
+    public static Builder CreateBuilder(SimpleResponse prototype) {
+      return new Builder(prototype);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    public sealed partial class Builder : pb::GeneratedBuilder<SimpleResponse, Builder> {
+      protected override Builder ThisBuilder {
+        get { return this; }
+      }
+      public Builder() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+      }
+      internal Builder(SimpleResponse cloneFrom) {
+        result = cloneFrom;
+        resultIsReadOnly = true;
+      }
+
+      private bool resultIsReadOnly;
+      private SimpleResponse result;
+
+      private SimpleResponse PrepareBuilder() {
+        if (resultIsReadOnly) {
+          SimpleResponse original = result;
+          result = new SimpleResponse();
+          resultIsReadOnly = false;
+          MergeFrom(original);
+        }
+        return result;
+      }
+
+      public override bool IsInitialized {
+        get { return result.IsInitialized; }
+      }
+
+      protected override SimpleResponse MessageBeingBuilt {
+        get { return PrepareBuilder(); }
+      }
+
+      public override Builder Clear() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+        return this;
+      }
+
+      public override Builder Clone() {
+        if (resultIsReadOnly) {
+          return new Builder(result);
+        } else {
+          return new Builder().MergeFrom(result);
+        }
+      }
+
+      public override pbd::MessageDescriptor DescriptorForType {
+        get { return global::grpc.testing.SimpleResponse.Descriptor; }
+      }
+
+      public override SimpleResponse DefaultInstanceForType {
+        get { return global::grpc.testing.SimpleResponse.DefaultInstance; }
+      }
+
+      public override SimpleResponse BuildPartial() {
+        if (resultIsReadOnly) {
+          return result;
+        }
+        resultIsReadOnly = true;
+        return result.MakeReadOnly();
+      }
+
+      public override Builder MergeFrom(pb::IMessage other) {
+        if (other is SimpleResponse) {
+          return MergeFrom((SimpleResponse) other);
+        } else {
+          base.MergeFrom(other);
+          return this;
+        }
+      }
+
+      public override Builder MergeFrom(SimpleResponse other) {
+        if (other == global::grpc.testing.SimpleResponse.DefaultInstance) return this;
+        PrepareBuilder();
+        if (other.HasPayload) {
+          MergePayload(other.Payload);
+        }
+        if (other.HasUsername) {
+          Username = other.Username;
+        }
+        if (other.HasOauthScope) {
+          OauthScope = other.OauthScope;
+        }
+        this.MergeUnknownFields(other.UnknownFields);
+        return this;
+      }
+
+      public override Builder MergeFrom(pb::ICodedInputStream input) {
+        return MergeFrom(input, pb::ExtensionRegistry.Empty);
+      }
+
+      public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+        PrepareBuilder();
+        pb::UnknownFieldSet.Builder unknownFields = null;
+        uint tag;
+        string field_name;
+        while (input.ReadTag(out tag, out field_name)) {
+          if(tag == 0 && field_name != null) {
+            int field_ordinal = global::System.Array.BinarySearch(_simpleResponseFieldNames, field_name, global::System.StringComparer.Ordinal);
+            if(field_ordinal >= 0)
+              tag = _simpleResponseFieldTags[field_ordinal];
+            else {
+              if (unknownFields == null) {
+                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+              }
+              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
+              continue;
+            }
+          }
+          switch (tag) {
+            case 0: {
+              throw pb::InvalidProtocolBufferException.InvalidTag();
+            }
+            default: {
+              if (pb::WireFormat.IsEndGroupTag(tag)) {
+                if (unknownFields != null) {
+                  this.UnknownFields = unknownFields.Build();
+                }
+                return this;
+              }
+              if (unknownFields == null) {
+                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+              }
+              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
+              break;
+            }
+            case 10: {
+              global::grpc.testing.Payload.Builder subBuilder = global::grpc.testing.Payload.CreateBuilder();
+              if (result.hasPayload) {
+                subBuilder.MergeFrom(Payload);
+              }
+              input.ReadMessage(subBuilder, extensionRegistry);
+              Payload = subBuilder.BuildPartial();
+              break;
+            }
+            case 18: {
+              result.hasUsername = input.ReadString(ref result.username_);
+              break;
+            }
+            case 26: {
+              result.hasOauthScope = input.ReadString(ref result.oauthScope_);
+              break;
+            }
+          }
+        }
+
+        if (unknownFields != null) {
+          this.UnknownFields = unknownFields.Build();
+        }
+        return this;
+      }
+
+
+      public bool HasPayload {
+       get { return result.hasPayload; }
+      }
+      public global::grpc.testing.Payload Payload {
+        get { return result.Payload; }
+        set { SetPayload(value); }
+      }
+      public Builder SetPayload(global::grpc.testing.Payload value) {
+        pb::ThrowHelper.ThrowIfNull(value, "value");
+        PrepareBuilder();
+        result.hasPayload = true;
+        result.payload_ = value;
+        return this;
+      }
+      public Builder SetPayload(global::grpc.testing.Payload.Builder builderForValue) {
+        pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
+        PrepareBuilder();
+        result.hasPayload = true;
+        result.payload_ = builderForValue.Build();
+        return this;
+      }
+      public Builder MergePayload(global::grpc.testing.Payload value) {
+        pb::ThrowHelper.ThrowIfNull(value, "value");
+        PrepareBuilder();
+        if (result.hasPayload &&
+            result.payload_ != global::grpc.testing.Payload.DefaultInstance) {
+            result.payload_ = global::grpc.testing.Payload.CreateBuilder(result.payload_).MergeFrom(value).BuildPartial();
+        } else {
+          result.payload_ = value;
+        }
+        result.hasPayload = true;
+        return this;
+      }
+      public Builder ClearPayload() {
+        PrepareBuilder();
+        result.hasPayload = false;
+        result.payload_ = null;
+        return this;
+      }
+
+      public bool HasUsername {
+        get { return result.hasUsername; }
+      }
+      public string Username {
+        get { return result.Username; }
+        set { SetUsername(value); }
+      }
+      public Builder SetUsername(string value) {
+        pb::ThrowHelper.ThrowIfNull(value, "value");
+        PrepareBuilder();
+        result.hasUsername = true;
+        result.username_ = value;
+        return this;
+      }
+      public Builder ClearUsername() {
+        PrepareBuilder();
+        result.hasUsername = false;
+        result.username_ = "";
+        return this;
+      }
+
+      public bool HasOauthScope {
+        get { return result.hasOauthScope; }
+      }
+      public string OauthScope {
+        get { return result.OauthScope; }
+        set { SetOauthScope(value); }
+      }
+      public Builder SetOauthScope(string value) {
+        pb::ThrowHelper.ThrowIfNull(value, "value");
+        PrepareBuilder();
+        result.hasOauthScope = true;
+        result.oauthScope_ = value;
+        return this;
+      }
+      public Builder ClearOauthScope() {
+        PrepareBuilder();
+        result.hasOauthScope = false;
+        result.oauthScope_ = "";
+        return this;
+      }
+    }
+    static SimpleResponse() {
+      object.ReferenceEquals(global::grpc.testing.Messages.Descriptor, null);
+    }
+  }
+
+  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+  public sealed partial class StreamingInputCallRequest : pb::GeneratedMessage<StreamingInputCallRequest, StreamingInputCallRequest.Builder> {
+    private StreamingInputCallRequest() { }
+    private static readonly StreamingInputCallRequest defaultInstance = new StreamingInputCallRequest().MakeReadOnly();
+    private static readonly string[] _streamingInputCallRequestFieldNames = new string[] { "payload" };
+    private static readonly uint[] _streamingInputCallRequestFieldTags = new uint[] { 10 };
+    public static StreamingInputCallRequest DefaultInstance {
+      get { return defaultInstance; }
+    }
+
+    public override StreamingInputCallRequest DefaultInstanceForType {
+      get { return DefaultInstance; }
+    }
+
+    protected override StreamingInputCallRequest ThisMessage {
+      get { return this; }
+    }
+
+    public static pbd::MessageDescriptor Descriptor {
+      get { return global::grpc.testing.Messages.internal__static_grpc_testing_StreamingInputCallRequest__Descriptor; }
+    }
+
+    protected override pb::FieldAccess.FieldAccessorTable<StreamingInputCallRequest, StreamingInputCallRequest.Builder> InternalFieldAccessors {
+      get { return global::grpc.testing.Messages.internal__static_grpc_testing_StreamingInputCallRequest__FieldAccessorTable; }
+    }
+
+    public const int PayloadFieldNumber = 1;
+    private bool hasPayload;
+    private global::grpc.testing.Payload payload_;
+    public bool HasPayload {
+      get { return hasPayload; }
+    }
+    public global::grpc.testing.Payload Payload {
+      get { return payload_ ?? global::grpc.testing.Payload.DefaultInstance; }
+    }
+
+    public override bool IsInitialized {
+      get {
+        return true;
+      }
+    }
+
+    public override void WriteTo(pb::ICodedOutputStream output) {
+      int size = SerializedSize;
+      string[] field_names = _streamingInputCallRequestFieldNames;
+      if (hasPayload) {
+        output.WriteMessage(1, field_names[0], Payload);
+      }
+      UnknownFields.WriteTo(output);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public override int SerializedSize {
+      get {
+        int size = memoizedSerializedSize;
+        if (size != -1) return size;
+
+        size = 0;
+        if (hasPayload) {
+          size += pb::CodedOutputStream.ComputeMessageSize(1, Payload);
+        }
+        size += UnknownFields.SerializedSize;
+        memoizedSerializedSize = size;
+        return size;
+      }
+    }
+
+    public static StreamingInputCallRequest ParseFrom(pb::ByteString data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static StreamingInputCallRequest ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static StreamingInputCallRequest ParseFrom(byte[] data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static StreamingInputCallRequest ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static StreamingInputCallRequest ParseFrom(global::System.IO.Stream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static StreamingInputCallRequest ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    public static StreamingInputCallRequest ParseDelimitedFrom(global::System.IO.Stream input) {
+      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
+    }
+    public static StreamingInputCallRequest ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
+    }
+    public static StreamingInputCallRequest ParseFrom(pb::ICodedInputStream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static StreamingInputCallRequest ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    private StreamingInputCallRequest MakeReadOnly() {
+      return this;
+    }
+
+    public static Builder CreateBuilder() { return new Builder(); }
+    public override Builder ToBuilder() { return CreateBuilder(this); }
+    public override Builder CreateBuilderForType() { return new Builder(); }
+    public static Builder CreateBuilder(StreamingInputCallRequest prototype) {
+      return new Builder(prototype);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    public sealed partial class Builder : pb::GeneratedBuilder<StreamingInputCallRequest, Builder> {
+      protected override Builder ThisBuilder {
+        get { return this; }
+      }
+      public Builder() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+      }
+      internal Builder(StreamingInputCallRequest cloneFrom) {
+        result = cloneFrom;
+        resultIsReadOnly = true;
+      }
+
+      private bool resultIsReadOnly;
+      private StreamingInputCallRequest result;
+
+      private StreamingInputCallRequest PrepareBuilder() {
+        if (resultIsReadOnly) {
+          StreamingInputCallRequest original = result;
+          result = new StreamingInputCallRequest();
+          resultIsReadOnly = false;
+          MergeFrom(original);
+        }
+        return result;
+      }
+
+      public override bool IsInitialized {
+        get { return result.IsInitialized; }
+      }
+
+      protected override StreamingInputCallRequest MessageBeingBuilt {
+        get { return PrepareBuilder(); }
+      }
+
+      public override Builder Clear() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+        return this;
+      }
+
+      public override Builder Clone() {
+        if (resultIsReadOnly) {
+          return new Builder(result);
+        } else {
+          return new Builder().MergeFrom(result);
+        }
+      }
+
+      public override pbd::MessageDescriptor DescriptorForType {
+        get { return global::grpc.testing.StreamingInputCallRequest.Descriptor; }
+      }
+
+      public override StreamingInputCallRequest DefaultInstanceForType {
+        get { return global::grpc.testing.StreamingInputCallRequest.DefaultInstance; }
+      }
+
+      public override StreamingInputCallRequest BuildPartial() {
+        if (resultIsReadOnly) {
+          return result;
+        }
+        resultIsReadOnly = true;
+        return result.MakeReadOnly();
+      }
+
+      public override Builder MergeFrom(pb::IMessage other) {
+        if (other is StreamingInputCallRequest) {
+          return MergeFrom((StreamingInputCallRequest) other);
+        } else {
+          base.MergeFrom(other);
+          return this;
+        }
+      }
+
+      public override Builder MergeFrom(StreamingInputCallRequest other) {
+        if (other == global::grpc.testing.StreamingInputCallRequest.DefaultInstance) return this;
+        PrepareBuilder();
+        if (other.HasPayload) {
+          MergePayload(other.Payload);
+        }
+        this.MergeUnknownFields(other.UnknownFields);
+        return this;
+      }
+
+      public override Builder MergeFrom(pb::ICodedInputStream input) {
+        return MergeFrom(input, pb::ExtensionRegistry.Empty);
+      }
+
+      public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+        PrepareBuilder();
+        pb::UnknownFieldSet.Builder unknownFields = null;
+        uint tag;
+        string field_name;
+        while (input.ReadTag(out tag, out field_name)) {
+          if(tag == 0 && field_name != null) {
+            int field_ordinal = global::System.Array.BinarySearch(_streamingInputCallRequestFieldNames, field_name, global::System.StringComparer.Ordinal);
+            if(field_ordinal >= 0)
+              tag = _streamingInputCallRequestFieldTags[field_ordinal];
+            else {
+              if (unknownFields == null) {
+                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+              }
+              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
+              continue;
+            }
+          }
+          switch (tag) {
+            case 0: {
+              throw pb::InvalidProtocolBufferException.InvalidTag();
+            }
+            default: {
+              if (pb::WireFormat.IsEndGroupTag(tag)) {
+                if (unknownFields != null) {
+                  this.UnknownFields = unknownFields.Build();
+                }
+                return this;
+              }
+              if (unknownFields == null) {
+                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+              }
+              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
+              break;
+            }
+            case 10: {
+              global::grpc.testing.Payload.Builder subBuilder = global::grpc.testing.Payload.CreateBuilder();
+              if (result.hasPayload) {
+                subBuilder.MergeFrom(Payload);
+              }
+              input.ReadMessage(subBuilder, extensionRegistry);
+              Payload = subBuilder.BuildPartial();
+              break;
+            }
+          }
+        }
+
+        if (unknownFields != null) {
+          this.UnknownFields = unknownFields.Build();
+        }
+        return this;
+      }
+
+
+      public bool HasPayload {
+       get { return result.hasPayload; }
+      }
+      public global::grpc.testing.Payload Payload {
+        get { return result.Payload; }
+        set { SetPayload(value); }
+      }
+      public Builder SetPayload(global::grpc.testing.Payload value) {
+        pb::ThrowHelper.ThrowIfNull(value, "value");
+        PrepareBuilder();
+        result.hasPayload = true;
+        result.payload_ = value;
+        return this;
+      }
+      public Builder SetPayload(global::grpc.testing.Payload.Builder builderForValue) {
+        pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
+        PrepareBuilder();
+        result.hasPayload = true;
+        result.payload_ = builderForValue.Build();
+        return this;
+      }
+      public Builder MergePayload(global::grpc.testing.Payload value) {
+        pb::ThrowHelper.ThrowIfNull(value, "value");
+        PrepareBuilder();
+        if (result.hasPayload &&
+            result.payload_ != global::grpc.testing.Payload.DefaultInstance) {
+            result.payload_ = global::grpc.testing.Payload.CreateBuilder(result.payload_).MergeFrom(value).BuildPartial();
+        } else {
+          result.payload_ = value;
+        }
+        result.hasPayload = true;
+        return this;
+      }
+      public Builder ClearPayload() {
+        PrepareBuilder();
+        result.hasPayload = false;
+        result.payload_ = null;
+        return this;
+      }
+    }
+    static StreamingInputCallRequest() {
+      object.ReferenceEquals(global::grpc.testing.Messages.Descriptor, null);
+    }
+  }
+
+  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+  public sealed partial class StreamingInputCallResponse : pb::GeneratedMessage<StreamingInputCallResponse, StreamingInputCallResponse.Builder> {
+    private StreamingInputCallResponse() { }
+    private static readonly StreamingInputCallResponse defaultInstance = new StreamingInputCallResponse().MakeReadOnly();
+    private static readonly string[] _streamingInputCallResponseFieldNames = new string[] { "aggregated_payload_size" };
+    private static readonly uint[] _streamingInputCallResponseFieldTags = new uint[] { 8 };
+    public static StreamingInputCallResponse DefaultInstance {
+      get { return defaultInstance; }
+    }
+
+    public override StreamingInputCallResponse DefaultInstanceForType {
+      get { return DefaultInstance; }
+    }
+
+    protected override StreamingInputCallResponse ThisMessage {
+      get { return this; }
+    }
+
+    public static pbd::MessageDescriptor Descriptor {
+      get { return global::grpc.testing.Messages.internal__static_grpc_testing_StreamingInputCallResponse__Descriptor; }
+    }
+
+    protected override pb::FieldAccess.FieldAccessorTable<StreamingInputCallResponse, StreamingInputCallResponse.Builder> InternalFieldAccessors {
+      get { return global::grpc.testing.Messages.internal__static_grpc_testing_StreamingInputCallResponse__FieldAccessorTable; }
+    }
+
+    public const int AggregatedPayloadSizeFieldNumber = 1;
+    private bool hasAggregatedPayloadSize;
+    private int aggregatedPayloadSize_;
+    public bool HasAggregatedPayloadSize {
+      get { return hasAggregatedPayloadSize; }
+    }
+    public int AggregatedPayloadSize {
+      get { return aggregatedPayloadSize_; }
+    }
+
+    public override bool IsInitialized {
+      get {
+        return true;
+      }
+    }
+
+    public override void WriteTo(pb::ICodedOutputStream output) {
+      int size = SerializedSize;
+      string[] field_names = _streamingInputCallResponseFieldNames;
+      if (hasAggregatedPayloadSize) {
+        output.WriteInt32(1, field_names[0], AggregatedPayloadSize);
+      }
+      UnknownFields.WriteTo(output);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public override int SerializedSize {
+      get {
+        int size = memoizedSerializedSize;
+        if (size != -1) return size;
+
+        size = 0;
+        if (hasAggregatedPayloadSize) {
+          size += pb::CodedOutputStream.ComputeInt32Size(1, AggregatedPayloadSize);
+        }
+        size += UnknownFields.SerializedSize;
+        memoizedSerializedSize = size;
+        return size;
+      }
+    }
+
+    public static StreamingInputCallResponse ParseFrom(pb::ByteString data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static StreamingInputCallResponse ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static StreamingInputCallResponse ParseFrom(byte[] data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static StreamingInputCallResponse ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static StreamingInputCallResponse ParseFrom(global::System.IO.Stream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static StreamingInputCallResponse ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    public static StreamingInputCallResponse ParseDelimitedFrom(global::System.IO.Stream input) {
+      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
+    }
+    public static StreamingInputCallResponse ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
+    }
+    public static StreamingInputCallResponse ParseFrom(pb::ICodedInputStream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static StreamingInputCallResponse ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    private StreamingInputCallResponse MakeReadOnly() {
+      return this;
+    }
+
+    public static Builder CreateBuilder() { return new Builder(); }
+    public override Builder ToBuilder() { return CreateBuilder(this); }
+    public override Builder CreateBuilderForType() { return new Builder(); }
+    public static Builder CreateBuilder(StreamingInputCallResponse prototype) {
+      return new Builder(prototype);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    public sealed partial class Builder : pb::GeneratedBuilder<StreamingInputCallResponse, Builder> {
+      protected override Builder ThisBuilder {
+        get { return this; }
+      }
+      public Builder() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+      }
+      internal Builder(StreamingInputCallResponse cloneFrom) {
+        result = cloneFrom;
+        resultIsReadOnly = true;
+      }
+
+      private bool resultIsReadOnly;
+      private StreamingInputCallResponse result;
+
+      private StreamingInputCallResponse PrepareBuilder() {
+        if (resultIsReadOnly) {
+          StreamingInputCallResponse original = result;
+          result = new StreamingInputCallResponse();
+          resultIsReadOnly = false;
+          MergeFrom(original);
+        }
+        return result;
+      }
+
+      public override bool IsInitialized {
+        get { return result.IsInitialized; }
+      }
+
+      protected override StreamingInputCallResponse MessageBeingBuilt {
+        get { return PrepareBuilder(); }
+      }
+
+      public override Builder Clear() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+        return this;
+      }
+
+      public override Builder Clone() {
+        if (resultIsReadOnly) {
+          return new Builder(result);
+        } else {
+          return new Builder().MergeFrom(result);
+        }
+      }
+
+      public override pbd::MessageDescriptor DescriptorForType {
+        get { return global::grpc.testing.StreamingInputCallResponse.Descriptor; }
+      }
+
+      public override StreamingInputCallResponse DefaultInstanceForType {
+        get { return global::grpc.testing.StreamingInputCallResponse.DefaultInstance; }
+      }
+
+      public override StreamingInputCallResponse BuildPartial() {
+        if (resultIsReadOnly) {
+          return result;
+        }
+        resultIsReadOnly = true;
+        return result.MakeReadOnly();
+      }
+
+      public override Builder MergeFrom(pb::IMessage other) {
+        if (other is StreamingInputCallResponse) {
+          return MergeFrom((StreamingInputCallResponse) other);
+        } else {
+          base.MergeFrom(other);
+          return this;
+        }
+      }
+
+      public override Builder MergeFrom(StreamingInputCallResponse other) {
+        if (other == global::grpc.testing.StreamingInputCallResponse.DefaultInstance) return this;
+        PrepareBuilder();
+        if (other.HasAggregatedPayloadSize) {
+          AggregatedPayloadSize = other.AggregatedPayloadSize;
+        }
+        this.MergeUnknownFields(other.UnknownFields);
+        return this;
+      }
+
+      public override Builder MergeFrom(pb::ICodedInputStream input) {
+        return MergeFrom(input, pb::ExtensionRegistry.Empty);
+      }
+
+      public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+        PrepareBuilder();
+        pb::UnknownFieldSet.Builder unknownFields = null;
+        uint tag;
+        string field_name;
+        while (input.ReadTag(out tag, out field_name)) {
+          if(tag == 0 && field_name != null) {
+            int field_ordinal = global::System.Array.BinarySearch(_streamingInputCallResponseFieldNames, field_name, global::System.StringComparer.Ordinal);
+            if(field_ordinal >= 0)
+              tag = _streamingInputCallResponseFieldTags[field_ordinal];
+            else {
+              if (unknownFields == null) {
+                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+              }
+              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
+              continue;
+            }
+          }
+          switch (tag) {
+            case 0: {
+              throw pb::InvalidProtocolBufferException.InvalidTag();
+            }
+            default: {
+              if (pb::WireFormat.IsEndGroupTag(tag)) {
+                if (unknownFields != null) {
+                  this.UnknownFields = unknownFields.Build();
+                }
+                return this;
+              }
+              if (unknownFields == null) {
+                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+              }
+              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
+              break;
+            }
+            case 8: {
+              result.hasAggregatedPayloadSize = input.ReadInt32(ref result.aggregatedPayloadSize_);
+              break;
+            }
+          }
+        }
+
+        if (unknownFields != null) {
+          this.UnknownFields = unknownFields.Build();
+        }
+        return this;
+      }
+
+
+      public bool HasAggregatedPayloadSize {
+        get { return result.hasAggregatedPayloadSize; }
+      }
+      public int AggregatedPayloadSize {
+        get { return result.AggregatedPayloadSize; }
+        set { SetAggregatedPayloadSize(value); }
+      }
+      public Builder SetAggregatedPayloadSize(int value) {
+        PrepareBuilder();
+        result.hasAggregatedPayloadSize = true;
+        result.aggregatedPayloadSize_ = value;
+        return this;
+      }
+      public Builder ClearAggregatedPayloadSize() {
+        PrepareBuilder();
+        result.hasAggregatedPayloadSize = false;
+        result.aggregatedPayloadSize_ = 0;
+        return this;
+      }
+    }
+    static StreamingInputCallResponse() {
+      object.ReferenceEquals(global::grpc.testing.Messages.Descriptor, null);
+    }
+  }
+
+  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+  public sealed partial class ResponseParameters : pb::GeneratedMessage<ResponseParameters, ResponseParameters.Builder> {
+    private ResponseParameters() { }
+    private static readonly ResponseParameters defaultInstance = new ResponseParameters().MakeReadOnly();
+    private static readonly string[] _responseParametersFieldNames = new string[] { "interval_us", "size" };
+    private static readonly uint[] _responseParametersFieldTags = new uint[] { 16, 8 };
+    public static ResponseParameters DefaultInstance {
+      get { return defaultInstance; }
+    }
+
+    public override ResponseParameters DefaultInstanceForType {
+      get { return DefaultInstance; }
+    }
+
+    protected override ResponseParameters ThisMessage {
+      get { return this; }
+    }
+
+    public static pbd::MessageDescriptor Descriptor {
+      get { return global::grpc.testing.Messages.internal__static_grpc_testing_ResponseParameters__Descriptor; }
+    }
+
+    protected override pb::FieldAccess.FieldAccessorTable<ResponseParameters, ResponseParameters.Builder> InternalFieldAccessors {
+      get { return global::grpc.testing.Messages.internal__static_grpc_testing_ResponseParameters__FieldAccessorTable; }
+    }
+
+    public const int SizeFieldNumber = 1;
+    private bool hasSize;
+    private int size_;
+    public bool HasSize {
+      get { return hasSize; }
+    }
+    public int Size {
+      get { return size_; }
+    }
+
+    public const int IntervalUsFieldNumber = 2;
+    private bool hasIntervalUs;
+    private int intervalUs_;
+    public bool HasIntervalUs {
+      get { return hasIntervalUs; }
+    }
+    public int IntervalUs {
+      get { return intervalUs_; }
+    }
+
+    public override bool IsInitialized {
+      get {
+        return true;
+      }
+    }
+
+    public override void WriteTo(pb::ICodedOutputStream output) {
+      int size = SerializedSize;
+      string[] field_names = _responseParametersFieldNames;
+      if (hasSize) {
+        output.WriteInt32(1, field_names[1], Size);
+      }
+      if (hasIntervalUs) {
+        output.WriteInt32(2, field_names[0], IntervalUs);
+      }
+      UnknownFields.WriteTo(output);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public override int SerializedSize {
+      get {
+        int size = memoizedSerializedSize;
+        if (size != -1) return size;
+
+        size = 0;
+        if (hasSize) {
+          size += pb::CodedOutputStream.ComputeInt32Size(1, Size);
+        }
+        if (hasIntervalUs) {
+          size += pb::CodedOutputStream.ComputeInt32Size(2, IntervalUs);
+        }
+        size += UnknownFields.SerializedSize;
+        memoizedSerializedSize = size;
+        return size;
+      }
+    }
+
+    public static ResponseParameters ParseFrom(pb::ByteString data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static ResponseParameters ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static ResponseParameters ParseFrom(byte[] data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static ResponseParameters ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static ResponseParameters ParseFrom(global::System.IO.Stream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static ResponseParameters ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    public static ResponseParameters ParseDelimitedFrom(global::System.IO.Stream input) {
+      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
+    }
+    public static ResponseParameters ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
+    }
+    public static ResponseParameters ParseFrom(pb::ICodedInputStream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static ResponseParameters ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    private ResponseParameters MakeReadOnly() {
+      return this;
+    }
+
+    public static Builder CreateBuilder() { return new Builder(); }
+    public override Builder ToBuilder() { return CreateBuilder(this); }
+    public override Builder CreateBuilderForType() { return new Builder(); }
+    public static Builder CreateBuilder(ResponseParameters prototype) {
+      return new Builder(prototype);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    public sealed partial class Builder : pb::GeneratedBuilder<ResponseParameters, Builder> {
+      protected override Builder ThisBuilder {
+        get { return this; }
+      }
+      public Builder() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+      }
+      internal Builder(ResponseParameters cloneFrom) {
+        result = cloneFrom;
+        resultIsReadOnly = true;
+      }
+
+      private bool resultIsReadOnly;
+      private ResponseParameters result;
+
+      private ResponseParameters PrepareBuilder() {
+        if (resultIsReadOnly) {
+          ResponseParameters original = result;
+          result = new ResponseParameters();
+          resultIsReadOnly = false;
+          MergeFrom(original);
+        }
+        return result;
+      }
+
+      public override bool IsInitialized {
+        get { return result.IsInitialized; }
+      }
+
+      protected override ResponseParameters MessageBeingBuilt {
+        get { return PrepareBuilder(); }
+      }
+
+      public override Builder Clear() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+        return this;
+      }
+
+      public override Builder Clone() {
+        if (resultIsReadOnly) {
+          return new Builder(result);
+        } else {
+          return new Builder().MergeFrom(result);
+        }
+      }
+
+      public override pbd::MessageDescriptor DescriptorForType {
+        get { return global::grpc.testing.ResponseParameters.Descriptor; }
+      }
+
+      public override ResponseParameters DefaultInstanceForType {
+        get { return global::grpc.testing.ResponseParameters.DefaultInstance; }
+      }
+
+      public override ResponseParameters BuildPartial() {
+        if (resultIsReadOnly) {
+          return result;
+        }
+        resultIsReadOnly = true;
+        return result.MakeReadOnly();
+      }
+
+      public override Builder MergeFrom(pb::IMessage other) {
+        if (other is ResponseParameters) {
+          return MergeFrom((ResponseParameters) other);
+        } else {
+          base.MergeFrom(other);
+          return this;
+        }
+      }
+
+      public override Builder MergeFrom(ResponseParameters other) {
+        if (other == global::grpc.testing.ResponseParameters.DefaultInstance) return this;
+        PrepareBuilder();
+        if (other.HasSize) {
+          Size = other.Size;
+        }
+        if (other.HasIntervalUs) {
+          IntervalUs = other.IntervalUs;
+        }
+        this.MergeUnknownFields(other.UnknownFields);
+        return this;
+      }
+
+      public override Builder MergeFrom(pb::ICodedInputStream input) {
+        return MergeFrom(input, pb::ExtensionRegistry.Empty);
+      }
+
+      public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+        PrepareBuilder();
+        pb::UnknownFieldSet.Builder unknownFields = null;
+        uint tag;
+        string field_name;
+        while (input.ReadTag(out tag, out field_name)) {
+          if(tag == 0 && field_name != null) {
+            int field_ordinal = global::System.Array.BinarySearch(_responseParametersFieldNames, field_name, global::System.StringComparer.Ordinal);
+            if(field_ordinal >= 0)
+              tag = _responseParametersFieldTags[field_ordinal];
+            else {
+              if (unknownFields == null) {
+                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+              }
+              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
+              continue;
+            }
+          }
+          switch (tag) {
+            case 0: {
+              throw pb::InvalidProtocolBufferException.InvalidTag();
+            }
+            default: {
+              if (pb::WireFormat.IsEndGroupTag(tag)) {
+                if (unknownFields != null) {
+                  this.UnknownFields = unknownFields.Build();
+                }
+                return this;
+              }
+              if (unknownFields == null) {
+                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+              }
+              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
+              break;
+            }
+            case 8: {
+              result.hasSize = input.ReadInt32(ref result.size_);
+              break;
+            }
+            case 16: {
+              result.hasIntervalUs = input.ReadInt32(ref result.intervalUs_);
+              break;
+            }
+          }
+        }
+
+        if (unknownFields != null) {
+          this.UnknownFields = unknownFields.Build();
+        }
+        return this;
+      }
+
+
+      public bool HasSize {
+        get { return result.hasSize; }
+      }
+      public int Size {
+        get { return result.Size; }
+        set { SetSize(value); }
+      }
+      public Builder SetSize(int value) {
+        PrepareBuilder();
+        result.hasSize = true;
+        result.size_ = value;
+        return this;
+      }
+      public Builder ClearSize() {
+        PrepareBuilder();
+        result.hasSize = false;
+        result.size_ = 0;
+        return this;
+      }
+
+      public bool HasIntervalUs {
+        get { return result.hasIntervalUs; }
+      }
+      public int IntervalUs {
+        get { return result.IntervalUs; }
+        set { SetIntervalUs(value); }
+      }
+      public Builder SetIntervalUs(int value) {
+        PrepareBuilder();
+        result.hasIntervalUs = true;
+        result.intervalUs_ = value;
+        return this;
+      }
+      public Builder ClearIntervalUs() {
+        PrepareBuilder();
+        result.hasIntervalUs = false;
+        result.intervalUs_ = 0;
+        return this;
+      }
+    }
+    static ResponseParameters() {
+      object.ReferenceEquals(global::grpc.testing.Messages.Descriptor, null);
+    }
+  }
+
+  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+  public sealed partial class StreamingOutputCallRequest : pb::GeneratedMessage<StreamingOutputCallRequest, StreamingOutputCallRequest.Builder> {
+    private StreamingOutputCallRequest() { }
+    private static readonly StreamingOutputCallRequest defaultInstance = new StreamingOutputCallRequest().MakeReadOnly();
+    private static readonly string[] _streamingOutputCallRequestFieldNames = new string[] { "payload", "response_parameters", "response_type" };
+    private static readonly uint[] _streamingOutputCallRequestFieldTags = new uint[] { 26, 18, 8 };
+    public static StreamingOutputCallRequest DefaultInstance {
+      get { return defaultInstance; }
+    }
+
+    public override StreamingOutputCallRequest DefaultInstanceForType {
+      get { return DefaultInstance; }
+    }
+
+    protected override StreamingOutputCallRequest ThisMessage {
+      get { return this; }
+    }
+
+    public static pbd::MessageDescriptor Descriptor {
+      get { return global::grpc.testing.Messages.internal__static_grpc_testing_StreamingOutputCallRequest__Descriptor; }
+    }
+
+    protected override pb::FieldAccess.FieldAccessorTable<StreamingOutputCallRequest, StreamingOutputCallRequest.Builder> InternalFieldAccessors {
+      get { return global::grpc.testing.Messages.internal__static_grpc_testing_StreamingOutputCallRequest__FieldAccessorTable; }
+    }
+
+    public const int ResponseTypeFieldNumber = 1;
+    private bool hasResponseType;
+    private global::grpc.testing.PayloadType responseType_ = global::grpc.testing.PayloadType.COMPRESSABLE;
+    public bool HasResponseType {
+      get { return hasResponseType; }
+    }
+    public global::grpc.testing.PayloadType ResponseType {
+      get { return responseType_; }
+    }
+
+    public const int ResponseParametersFieldNumber = 2;
+    private pbc::PopsicleList<global::grpc.testing.ResponseParameters> responseParameters_ = new pbc::PopsicleList<global::grpc.testing.ResponseParameters>();
+    public scg::IList<global::grpc.testing.ResponseParameters> ResponseParametersList {
+      get { return responseParameters_; }
+    }
+    public int ResponseParametersCount {
+      get { return responseParameters_.Count; }
+    }
+    public global::grpc.testing.ResponseParameters GetResponseParameters(int index) {
+      return responseParameters_[index];
+    }
+
+    public const int PayloadFieldNumber = 3;
+    private bool hasPayload;
+    private global::grpc.testing.Payload payload_;
+    public bool HasPayload {
+      get { return hasPayload; }
+    }
+    public global::grpc.testing.Payload Payload {
+      get { return payload_ ?? global::grpc.testing.Payload.DefaultInstance; }
+    }
+
+    public override bool IsInitialized {
+      get {
+        return true;
+      }
+    }
+
+    public override void WriteTo(pb::ICodedOutputStream output) {
+      int size = SerializedSize;
+      string[] field_names = _streamingOutputCallRequestFieldNames;
+      if (hasResponseType) {
+        output.WriteEnum(1, field_names[2], (int) ResponseType, ResponseType);
+      }
+      if (responseParameters_.Count > 0) {
+        output.WriteMessageArray(2, field_names[1], responseParameters_);
+      }
+      if (hasPayload) {
+        output.WriteMessage(3, field_names[0], Payload);
+      }
+      UnknownFields.WriteTo(output);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public override int SerializedSize {
+      get {
+        int size = memoizedSerializedSize;
+        if (size != -1) return size;
+
+        size = 0;
+        if (hasResponseType) {
+          size += pb::CodedOutputStream.ComputeEnumSize(1, (int) ResponseType);
+        }
+        foreach (global::grpc.testing.ResponseParameters element in ResponseParametersList) {
+          size += pb::CodedOutputStream.ComputeMessageSize(2, element);
+        }
+        if (hasPayload) {
+          size += pb::CodedOutputStream.ComputeMessageSize(3, Payload);
+        }
+        size += UnknownFields.SerializedSize;
+        memoizedSerializedSize = size;
+        return size;
+      }
+    }
+
+    public static StreamingOutputCallRequest ParseFrom(pb::ByteString data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static StreamingOutputCallRequest ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static StreamingOutputCallRequest ParseFrom(byte[] data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static StreamingOutputCallRequest ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static StreamingOutputCallRequest ParseFrom(global::System.IO.Stream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static StreamingOutputCallRequest ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    public static StreamingOutputCallRequest ParseDelimitedFrom(global::System.IO.Stream input) {
+      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
+    }
+    public static StreamingOutputCallRequest ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
+    }
+    public static StreamingOutputCallRequest ParseFrom(pb::ICodedInputStream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static StreamingOutputCallRequest ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    private StreamingOutputCallRequest MakeReadOnly() {
+      responseParameters_.MakeReadOnly();
+      return this;
+    }
+
+    public static Builder CreateBuilder() { return new Builder(); }
+    public override Builder ToBuilder() { return CreateBuilder(this); }
+    public override Builder CreateBuilderForType() { return new Builder(); }
+    public static Builder CreateBuilder(StreamingOutputCallRequest prototype) {
+      return new Builder(prototype);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    public sealed partial class Builder : pb::GeneratedBuilder<StreamingOutputCallRequest, Builder> {
+      protected override Builder ThisBuilder {
+        get { return this; }
+      }
+      public Builder() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+      }
+      internal Builder(StreamingOutputCallRequest cloneFrom) {
+        result = cloneFrom;
+        resultIsReadOnly = true;
+      }
+
+      private bool resultIsReadOnly;
+      private StreamingOutputCallRequest result;
+
+      private StreamingOutputCallRequest PrepareBuilder() {
+        if (resultIsReadOnly) {
+          StreamingOutputCallRequest original = result;
+          result = new StreamingOutputCallRequest();
+          resultIsReadOnly = false;
+          MergeFrom(original);
+        }
+        return result;
+      }
+
+      public override bool IsInitialized {
+        get { return result.IsInitialized; }
+      }
+
+      protected override StreamingOutputCallRequest MessageBeingBuilt {
+        get { return PrepareBuilder(); }
+      }
+
+      public override Builder Clear() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+        return this;
+      }
+
+      public override Builder Clone() {
+        if (resultIsReadOnly) {
+          return new Builder(result);
+        } else {
+          return new Builder().MergeFrom(result);
+        }
+      }
+
+      public override pbd::MessageDescriptor DescriptorForType {
+        get { return global::grpc.testing.StreamingOutputCallRequest.Descriptor; }
+      }
+
+      public override StreamingOutputCallRequest DefaultInstanceForType {
+        get { return global::grpc.testing.StreamingOutputCallRequest.DefaultInstance; }
+      }
+
+      public override StreamingOutputCallRequest BuildPartial() {
+        if (resultIsReadOnly) {
+          return result;
+        }
+        resultIsReadOnly = true;
+        return result.MakeReadOnly();
+      }
+
+      public override Builder MergeFrom(pb::IMessage other) {
+        if (other is StreamingOutputCallRequest) {
+          return MergeFrom((StreamingOutputCallRequest) other);
+        } else {
+          base.MergeFrom(other);
+          return this;
+        }
+      }
+
+      public override Builder MergeFrom(StreamingOutputCallRequest other) {
+        if (other == global::grpc.testing.StreamingOutputCallRequest.DefaultInstance) return this;
+        PrepareBuilder();
+        if (other.HasResponseType) {
+          ResponseType = other.ResponseType;
+        }
+        if (other.responseParameters_.Count != 0) {
+          result.responseParameters_.Add(other.responseParameters_);
+        }
+        if (other.HasPayload) {
+          MergePayload(other.Payload);
+        }
+        this.MergeUnknownFields(other.UnknownFields);
+        return this;
+      }
+
+      public override Builder MergeFrom(pb::ICodedInputStream input) {
+        return MergeFrom(input, pb::ExtensionRegistry.Empty);
+      }
+
+      public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+        PrepareBuilder();
+        pb::UnknownFieldSet.Builder unknownFields = null;
+        uint tag;
+        string field_name;
+        while (input.ReadTag(out tag, out field_name)) {
+          if(tag == 0 && field_name != null) {
+            int field_ordinal = global::System.Array.BinarySearch(_streamingOutputCallRequestFieldNames, field_name, global::System.StringComparer.Ordinal);
+            if(field_ordinal >= 0)
+              tag = _streamingOutputCallRequestFieldTags[field_ordinal];
+            else {
+              if (unknownFields == null) {
+                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+              }
+              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
+              continue;
+            }
+          }
+          switch (tag) {
+            case 0: {
+              throw pb::InvalidProtocolBufferException.InvalidTag();
+            }
+            default: {
+              if (pb::WireFormat.IsEndGroupTag(tag)) {
+                if (unknownFields != null) {
+                  this.UnknownFields = unknownFields.Build();
+                }
+                return this;
+              }
+              if (unknownFields == null) {
+                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+              }
+              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
+              break;
+            }
+            case 8: {
+              object unknown;
+              if(input.ReadEnum(ref result.responseType_, out unknown)) {
+                result.hasResponseType = true;
+              } else if(unknown is int) {
+                if (unknownFields == null) {
+                  unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+                }
+                unknownFields.MergeVarintField(1, (ulong)(int)unknown);
+              }
+              break;
+            }
+            case 18: {
+              input.ReadMessageArray(tag, field_name, result.responseParameters_, global::grpc.testing.ResponseParameters.DefaultInstance, extensionRegistry);
+              break;
+            }
+            case 26: {
+              global::grpc.testing.Payload.Builder subBuilder = global::grpc.testing.Payload.CreateBuilder();
+              if (result.hasPayload) {
+                subBuilder.MergeFrom(Payload);
+              }
+              input.ReadMessage(subBuilder, extensionRegistry);
+              Payload = subBuilder.BuildPartial();
+              break;
+            }
+          }
+        }
+
+        if (unknownFields != null) {
+          this.UnknownFields = unknownFields.Build();
+        }
+        return this;
+      }
+
+
+      public bool HasResponseType {
+       get { return result.hasResponseType; }
+      }
+      public global::grpc.testing.PayloadType ResponseType {
+        get { return result.ResponseType; }
+        set { SetResponseType(value); }
+      }
+      public Builder SetResponseType(global::grpc.testing.PayloadType value) {
+        PrepareBuilder();
+        result.hasResponseType = true;
+        result.responseType_ = value;
+        return this;
+      }
+      public Builder ClearResponseType() {
+        PrepareBuilder();
+        result.hasResponseType = false;
+        result.responseType_ = global::grpc.testing.PayloadType.COMPRESSABLE;
+        return this;
+      }
+
+      public pbc::IPopsicleList<global::grpc.testing.ResponseParameters> ResponseParametersList {
+        get { return PrepareBuilder().responseParameters_; }
+      }
+      public int ResponseParametersCount {
+        get { return result.ResponseParametersCount; }
+      }
+      public global::grpc.testing.ResponseParameters GetResponseParameters(int index) {
+        return result.GetResponseParameters(index);
+      }
+      public Builder SetResponseParameters(int index, global::grpc.testing.ResponseParameters value) {
+        pb::ThrowHelper.ThrowIfNull(value, "value");
+        PrepareBuilder();
+        result.responseParameters_[index] = value;
+        return this;
+      }
+      public Builder SetResponseParameters(int index, global::grpc.testing.ResponseParameters.Builder builderForValue) {
+        pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
+        PrepareBuilder();
+        result.responseParameters_[index] = builderForValue.Build();
+        return this;
+      }
+      public Builder AddResponseParameters(global::grpc.testing.ResponseParameters value) {
+        pb::ThrowHelper.ThrowIfNull(value, "value");
+        PrepareBuilder();
+        result.responseParameters_.Add(value);
+        return this;
+      }
+      public Builder AddResponseParameters(global::grpc.testing.ResponseParameters.Builder builderForValue) {
+        pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
+        PrepareBuilder();
+        result.responseParameters_.Add(builderForValue.Build());
+        return this;
+      }
+      public Builder AddRangeResponseParameters(scg::IEnumerable<global::grpc.testing.ResponseParameters> values) {
+        PrepareBuilder();
+        result.responseParameters_.Add(values);
+        return this;
+      }
+      public Builder ClearResponseParameters() {
+        PrepareBuilder();
+        result.responseParameters_.Clear();
+        return this;
+      }
+
+      public bool HasPayload {
+       get { return result.hasPayload; }
+      }
+      public global::grpc.testing.Payload Payload {
+        get { return result.Payload; }
+        set { SetPayload(value); }
+      }
+      public Builder SetPayload(global::grpc.testing.Payload value) {
+        pb::ThrowHelper.ThrowIfNull(value, "value");
+        PrepareBuilder();
+        result.hasPayload = true;
+        result.payload_ = value;
+        return this;
+      }
+      public Builder SetPayload(global::grpc.testing.Payload.Builder builderForValue) {
+        pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
+        PrepareBuilder();
+        result.hasPayload = true;
+        result.payload_ = builderForValue.Build();
+        return this;
+      }
+      public Builder MergePayload(global::grpc.testing.Payload value) {
+        pb::ThrowHelper.ThrowIfNull(value, "value");
+        PrepareBuilder();
+        if (result.hasPayload &&
+            result.payload_ != global::grpc.testing.Payload.DefaultInstance) {
+            result.payload_ = global::grpc.testing.Payload.CreateBuilder(result.payload_).MergeFrom(value).BuildPartial();
+        } else {
+          result.payload_ = value;
+        }
+        result.hasPayload = true;
+        return this;
+      }
+      public Builder ClearPayload() {
+        PrepareBuilder();
+        result.hasPayload = false;
+        result.payload_ = null;
+        return this;
+      }
+    }
+    static StreamingOutputCallRequest() {
+      object.ReferenceEquals(global::grpc.testing.Messages.Descriptor, null);
+    }
+  }
+
+  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+  public sealed partial class StreamingOutputCallResponse : pb::GeneratedMessage<StreamingOutputCallResponse, StreamingOutputCallResponse.Builder> {
+    private StreamingOutputCallResponse() { }
+    private static readonly StreamingOutputCallResponse defaultInstance = new StreamingOutputCallResponse().MakeReadOnly();
+    private static readonly string[] _streamingOutputCallResponseFieldNames = new string[] { "payload" };
+    private static readonly uint[] _streamingOutputCallResponseFieldTags = new uint[] { 10 };
+    public static StreamingOutputCallResponse DefaultInstance {
+      get { return defaultInstance; }
+    }
+
+    public override StreamingOutputCallResponse DefaultInstanceForType {
+      get { return DefaultInstance; }
+    }
+
+    protected override StreamingOutputCallResponse ThisMessage {
+      get { return this; }
+    }
+
+    public static pbd::MessageDescriptor Descriptor {
+      get { return global::grpc.testing.Messages.internal__static_grpc_testing_StreamingOutputCallResponse__Descriptor; }
+    }
+
+    protected override pb::FieldAccess.FieldAccessorTable<StreamingOutputCallResponse, StreamingOutputCallResponse.Builder> InternalFieldAccessors {
+      get { return global::grpc.testing.Messages.internal__static_grpc_testing_StreamingOutputCallResponse__FieldAccessorTable; }
+    }
+
+    public const int PayloadFieldNumber = 1;
+    private bool hasPayload;
+    private global::grpc.testing.Payload payload_;
+    public bool HasPayload {
+      get { return hasPayload; }
+    }
+    public global::grpc.testing.Payload Payload {
+      get { return payload_ ?? global::grpc.testing.Payload.DefaultInstance; }
+    }
+
+    public override bool IsInitialized {
+      get {
+        return true;
+      }
+    }
+
+    public override void WriteTo(pb::ICodedOutputStream output) {
+      int size = SerializedSize;
+      string[] field_names = _streamingOutputCallResponseFieldNames;
+      if (hasPayload) {
+        output.WriteMessage(1, field_names[0], Payload);
+      }
+      UnknownFields.WriteTo(output);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public override int SerializedSize {
+      get {
+        int size = memoizedSerializedSize;
+        if (size != -1) return size;
+
+        size = 0;
+        if (hasPayload) {
+          size += pb::CodedOutputStream.ComputeMessageSize(1, Payload);
+        }
+        size += UnknownFields.SerializedSize;
+        memoizedSerializedSize = size;
+        return size;
+      }
+    }
+
+    public static StreamingOutputCallResponse ParseFrom(pb::ByteString data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static StreamingOutputCallResponse ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static StreamingOutputCallResponse ParseFrom(byte[] data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static StreamingOutputCallResponse ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static StreamingOutputCallResponse ParseFrom(global::System.IO.Stream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static StreamingOutputCallResponse ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    public static StreamingOutputCallResponse ParseDelimitedFrom(global::System.IO.Stream input) {
+      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
+    }
+    public static StreamingOutputCallResponse ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
+    }
+    public static StreamingOutputCallResponse ParseFrom(pb::ICodedInputStream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static StreamingOutputCallResponse ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    private StreamingOutputCallResponse MakeReadOnly() {
+      return this;
+    }
+
+    public static Builder CreateBuilder() { return new Builder(); }
+    public override Builder ToBuilder() { return CreateBuilder(this); }
+    public override Builder CreateBuilderForType() { return new Builder(); }
+    public static Builder CreateBuilder(StreamingOutputCallResponse prototype) {
+      return new Builder(prototype);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    public sealed partial class Builder : pb::GeneratedBuilder<StreamingOutputCallResponse, Builder> {
+      protected override Builder ThisBuilder {
+        get { return this; }
+      }
+      public Builder() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+      }
+      internal Builder(StreamingOutputCallResponse cloneFrom) {
+        result = cloneFrom;
+        resultIsReadOnly = true;
+      }
+
+      private bool resultIsReadOnly;
+      private StreamingOutputCallResponse result;
+
+      private StreamingOutputCallResponse PrepareBuilder() {
+        if (resultIsReadOnly) {
+          StreamingOutputCallResponse original = result;
+          result = new StreamingOutputCallResponse();
+          resultIsReadOnly = false;
+          MergeFrom(original);
+        }
+        return result;
+      }
+
+      public override bool IsInitialized {
+        get { return result.IsInitialized; }
+      }
+
+      protected override StreamingOutputCallResponse MessageBeingBuilt {
+        get { return PrepareBuilder(); }
+      }
+
+      public override Builder Clear() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+        return this;
+      }
+
+      public override Builder Clone() {
+        if (resultIsReadOnly) {
+          return new Builder(result);
+        } else {
+          return new Builder().MergeFrom(result);
+        }
+      }
+
+      public override pbd::MessageDescriptor DescriptorForType {
+        get { return global::grpc.testing.StreamingOutputCallResponse.Descriptor; }
+      }
+
+      public override StreamingOutputCallResponse DefaultInstanceForType {
+        get { return global::grpc.testing.StreamingOutputCallResponse.DefaultInstance; }
+      }
+
+      public override StreamingOutputCallResponse BuildPartial() {
+        if (resultIsReadOnly) {
+          return result;
+        }
+        resultIsReadOnly = true;
+        return result.MakeReadOnly();
+      }
+
+      public override Builder MergeFrom(pb::IMessage other) {
+        if (other is StreamingOutputCallResponse) {
+          return MergeFrom((StreamingOutputCallResponse) other);
+        } else {
+          base.MergeFrom(other);
+          return this;
+        }
+      }
+
+      public override Builder MergeFrom(StreamingOutputCallResponse other) {
+        if (other == global::grpc.testing.StreamingOutputCallResponse.DefaultInstance) return this;
+        PrepareBuilder();
+        if (other.HasPayload) {
+          MergePayload(other.Payload);
+        }
+        this.MergeUnknownFields(other.UnknownFields);
+        return this;
+      }
+
+      public override Builder MergeFrom(pb::ICodedInputStream input) {
+        return MergeFrom(input, pb::ExtensionRegistry.Empty);
+      }
+
+      public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+        PrepareBuilder();
+        pb::UnknownFieldSet.Builder unknownFields = null;
+        uint tag;
+        string field_name;
+        while (input.ReadTag(out tag, out field_name)) {
+          if(tag == 0 && field_name != null) {
+            int field_ordinal = global::System.Array.BinarySearch(_streamingOutputCallResponseFieldNames, field_name, global::System.StringComparer.Ordinal);
+            if(field_ordinal >= 0)
+              tag = _streamingOutputCallResponseFieldTags[field_ordinal];
+            else {
+              if (unknownFields == null) {
+                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+              }
+              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
+              continue;
+            }
+          }
+          switch (tag) {
+            case 0: {
+              throw pb::InvalidProtocolBufferException.InvalidTag();
+            }
+            default: {
+              if (pb::WireFormat.IsEndGroupTag(tag)) {
+                if (unknownFields != null) {
+                  this.UnknownFields = unknownFields.Build();
+                }
+                return this;
+              }
+              if (unknownFields == null) {
+                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+              }
+              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
+              break;
+            }
+            case 10: {
+              global::grpc.testing.Payload.Builder subBuilder = global::grpc.testing.Payload.CreateBuilder();
+              if (result.hasPayload) {
+                subBuilder.MergeFrom(Payload);
+              }
+              input.ReadMessage(subBuilder, extensionRegistry);
+              Payload = subBuilder.BuildPartial();
+              break;
+            }
+          }
+        }
+
+        if (unknownFields != null) {
+          this.UnknownFields = unknownFields.Build();
+        }
+        return this;
+      }
+
+
+      public bool HasPayload {
+       get { return result.hasPayload; }
+      }
+      public global::grpc.testing.Payload Payload {
+        get { return result.Payload; }
+        set { SetPayload(value); }
+      }
+      public Builder SetPayload(global::grpc.testing.Payload value) {
+        pb::ThrowHelper.ThrowIfNull(value, "value");
+        PrepareBuilder();
+        result.hasPayload = true;
+        result.payload_ = value;
+        return this;
+      }
+      public Builder SetPayload(global::grpc.testing.Payload.Builder builderForValue) {
+        pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
+        PrepareBuilder();
+        result.hasPayload = true;
+        result.payload_ = builderForValue.Build();
+        return this;
+      }
+      public Builder MergePayload(global::grpc.testing.Payload value) {
+        pb::ThrowHelper.ThrowIfNull(value, "value");
+        PrepareBuilder();
+        if (result.hasPayload &&
+            result.payload_ != global::grpc.testing.Payload.DefaultInstance) {
+            result.payload_ = global::grpc.testing.Payload.CreateBuilder(result.payload_).MergeFrom(value).BuildPartial();
+        } else {
+          result.payload_ = value;
+        }
+        result.hasPayload = true;
+        return this;
+      }
+      public Builder ClearPayload() {
+        PrepareBuilder();
+        result.hasPayload = false;
+        result.payload_ = null;
+        return this;
+      }
+    }
+    static StreamingOutputCallResponse() {
+      object.ReferenceEquals(global::grpc.testing.Messages.Descriptor, null);
+    }
+  }
+
+  #endregion
+
+}
+
+#endregion Designer generated code
diff --git a/src/csharp/Grpc.IntegrationTesting/Properties/AssemblyInfo.cs b/src/csharp/Grpc.IntegrationTesting/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000000..f633c19132
--- /dev/null
+++ b/src/csharp/Grpc.IntegrationTesting/Properties/AssemblyInfo.cs
@@ -0,0 +1,22 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+// Information about this assembly is defined by the following attributes.
+// Change them to the values specific to your project.
+[assembly: AssemblyTitle("Grpc.IntegrationTesting")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("")]
+[assembly: AssemblyCopyright("Google Inc.  All rights reserved.")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}".
+// The form "{Major}.{Minor}.*" will automatically update the build and revision,
+// and "{Major}.{Minor}.{Build}.*" will update just the revision.
+[assembly: AssemblyVersion("0.1.*")]
+// The following attributes are used to specify the signing key for the assembly,
+// if desired. See the Mono documentation for more information about signing.
+//[assembly: AssemblyDelaySign(false)]
+//[assembly: AssemblyKeyFile("")]
+
diff --git a/src/csharp/Grpc.IntegrationTesting/TestServiceGrpc.cs b/src/csharp/Grpc.IntegrationTesting/TestServiceGrpc.cs
new file mode 100644
index 0000000000..b71704bcc7
--- /dev/null
+++ b/src/csharp/Grpc.IntegrationTesting/TestServiceGrpc.cs
@@ -0,0 +1,202 @@
+#region Copyright notice and license
+
+// Copyright 2015, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Grpc.Core;
+
+namespace grpc.testing
+{
+    /// <summary>
+    /// TestService (this is handwritten version of code that will normally be generated).
+    /// </summary>
+    public class TestServiceGrpc
+    {
+        readonly static Marshaller<Empty> emptyMarshaller = Marshallers.Create((arg) => arg.ToByteArray(), Empty.ParseFrom);
+        readonly static Marshaller<SimpleRequest> simpleRequestMarshaller = Marshallers.Create((arg) => arg.ToByteArray(), SimpleRequest.ParseFrom);
+        readonly static Marshaller<SimpleResponse> simpleResponseMarshaller = Marshallers.Create((arg) => arg.ToByteArray(), SimpleResponse.ParseFrom);
+        readonly static Marshaller<StreamingOutputCallRequest> streamingOutputCallRequestMarshaller = Marshallers.Create((arg) => arg.ToByteArray(), StreamingOutputCallRequest.ParseFrom);
+        readonly static Marshaller<StreamingOutputCallResponse> streamingOutputCallResponseMarshaller = Marshallers.Create((arg) => arg.ToByteArray(), StreamingOutputCallResponse.ParseFrom);
+        readonly static Marshaller<StreamingInputCallRequest> streamingInputCallRequestMarshaller = Marshallers.Create((arg) => arg.ToByteArray(), StreamingInputCallRequest.ParseFrom);
+        readonly static Marshaller<StreamingInputCallResponse> streamingInputCallResponseMarshaller = Marshallers.Create((arg) => arg.ToByteArray(), StreamingInputCallResponse.ParseFrom);
+
+        readonly static Method<Empty, Empty> emptyCallMethod = new Method<Empty, Empty>(
+            MethodType.Unary,
+            "/grpc.testing.TestService/EmptyCall",
+            emptyMarshaller,
+            emptyMarshaller
+        );
+        readonly static Method<SimpleRequest, SimpleResponse> unaryCallMethod = new Method<SimpleRequest, SimpleResponse>(
+            MethodType.Unary,
+            "/grpc.testing.TestService/UnaryCall",
+            simpleRequestMarshaller,
+            simpleResponseMarshaller
+        );
+        readonly static Method<StreamingOutputCallRequest, StreamingOutputCallResponse> streamingOutputCallMethod = new Method<StreamingOutputCallRequest, StreamingOutputCallResponse>(
+            MethodType.ServerStreaming,
+            "/grpc.testing.TestService/StreamingOutputCall",
+            streamingOutputCallRequestMarshaller,
+            streamingOutputCallResponseMarshaller
+            );
+        readonly static Method<StreamingInputCallRequest, StreamingInputCallResponse> streamingInputCallMethod = new Method<StreamingInputCallRequest, StreamingInputCallResponse>(
+            MethodType.ClientStreaming,
+            "/grpc.testing.TestService/StreamingInputCall",
+            streamingInputCallRequestMarshaller,
+            streamingInputCallResponseMarshaller
+            );
+        readonly static Method<StreamingOutputCallRequest, StreamingOutputCallResponse> fullDuplexCallMethod = new Method<StreamingOutputCallRequest, StreamingOutputCallResponse>(
+            MethodType.DuplexStreaming,
+            "/grpc.testing.TestService/FullDuplexCall",
+            streamingOutputCallRequestMarshaller,
+            streamingOutputCallResponseMarshaller
+            );
+        readonly static Method<StreamingOutputCallRequest, StreamingOutputCallResponse> halfDuplexCallMethod = new Method<StreamingOutputCallRequest, StreamingOutputCallResponse>(
+            MethodType.DuplexStreaming,
+            "/grpc.testing.TestService/HalfDuplexCall",
+            streamingOutputCallRequestMarshaller,
+            streamingOutputCallResponseMarshaller
+            );
+
+        public interface ITestServiceClient
+        {
+            Empty EmptyCall(Empty request, CancellationToken token = default(CancellationToken));
+
+            Task<Empty> EmptyCallAsync(Empty request, CancellationToken token = default(CancellationToken));
+
+            SimpleResponse UnaryCall(SimpleRequest request, CancellationToken token = default(CancellationToken));
+
+            Task<SimpleResponse> UnaryCallAsync(SimpleRequest request, CancellationToken token = default(CancellationToken));
+
+            void StreamingOutputCall(StreamingOutputCallRequest request, IObserver<StreamingOutputCallResponse> responseObserver, CancellationToken token = default(CancellationToken));
+
+            ClientStreamingAsyncResult<StreamingInputCallRequest, StreamingInputCallResponse> StreamingInputCall(CancellationToken token = default(CancellationToken));
+
+            IObserver<StreamingOutputCallRequest> FullDuplexCall(IObserver<StreamingOutputCallResponse> responseObserver, CancellationToken token = default(CancellationToken));
+
+            IObserver<StreamingOutputCallRequest> HalfDuplexCall(IObserver<StreamingOutputCallResponse> responseObserver, CancellationToken token = default(CancellationToken));
+        }
+
+        public class TestServiceClientStub : ITestServiceClient
+        {
+            readonly Channel channel;
+
+            public TestServiceClientStub(Channel channel)
+            {
+                this.channel = channel;
+            }
+
+            public Empty EmptyCall(Empty request, CancellationToken token = default(CancellationToken))
+            {
+                var call = new Grpc.Core.Call<Empty, Empty>(emptyCallMethod, channel);
+                return Calls.BlockingUnaryCall(call, request, token);
+            }
+
+            public Task<Empty> EmptyCallAsync(Empty request, CancellationToken token = default(CancellationToken))
+            {
+                var call = new Grpc.Core.Call<Empty, Empty>(emptyCallMethod, channel);
+                return Calls.AsyncUnaryCall(call, request, token);
+            }
+
+            public SimpleResponse UnaryCall(SimpleRequest request, CancellationToken token = default(CancellationToken))
+            {
+                var call = new Grpc.Core.Call<SimpleRequest, SimpleResponse>(unaryCallMethod, channel);
+                return Calls.BlockingUnaryCall(call, request, token);
+            }
+
+            public Task<SimpleResponse> UnaryCallAsync(SimpleRequest request, CancellationToken token = default(CancellationToken))
+            {
+                var call = new Grpc.Core.Call<SimpleRequest, SimpleResponse>(unaryCallMethod, channel);
+                return Calls.AsyncUnaryCall(call, request, token);
+            }
+
+            public void StreamingOutputCall(StreamingOutputCallRequest request, IObserver<StreamingOutputCallResponse> responseObserver, CancellationToken token = default(CancellationToken)) {
+                var call = new Grpc.Core.Call<StreamingOutputCallRequest, StreamingOutputCallResponse>(streamingOutputCallMethod, channel);
+                Calls.AsyncServerStreamingCall(call, request, responseObserver, token);
+            }
+
+            public ClientStreamingAsyncResult<StreamingInputCallRequest, StreamingInputCallResponse> StreamingInputCall(CancellationToken token = default(CancellationToken))
+            {
+                var call = new Grpc.Core.Call<StreamingInputCallRequest, StreamingInputCallResponse>(streamingInputCallMethod, channel);
+                return Calls.AsyncClientStreamingCall(call, token);
+            }
+
+            public IObserver<StreamingOutputCallRequest> FullDuplexCall(IObserver<StreamingOutputCallResponse> responseObserver, CancellationToken token = default(CancellationToken))
+            {
+                var call = new Grpc.Core.Call<StreamingOutputCallRequest, StreamingOutputCallResponse>(fullDuplexCallMethod, channel);
+                return Calls.DuplexStreamingCall(call, responseObserver, token);
+            }
+
+
+            public IObserver<StreamingOutputCallRequest> HalfDuplexCall(IObserver<StreamingOutputCallResponse> responseObserver, CancellationToken token = default(CancellationToken))
+            {
+                var call = new Grpc.Core.Call<StreamingOutputCallRequest, StreamingOutputCallResponse>(halfDuplexCallMethod, channel);
+                return Calls.DuplexStreamingCall(call, responseObserver, token);
+            }
+        }
+
+        // server-side interface
+        public interface ITestService
+        {
+            void EmptyCall(Empty request, IObserver<Empty> responseObserver);
+
+            void UnaryCall(SimpleRequest request, IObserver<SimpleResponse> responseObserver);
+
+            void StreamingOutputCall(StreamingOutputCallRequest request, IObserver<StreamingOutputCallResponse> responseObserver);
+
+            IObserver<StreamingInputCallRequest> StreamingInputCall(IObserver<StreamingInputCallResponse> responseObserver);
+
+            IObserver<StreamingOutputCallRequest> FullDuplexCall(IObserver<StreamingOutputCallResponse> responseObserver);
+
+            IObserver<StreamingOutputCallRequest> HalfDuplexCall(IObserver<StreamingOutputCallResponse> responseObserver);
+        }
+
+        public static ServerServiceDefinition BindService(ITestService serviceImpl)
+        {
+            return ServerServiceDefinition.CreateBuilder("/grpc.testing.TestService/")
+                .AddMethod(emptyCallMethod, serviceImpl.EmptyCall)
+                .AddMethod(unaryCallMethod, serviceImpl.UnaryCall)
+                .AddMethod(streamingOutputCallMethod, serviceImpl.StreamingOutputCall)
+                .AddMethod(streamingInputCallMethod, serviceImpl.StreamingInputCall)
+                .AddMethod(fullDuplexCallMethod, serviceImpl.FullDuplexCall)
+                .AddMethod(halfDuplexCallMethod, serviceImpl.HalfDuplexCall)
+                .Build();
+        }
+
+        public static ITestServiceClient NewStub(Channel channel)
+        {
+            return new TestServiceClientStub(channel);
+        }
+    }
+}
diff --git a/src/csharp/Grpc.IntegrationTesting/packages.config b/src/csharp/Grpc.IntegrationTesting/packages.config
new file mode 100644
index 0000000000..51c17bcd5e
--- /dev/null
+++ b/src/csharp/Grpc.IntegrationTesting/packages.config
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="Google.ProtocolBuffers" version="2.4.1.521" targetFramework="net45" />
+  <package id="NUnit" version="2.6.4" targetFramework="net45" />
+</packages>
\ No newline at end of file
diff --git a/src/csharp/Grpc.IntegrationTesting/proto/empty.proto b/src/csharp/Grpc.IntegrationTesting/proto/empty.proto
new file mode 100644
index 0000000000..4295a0a960
--- /dev/null
+++ b/src/csharp/Grpc.IntegrationTesting/proto/empty.proto
@@ -0,0 +1,43 @@
+
+// Copyright 2015, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+syntax = "proto2";
+
+package grpc.testing;
+
+// An empty message that you can re-use to avoid defining duplicated empty
+// messages in your project. A typical example is to use it as argument or the
+// return value of a service API. For instance:
+//
+//   service Foo {
+//     rpc Bar (grpc.testing.Empty) returns (grpc.testing.Empty) { };
+//   };
+//
+message Empty {}
diff --git a/src/csharp/Grpc.IntegrationTesting/proto/messages.proto b/src/csharp/Grpc.IntegrationTesting/proto/messages.proto
new file mode 100644
index 0000000000..65a8140465
--- /dev/null
+++ b/src/csharp/Grpc.IntegrationTesting/proto/messages.proto
@@ -0,0 +1,132 @@
+
+// Copyright 2015, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Message definitions to be used by integration test service definitions.
+
+syntax = "proto2";
+
+package grpc.testing;
+
+// The type of payload that should be returned.
+enum PayloadType {
+  // Compressable text format.
+  COMPRESSABLE = 0;
+
+  // Uncompressable binary format.
+  UNCOMPRESSABLE = 1;
+
+  // Randomly chosen from all other formats defined in this enum.
+  RANDOM = 2;
+}
+
+// A block of data, to simply increase gRPC message size.
+message Payload {
+  // The type of data in body.
+  optional PayloadType type = 1;
+  // Primary contents of payload.
+  optional bytes body = 2;
+}
+
+// Unary request.
+message SimpleRequest {
+  // Desired payload type in the response from the server.
+  // If response_type is RANDOM, server randomly chooses one from other formats.
+  optional PayloadType response_type = 1;
+
+  // Desired payload size in the response from the server.
+  // If response_type is COMPRESSABLE, this denotes the size before compression.
+  optional int32 response_size = 2;
+
+  // Optional input payload sent along with the request.
+  optional Payload payload = 3;
+
+  // Whether SimpleResponse should include username.
+  optional bool fill_username = 4;
+
+  // Whether SimpleResponse should include OAuth scope.
+  optional bool fill_oauth_scope = 5;
+}
+
+// Unary response, as configured by the request.
+message SimpleResponse {
+  // Payload to increase message size.
+  optional Payload payload = 1;
+  // The user the request came from, for verifying authentication was
+  // successful when the client expected it.
+  optional string username = 2;
+  // OAuth scope.
+  optional string oauth_scope = 3;
+}
+
+// Client-streaming request.
+message StreamingInputCallRequest {
+  // Optional input payload sent along with the request.
+  optional Payload payload = 1;
+
+  // Not expecting any payload from the response.
+}
+
+// Client-streaming response.
+message StreamingInputCallResponse {
+  // Aggregated size of payloads received from the client.
+  optional int32 aggregated_payload_size = 1;
+}
+
+// Configuration for a particular response.
+message ResponseParameters {
+  // Desired payload sizes in responses from the server.
+  // If response_type is COMPRESSABLE, this denotes the size before compression.
+  optional int32 size = 1;
+
+  // Desired interval between consecutive responses in the response stream in
+  // microseconds.
+  optional int32 interval_us = 2;
+}
+
+// Server-streaming request.
+message StreamingOutputCallRequest {
+  // Desired payload type in the response from the server.
+  // If response_type is RANDOM, the payload from each response in the stream
+  // might be of different types. This is to simulate a mixed type of payload
+  // stream.
+  optional PayloadType response_type = 1;
+
+  // Configuration for each expected response message.
+  repeated ResponseParameters response_parameters = 2;
+
+  // Optional input payload sent along with the request.
+  optional Payload payload = 3;
+}
+
+// Server-streaming response, as configured by the request and parameters.
+message StreamingOutputCallResponse {
+  // Payload to increase response size.
+  optional Payload payload = 1;
+}
diff --git a/src/csharp/Grpc.IntegrationTesting/proto/test.proto b/src/csharp/Grpc.IntegrationTesting/proto/test.proto
new file mode 100644
index 0000000000..927a3a83aa
--- /dev/null
+++ b/src/csharp/Grpc.IntegrationTesting/proto/test.proto
@@ -0,0 +1,72 @@
+
+// Copyright 2015, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// An integration test service that covers all the method signature permutations
+// of unary/streaming requests/responses.
+syntax = "proto2";
+
+import "empty.proto";
+import "messages.proto";
+
+package grpc.testing;
+
+// A simple service to test the various types of RPCs and experiment with
+// performance with various types of payload.
+service TestService {
+  // One empty request followed by one empty response.
+  rpc EmptyCall(grpc.testing.Empty) returns (grpc.testing.Empty);
+
+  // One request followed by one response.
+  // TODO(Issue 527): Describe required server behavior.
+  rpc UnaryCall(SimpleRequest) returns (SimpleResponse);
+
+  // One request followed by a sequence of responses (streamed download).
+  // The server returns the payload with client desired type and sizes.
+  rpc StreamingOutputCall(StreamingOutputCallRequest)
+      returns (stream StreamingOutputCallResponse);
+
+  // A sequence of requests followed by one response (streamed upload).
+  // The server returns the aggregated size of client payload as the result.
+  rpc StreamingInputCall(stream StreamingInputCallRequest)
+      returns (StreamingInputCallResponse);
+
+  // A sequence of requests with each request served by the server immediately.
+  // As one request could lead to multiple responses, this interface
+  // demonstrates the idea of full duplexing.
+  rpc FullDuplexCall(stream StreamingOutputCallRequest)
+      returns (stream StreamingOutputCallResponse);
+
+  // A sequence of requests followed by a sequence of responses.
+  // The server buffers all the client requests and then serves them in order. A
+  // stream of responses are returned to the client when the server starts with
+  // first request.
+  rpc HalfDuplexCall(stream StreamingOutputCallRequest)
+      returns (stream StreamingOutputCallResponse);
+}