/*
 *
 * Copyright 2015 gRPC authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

#import "InteropTests.h"

#include <grpc/status.h>

#import <GRPCClient/GRPCCall+ChannelArg.h>
#import <GRPCClient/GRPCCall+Interceptor.h>
#import <GRPCClient/GRPCCall+Tests.h>
#import <GRPCClient/GRPCInterceptor.h>
#import <GRPCClient/internal_testing/GRPCCall+InternalTests.h>
#import <ProtoRPC/ProtoRPC.h>
#import <RxLibrary/GRXBufferedPipe.h>
#import <RxLibrary/GRXWriter+Immediate.h>
#import <grpc/grpc.h>
#import <grpc/support/log.h>
#import "src/objective-c/tests/RemoteTestClient/Messages.pbobjc.h"
#import "src/objective-c/tests/RemoteTestClient/Test.pbobjc.h"
#import "src/objective-c/tests/RemoteTestClient/Test.pbrpc.h"

#import "../Common/TestUtils.h"
#import "InteropTestsBlockCallbacks.h"

#define SMALL_PAYLOAD_SIZE 10
#define LARGE_REQUEST_PAYLOAD_SIZE 271828
#define LARGE_RESPONSE_PAYLOAD_SIZE 314159

static const int kTestRetries = 3;
extern const char *kCFStreamVarName;

@interface RMTStreamingOutputCallRequest (Constructors)
+ (instancetype)messageWithPayloadSize:(NSNumber *)payloadSize
                 requestedResponseSize:(NSNumber *)responseSize;
@end

@implementation RMTStreamingOutputCallRequest (Constructors)
+ (instancetype)messageWithPayloadSize:(NSNumber *)payloadSize
                 requestedResponseSize:(NSNumber *)responseSize {
  RMTStreamingOutputCallRequest *request = [self message];
  RMTResponseParameters *parameters = [RMTResponseParameters message];
  parameters.size = responseSize.intValue;
  [request.responseParametersArray addObject:parameters];
  request.payload.body = [NSMutableData dataWithLength:payloadSize.unsignedIntegerValue];
  return request;
}
@end

@interface RMTStreamingOutputCallResponse (Constructors)
+ (instancetype)messageWithPayloadSize:(NSNumber *)payloadSize;
@end

@implementation RMTStreamingOutputCallResponse (Constructors)
+ (instancetype)messageWithPayloadSize:(NSNumber *)payloadSize {
  RMTStreamingOutputCallResponse *response = [self message];
  response.payload.type = RMTPayloadType_Compressable;
  response.payload.body = [NSMutableData dataWithLength:payloadSize.unsignedIntegerValue];
  return response;
}
@end

BOOL isRemoteInteropTest(NSString *host) {
  return [host isEqualToString:@"grpc-test.sandbox.googleapis.com"];
}

@interface DefaultInterceptorFactory : NSObject <GRPCInterceptorFactory>

- (GRPCInterceptor *)createInterceptorWithManager:(GRPCInterceptorManager *)interceptorManager;

@end

@implementation DefaultInterceptorFactory

- (GRPCInterceptor *)createInterceptorWithManager:(GRPCInterceptorManager *)interceptorManager {
  dispatch_queue_t queue = dispatch_queue_create(NULL, DISPATCH_QUEUE_SERIAL);
  return [[GRPCInterceptor alloc] initWithInterceptorManager:interceptorManager
                                               dispatchQueue:queue];
}

@end

@interface HookInterceptorFactory : NSObject <GRPCInterceptorFactory>

- (instancetype)
      initWithDispatchQueue:(dispatch_queue_t)dispatchQueue
                  startHook:(void (^)(GRPCRequestOptions *requestOptions,
                                      GRPCCallOptions *callOptions,
                                      GRPCInterceptorManager *manager))startHook
              writeDataHook:(void (^)(id data, GRPCInterceptorManager *manager))writeDataHook
                 finishHook:(void (^)(GRPCInterceptorManager *manager))finishHook
    receiveNextMessagesHook:(void (^)(NSUInteger numberOfMessages,
                                      GRPCInterceptorManager *manager))receiveNextMessagesHook
         responseHeaderHook:(void (^)(NSDictionary *initialMetadata,
                                      GRPCInterceptorManager *manager))responseHeaderHook
           responseDataHook:(void (^)(id data, GRPCInterceptorManager *manager))responseDataHook
          responseCloseHook:(void (^)(NSDictionary *trailingMetadata, NSError *error,
                                      GRPCInterceptorManager *manager))responseCloseHook
           didWriteDataHook:(void (^)(GRPCInterceptorManager *manager))didWriteDataHook;

- (GRPCInterceptor *)createInterceptorWithManager:(GRPCInterceptorManager *)interceptorManager;

@end

@interface HookInterceptor : GRPCInterceptor

- (instancetype)
    initWithInterceptorManager:(GRPCInterceptorManager *)interceptorManager
                 dispatchQueue:(dispatch_queue_t)dispatchQueue
                     startHook:(void (^)(GRPCRequestOptions *requestOptions,
                                         GRPCCallOptions *callOptions,
                                         GRPCInterceptorManager *manager))startHook
                 writeDataHook:(void (^)(id data, GRPCInterceptorManager *manager))writeDataHook
                    finishHook:(void (^)(GRPCInterceptorManager *manager))finishHook
       receiveNextMessagesHook:(void (^)(NSUInteger numberOfMessages,
                                         GRPCInterceptorManager *manager))receiveNextMessagesHook
            responseHeaderHook:(void (^)(NSDictionary *initialMetadata,
                                         GRPCInterceptorManager *manager))responseHeaderHook
              responseDataHook:(void (^)(id data, GRPCInterceptorManager *manager))responseDataHook
             responseCloseHook:(void (^)(NSDictionary *trailingMetadata, NSError *error,
                                         GRPCInterceptorManager *manager))responseCloseHook
              didWriteDataHook:(void (^)(GRPCInterceptorManager *manager))didWriteDataHook;

@end

@implementation HookInterceptorFactory {
 @protected
  void (^_startHook)(GRPCRequestOptions *requestOptions, GRPCCallOptions *callOptions,
                     GRPCInterceptorManager *manager);
  void (^_writeDataHook)(id data, GRPCInterceptorManager *manager);
  void (^_finishHook)(GRPCInterceptorManager *manager);
  void (^_receiveNextMessagesHook)(NSUInteger numberOfMessages, GRPCInterceptorManager *manager);
  void (^_responseHeaderHook)(NSDictionary *initialMetadata, GRPCInterceptorManager *manager);
  void (^_responseDataHook)(id data, GRPCInterceptorManager *manager);
  void (^_responseCloseHook)(NSDictionary *trailingMetadata, NSError *error,
                             GRPCInterceptorManager *manager);
  void (^_didWriteDataHook)(GRPCInterceptorManager *manager);
  dispatch_queue_t _dispatchQueue;
}

- (instancetype)
      initWithDispatchQueue:(dispatch_queue_t)dispatchQueue
                  startHook:(void (^)(GRPCRequestOptions *requestOptions,
                                      GRPCCallOptions *callOptions,
                                      GRPCInterceptorManager *manager))startHook
              writeDataHook:(void (^)(id data, GRPCInterceptorManager *manager))writeDataHook
                 finishHook:(void (^)(GRPCInterceptorManager *manager))finishHook
    receiveNextMessagesHook:(void (^)(NSUInteger numberOfMessages,
                                      GRPCInterceptorManager *manager))receiveNextMessagesHook
         responseHeaderHook:(void (^)(NSDictionary *initialMetadata,
                                      GRPCInterceptorManager *manager))responseHeaderHook
           responseDataHook:(void (^)(id data, GRPCInterceptorManager *manager))responseDataHook
          responseCloseHook:(void (^)(NSDictionary *trailingMetadata, NSError *error,
                                      GRPCInterceptorManager *manager))responseCloseHook
           didWriteDataHook:(void (^)(GRPCInterceptorManager *manager))didWriteDataHook {
  if ((self = [super init])) {
    _dispatchQueue = dispatchQueue;
    _startHook = startHook;
    _writeDataHook = writeDataHook;
    _finishHook = finishHook;
    _receiveNextMessagesHook = receiveNextMessagesHook;
    _responseHeaderHook = responseHeaderHook;
    _responseDataHook = responseDataHook;
    _responseCloseHook = responseCloseHook;
    _didWriteDataHook = didWriteDataHook;
  }
  return self;
}

- (GRPCInterceptor *)createInterceptorWithManager:(GRPCInterceptorManager *)interceptorManager {
  return [[HookInterceptor alloc] initWithInterceptorManager:interceptorManager
                                               dispatchQueue:_dispatchQueue
                                                   startHook:_startHook
                                               writeDataHook:_writeDataHook
                                                  finishHook:_finishHook
                                     receiveNextMessagesHook:_receiveNextMessagesHook
                                          responseHeaderHook:_responseHeaderHook
                                            responseDataHook:_responseDataHook
                                           responseCloseHook:_responseCloseHook
                                            didWriteDataHook:_didWriteDataHook];
}

@end

@implementation HookInterceptor {
  void (^_startHook)(GRPCRequestOptions *requestOptions, GRPCCallOptions *callOptions,
                     GRPCInterceptorManager *manager);
  void (^_writeDataHook)(id data, GRPCInterceptorManager *manager);
  void (^_finishHook)(GRPCInterceptorManager *manager);
  void (^_receiveNextMessagesHook)(NSUInteger numberOfMessages, GRPCInterceptorManager *manager);
  void (^_responseHeaderHook)(NSDictionary *initialMetadata, GRPCInterceptorManager *manager);
  void (^_responseDataHook)(id data, GRPCInterceptorManager *manager);
  void (^_responseCloseHook)(NSDictionary *trailingMetadata, NSError *error,
                             GRPCInterceptorManager *manager);
  void (^_didWriteDataHook)(GRPCInterceptorManager *manager);
  GRPCInterceptorManager *_manager;
  dispatch_queue_t _dispatchQueue;
}

- (dispatch_queue_t)dispatchQueue {
  return _dispatchQueue;
}

- (instancetype)
    initWithInterceptorManager:(GRPCInterceptorManager *)interceptorManager
                 dispatchQueue:(dispatch_queue_t)dispatchQueue
                     startHook:(void (^)(GRPCRequestOptions *requestOptions,
                                         GRPCCallOptions *callOptions,
                                         GRPCInterceptorManager *manager))startHook
                 writeDataHook:(void (^)(id data, GRPCInterceptorManager *manager))writeDataHook
                    finishHook:(void (^)(GRPCInterceptorManager *manager))finishHook
       receiveNextMessagesHook:(void (^)(NSUInteger numberOfMessages,
                                         GRPCInterceptorManager *manager))receiveNextMessagesHook
            responseHeaderHook:(void (^)(NSDictionary *initialMetadata,
                                         GRPCInterceptorManager *manager))responseHeaderHook
              responseDataHook:(void (^)(id data, GRPCInterceptorManager *manager))responseDataHook
             responseCloseHook:(void (^)(NSDictionary *trailingMetadata, NSError *error,
                                         GRPCInterceptorManager *manager))responseCloseHook
              didWriteDataHook:(void (^)(GRPCInterceptorManager *manager))didWriteDataHook {
  if ((self = [super initWithInterceptorManager:interceptorManager dispatchQueue:dispatchQueue])) {
    _startHook = startHook;
    _writeDataHook = writeDataHook;
    _finishHook = finishHook;
    _receiveNextMessagesHook = receiveNextMessagesHook;
    _responseHeaderHook = responseHeaderHook;
    _responseDataHook = responseDataHook;
    _responseCloseHook = responseCloseHook;
    _didWriteDataHook = didWriteDataHook;
    _dispatchQueue = dispatchQueue;
    _manager = interceptorManager;
  }
  return self;
}

- (void)startWithRequestOptions:(GRPCRequestOptions *)requestOptions
                    callOptions:(GRPCCallOptions *)callOptions {
  if (_startHook) {
    _startHook(requestOptions, callOptions, _manager);
  }
}

- (void)writeData:(id)data {
  if (_writeDataHook) {
    _writeDataHook(data, _manager);
  }
}

- (void)finish {
  if (_finishHook) {
    _finishHook(_manager);
  }
}

- (void)receiveNextMessages:(NSUInteger)numberOfMessages {
  if (_receiveNextMessagesHook) {
    _receiveNextMessagesHook(numberOfMessages, _manager);
  }
}

- (void)didReceiveInitialMetadata:(NSDictionary *)initialMetadata {
  if (_responseHeaderHook) {
    _responseHeaderHook(initialMetadata, _manager);
  }
}

- (void)didReceiveData:(id)data {
  if (_responseDataHook) {
    _responseDataHook(data, _manager);
  }
}

- (void)didCloseWithTrailingMetadata:(NSDictionary *)trailingMetadata error:(NSError *)error {
  if (_responseCloseHook) {
    _responseCloseHook(trailingMetadata, error, _manager);
  }
}

- (void)didWriteData {
  if (_didWriteDataHook) {
    _didWriteDataHook(_manager);
  }
}

@end

@interface GlobalInterceptorFactory : HookInterceptorFactory

@property BOOL enabled;

- (instancetype)initWithDispatchQueue:(dispatch_queue_t)dispatchQueue;

- (void)setStartHook:(void (^)(GRPCRequestOptions *requestOptions, GRPCCallOptions *callOptions,
                               GRPCInterceptorManager *manager))startHook
              writeDataHook:(void (^)(id data, GRPCInterceptorManager *manager))writeDataHook
                 finishHook:(void (^)(GRPCInterceptorManager *manager))finishHook
    receiveNextMessagesHook:(void (^)(NSUInteger numberOfMessages,
                                      GRPCInterceptorManager *manager))receiveNextMessagesHook
         responseHeaderHook:(void (^)(NSDictionary *initialMetadata,
                                      GRPCInterceptorManager *manager))responseHeaderHook
           responseDataHook:(void (^)(id data, GRPCInterceptorManager *manager))responseDataHook
          responseCloseHook:(void (^)(NSDictionary *trailingMetadata, NSError *error,
                                      GRPCInterceptorManager *manager))responseCloseHook
           didWriteDataHook:(void (^)(GRPCInterceptorManager *manager))didWriteDataHook;

@end

@implementation GlobalInterceptorFactory

- (instancetype)initWithDispatchQueue:(dispatch_queue_t)dispatchQueue {
  _enabled = NO;
  return [super initWithDispatchQueue:dispatchQueue
                            startHook:nil
                        writeDataHook:nil
                           finishHook:nil
              receiveNextMessagesHook:nil
                   responseHeaderHook:nil
                     responseDataHook:nil
                    responseCloseHook:nil
                     didWriteDataHook:nil];
}

- (GRPCInterceptor *)createInterceptorWithManager:(GRPCInterceptorManager *)interceptorManager {
  if (_enabled) {
    return [[HookInterceptor alloc] initWithInterceptorManager:interceptorManager
                                                 dispatchQueue:_dispatchQueue
                                                     startHook:_startHook
                                                 writeDataHook:_writeDataHook
                                                    finishHook:_finishHook
                                       receiveNextMessagesHook:_receiveNextMessagesHook
                                            responseHeaderHook:_responseHeaderHook
                                              responseDataHook:_responseDataHook
                                             responseCloseHook:_responseCloseHook
                                              didWriteDataHook:_didWriteDataHook];
  } else {
    return nil;
  }
}

- (void)setStartHook:(void (^)(GRPCRequestOptions *requestOptions, GRPCCallOptions *callOptions,
                               GRPCInterceptorManager *manager))startHook
              writeDataHook:(void (^)(id data, GRPCInterceptorManager *manager))writeDataHook
                 finishHook:(void (^)(GRPCInterceptorManager *manager))finishHook
    receiveNextMessagesHook:(void (^)(NSUInteger numberOfMessages,
                                      GRPCInterceptorManager *manager))receiveNextMessagesHook
         responseHeaderHook:(void (^)(NSDictionary *initialMetadata,
                                      GRPCInterceptorManager *manager))responseHeaderHook
           responseDataHook:(void (^)(id data, GRPCInterceptorManager *manager))responseDataHook
          responseCloseHook:(void (^)(NSDictionary *trailingMetadata, NSError *error,
                                      GRPCInterceptorManager *manager))responseCloseHook
           didWriteDataHook:(void (^)(GRPCInterceptorManager *manager))didWriteDataHook {
  _startHook = startHook;
  _writeDataHook = writeDataHook;
  _finishHook = finishHook;
  _receiveNextMessagesHook = receiveNextMessagesHook;
  _responseHeaderHook = responseHeaderHook;
  _responseDataHook = responseDataHook;
  _responseCloseHook = responseCloseHook;
  _didWriteDataHook = didWriteDataHook;
}

@end

static GlobalInterceptorFactory *globalInterceptorFactory = nil;
static dispatch_once_t initGlobalInterceptorFactory;

#pragma mark Tests

@implementation InteropTests

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
- (void)retriableTest:(SEL)selector retries:(int)retries timeout:(NSTimeInterval)timeout {
  for (int i = 0; i < retries; i++) {
    NSDate *waitUntil = [[NSDate date] dateByAddingTimeInterval:timeout];
    NSCondition *cv = [[NSCondition alloc] init];
    __block BOOL done = NO;
    [cv lock];
    dispatch_async(dispatch_get_global_queue(QOS_CLASS_BACKGROUND, 0), ^{
      [self performSelector:selector];
      [cv lock];
      done = YES;
      [cv signal];
      [cv unlock];
    });
    while (!done && [waitUntil timeIntervalSinceNow] > 0) {
      [cv waitUntilDate:waitUntil];
    }
    if (done) {
      [cv unlock];
      break;
    } else {
      [cv unlock];
      [self tearDown];
      [self setUp];
    }
  }
}
#pragma clang diagnostic pop

+ (XCTestSuite *)defaultTestSuite {
  if (self == [InteropTests class]) {
    return [XCTestSuite testSuiteWithName:@"InteropTestsEmptySuite"];
  }
  return super.defaultTestSuite;
}

+ (NSString *)host {
  return nil;
}

// This number indicates how many bytes of overhead does Protocol Buffers encoding add onto the
// message. The number varies as different message.proto is used on different servers. The actual
// number for each interop server is overridden in corresponding derived test classes.
- (int32_t)encodingOverhead {
  return 0;
}

// For backwards compatibility
+ (GRPCTransportType)transportType {
  return GRPCTransportTypeChttp2BoringSSL;
}

+ (GRPCTransportID)transport {
  return NULL;
}

+ (NSString *)PEMRootCertificates {
  return nil;
}

+ (NSString *)hostNameOverride {
  return nil;
}

+ (void)setUp {
  dispatch_once(&initGlobalInterceptorFactory, ^{
    dispatch_queue_t globalInterceptorQueue = dispatch_queue_create(NULL, DISPATCH_QUEUE_SERIAL);
    globalInterceptorFactory =
        [[GlobalInterceptorFactory alloc] initWithDispatchQueue:globalInterceptorQueue];
    [GRPCCall2 registerGlobalInterceptor:globalInterceptorFactory];
  });
}

- (void)setUp {
  self.continueAfterFailure = YES;
  [GRPCCall resetHostSettings];
  GRPCResetCallConnections();
  XCTAssertNotNil([[self class] host]);
}

- (void)testEmptyUnaryRPC {
  GRPCTestRunWithFlakeRepeats(self, ^(GRPCTestWaiter waiter, GRPCTestAssert assertBlock) {
    RMTTestService *service = [RMTTestService serviceWithHost:[[self class] host]];
    __weak XCTestExpectation *expectation = [self expectationWithDescription:@"EmptyUnary"];

    GPBEmpty *request = [GPBEmpty message];

    __weak RMTTestService *weakService = service;
    [service emptyCallWithRequest:request
                          handler:^(GPBEmpty *response, NSError *error) {
                            if (weakService == nil) {
                              return;
                            }

                            XCTAssertNil(error, @"Finished with unexpected error: %@", error);

                            id expectedResponse = [GPBEmpty message];
                            XCTAssertEqualObjects(response, expectedResponse);

                            [expectation fulfill];
                          }];
    waiter(@[ expectation ], GRPCInteropTestTimeoutDefault);
  });
}

- (void)testEmptyUnaryRPCWithV2API {
  GRPCTestRunWithFlakeRepeats(self, ^(GRPCTestWaiter waiterBlock, GRPCTestAssert assertBlock) {
    RMTTestService *service = [RMTTestService serviceWithHost:[[self class] host]];
    __weak XCTestExpectation *expectReceive =
        [self expectationWithDescription:@"EmptyUnaryWithV2API received message"];
    __weak XCTestExpectation *expectComplete =
        [self expectationWithDescription:@"EmptyUnaryWithV2API completed"];

    GPBEmpty *request = [GPBEmpty message];
    GRPCMutableCallOptions *options = [[GRPCMutableCallOptions alloc] init];
    // For backwards compatibility
    options.transportType = [[self class] transportType];
    options.transport = [[self class] transport];
    options.PEMRootCertificates = [[self class] PEMRootCertificates];
    options.hostNameOverride = [[self class] hostNameOverride];

    __weak RMTTestService *weakService = service;
    GRPCUnaryProtoCall *call = [service
        emptyCallWithMessage:request
             responseHandler:[[InteropTestsBlockCallbacks alloc] initWithInitialMetadataCallback:nil
                                 messageCallback:^(id message) {
                                   if (weakService == nil) {
                                     return;
                                   }
                                   if (message) {
                                     id expectedResponse = [GPBEmpty message];
                                     XCTAssertEqualObjects(message, expectedResponse);
                                     [expectReceive fulfill];
                                   }
                                 }
                                 closeCallback:^(NSDictionary *trailingMetadata, NSError *error) {
                                   if (weakService == nil) {
                                     return;
                                   }
                                   XCTAssertNil(error, @"Unexpected error: %@", error);
                                   [expectComplete fulfill];
                                 }]
                 callOptions:options];
    [call start];
    waiterBlock(@[ expectReceive, expectComplete ], GRPCInteropTestTimeoutDefault);
  });
}

// Test that responses can be dispatched even if we do not run main run-loop
- (void)testAsyncDispatchWithV2API {
  GRPCTestRunWithFlakeRepeats(self, ^(GRPCTestWaiter waiterBlock, GRPCTestAssert assertBlock) {
    RMTTestService *service = [RMTTestService serviceWithHost:[[self class] host]];

    XCTestExpectation *receiveExpect = [self expectationWithDescription:@"receiveExpect"];
    XCTestExpectation *closeExpect = [self expectationWithDescription:@"closeExpect"];

    GPBEmpty *request = [GPBEmpty message];
    GRPCMutableCallOptions *options = [[GRPCMutableCallOptions alloc] init];
    // For backwards compatibility
    options.transportType = [[self class] transportType];
    options.transport = [[self class] transport];
    options.PEMRootCertificates = [[self class] PEMRootCertificates];
    options.hostNameOverride = [[self class] hostNameOverride];

    __block BOOL messageReceived = NO;
    __block BOOL done = NO;
    __weak RMTTestService *weakService = service;
    GRPCUnaryProtoCall *call = [service
        emptyCallWithMessage:request
             responseHandler:[[InteropTestsBlockCallbacks alloc] initWithInitialMetadataCallback:nil
                                 messageCallback:^(id message) {
                                   if (weakService == nil) {
                                     return;
                                   }
                                   if (message) {
                                     id expectedResponse = [GPBEmpty message];
                                     XCTAssertEqualObjects(message, expectedResponse);
                                     messageReceived = YES;
                                   }
                                   [receiveExpect fulfill];
                                 }
                                 closeCallback:^(NSDictionary *trailingMetadata, NSError *error) {
                                   if (weakService == nil) {
                                     return;
                                   }
                                   XCTAssertNil(error, @"Unexpected error: %@", error);
                                   done = YES;
                                   [closeExpect fulfill];
                                 }]
                 callOptions:options];

    [call start];

    waiterBlock(@[ receiveExpect, closeExpect ], GRPCInteropTestTimeoutDefault);
    XCTAssertTrue(messageReceived);
    XCTAssertTrue(done);
  });
}

- (void)testLargeUnaryRPC {
  GRPCTestRunWithFlakeRepeats(self, ^(GRPCTestWaiter waiterBlock, GRPCTestAssert assertBlock) {
    RMTTestService *service = [RMTTestService serviceWithHost:[[self class] host]];
    __weak XCTestExpectation *expectation = [self expectationWithDescription:@"LargeUnary"];

    RMTSimpleRequest *request = [RMTSimpleRequest message];
    request.responseType = RMTPayloadType_Compressable;
    request.responseSize = LARGE_RESPONSE_PAYLOAD_SIZE;
    request.payload.body = [NSMutableData dataWithLength:LARGE_REQUEST_PAYLOAD_SIZE];

    __weak RMTTestService *weakService = service;
    [service unaryCallWithRequest:request
                          handler:^(RMTSimpleResponse *response, NSError *error) {
                            if (weakService == nil) {
                              return;
                            }

                            XCTAssertNil(error, @"Finished with unexpected error: %@", error);

                            RMTSimpleResponse *expectedResponse = [RMTSimpleResponse message];
                            expectedResponse.payload.type = RMTPayloadType_Compressable;
                            expectedResponse.payload.body =
                                [NSMutableData dataWithLength:LARGE_RESPONSE_PAYLOAD_SIZE];
                            XCTAssertEqualObjects(response, expectedResponse);

                            [expectation fulfill];
                          }];
    waiterBlock(@[ expectation ], GRPCInteropTestTimeoutDefault);
  });
}

- (void)testUnaryResponseHandler {
  // The test does not work on a remote server since it does not echo a trailer
  if ([[self class] isRemoteTest]) {
    return;
  }

  GRPCTestRunWithFlakeRepeats(self, ^(GRPCTestWaiter waiterBlock, GRPCTestAssert assertBlock) {
    RMTTestService *service = [RMTTestService serviceWithHost:[[self class] host]];

    XCTestExpectation *expectComplete = [self expectationWithDescription:@"call complete"];
    XCTestExpectation *expectCompleteMainQueue =
        [self expectationWithDescription:@"main queue call complete"];

    RMTSimpleRequest *request = [RMTSimpleRequest message];
    request.responseType = RMTPayloadType_Compressable;
    request.responseSize = LARGE_RESPONSE_PAYLOAD_SIZE;
    request.payload.body = [NSMutableData dataWithLength:LARGE_REQUEST_PAYLOAD_SIZE];

    GRPCMutableCallOptions *options = [[GRPCMutableCallOptions alloc] init];
    // For backwards compatibility
    options.transportType = [[self class] transportType];
    options.transport = [[self class] transport];
    options.PEMRootCertificates = [[self class] PEMRootCertificates];
    options.hostNameOverride = [[self class] hostNameOverride];
    const unsigned char raw_bytes[] = {1, 2, 3, 4};
    NSData *trailer_data = [NSData dataWithBytes:raw_bytes length:sizeof(raw_bytes)];
    options.initialMetadata = @{
      @"x-grpc-test-echo-trailing-bin" : trailer_data,
      @"x-grpc-test-echo-initial" : @"test-header"
    };

    __weak RMTTestService *weakService = service;

    __block GRPCUnaryResponseHandler *handler = [[GRPCUnaryResponseHandler alloc]
        initWithResponseHandler:^(GPBMessage *response, NSError *error) {
          if (weakService == nil) {
            return;
          }

          XCTAssertNil(error, @"Unexpected error: %@", error);
          RMTSimpleResponse *expectedResponse = [RMTSimpleResponse message];
          expectedResponse.payload.type = RMTPayloadType_Compressable;
          expectedResponse.payload.body =
              [NSMutableData dataWithLength:LARGE_RESPONSE_PAYLOAD_SIZE];
          XCTAssertEqualObjects(response, expectedResponse);
          XCTAssertEqualObjects(handler.responseHeaders[@"x-grpc-test-echo-initial"],
                                @"test-header");
          XCTAssertEqualObjects(handler.responseTrailers[@"x-grpc-test-echo-trailing-bin"],
                                trailer_data);
          [expectComplete fulfill];
        }
          responseDispatchQueue:dispatch_queue_create(NULL, DISPATCH_QUEUE_SERIAL)];
    __block GRPCUnaryResponseHandler *handlerMainQueue = [[GRPCUnaryResponseHandler alloc]
        initWithResponseHandler:^(GPBMessage *response, NSError *error) {
          if (weakService == nil) {
            return;
          }
          XCTAssertNil(error, @"Unexpected error: %@", error);
          RMTSimpleResponse *expectedResponse = [RMTSimpleResponse message];
          expectedResponse.payload.type = RMTPayloadType_Compressable;
          expectedResponse.payload.body =
              [NSMutableData dataWithLength:LARGE_RESPONSE_PAYLOAD_SIZE];
          XCTAssertEqualObjects(response, expectedResponse);
          XCTAssertEqualObjects(handlerMainQueue.responseHeaders[@"x-grpc-test-echo-initial"],
                                @"test-header");
          XCTAssertEqualObjects(handlerMainQueue.responseTrailers[@"x-grpc-test-echo-trailing-bin"],
                                trailer_data);
          [expectCompleteMainQueue fulfill];
        }
          responseDispatchQueue:nil];

    [[service unaryCallWithMessage:request responseHandler:handler callOptions:options] start];
    [[service unaryCallWithMessage:request responseHandler:handlerMainQueue
                       callOptions:options] start];

    waiterBlock(@[ expectComplete, expectCompleteMainQueue ], GRPCInteropTestTimeoutDefault);
  });
}

- (void)testLargeUnaryRPCWithV2API {
  GRPCTestRunWithFlakeRepeats(self, ^(GRPCTestWaiter waiterBlock, GRPCTestAssert assertBlock) {
    RMTTestService *service = [RMTTestService serviceWithHost:[[self class] host]];
    __weak XCTestExpectation *expectReceive =
        [self expectationWithDescription:@"LargeUnaryWithV2API received message"];
    __weak XCTestExpectation *expectComplete =
        [self expectationWithDescription:@"LargeUnaryWithV2API received complete"];

    RMTSimpleRequest *request = [RMTSimpleRequest message];
    request.responseType = RMTPayloadType_Compressable;
    request.responseSize = LARGE_RESPONSE_PAYLOAD_SIZE;
    request.payload.body = [NSMutableData dataWithLength:LARGE_REQUEST_PAYLOAD_SIZE];

    GRPCMutableCallOptions *options = [[GRPCMutableCallOptions alloc] init];
    // For backwards compatibility
    options.transportType = [[self class] transportType];
    options.transport = [[self class] transport];
    options.PEMRootCertificates = [[self class] PEMRootCertificates];
    options.hostNameOverride = [[self class] hostNameOverride];

    __weak RMTTestService *weakService = service;
    GRPCUnaryProtoCall *call = [service
        unaryCallWithMessage:request
             responseHandler:[[InteropTestsBlockCallbacks alloc] initWithInitialMetadataCallback:nil
                                 messageCallback:^(id message) {
                                   if (weakService == nil) {
                                     return;
                                   }
                                   XCTAssertNotNil(message);
                                   if (message) {
                                     RMTSimpleResponse *expectedResponse =
                                         [RMTSimpleResponse message];
                                     expectedResponse.payload.type = RMTPayloadType_Compressable;
                                     expectedResponse.payload.body =
                                         [NSMutableData dataWithLength:LARGE_RESPONSE_PAYLOAD_SIZE];
                                     XCTAssertEqualObjects(message, expectedResponse);

                                     [expectReceive fulfill];
                                   }
                                 }
                                 closeCallback:^(NSDictionary *trailingMetadata, NSError *error) {
                                   if (weakService == nil) {
                                     return;
                                   }
                                   XCTAssertNil(error, @"Unexpected error: %@", error);
                                   [expectComplete fulfill];
                                 }]
                 callOptions:options];
    [call start];
    waiterBlock(@[ expectReceive, expectComplete ], GRPCInteropTestTimeoutDefault);
  });
}

- (void)testConcurrentRPCsWithErrorsWithV2API {
  GRPCTestRunWithFlakeRepeats(self, ^(GRPCTestWaiter waiterBlock, GRPCTestAssert assertBlock) {
    RMTTestService *service = [RMTTestService serviceWithHost:[[self class] host]];
    NSMutableArray *completeExpectations = [NSMutableArray array];
    NSMutableArray *calls = [NSMutableArray array];
    int num_rpcs = 10;
    for (int i = 0; i < num_rpcs; ++i) {
      [completeExpectations
          addObject:[self expectationWithDescription:
                              [NSString stringWithFormat:@"Received trailer for RPC %d", i]]];

      RMTSimpleRequest *request = [RMTSimpleRequest message];
      request.responseType = RMTPayloadType_Compressable;
      request.responseSize = SMALL_PAYLOAD_SIZE;
      request.payload.body = [NSMutableData dataWithLength:SMALL_PAYLOAD_SIZE];
      if (i % 3 == 0) {
        request.responseStatus.code = GRPC_STATUS_UNAVAILABLE;
      } else if (i % 7 == 0) {
        request.responseStatus.code = GRPC_STATUS_CANCELLED;
      }
      GRPCMutableCallOptions *options = [[GRPCMutableCallOptions alloc] init];
      // For backwards compatibility
      options.transportType = [[self class] transportType];
      options.transport = [[self class] transport];
      options.PEMRootCertificates = [[self class] PEMRootCertificates];
      options.hostNameOverride = [[self class] hostNameOverride];

      __weak RMTTestService *weakService = service;
      GRPCUnaryProtoCall *call = [service
          unaryCallWithMessage:request
               responseHandler:[[InteropTestsBlockCallbacks alloc]
                                   initWithInitialMetadataCallback:nil
                                   messageCallback:^(id message) {
                                     if (weakService == nil) {
                                       return;
                                     }
                                     if (message) {
                                       RMTSimpleResponse *expectedResponse =
                                           [RMTSimpleResponse message];
                                       expectedResponse.payload.type = RMTPayloadType_Compressable;
                                       expectedResponse.payload.body =
                                           [NSMutableData dataWithLength:SMALL_PAYLOAD_SIZE];
                                       XCTAssertEqualObjects(message, expectedResponse);
                                     }
                                   }
                                   closeCallback:^(NSDictionary *trailingMetadata, NSError *error) {
                                     if (weakService == nil) {
                                       return;
                                     }
                                     [completeExpectations[i] fulfill];
                                   }]
                   callOptions:options];
      [calls addObject:call];
    }

    for (int i = 0; i < num_rpcs; ++i) {
      GRPCUnaryProtoCall *call = calls[i];
      [call start];
    }

    waiterBlock(completeExpectations, GRPCInteropTestTimeoutDefault);
  });
}

- (void)concurrentRPCsWithErrors {
  const int kNumRpcs = 10;
  __block int completedCallCount = 0;
  NSCondition *cv = [[NSCondition alloc] init];
  NSDate *waitUntil = [[NSDate date] dateByAddingTimeInterval:GRPCInteropTestTimeoutDefault];
  [cv lock];
  for (int i = 0; i < kNumRpcs; ++i) {
    RMTSimpleRequest *request = [RMTSimpleRequest message];
    request.responseType = RMTPayloadType_Compressable;
    request.responseSize = SMALL_PAYLOAD_SIZE;
    request.payload.body = [NSMutableData dataWithLength:SMALL_PAYLOAD_SIZE];
    if (i % 3 == 0) {
      request.responseStatus.code = GRPC_STATUS_UNAVAILABLE;
    } else if (i % 7 == 0) {
      request.responseStatus.code = GRPC_STATUS_CANCELLED;
    }

    RMTTestService *service = [RMTTestService serviceWithHost:[[self class] host]];
    __weak RMTTestService *weakService = service;
    GRPCProtoCall *call = [service
        RPCToUnaryCallWithRequest:request
                          handler:^(RMTSimpleResponse *response, NSError *error) {
                            if (weakService == nil) {
                              return;
                            }
                            if (error == nil) {
                              RMTSimpleResponse *expectedResponse = [RMTSimpleResponse message];
                              expectedResponse.payload.type = RMTPayloadType_Compressable;
                              expectedResponse.payload.body =
                                  [NSMutableData dataWithLength:SMALL_PAYLOAD_SIZE];
                              XCTAssertEqualObjects(response, expectedResponse);
                            }
                            // DEBUG
                            [cv lock];
                            if (++completedCallCount == kNumRpcs) {
                              [cv signal];
                            }
                            [cv unlock];
                          }];
    [call setResponseDispatchQueue:dispatch_queue_create(NULL, DISPATCH_QUEUE_SERIAL)];
    [call start];
  }
  while (completedCallCount < kNumRpcs && [waitUntil timeIntervalSinceNow] > 0) {
    [cv waitUntilDate:waitUntil];
  }
  [cv unlock];
}

- (void)testConcurrentRPCsWithErrors {
  [self retriableTest:@selector(concurrentRPCsWithErrors) retries:kTestRetries timeout:10];
}

- (void)testPacketCoalescing {
  GRPCTestRunWithFlakeRepeats(self, ^(GRPCTestWaiter waiterBlock, GRPCTestAssert assertBlock) {
    RMTTestService *service = [RMTTestService serviceWithHost:[[self class] host]];
    __weak XCTestExpectation *expectation = [self expectationWithDescription:@"LargeUnary"];

    RMTSimpleRequest *request = [RMTSimpleRequest message];
    request.responseType = RMTPayloadType_Compressable;
    request.responseSize = SMALL_PAYLOAD_SIZE;
    request.payload.body = [NSMutableData dataWithLength:SMALL_PAYLOAD_SIZE];

    [GRPCCall enableOpBatchLog:YES];
    __weak RMTTestService *weakService = service;
    [service unaryCallWithRequest:request
                          handler:^(RMTSimpleResponse *response, NSError *error) {
                            if (weakService == nil) {
                              return;
                            }
                            XCTAssertNil(error, @"Finished with unexpected error: %@", error);

                            RMTSimpleResponse *expectedResponse = [RMTSimpleResponse message];
                            expectedResponse.payload.type = RMTPayloadType_Compressable;
                            expectedResponse.payload.body = [NSMutableData dataWithLength:10];
                            XCTAssertEqualObjects(response, expectedResponse);

                            // The test is a success if there is a batch of exactly 3 ops
                            // (SEND_INITIAL_METADATA, SEND_MESSAGE, SEND_CLOSE_FROM_CLIENT).
                            // Without packet coalescing each batch of ops contains only one op.
                            NSArray *opBatches = [GRPCCall obtainAndCleanOpBatchLog];
                            const NSInteger kExpectedOpBatchSize = 3;
                            for (NSObject *o in opBatches) {
                              if ([o isKindOfClass:[NSArray class]]) {
                                NSArray *batch = (NSArray *)o;
                                if ([batch count] == kExpectedOpBatchSize) {
                                  [expectation fulfill];
                                  break;
                                }
                              }
                            }
                          }];

    waiterBlock(@[ expectation ], GRPCInteropTestTimeoutDefault);
    [GRPCCall enableOpBatchLog:NO];
  });
}

- (void)test4MBResponsesAreAccepted {
  GRPCTestRunWithFlakeRepeats(self, ^(GRPCTestWaiter waiterBlock, GRPCTestAssert assertBlock) {
    RMTTestService *service = [RMTTestService serviceWithHost:[[self class] host]];
    __weak XCTestExpectation *expectation = [self expectationWithDescription:@"MaxResponseSize"];

    RMTSimpleRequest *request = [RMTSimpleRequest message];
    const int32_t kPayloadSize =
        4 * 1024 * 1024 - self.encodingOverhead;  // 4MB - encoding overhead
    request.responseSize = kPayloadSize;

    __weak RMTTestService *weakService = service;
    [service unaryCallWithRequest:request
                          handler:^(RMTSimpleResponse *response, NSError *error) {
                            if (weakService == nil) {
                              return;
                            }
                            XCTAssertNil(error, @"Finished with unexpected error: %@", error);
                            XCTAssertEqual(response.payload.body.length, kPayloadSize);
                            [expectation fulfill];
                          }];

    waiterBlock(@[ expectation ], GRPCInteropTestTimeoutDefault);
  });
}

- (void)testResponsesOverMaxSizeFailWithActionableMessage {
  GRPCTestRunWithFlakeRepeats(self, ^(GRPCTestWaiter waiterBlock, GRPCTestAssert assertBlock) {
    RMTTestService *service = [RMTTestService serviceWithHost:[[self class] host]];
    __weak XCTestExpectation *expectation =
        [self expectationWithDescription:@"ResponseOverMaxSize"];

    RMTSimpleRequest *request = [RMTSimpleRequest message];
    const int32_t kPayloadSize = 4 * 1024 * 1024 - self.encodingOverhead + 1;  // 1B over max size
    request.responseSize = kPayloadSize;

    __weak RMTTestService *weakService = service;
    [service unaryCallWithRequest:request
                          handler:^(RMTSimpleResponse *response, NSError *error) {
                            if (weakService == nil) {
                              return;
                            }
                            // TODO(jcanizales): Catch the error and rethrow it with an
                            // actionable message:
                            // - Use +[GRPCCall setResponseSizeLimit:forHost:] to set a
                            // higher limit.
                            // - If you're developing the server, consider using response
                            // streaming, or let clients filter
                            //   responses by setting a google.protobuf.FieldMask in the
                            //   request:
                            //   https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
                            XCTAssertEqualObjects(
                                error.localizedDescription,
                                @"CLIENT: Received message larger than max (4194305 vs. 4194304)");
                            [expectation fulfill];
                          }];
    waiterBlock(@[ expectation ], GRPCInteropTestTimeoutDefault);
  });
}

- (void)testResponsesOver4MBAreAcceptedIfOptedIn {
  GRPCTestRunWithFlakeRepeats(self, ^(GRPCTestWaiter waiterBlock, GRPCTestAssert assertBlock) {
    RMTTestService *service = [RMTTestService serviceWithHost:[[self class] host]];
    __weak XCTestExpectation *expectation =
        [self expectationWithDescription:@"HigherResponseSizeLimit"];
    __block NSError *callError = nil;

    RMTSimpleRequest *request = [RMTSimpleRequest message];
    const size_t kPayloadSize = 5 * 1024 * 1024;  // 5MB
    request.responseSize = kPayloadSize;

    [GRPCCall setResponseSizeLimit:6 * 1024 * 1024 forHost:[[self class] host]];
    __weak RMTTestService *weakService = service;
    [service unaryCallWithRequest:request
                          handler:^(RMTSimpleResponse *response, NSError *error) {
                            if (weakService == nil) {
                              return;
                            }
                            callError = error;
                            [expectation fulfill];
                          }];

    waiterBlock(@[ expectation ], GRPCInteropTestTimeoutDefault);
    XCTAssertNil(callError, @"Finished with unexpected error: %@", callError);
  });
}

- (void)testClientStreamingRPC {
  GRPCTestRunWithFlakeRepeats(self, ^(GRPCTestWaiter waiterBlock, GRPCTestAssert assertBlock) {
    RMTTestService *service = [RMTTestService serviceWithHost:[[self class] host]];
    __weak XCTestExpectation *expectation = [self expectationWithDescription:@"ClientStreaming"];

    RMTStreamingInputCallRequest *request1 = [RMTStreamingInputCallRequest message];
    request1.payload.body = [NSMutableData dataWithLength:27182];

    RMTStreamingInputCallRequest *request2 = [RMTStreamingInputCallRequest message];
    request2.payload.body = [NSMutableData dataWithLength:8];

    RMTStreamingInputCallRequest *request3 = [RMTStreamingInputCallRequest message];
    request3.payload.body = [NSMutableData dataWithLength:1828];

    RMTStreamingInputCallRequest *request4 = [RMTStreamingInputCallRequest message];
    request4.payload.body = [NSMutableData dataWithLength:45904];

    GRXWriter *writer = [GRXWriter writerWithContainer:@[ request1, request2, request3, request4 ]];

    __weak RMTTestService *weakService = service;
    [service
        streamingInputCallWithRequestsWriter:writer
                                     handler:^(RMTStreamingInputCallResponse *response,
                                               NSError *error) {
                                       if (weakService == nil) {
                                         return;
                                       }
                                       XCTAssertNil(error, @"Finished with unexpected error: %@",
                                                    error);

                                       RMTStreamingInputCallResponse *expectedResponse =
                                           [RMTStreamingInputCallResponse message];
                                       expectedResponse.aggregatedPayloadSize = 74922;
                                       XCTAssertEqualObjects(response, expectedResponse);

                                       [expectation fulfill];
                                     }];

    waiterBlock(@[ expectation ], GRPCInteropTestTimeoutDefault);
  });
}

- (void)testServerStreamingRPC {
  GRPCTestRunWithFlakeRepeats(self, ^(GRPCTestWaiter waiterBlock, GRPCTestAssert assertBlock) {
    RMTTestService *service = [RMTTestService serviceWithHost:[[self class] host]];
    __weak XCTestExpectation *expectation = [self expectationWithDescription:@"ServerStreaming"];

    NSArray *expectedSizes = @[ @31415, @9, @2653, @58979 ];

    RMTStreamingOutputCallRequest *request = [RMTStreamingOutputCallRequest message];
    for (NSNumber *size in expectedSizes) {
      RMTResponseParameters *parameters = [RMTResponseParameters message];
      parameters.size = [size intValue];
      [request.responseParametersArray addObject:parameters];
    }

    __block int index = 0;
    __weak RMTTestService *weakService = service;
    [service
        streamingOutputCallWithRequest:request
                          eventHandler:^(BOOL done, RMTStreamingOutputCallResponse *response,
                                         NSError *error) {
                            if (weakService == nil) {
                              return;
                            }

                            assertBlock(
                                error == nil,
                                [NSString
                                    stringWithFormat:@"Finished with unexpected error: %@", error]);
                            assertBlock(done || response,
                                        @"Event handler called without an event.");

                            if (response) {
                              assertBlock(index < 4, @"More than 4 responses received.");

                              id expected = [RMTStreamingOutputCallResponse
                                  messageWithPayloadSize:expectedSizes[index]];
                              assertBlock(
                                  [response isEqual:expected],
                                  [NSString
                                      stringWithFormat:@"response %@ not equal to expected %@",
                                                       response, expected]);

                              index += 1;
                            }

                            if (done) {
                              assertBlock(
                                  index == 4,
                                  [NSString stringWithFormat:@"Received %@ responses instead of 4.",
                                                             @(index)]);
                              [expectation fulfill];
                            }
                          }];

    waiterBlock(@[ expectation ], GRPCInteropTestTimeoutDefault);
  });
}

- (void)testPingPongRPC {
  GRPCTestRunWithFlakeRepeats(self, ^(GRPCTestWaiter waiterBlock, GRPCTestAssert assertBlock) {
    RMTTestService *service = [RMTTestService serviceWithHost:[[self class] host]];
    __weak XCTestExpectation *expectation = [self expectationWithDescription:@"PingPong"];

    NSArray *requests = @[ @27182, @8, @1828, @45904 ];
    NSArray *responses = @[ @31415, @9, @2653, @58979 ];

    GRXBufferedPipe *requestsBuffer = [[GRXBufferedPipe alloc] init];

    __block int index = 0;

    id request = [RMTStreamingOutputCallRequest messageWithPayloadSize:requests[index]
                                                 requestedResponseSize:responses[index]];
    [requestsBuffer writeValue:request];

    __weak RMTTestService *weakService = service;
    [service
        fullDuplexCallWithRequestsWriter:requestsBuffer
                            eventHandler:^(BOOL done, RMTStreamingOutputCallResponse *response,
                                           NSError *error) {
                              if (weakService == nil) {
                                return;
                              }

                              assertBlock(
                                  error == nil,
                                  [NSString stringWithFormat:@"Finished with unexpected error: %@",
                                                             error]);
                              assertBlock(done || response,
                                          @"Event handler called without an event.");

                              if (response) {
                                assertBlock(index < 4, @"More than 4 responses received.");

                                id expected = [RMTStreamingOutputCallResponse
                                    messageWithPayloadSize:responses[index]];
                                assertBlock(
                                    [response isEqual:expected],
                                    [NSString
                                        stringWithFormat:@"response %@ not equal to expected %@",
                                                         response, expected]);

                                index += 1;
                                if (index < 4) {
                                  id request = [RMTStreamingOutputCallRequest
                                      messageWithPayloadSize:requests[index]
                                       requestedResponseSize:responses[index]];
                                  [requestsBuffer writeValue:request];
                                } else {
                                  [requestsBuffer writesFinishedWithError:nil];
                                }
                              }

                              if (done) {
                                assertBlock(
                                    index == 4,
                                    [NSString
                                        stringWithFormat:@"Received %@ responses instead of 4.",
                                                         @(index)]);
                                [expectation fulfill];
                              }
                            }];
    waiterBlock(@[ expectation ], GRPCInteropTestTimeoutDefault);
  });
}

- (void)testPingPongRPCWithV2API {
  GRPCTestRunWithFlakeRepeats(self, ^(GRPCTestWaiter waiterBlock, GRPCTestAssert assertBlock) {
    RMTTestService *service = [RMTTestService serviceWithHost:[[self class] host]];
    __weak XCTestExpectation *expectation = [self expectationWithDescription:@"PingPongWithV2API"];

    NSArray *requests = @[ @27182, @8, @1828, @45904 ];
    NSArray *responses = @[ @31415, @9, @2653, @58979 ];

    __block int index = 0;

    id request = [RMTStreamingOutputCallRequest messageWithPayloadSize:requests[index]
                                                 requestedResponseSize:responses[index]];
    GRPCMutableCallOptions *options = [[GRPCMutableCallOptions alloc] init];
    // For backwards compatibility
    options.transportType = [[self class] transportType];
    options.transport = [[self class] transport];
    options.PEMRootCertificates = [[self class] PEMRootCertificates];
    options.hostNameOverride = [[self class] hostNameOverride];

    __weak __block GRPCStreamingProtoCall *weakCall;
    GRPCStreamingProtoCall *call = [service
        fullDuplexCallWithResponseHandler:
            [[InteropTestsBlockCallbacks alloc] initWithInitialMetadataCallback:nil
                messageCallback:^(id message) {
                  GRPCStreamingProtoCall *localCall = weakCall;
                  if (localCall == nil) {
                    return;
                  }
                  assertBlock(index < 4, @"More than 4 responses received.");

                  id expected =
                      [RMTStreamingOutputCallResponse messageWithPayloadSize:responses[index]];
                  assertBlock([message isEqual:expected],
                              [NSString stringWithFormat:@"message %@ not equal to expected %@",
                                                         message, expected]);
                  index += 1;
                  if (index < 4) {
                    id request =
                        [RMTStreamingOutputCallRequest messageWithPayloadSize:requests[index]
                                                        requestedResponseSize:responses[index]];
                    [localCall writeMessage:request];
                  } else {
                    [localCall finish];
                  }
                }
                closeCallback:^(NSDictionary *trailingMetadata, NSError *error) {
                  if (weakCall == nil) {
                    return;
                  }
                  assertBlock(
                      error == nil,
                      [NSString stringWithFormat:@"Finished with unexpected error: %@", error]);
                  assertBlock(
                      index == 4,
                      [NSString stringWithFormat:@"Received %@ responses instead of 4.", @(index)]);
                  [expectation fulfill];
                }]
                              callOptions:options];
    weakCall = call;
    [call start];
    [call writeMessage:request];

    waiterBlock(@[ expectation ], GRPCInteropTestTimeoutDefault);
  });
}

- (void)testPingPongRPCWithFlowControl {
  GRPCTestRunWithFlakeRepeats(self, ^(GRPCTestWaiter waiterBlock, GRPCTestAssert assertBlock) {
    RMTTestService *service = [RMTTestService serviceWithHost:[[self class] host]];
    __weak XCTestExpectation *expectation = [self expectationWithDescription:@"PingPongWithV2API"];

    NSArray *requests = @[ @27182, @8, @1828, @45904 ];
    NSArray *responses = @[ @31415, @9, @2653, @58979 ];

    __block int index = 0;

    id request = [RMTStreamingOutputCallRequest messageWithPayloadSize:requests[index]
                                                 requestedResponseSize:responses[index]];
    GRPCMutableCallOptions *options = [[GRPCMutableCallOptions alloc] init];
    // For backwards compatibility
    options.transportType = [[self class] transportType];
    options.transport = [[self class] transport];
    options.PEMRootCertificates = [[self class] PEMRootCertificates];
    options.hostNameOverride = [[self class] hostNameOverride];
    options.flowControlEnabled = YES;
    __block int writeMessageCount = 0;

    __weak __block GRPCStreamingProtoCall *weakCall;
    GRPCStreamingProtoCall *call = [service
        fullDuplexCallWithResponseHandler:
            [[InteropTestsBlockCallbacks alloc] initWithInitialMetadataCallback:nil
                messageCallback:^(id message) {
                  GRPCStreamingProtoCall *localCall = weakCall;
                  if (localCall == nil) {
                    return;
                  }

                  assertBlock((index < 4), @"More than 4 responses received.");
                  id expected =
                      [RMTStreamingOutputCallResponse messageWithPayloadSize:responses[index]];
                  assertBlock(
                      [message isEqual:expected],
                      [NSString stringWithFormat:@"message %@ not equal to %@", message, expected]);

                  index += 1;
                  if (index < 4) {
                    id request =
                        [RMTStreamingOutputCallRequest messageWithPayloadSize:requests[index]
                                                        requestedResponseSize:responses[index]];
                    [localCall writeMessage:request];
                    [localCall receiveNextMessage];
                  } else {
                    [localCall finish];
                  }
                }
                closeCallback:^(NSDictionary *trailingMetadata, NSError *error) {
                  if (weakCall == nil) {
                    return;
                  }

                  assertBlock(
                      error == nil,
                      [NSString stringWithFormat:@"Finished with unexpected error: %@", error]);
                  assertBlock(
                      index == 4,
                      [NSString stringWithFormat:@"Received %i responses instead of 4.", index]);
                  [expectation fulfill];
                }
                writeMessageCallback:^{
                  writeMessageCount++;
                }]
                              callOptions:options];
    weakCall = call;
    [call start];
    [call receiveNextMessage];
    [call writeMessage:request];

    waiterBlock(@[ expectation ], GRPCInteropTestTimeoutDefault);
    assertBlock(
        writeMessageCount == 4,
        [NSString stringWithFormat:@"writeMessageCount %@ not equal to 4", @(writeMessageCount)]);
  });
}

- (void)testEmptyStreamRPC {
  GRPCTestRunWithFlakeRepeats(self, ^(GRPCTestWaiter waiterBlock, GRPCTestAssert assertBlock) {
    RMTTestService *service = [RMTTestService serviceWithHost:[[self class] host]];
    __weak XCTestExpectation *expectation = [self expectationWithDescription:@"EmptyStream"];
    __weak RMTTestService *weakService = service;
    [service
        fullDuplexCallWithRequestsWriter:[GRXWriter emptyWriter]
                            eventHandler:^(BOOL done, RMTStreamingOutputCallResponse *response,
                                           NSError *error) {
                              if (weakService == nil) {
                                return;
                              }
                              XCTAssertNil(error, @"Finished with unexpected error: %@", error);
                              XCTAssert(done, @"Unexpected response: %@", response);
                              [expectation fulfill];
                            }];
    waiterBlock(@[ expectation ], GRPCInteropTestTimeoutDefault);
  });
}

- (void)testCancelAfterBeginRPC {
  GRPCTestRunWithFlakeRepeats(self, ^(GRPCTestWaiter waiterBlock, GRPCTestAssert assertBlock) {
    RMTTestService *service = [RMTTestService serviceWithHost:[[self class] host]];
    __weak XCTestExpectation *expectation = [self expectationWithDescription:@"CancelAfterBegin"];

    // A buffered pipe to which we never write any value acts as a writer that just hangs.
    GRXBufferedPipe *requestsBuffer = [[GRXBufferedPipe alloc] init];

    __weak RMTTestService *weakService = service;
    GRPCProtoCall *call = [service
        RPCToStreamingInputCallWithRequestsWriter:requestsBuffer
                                          handler:^(RMTStreamingInputCallResponse *response,
                                                    NSError *error) {
                                            if (weakService == nil) {
                                              return;
                                            }
                                            XCTAssertEqual(error.code, GRPC_STATUS_CANCELLED);
                                            [expectation fulfill];
                                          }];
    XCTAssertEqual(call.state, GRXWriterStateNotStarted);

    [call start];
    XCTAssertEqual(call.state, GRXWriterStateStarted);

    [call cancel];
    XCTAssertEqual(call.state, GRXWriterStateFinished);

    waiterBlock(@[ expectation ], GRPCInteropTestTimeoutDefault);
  });
}

- (void)testCancelAfterBeginRPCWithV2API {
  GRPCTestRunWithFlakeRepeats(self, ^(GRPCTestWaiter waiterBlock, GRPCTestAssert assertBlock) {
    RMTTestService *service = [RMTTestService serviceWithHost:[[self class] host]];
    __weak XCTestExpectation *expectation =
        [self expectationWithDescription:@"CancelAfterBeginWithV2API"];

    // A buffered pipe to which we never write any value acts as a writer that just hangs.
    __weak RMTTestService *weakService = service;
    GRPCStreamingProtoCall *call = [service
        streamingInputCallWithResponseHandler:[[InteropTestsBlockCallbacks alloc]
                                                  initWithInitialMetadataCallback:nil
                                                  messageCallback:^(id message) {
                                                    if (weakService == nil) {
                                                      return;
                                                    }
                                                    XCTFail(@"Not expected to receive message");
                                                  }
                                                  closeCallback:^(NSDictionary *trailingMetadata,
                                                                  NSError *error) {
                                                    if (weakService == nil) {
                                                      return;
                                                    }
                                                    XCTAssertEqual(error.code,
                                                                   GRPC_STATUS_CANCELLED);
                                                    [expectation fulfill];
                                                  }]
                                  callOptions:nil];
    [call start];
    [call cancel];

    waiterBlock(@[ expectation ], GRPCInteropTestTimeoutDefault);
  });
}

- (void)testCancelAfterFirstResponseRPC {
  GRPCTestRunWithFlakeRepeats(self, ^(GRPCTestWaiter waiterBlock, GRPCTestAssert assertBlock) {
    RMTTestService *service = [RMTTestService serviceWithHost:[[self class] host]];
    __weak XCTestExpectation *expectation =
        [self expectationWithDescription:@"CancelAfterFirstResponse"];

    // A buffered pipe to which we write a single value but never close
    GRXBufferedPipe *requestsBuffer = [[GRXBufferedPipe alloc] init];

    __block BOOL receivedResponse = NO;

    id request = [RMTStreamingOutputCallRequest messageWithPayloadSize:@21782
                                                 requestedResponseSize:@31415];

    [requestsBuffer writeValue:request];

    __weak RMTTestService *weakService = service;
    __block GRPCProtoCall *call = [service
        RPCToFullDuplexCallWithRequestsWriter:requestsBuffer
                                 eventHandler:^(BOOL done, RMTStreamingOutputCallResponse *response,
                                                NSError *error) {
                                   if (weakService == nil) {
                                     return;
                                   }
                                   if (receivedResponse) {
                                     XCTAssert(done, @"Unexpected extra response %@", response);
                                     XCTAssertEqual(error.code, GRPC_STATUS_CANCELLED);
                                     [expectation fulfill];
                                   } else {
                                     XCTAssertNil(error, @"Finished with unexpected error: %@",
                                                  error);
                                     XCTAssertFalse(done, @"Finished without response");
                                     XCTAssertNotNil(response);
                                     receivedResponse = YES;
                                     [call cancel];
                                   }
                                 }];
    [call start];
    waiterBlock(@[ expectation ], GRPCInteropTestTimeoutDefault);
  });
}

- (void)testCancelAfterFirstResponseRPCWithV2API {
  GRPCTestRunWithFlakeRepeats(self, ^(GRPCTestWaiter waiterBlock, GRPCTestAssert assertBlock) {
    RMTTestService *service = [RMTTestService serviceWithHost:[[self class] host]];
    __weak XCTestExpectation *completionExpectation =
        [self expectationWithDescription:@"Call completed."];
    __weak XCTestExpectation *responseExpectation =
        [self expectationWithDescription:@"Received response."];

    __block BOOL receivedResponse = NO;

    GRPCMutableCallOptions *options = [[GRPCMutableCallOptions alloc] init];
    // For backwards compatibility
    options.transportType = self.class.transportType;
    options.transport = [[self class] transport];
    options.PEMRootCertificates = self.class.PEMRootCertificates;
    options.hostNameOverride = [[self class] hostNameOverride];

    id request = [RMTStreamingOutputCallRequest messageWithPayloadSize:@21782
                                                 requestedResponseSize:@31415];

    __weak __block GRPCStreamingProtoCall *weakCall;
    GRPCStreamingProtoCall *call = [service
        fullDuplexCallWithResponseHandler:[[InteropTestsBlockCallbacks alloc]
                                              initWithInitialMetadataCallback:nil
                                              messageCallback:^(id message) {
                                                GRPCStreamingProtoCall *localCall = weakCall;
                                                if (localCall == nil) {
                                                  return;
                                                }
                                                XCTAssertFalse(receivedResponse);
                                                receivedResponse = YES;
                                                [localCall cancel];
                                                [responseExpectation fulfill];
                                              }
                                              closeCallback:^(NSDictionary *trailingMetadata,
                                                              NSError *error) {
                                                if (weakCall == nil) {
                                                  return;
                                                }
                                                XCTAssertEqual(error.code, GRPC_STATUS_CANCELLED);
                                                [completionExpectation fulfill];
                                              }]
                              callOptions:options];
    weakCall = call;
    [call start];
    [call writeMessage:request];
    waiterBlock(@[ completionExpectation, responseExpectation ], GRPCInteropTestTimeoutDefault);
  });
}

- (void)testCancelAfterFirstRequestWithV2API {
  GRPCTestRunWithFlakeRepeats(self, ^(GRPCTestWaiter waiterBlock, GRPCTestAssert assertBlock) {
    RMTTestService *service = [RMTTestService serviceWithHost:[[self class] host]];
    __weak XCTestExpectation *completionExpectation =
        [self expectationWithDescription:@"Call completed."];

    GRPCMutableCallOptions *options = [[GRPCMutableCallOptions alloc] init];
    // For backwards compatibility
    options.transportType = self.class.transportType;
    options.transport = [[self class] transport];
    options.PEMRootCertificates = self.class.PEMRootCertificates;
    options.hostNameOverride = [[self class] hostNameOverride];

    id request = [RMTStreamingOutputCallRequest messageWithPayloadSize:@21782
                                                 requestedResponseSize:@31415];

    __weak RMTTestService *weakService = service;
    GRPCStreamingProtoCall *call = [service
        fullDuplexCallWithResponseHandler:[[InteropTestsBlockCallbacks alloc]
                                              initWithInitialMetadataCallback:nil
                                              messageCallback:^(id message) {
                                                if (weakService == nil) {
                                                  return;
                                                }
                                                XCTFail(@"Received unexpected response.");
                                              }
                                              closeCallback:^(NSDictionary *trailingMetadata,
                                                              NSError *error) {
                                                if (weakService == nil) {
                                                  return;
                                                }
                                                XCTAssertEqual(error.code, GRPC_STATUS_CANCELLED);
                                                [completionExpectation fulfill];
                                              }]
                              callOptions:options];
    [call start];
    [call writeMessage:request];
    [call cancel];
    waiterBlock(@[ completionExpectation ], GRPCInteropTestTimeoutDefault);
  });
}

- (void)testRPCAfterClosingOpenConnections {
  GRPCTestRunWithFlakeRepeats(self, ^(GRPCTestWaiter waiterBlock, GRPCTestAssert assertBlock) {
    RMTTestService *service = [RMTTestService serviceWithHost:[[self class] host]];
    __weak XCTestExpectation *expectation =
        [self expectationWithDescription:@"RPC after closing connection"];

    GPBEmpty *request = [GPBEmpty message];

    __weak RMTTestService *weakService = service;
    [service
        emptyCallWithRequest:request
                     handler:^(GPBEmpty *response, NSError *error) {
                       if (weakService == nil) {
                         return;
                       }
                       XCTAssertNil(error, @"First RPC finished with unexpected error: %@", error);

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
                       [GRPCCall closeOpenConnections];
#pragma clang diagnostic pop

                       [weakService
                           emptyCallWithRequest:request
                                        handler:^(GPBEmpty *response, NSError *error) {
                                          XCTAssertNil(
                                              error,
                                              @"Second RPC finished with unexpected error: %@",
                                              error);
                                          [expectation fulfill];
                                        }];
                     }];

    waiterBlock(@[ expectation ], GRPCInteropTestTimeoutDefault);
  });
}

- (void)testCompressedUnaryRPC {
  // This test needs to be disabled for remote test because interop server grpc-test
  // does not support compression.
  if (isRemoteInteropTest([[self class] host])) {
    return;
  }

  GRPCTestRunWithFlakeRepeats(self, ^(GRPCTestWaiter waiterBlock, GRPCTestAssert assertBlock) {
    RMTTestService *service = [RMTTestService serviceWithHost:[[self class] host]];
    __weak XCTestExpectation *expectation = [self expectationWithDescription:@"LargeUnary"];

    RMTSimpleRequest *request = [RMTSimpleRequest message];
    request.responseType = RMTPayloadType_Compressable;
    request.responseSize = LARGE_RESPONSE_PAYLOAD_SIZE;
    request.payload.body = [NSMutableData dataWithLength:LARGE_REQUEST_PAYLOAD_SIZE];
    request.expectCompressed.value = YES;
    [GRPCCall setDefaultCompressMethod:GRPCCompressGzip forhost:[[self class] host]];

    __weak RMTTestService *weakService = service;
    [service unaryCallWithRequest:request
                          handler:^(RMTSimpleResponse *response, NSError *error) {
                            if (weakService == nil) {
                              return;
                            }

                            XCTAssertNil(error, @"Finished with unexpected error: %@", error);

                            RMTSimpleResponse *expectedResponse = [RMTSimpleResponse message];
                            expectedResponse.payload.type = RMTPayloadType_Compressable;
                            expectedResponse.payload.body =
                                [NSMutableData dataWithLength:LARGE_RESPONSE_PAYLOAD_SIZE];
                            XCTAssertEqualObjects(response, expectedResponse);

                            [expectation fulfill];
                          }];

    waiterBlock(@[ expectation ], GRPCInteropTestTimeoutDefault);
  });
}

// TODO(b/268379869): This test has a race and is flaky in any configurations. One possible way to
// deflake this test is to find a way to disable ping ack on the interop server for this test case.
- (void)testKeepaliveWithV2API {
  return;

  GRPCTestRunWithFlakeRepeats(self, ^(GRPCTestWaiter waiterBlock, GRPCTestAssert assertBlock) {
    RMTTestService *service = [RMTTestService serviceWithHost:[[self class] host]];
    __weak XCTestExpectation *expectation = [self expectationWithDescription:@"Keepalive"];

    const NSTimeInterval kTestTimeout = 5;
    NSNumber *kRequestSize = @27182;
    NSNumber *kResponseSize = @31415;

    id request = [RMTStreamingOutputCallRequest messageWithPayloadSize:kRequestSize
                                                 requestedResponseSize:kResponseSize];
    GRPCMutableCallOptions *options = [[GRPCMutableCallOptions alloc] init];
    options.transportType = [[self class] transportType];
    options.transport = [[self class] transport];
    options.PEMRootCertificates = [[self class] PEMRootCertificates];
    options.hostNameOverride = [[self class] hostNameOverride];
    options.keepaliveInterval = 1.5;
    options.keepaliveTimeout = 0;

    __weak RMTTestService *weakService = service;
    GRPCStreamingProtoCall *call = [service
        fullDuplexCallWithResponseHandler:
            [[InteropTestsBlockCallbacks alloc]
                initWithInitialMetadataCallback:nil
                                messageCallback:nil
                                  closeCallback:^(NSDictionary *trailingMetadata, NSError *error) {
                                    if (weakService == nil) {
                                      return;
                                    }
                                    XCTAssertNotNil(error);
                                    XCTAssertEqual(
                                        error.code, GRPC_STATUS_UNAVAILABLE,
                                        @"Received status %@ instead of UNAVAILABLE (14).",
                                        @(error.code));
                                    [expectation fulfill];
                                  }]
                              callOptions:options];
    [call writeMessage:request];
    [call start];

    waiterBlock(@[ expectation ], kTestTimeout);
    [call finish];
  });
}

- (void)testDefaultInterceptor {
  GRPCTestRunWithFlakeRepeats(self, ^(GRPCTestWaiter waiterBlock, GRPCTestAssert assertBlock) {
    RMTTestService *service = [RMTTestService serviceWithHost:[[self class] host]];
    __weak XCTestExpectation *expectation =
        [self expectationWithDescription:@"testDefaultInterceptor"];

    NSArray *requests = @[ @27182, @8, @1828, @45904 ];
    NSArray *responses = @[ @31415, @9, @2653, @58979 ];

    __block int index = 0;

    id request = [RMTStreamingOutputCallRequest messageWithPayloadSize:requests[index]
                                                 requestedResponseSize:responses[index]];
    GRPCMutableCallOptions *options = [[GRPCMutableCallOptions alloc] init];
    // For backwards compatibility
    options.transportType = [[self class] transportType];
    options.transport = [[self class] transport];
    options.PEMRootCertificates = [[self class] PEMRootCertificates];
    options.hostNameOverride = [[self class] hostNameOverride];
    options.interceptorFactories = @[ [[DefaultInterceptorFactory alloc] init] ];

    __weak __block GRPCStreamingProtoCall *weakCall;
    GRPCStreamingProtoCall *call = [service
        fullDuplexCallWithResponseHandler:
            [[InteropTestsBlockCallbacks alloc] initWithInitialMetadataCallback:nil
                messageCallback:^(id message) {
                  GRPCStreamingProtoCall *localCall = weakCall;
                  if (localCall == nil) {
                    return;
                  }
                  assertBlock(index < 4, @"More than 4 responses received.");

                  id expected =
                      [RMTStreamingOutputCallResponse messageWithPayloadSize:responses[index]];
                  assertBlock([message isEqual:expected],
                              [NSString stringWithFormat:@"message %@ not equal to expected %@",
                                                         message, expected]);

                  index += 1;
                  if (index < 4) {
                    id request =
                        [RMTStreamingOutputCallRequest messageWithPayloadSize:requests[index]
                                                        requestedResponseSize:responses[index]];
                    [localCall writeMessage:request];
                  } else {
                    [localCall finish];
                  }
                }
                closeCallback:^(NSDictionary *trailingMetadata, NSError *error) {
                  if (weakCall == nil) {
                    return;
                  }

                  assertBlock(
                      index == 4,
                      [NSString stringWithFormat:@"Received %@ responses instead of 4.", @(index)]);

                  assertBlock(
                      error == nil,
                      [NSString stringWithFormat:@"Finished with unexpected error: %@", error]);

                  [expectation fulfill];
                }]
                              callOptions:options];
    weakCall = call;
    [call start];
    [call writeMessage:request];

    waiterBlock(@[ expectation ], GRPCInteropTestTimeoutDefault);
  });
}

- (void)testLoggingInterceptor {
  GRPCTestRunWithFlakeRepeats(self, ^(GRPCTestWaiter waiterBlock, GRPCTestAssert assertBlock) {
    RMTTestService *service = [RMTTestService serviceWithHost:[[self class] host]];
    __weak XCTestExpectation *expectation =
        [self expectationWithDescription:@"testLoggingInterceptor"];

    __block NSUInteger startCount = 0;
    __block NSUInteger writeDataCount = 0;
    __block NSUInteger finishCount = 0;
    __block NSUInteger receiveNextMessageCount = 0;
    __block NSUInteger responseHeaderCount = 0;
    __block NSUInteger responseDataCount = 0;
    __block NSUInteger responseCloseCount = 0;
    __block NSUInteger didWriteDataCount = 0;
    id<GRPCInterceptorFactory> factory = [[HookInterceptorFactory alloc]
        initWithDispatchQueue:dispatch_queue_create(NULL, DISPATCH_QUEUE_SERIAL)
        startHook:^(GRPCRequestOptions *requestOptions, GRPCCallOptions *callOptions,
                    GRPCInterceptorManager *manager) {
          startCount++;
          XCTAssertEqualObjects(requestOptions.host, [[self class] host]);
          XCTAssertEqualObjects(requestOptions.path, @"/grpc.testing.TestService/FullDuplexCall");
          XCTAssertEqual(requestOptions.safety, GRPCCallSafetyDefault);
          [manager startNextInterceptorWithRequest:[requestOptions copy]
                                       callOptions:[callOptions copy]];
        }
        writeDataHook:^(id data, GRPCInterceptorManager *manager) {
          writeDataCount++;
          [manager writeNextInterceptorWithData:data];
        }
        finishHook:^(GRPCInterceptorManager *manager) {
          finishCount++;
          [manager finishNextInterceptor];
        }
        receiveNextMessagesHook:^(NSUInteger numberOfMessages, GRPCInterceptorManager *manager) {
          receiveNextMessageCount++;
          [manager receiveNextInterceptorMessages:numberOfMessages];
        }
        responseHeaderHook:^(NSDictionary *initialMetadata, GRPCInterceptorManager *manager) {
          responseHeaderCount++;
          [manager forwardPreviousInterceptorWithInitialMetadata:initialMetadata];
        }
        responseDataHook:^(id data, GRPCInterceptorManager *manager) {
          responseDataCount++;
          [manager forwardPreviousInterceptorWithData:data];
        }
        responseCloseHook:^(NSDictionary *trailingMetadata, NSError *error,
                            GRPCInterceptorManager *manager) {
          responseCloseCount++;
          [manager forwardPreviousInterceptorCloseWithTrailingMetadata:trailingMetadata
                                                                 error:error];
        }
        didWriteDataHook:^(GRPCInterceptorManager *manager) {
          didWriteDataCount++;
          [manager forwardPreviousInterceptorDidWriteData];
        }];

    NSArray *requests = @[ @1, @2, @3, @4 ];
    NSArray *responses = @[ @1, @2, @3, @4 ];

    __block int messageIndex = 0;

    id request = [RMTStreamingOutputCallRequest messageWithPayloadSize:requests[messageIndex]
                                                 requestedResponseSize:responses[messageIndex]];
    GRPCMutableCallOptions *options = [[GRPCMutableCallOptions alloc] init];
    // For backwards compatibility
    options.transportType = [[self class] transportType];
    options.transport = [[self class] transport];
    options.PEMRootCertificates = [[self class] PEMRootCertificates];
    options.hostNameOverride = [[self class] hostNameOverride];
    options.flowControlEnabled = YES;
    options.interceptorFactories = @[ factory ];

    __block int writeMessageCount = 0;
    __block __weak GRPCStreamingProtoCall *weakCall;
    GRPCStreamingProtoCall *call = [service
        fullDuplexCallWithResponseHandler:
            [[InteropTestsBlockCallbacks alloc] initWithInitialMetadataCallback:nil
                messageCallback:^(id message) {
                  GRPCStreamingProtoCall *localCall = weakCall;
                  if (localCall == nil) {
                    return;
                  }
                  assertBlock((messageIndex < 4), @"More than 4 responses received.");

                  id expected = [RMTStreamingOutputCallResponse
                      messageWithPayloadSize:responses[messageIndex]];
                  assertBlock([message isEqual:expected],
                              [NSString stringWithFormat:@"message %@ not equal to expected %@",
                                                         message, expected]);
                  messageIndex += 1;
                  if (messageIndex < 4) {
                    id request = [RMTStreamingOutputCallRequest
                        messageWithPayloadSize:requests[messageIndex]
                         requestedResponseSize:responses[messageIndex]];
                    [localCall writeMessage:request];
                    [localCall receiveNextMessage];
                  } else {
                    [localCall finish];
                  }
                }
                closeCallback:^(NSDictionary *trailingMetadata, NSError *error) {
                  if (weakCall == nil) {
                    return;
                  }
                  assertBlock(
                      error == nil,
                      [NSString stringWithFormat:@"Finished with unexpected error: %@", error]);
                  assertBlock(messageIndex == 4,
                              [NSString stringWithFormat:@"Received %@ responses instead of 4.",
                                                         @(messageIndex)]);
                  [expectation fulfill];
                }
                writeMessageCallback:^{
                  writeMessageCount++;
                }]
                              callOptions:options];

    weakCall = call;
    [call start];
    [call receiveNextMessage];
    [call writeMessage:request];

    waiterBlock(@[ expectation ], GRPCInteropTestTimeoutDefault);

    assertBlock(startCount == 1, [NSString stringWithFormat:@"%@", @(startCount)]);
    assertBlock(writeDataCount == 4, [NSString stringWithFormat:@"%@", @(writeDataCount)]);
    assertBlock(finishCount == 1, [NSString stringWithFormat:@"%@", @(finishCount)]);
    assertBlock(receiveNextMessageCount == 4,
                [NSString stringWithFormat:@"%@", @(receiveNextMessageCount)]);
    assertBlock(responseHeaderCount == 1,
                [NSString stringWithFormat:@"%@", @(responseHeaderCount)]);
    assertBlock(responseDataCount == 4, [NSString stringWithFormat:@"%@", @(responseDataCount)]);
    assertBlock(responseCloseCount == 1, [NSString stringWithFormat:@"%@", @(responseCloseCount)]);
    assertBlock(didWriteDataCount == 4, [NSString stringWithFormat:@"%@", @(didWriteDataCount)]);
    assertBlock(writeMessageCount == 4, [NSString stringWithFormat:@"%@", @(writeMessageCount)]);
  });
}

// Chain a default interceptor and a hook interceptor which, after one write, cancels the call
// under the hood but forward further data to the user.
- (void)testHijackingInterceptor {
  GRPCTestRunWithFlakeRepeats(self, ^(GRPCTestWaiter waiterBlock, GRPCTestAssert assertBlock) {
    RMTTestService *service = [RMTTestService serviceWithHost:[[self class] host]];
    NSUInteger kCancelAfterWrites = 1;
    __weak XCTestExpectation *expectUserCallComplete =
        [self expectationWithDescription:@"User call completed."];
    __weak XCTestExpectation *expectResponseCallbackComplete =
        [self expectationWithDescription:@"Hook interceptor response callback completed"];

    NSArray *responses = @[ @1, @2, @3, @4 ];
    __block int index = 0;

    __block NSUInteger startCount = 0;
    __block NSUInteger writeDataCount = 0;
    __block NSUInteger finishCount = 0;
    __block NSUInteger responseHeaderCount = 0;
    __block NSUInteger responseDataCount = 0;
    __block NSUInteger responseCloseCount = 0;
    id<GRPCInterceptorFactory> factory = [[HookInterceptorFactory alloc]
        initWithDispatchQueue:dispatch_queue_create(NULL, DISPATCH_QUEUE_SERIAL)
        startHook:^(GRPCRequestOptions *requestOptions, GRPCCallOptions *callOptions,
                    GRPCInterceptorManager *manager) {
          startCount++;
          [manager startNextInterceptorWithRequest:[requestOptions copy]
                                       callOptions:[callOptions copy]];
        }
        writeDataHook:^(id data, GRPCInterceptorManager *manager) {
          writeDataCount++;
          if (index < kCancelAfterWrites) {
            [manager writeNextInterceptorWithData:data];
          } else if (index == kCancelAfterWrites) {
            [manager cancelNextInterceptor];
            [manager forwardPreviousInterceptorWithData:[[RMTStreamingOutputCallResponse
                                                            messageWithPayloadSize:responses[index]]
                                                            data]];
          } else {  // (index > kCancelAfterWrites)
            [manager forwardPreviousInterceptorWithData:[[RMTStreamingOutputCallResponse
                                                            messageWithPayloadSize:responses[index]]
                                                            data]];
          }
        }
        finishHook:^(GRPCInterceptorManager *manager) {
          finishCount++;
          // finish must happen after the hijacking, so directly reply with a close
          [manager forwardPreviousInterceptorCloseWithTrailingMetadata:@{@"grpc-status" : @"0"}
                                                                 error:nil];
          [manager shutDown];
        }
        receiveNextMessagesHook:nil
        responseHeaderHook:^(NSDictionary *initialMetadata, GRPCInterceptorManager *manager) {
          responseHeaderCount++;
          [manager forwardPreviousInterceptorWithInitialMetadata:initialMetadata];
        }
        responseDataHook:^(id data, GRPCInterceptorManager *manager) {
          responseDataCount++;
          [manager forwardPreviousInterceptorWithData:data];
        }
        responseCloseHook:^(NSDictionary *trailingMetadata, NSError *error,
                            GRPCInterceptorManager *manager) {
          responseCloseCount++;
          // since we canceled the call, it should return cancel error
          XCTAssertNil(trailingMetadata);
          XCTAssertNotNil(error);
          XCTAssertEqual(error.code, GRPC_STATUS_CANCELLED);
          [expectResponseCallbackComplete fulfill];
        }
        didWriteDataHook:nil];

    NSArray *requests = @[ @1, @2, @3, @4 ];

    id request = [RMTStreamingOutputCallRequest messageWithPayloadSize:requests[index]
                                                 requestedResponseSize:responses[index]];
    GRPCMutableCallOptions *options = [[GRPCMutableCallOptions alloc] init];
    // For backwards compatibility
    options.transportType = [[self class] transportType];
    options.transport = [[self class] transport];
    options.PEMRootCertificates = [[self class] PEMRootCertificates];
    options.hostNameOverride = [[self class] hostNameOverride];
    options.interceptorFactories = @[ [[DefaultInterceptorFactory alloc] init], factory ];

    __weak __block GRPCStreamingProtoCall *weakCall;
    GRPCStreamingProtoCall *call = [service
        fullDuplexCallWithResponseHandler:
            [[InteropTestsBlockCallbacks alloc] initWithInitialMetadataCallback:nil
                messageCallback:^(id message) {
                  GRPCStreamingProtoCall *localCall = weakCall;
                  if (localCall == nil) {
                    return;
                  }

                  assertBlock(index < 4, @"More than 4 responses received.");

                  id expected =
                      [RMTStreamingOutputCallResponse messageWithPayloadSize:responses[index]];
                  assertBlock([message isEqual:expected],
                              [NSString stringWithFormat:@"message %@ not equal to expected %@",
                                                         message, expected]);
                  index += 1;
                  if (index < 4) {
                    id request =
                        [RMTStreamingOutputCallRequest messageWithPayloadSize:requests[index]
                                                        requestedResponseSize:responses[index]];
                    [localCall writeMessage:request];
                    [localCall receiveNextMessage];
                  } else {
                    [self waitForExpectations:@[ expectResponseCallbackComplete ]
                                      timeout:GRPCInteropTestTimeoutDefault];
                    [localCall finish];
                  }
                }
                closeCallback:^(NSDictionary *trailingMetadata, NSError *error) {
                  if (weakCall == nil) {
                    return;
                  }
                  assertBlock(
                      error == nil,
                      [NSString stringWithFormat:@"Finished with unexpected error: %@", error]);
                  assertBlock(
                      index == 4,
                      [NSString stringWithFormat:@"Received %@ responses instead of 4.", @(index)]);

                  [expectUserCallComplete fulfill];
                }]
                              callOptions:options];
    weakCall = call;
    [call start];
    [call receiveNextMessage];
    [call writeMessage:request];

    waiterBlock(@[ expectUserCallComplete ], GRPCInteropTestTimeoutDefault);
    assertBlock(startCount == 1, [NSString stringWithFormat:@"%@", @(startCount)]);
    assertBlock(writeDataCount == 4, [NSString stringWithFormat:@"%@", @(writeDataCount)]);
    assertBlock(finishCount == 1, [NSString stringWithFormat:@"%@", @(finishCount)]);
    assertBlock(responseHeaderCount == 1,
                [NSString stringWithFormat:@"%@", @(responseHeaderCount)]);
    assertBlock(responseDataCount == 1, [NSString stringWithFormat:@"%@", @(responseDataCount)]);
    assertBlock(responseCloseCount == 1, [NSString stringWithFormat:@"%@", @(responseCloseCount)]);
  });
}

- (void)testGlobalInterceptor {
  GRPCTestRunWithFlakeRepeats(self, ^(GRPCTestWaiter waiterBlock, GRPCTestAssert assertBlock) {
    RMTTestService *service = [RMTTestService serviceWithHost:[[self class] host]];
    __weak XCTestExpectation *expectation =
        [self expectationWithDescription:@"testGlobalInterceptor"];

    __block NSUInteger startCount = 0;
    __block NSUInteger writeDataCount = 0;
    __block NSUInteger finishCount = 0;
    __block NSUInteger receiveNextMessageCount = 0;
    __block NSUInteger responseHeaderCount = 0;
    __block NSUInteger responseDataCount = 0;
    __block NSUInteger responseCloseCount = 0;
    __block NSUInteger didWriteDataCount = 0;
    [globalInterceptorFactory
        setStartHook:^(GRPCRequestOptions *requestOptions, GRPCCallOptions *callOptions,
                       GRPCInterceptorManager *manager) {
          startCount++;
          XCTAssertEqualObjects(requestOptions.host, [[self class] host]);
          XCTAssertEqualObjects(requestOptions.path, @"/grpc.testing.TestService/FullDuplexCall");
          XCTAssertEqual(requestOptions.safety, GRPCCallSafetyDefault);
          [manager startNextInterceptorWithRequest:[requestOptions copy]
                                       callOptions:[callOptions copy]];
        }
        writeDataHook:^(id data, GRPCInterceptorManager *manager) {
          writeDataCount++;
          [manager writeNextInterceptorWithData:data];
        }
        finishHook:^(GRPCInterceptorManager *manager) {
          finishCount++;
          [manager finishNextInterceptor];
        }
        receiveNextMessagesHook:^(NSUInteger numberOfMessages, GRPCInterceptorManager *manager) {
          receiveNextMessageCount++;
          [manager receiveNextInterceptorMessages:numberOfMessages];
        }
        responseHeaderHook:^(NSDictionary *initialMetadata, GRPCInterceptorManager *manager) {
          responseHeaderCount++;
          [manager forwardPreviousInterceptorWithInitialMetadata:initialMetadata];
        }
        responseDataHook:^(id data, GRPCInterceptorManager *manager) {
          responseDataCount++;
          [manager forwardPreviousInterceptorWithData:data];
        }
        responseCloseHook:^(NSDictionary *trailingMetadata, NSError *error,
                            GRPCInterceptorManager *manager) {
          responseCloseCount++;
          [manager forwardPreviousInterceptorCloseWithTrailingMetadata:trailingMetadata
                                                                 error:error];
        }
        didWriteDataHook:^(GRPCInterceptorManager *manager) {
          didWriteDataCount++;
          [manager forwardPreviousInterceptorDidWriteData];
        }];

    NSArray *requests = @[ @1, @2, @3, @4 ];
    NSArray *responses = @[ @1, @2, @3, @4 ];

    __block int index = 0;

    id request = [RMTStreamingOutputCallRequest messageWithPayloadSize:requests[index]
                                                 requestedResponseSize:responses[index]];
    GRPCMutableCallOptions *options = [[GRPCMutableCallOptions alloc] init];
    // For backwards compatibility
    options.transportType = [[self class] transportType];
    options.transport = [[self class] transport];
    options.PEMRootCertificates = [[self class] PEMRootCertificates];
    options.hostNameOverride = [[self class] hostNameOverride];
    options.flowControlEnabled = YES;
    globalInterceptorFactory.enabled = YES;

    __block int writeMessageCount = 0;
    __weak __block GRPCStreamingProtoCall *weakCall;
    __block GRPCStreamingProtoCall *call = [service
        fullDuplexCallWithResponseHandler:
            [[InteropTestsBlockCallbacks alloc] initWithInitialMetadataCallback:nil
                messageCallback:^(id message) {
                  GRPCStreamingProtoCall *localCall = weakCall;
                  if (localCall == nil) {
                    return;
                  }
                  assertBlock(index < 4, @"More than 4 responses received.");

                  index += 1;
                  if (index < 4) {
                    id request =
                        [RMTStreamingOutputCallRequest messageWithPayloadSize:requests[index]
                                                        requestedResponseSize:responses[index]];
                    [localCall writeMessage:request];
                    [localCall receiveNextMessage];
                  } else {
                    [localCall finish];
                  }
                }
                closeCallback:^(NSDictionary *trailingMetadata, NSError *error) {
                  if (weakCall == nil) {
                    return;
                  }
                  assertBlock(
                      error == nil,
                      [NSString stringWithFormat:@"Finished with unexpected error: %@", error]);
                  [expectation fulfill];
                }
                writeMessageCallback:^{
                  writeMessageCount++;
                }]
                              callOptions:options];
    weakCall = call;
    [call start];
    [call receiveNextMessage];
    [call writeMessage:request];
    waiterBlock(@[ expectation ], GRPCInteropTestTimeoutDefault);

    assertBlock(startCount == 1, [NSString stringWithFormat:@"%@", @(startCount)]);
    assertBlock(writeDataCount == 4, [NSString stringWithFormat:@"%@", @(writeDataCount)]);
    assertBlock(finishCount == 1, [NSString stringWithFormat:@"%@", @(finishCount)]);
    assertBlock(receiveNextMessageCount == 4,
                [NSString stringWithFormat:@"%@", @(receiveNextMessageCount)]);
    assertBlock(responseHeaderCount == 1,
                [NSString stringWithFormat:@"%@", @(responseHeaderCount)]);
    assertBlock(responseDataCount == 4, [NSString stringWithFormat:@"%@", @(responseDataCount)]);
    assertBlock(responseCloseCount == 1, [NSString stringWithFormat:@"%@", @(responseCloseCount)]);
    assertBlock(didWriteDataCount == 4, [NSString stringWithFormat:@"%@", @(didWriteDataCount)]);
    assertBlock(writeMessageCount == 4, [NSString stringWithFormat:@"%@", @(writeMessageCount)]);
    globalInterceptorFactory.enabled = NO;
  });
}

- (void)testConflictingGlobalInterceptors {
  id<GRPCInterceptorFactory> factory = [[HookInterceptorFactory alloc]
        initWithDispatchQueue:dispatch_queue_create(NULL, DISPATCH_QUEUE_SERIAL)
                    startHook:nil
                writeDataHook:nil
                   finishHook:nil
      receiveNextMessagesHook:nil
           responseHeaderHook:nil
             responseDataHook:nil
            responseCloseHook:nil
             didWriteDataHook:nil];
  @try {
    [GRPCCall2 registerGlobalInterceptor:factory];
    XCTFail(@"Did not receive an exception when registering global interceptor the second time");
  } @catch (NSException *exception) {
    // Do nothing; test passes
  }
}

- (void)testInterceptorAndGlobalInterceptor {
  GRPCTestRunWithFlakeRepeats(self, ^(GRPCTestWaiter waiterBlock, GRPCTestAssert assertBlock) {
    RMTTestService *service = [RMTTestService serviceWithHost:[[self class] host]];
    __weak XCTestExpectation *expectation =
        [self expectationWithDescription:@"testInterceptorAndGlobalInterceptor"];

    __block NSUInteger startCount = 0;
    __block NSUInteger writeDataCount = 0;
    __block NSUInteger finishCount = 0;
    __block NSUInteger receiveNextMessageCount = 0;
    __block NSUInteger responseHeaderCount = 0;
    __block NSUInteger responseDataCount = 0;
    __block NSUInteger responseCloseCount = 0;
    __block NSUInteger didWriteDataCount = 0;

    id<GRPCInterceptorFactory> factory = [[HookInterceptorFactory alloc]
        initWithDispatchQueue:dispatch_queue_create(NULL, DISPATCH_QUEUE_SERIAL)
        startHook:^(GRPCRequestOptions *requestOptions, GRPCCallOptions *callOptions,
                    GRPCInterceptorManager *manager) {
          startCount++;
          XCTAssertEqualObjects(requestOptions.host, [[self class] host]);
          XCTAssertEqualObjects(requestOptions.path, @"/grpc.testing.TestService/FullDuplexCall");
          XCTAssertEqual(requestOptions.safety, GRPCCallSafetyDefault);
          [manager startNextInterceptorWithRequest:[requestOptions copy]
                                       callOptions:[callOptions copy]];
        }
        writeDataHook:^(id data, GRPCInterceptorManager *manager) {
          writeDataCount++;
          [manager writeNextInterceptorWithData:data];
        }
        finishHook:^(GRPCInterceptorManager *manager) {
          finishCount++;
          [manager finishNextInterceptor];
        }
        receiveNextMessagesHook:^(NSUInteger numberOfMessages, GRPCInterceptorManager *manager) {
          receiveNextMessageCount++;
          [manager receiveNextInterceptorMessages:numberOfMessages];
        }
        responseHeaderHook:^(NSDictionary *initialMetadata, GRPCInterceptorManager *manager) {
          responseHeaderCount++;
          [manager forwardPreviousInterceptorWithInitialMetadata:initialMetadata];
        }
        responseDataHook:^(id data, GRPCInterceptorManager *manager) {
          responseDataCount++;
          [manager forwardPreviousInterceptorWithData:data];
        }
        responseCloseHook:^(NSDictionary *trailingMetadata, NSError *error,
                            GRPCInterceptorManager *manager) {
          responseCloseCount++;
          [manager forwardPreviousInterceptorCloseWithTrailingMetadata:trailingMetadata
                                                                 error:error];
        }
        didWriteDataHook:^(GRPCInterceptorManager *manager) {
          didWriteDataCount++;
          [manager forwardPreviousInterceptorDidWriteData];
        }];

    __block NSUInteger globalStartCount = 0;
    __block NSUInteger globalWriteDataCount = 0;
    __block NSUInteger globalFinishCount = 0;
    __block NSUInteger globalReceiveNextMessageCount = 0;
    __block NSUInteger globalResponseHeaderCount = 0;
    __block NSUInteger globalResponseDataCount = 0;
    __block NSUInteger globalResponseCloseCount = 0;
    __block NSUInteger globalDidWriteDataCount = 0;

    [globalInterceptorFactory
        setStartHook:^(GRPCRequestOptions *requestOptions, GRPCCallOptions *callOptions,
                       GRPCInterceptorManager *manager) {
          globalStartCount++;
          XCTAssertEqualObjects(requestOptions.host, [[self class] host]);
          XCTAssertEqualObjects(requestOptions.path, @"/grpc.testing.TestService/FullDuplexCall");
          XCTAssertEqual(requestOptions.safety, GRPCCallSafetyDefault);
          [manager startNextInterceptorWithRequest:[requestOptions copy]
                                       callOptions:[callOptions copy]];
        }
        writeDataHook:^(id data, GRPCInterceptorManager *manager) {
          globalWriteDataCount++;
          [manager writeNextInterceptorWithData:data];
        }
        finishHook:^(GRPCInterceptorManager *manager) {
          globalFinishCount++;
          [manager finishNextInterceptor];
        }
        receiveNextMessagesHook:^(NSUInteger numberOfMessages, GRPCInterceptorManager *manager) {
          globalReceiveNextMessageCount++;
          [manager receiveNextInterceptorMessages:numberOfMessages];
        }
        responseHeaderHook:^(NSDictionary *initialMetadata, GRPCInterceptorManager *manager) {
          globalResponseHeaderCount++;
          [manager forwardPreviousInterceptorWithInitialMetadata:initialMetadata];
        }
        responseDataHook:^(id data, GRPCInterceptorManager *manager) {
          globalResponseDataCount++;
          [manager forwardPreviousInterceptorWithData:data];
        }
        responseCloseHook:^(NSDictionary *trailingMetadata, NSError *error,
                            GRPCInterceptorManager *manager) {
          globalResponseCloseCount++;
          [manager forwardPreviousInterceptorCloseWithTrailingMetadata:trailingMetadata
                                                                 error:error];
        }
        didWriteDataHook:^(GRPCInterceptorManager *manager) {
          globalDidWriteDataCount++;
          [manager forwardPreviousInterceptorDidWriteData];
        }];

    NSArray *requests = @[ @1, @2, @3, @4 ];
    NSArray *responses = @[ @1, @2, @3, @4 ];

    __block int index = 0;

    id request = [RMTStreamingOutputCallRequest messageWithPayloadSize:requests[index]
                                                 requestedResponseSize:responses[index]];
    GRPCMutableCallOptions *options = [[GRPCMutableCallOptions alloc] init];
    // For backwards compatibility
    options.transportType = [[self class] transportType];
    options.transport = [[self class] transport];
    options.PEMRootCertificates = [[self class] PEMRootCertificates];
    options.hostNameOverride = [[self class] hostNameOverride];
    options.flowControlEnabled = YES;
    options.interceptorFactories = @[ factory ];
    globalInterceptorFactory.enabled = YES;

    __block int writeMessageCount = 0;
    __weak __block GRPCStreamingProtoCall *weakCall;
    GRPCStreamingProtoCall *call = [service
        fullDuplexCallWithResponseHandler:[[InteropTestsBlockCallbacks alloc]
                                              initWithInitialMetadataCallback:nil
                                              messageCallback:^(id message) {
                                                GRPCStreamingProtoCall *localCall = weakCall;
                                                if (localCall == nil) {
                                                  return;
                                                }
                                                index += 1;
                                                if (index < 4) {
                                                  id request = [RMTStreamingOutputCallRequest
                                                      messageWithPayloadSize:requests[index]
                                                       requestedResponseSize:responses[index]];
                                                  [localCall writeMessage:request];
                                                  [localCall receiveNextMessage];
                                                } else {
                                                  [localCall finish];
                                                }
                                              }
                                              closeCallback:^(NSDictionary *trailingMetadata,
                                                              NSError *error) {
                                                if (weakCall == nil) {
                                                  return;
                                                }
                                                [expectation fulfill];
                                              }
                                              writeMessageCallback:^{
                                                writeMessageCount++;
                                              }]
                              callOptions:options];
    weakCall = call;
    [call start];
    [call receiveNextMessage];
    [call writeMessage:request];

    waiterBlock(@[ expectation ], GRPCInteropTestTimeoutDefault);
    assertBlock(startCount == 1, [NSString stringWithFormat:@"%@", @(startCount)]);
    assertBlock(writeDataCount == 4, [NSString stringWithFormat:@"%@", @(writeDataCount)]);
    assertBlock(finishCount == 1, [NSString stringWithFormat:@"%@", @(finishCount)]);
    assertBlock(receiveNextMessageCount == 4,
                [NSString stringWithFormat:@"%@", @(receiveNextMessageCount)]);
    assertBlock(responseHeaderCount == 1,
                [NSString stringWithFormat:@"%@", @(responseHeaderCount)]);
    assertBlock(responseDataCount == 4, [NSString stringWithFormat:@"%@", @(responseDataCount)]);
    assertBlock(responseCloseCount == 1, [NSString stringWithFormat:@"%@", @(responseCloseCount)]);
    assertBlock(didWriteDataCount == 4, [NSString stringWithFormat:@"%@", @(didWriteDataCount)]);
    assertBlock(globalStartCount == 1, [NSString stringWithFormat:@"%@", @(globalStartCount)]);
    assertBlock(globalWriteDataCount == 4,
                [NSString stringWithFormat:@"%@", @(globalWriteDataCount)]);
    assertBlock(globalFinishCount == 1, [NSString stringWithFormat:@"%@", @(globalFinishCount)]);
    assertBlock(globalReceiveNextMessageCount == 4,
                [NSString stringWithFormat:@"%@", @(globalReceiveNextMessageCount)]);
    assertBlock(globalResponseHeaderCount == 1,
                [NSString stringWithFormat:@"%@", @(globalResponseHeaderCount)]);
    assertBlock(globalResponseDataCount == 4,
                [NSString stringWithFormat:@"%@", @(globalResponseDataCount)]);
    assertBlock(globalResponseCloseCount == 1,
                [NSString stringWithFormat:@"%@", @(globalResponseCloseCount)]);
    assertBlock(globalDidWriteDataCount == 4,
                [NSString stringWithFormat:@"%@", @(globalDidWriteDataCount)]);
    assertBlock(writeMessageCount == 4, [NSString stringWithFormat:@"%@", @(writeMessageCount)]);
    globalInterceptorFactory.enabled = NO;
  });
}

@end
